Pertimbangkan sebuah jembatan dengan panjang B yang dibentuk oleh ubin berlabel digit bilangan bulat positif. Misalnya, jika B berusia 41, maka akan terlihat seperti ini:

-----------------------------------------
12345678910111213141516171819202122232425

Sekarang bayangkan sebuah kereta dengan panjang T melintasi jembatan. Titik paling kiri dari kereta dimulai pada posisi X (1-diindeks). Untuk mendapatkan pemahaman yang lebih baik tentang masalah ini, mari buat skema acara, dengan B = 41, T = 10, X = 10 . Kereta ditarik menggunakan tanda sama ( =) dan garis:

         __________
         | ======== |
         | ======== |
-----------------------------------------
12345678910111213141516171819202122232425

Kereta bisa bergerak maju, di setiap langkah, dengan jumlah ubin unik yang letaknya. Misalnya, ubin tempat kereta berdiri di atas adalah [1, 0, 1, 1, 1, 2, 1, 3, 1, 4]:, ubin unik (diduplikasi) adalah:, [1, 0, 2, 3, 4]dan jumlahnya adalah 10. Oleh karena itu, kereta dapat naik dengan 10ubin. Kita harus menggambarnya lagi dan ulangi prosesnya sampai titik paling kiri kereta telah melewati ubin terakhir:

                   __________
                   | ======== |
                   | ======== |
-----------------------------------------
12345678910111213141516171819202122232425

Jumlah ubin unik: 1 + 5 + 6 + 7 + 8 + 9 = 36. Kereta melaju dengan 36 ubin ...

                                                       __________
                                                       | ======== |
                                                       | ======== |
-----------------------------------------
12345678910111213141516171819202122232425

Kereta jelas melintasi jembatan sepenuhnya, jadi kita harus berhenti sekarang.

Karena orang-orang di dalam merasa bosan, mereka menghitung ubin kereta yang telah maju setiap kali. Dalam kasus khusus ini, 10dan 36. Merangkum semuanya, kereta telah bergerak 46sebelum melewati jembatan.

Tugas

Diberikan tiga bilangan bulat positif, B (panjang jembatan), T (panjang kereta) dan X (posisi awal, 1-diindeks ), tugas Anda adalah menentukan berapa banyak ubin kereta yang telah dipindahkan sampai melintasi jembatan mengikuti aturan atas.

• Anda dapat mengasumsikan bahwa:
  • B lebih tinggi dari T .
  • X lebih rendah dari B .
  • T setidaknya 2 .
  • Kereta akhirnya melintasi jembatan.
• Semua aturan standar kami berlaku.
• Ini adalah kode-golf , jadi kode terpendek dalam byte menang!

Uji kasus

Input ([B, T, X]) -> Output

[41, 10, 10] -> 46
[40, 10, 10] -> 46
[30, 4, 16] -> 24
[50, 6, 11] -> 50

Contoh lain yang berfungsi untuk kasus uji terakhir:

Jembatan itu panjangnya 50, kereta 6, dan posisi awal adalah 11.

          _______ Albania
          | ==== |
          | ==== |
--------------------------------------------------
12345678910111213141516171819202122232425262728293

Ubin unik: [0, 1, 2]. Jumlah: 3.

             _______ Albania
             | ==== |
             | ==== |
--------------------------------------------------
12345678910111213141516171819202122232425262728293

Ubin unik: [1, 2, 3, 4]. Jumlah: 10.

                       _______ Albania
                       | ==== |
                       | ==== |
--------------------------------------------------
12345678910111213141516171819202122232425262728293

Ubin unik: [1, 7, 8, 9]. Jumlah: 25.

                                                _______ Albania
                                                | ==== |
                                                | ==== |
--------------------------------------------------
12345678910111213141516171819202122232425262728293

Ubin unik: [9, 3]. Jumlah: 12.
                                                            _______ Albania
                                                            | ==== |
                                                            | ==== |
--------------------------------------------------
12345678910111213141516171819202122232425262728293

Kereta ada jembatan. Jumlah total: 3 + 10 + 25 + 12 = 50.

Sekam , 20 byte

ṁ←U¡S↓←moΣuX_⁰↓Θ↑ṁdN

Cobalah online!

Membawa tiga argumen dalam rangka T , B , X .

Penjelasan

ṁ←U¡S↓←moΣuX_⁰↓Θ↑ṁdN
                 ṁdN    Build the list of digits of natural numbers
              ↓Θ↑       Take the first B digits, add a 0 in front
                        then drop the first X digits
           X_⁰          Get all sublists of length T
       moΣu             Map the sum of unique values of each sublist

   ¡S↓←                 Repeatedly drop as many elements from the start of the list as the
                        first element of the list says;
                        keep all partial results in an infinite list.

  U                     Take elements until the first repeated one
                        (drops tail of infinite empty lists)

ṁ←                      Sum the first elements of each remaining sublist

Python 2 , 110 105 104 103 100 97 96 byte

• Disimpan lima byte berkat Tn. Xcoder ; menghapus tugas yang tidak perlu, memindahkan negasi ke ruang kosong yang tersedia.
• Menyimpan satu byte berkat Tn. Xcoder ; bermain golf [~-x:x+~-t]untuk [~-x:][:t].
• Disimpan satu byte; bermain golf ...range(1,-~b)))[:b]untuk ...range(b)))[1:-~b].
• Disimpan tiga byte; bermain golf [1:-~b][~-x:]untuk [:-~b][x:].
• Disimpan tiga byte; bermain golf [:-~b][x:]untuk [x:-~b].
• Menyimpan satu byte berkat Lynn ; bermain golf whileloop ke execpernyataan.

b,t,x=input();S=x;exec"x+=sum(set(map(int,''.join(map(str,range(b)))[x:-~b][:t])));"*b;print-S+x

Cobalah online!

Haskell, 106 102 byte

import Data.List
(b#t)x|x>b=0|y<-sum[read[c]|c<-nub$take t$drop(x-1)$take b$show=<<[1..]]=y+(b#t)(x+y)

Cobalah online!

(b#t)x
   |x>b=0                 -- if the train has left the bridge, return 0
   |y<-sum[   ]           -- else let y be the sum of
      read[c]|c<-         -- the digits c where c comes from
        nub               -- the uniquified list of
            show=<<[1..]] -- starting with the digits of all integers concatenated
          take b          -- taking b digits (length of bridge)
         drop(x-1)        -- dropping the part before the train
        take t            -- take the digits under the train
     =y+(b#t)(x+y)        -- return y plus a recursive call with the train advanced

R , 123 byte

function(B,T,X){s=substring
while(X<B){F=F+(S=sum(unique(strtoi(s(s(paste(1:B,collapse=''),1,B),K<-X+1:T-1,K)))))
X=X+S}
F}

Hanya mengimplementasikan algoritma yang dijelaskan.

R cukup buruk pada string.

function(B,T,X){
 s <- substring                         # alias
 b <- s(paste(1:B,collapse=''),1,B)     # bridge characters
 while(X<B){                            # until we crossed the bridge
  K <- X+1:T-1                          # indices of the characters
  S <- s(b,K,K)                         # the characters from b
  S <- sum(unique(strtoi(S)))           # sum
  F <- F + S                            # F defaults to 0 at the beginning
  X <- X + S                            # advance the train
 }
 F                                      # number of steps, returned
}

Cobalah online!

Jelly ,  22  21 byte

ḣ⁵QS
RDẎḣ⁸ṫṫÇ‘$$ÐĿÇ€S

Program lengkap yang mengambil tiga argumen - urutannya adalah B , X , T - yang mencetak hasilnya.

Cobalah online!

Bagaimana?

ḣ⁵QS - Link 1, calculate next jump: list of digits, bridge under and beyond train's left
 ⁵   - program's fifth command line argument (3rd input) = T (train length)
ḣ    - head to index (get the digits of the tiles under the train)
  Q  - de-duplicate
   S - sum

RDẎḣ⁸ṫṫÇ‘$$ÐĿÇ€S - Main link: number, B (bridge length); number, X (starting position)
R                - range(B) = [1,2,3,...,B-1,B]
 D               - to decimal list (vectorises) = [[1],[2],[3],...,[digits of B-1],[digits of B]]
  Ẏ              - tighten (flatten by one) = [1,2,3,...,digits of B-1,digits of B]
    ⁸            - chain's left argument, B
   ḣ             - head to index (truncate to only the bridge's digits)
     ṫ           - tail from index (implicit X) (truncate from the train's left)
           ÐĿ    - loop, collecting results, until no more change occurs:
          $      -   last two links as a monad:
         $       -     last two links as a monad:
       Ç         -       call last link (1) as a monad (get next jump)
        ‘        -       increment
      ṫ          -     tail from that index (remove the track to the left after train jumps)
             Ç€  - call last link (1) as a monad for €ach (gets the jump sizes taken again)
               S - sum
                 - implicit print

JavaScript (ES6), 117 byte

f=(B,T,X,g=b=>b?g(b-1)+b:'',o=0)=>X<B?[...g(B).substr(X-1,T)].map((e,i,a)=>o+=i+X>B|a[-e]?0:a[-e]=+e)&&o+f(B,T,X+o):0

Sepasang fungsi rekursif:

1. f() jumlah gerakan kereta.
2. g() menciptakan string angka.

Kurang golf:

f=
(B,T,X,
 g=b=>b?g(b-1)+b:'',                       //creates the string of numbers
 o=0                                       //sum of tiles the train sits on
)=>
  X<B?                                     //if we're not past the bridge:
      [...g(B).substr(X - 1,T)].map(       //  grab the tiles we're sitting on
        (e,i,a)=>o += i + X > B |          //  if we've passed the bridge,
                      a[-e] ? 0 :          //  ... or we've seen this tile before, add 0 to o
                              a[-e] = +e   //  else store this tile and add its value to o
      ) &&
      o + f(B,T,X+o) :                     //recurse
  0

f=(B,T,X,g=b=>b?g(b-1)+b:'',o=0)=>X<B?[...g(B).substr(X-1,T)].map((e,i,a)=>o+=i+X>B|a[-e]?0:a[-e]=+e)&&o+f(B,T,X+o):0

console.log(f(41, 10, 10));  //46
console.log(f(40, 10, 10));  //46
console.log(f(30, 4, 16));   //24
console.log(f(50, 6, 11));   //50

PHP> = 7.1, 153 byte

<?$s=substr;[,$p,$q,$r]=$argv;while($i<$p)$a.=++$i;$a=$s($a,0,$p);;while($r<$p){$x+=$n=array_sum(array_unique(str_split($s($a,$r-1,$q))));$r+=$n;}echo$x;

Cobalah online!

Untuk membuatnya kompatibel dengan versi PHP yang lebih rendah, ubah [,$p,$q,$r]=ke list(,$p,$q,$r)=(+4 byte).

<?
[,$bridgelen,$trainlen,$position] = $argv;                  // grab input
while($i<$bridgelen)                                        // until the bridge is long enough...
  $bridgestr .= ++$i;                                       // add to the bridge
$bridgestr = substr($bridgestr,0,$bridgelen);               // cut the bridge down to size (if it splits mid-number)
while($position<$bridgelen){                                // while we are still on the bridge...
  $currtiles =                                              // set current tiles crossed to the...
    array_sum(                                              // sum of tiles...
      array_unique(                                         // uniquely...
        str_split(substr($bridgestr,$position-1,$trainlen)) // under the train
      )
    )
  ;
  $totaltiles += $currtiles;                                // increment total tiles crossed
  $position += $currtiles;                                  // set new position
}
echo $totaltiles;                                           // echo total tiles crossed