Birleştirilmiş pozitif tamsayıların rakamları ile etiketlenmiş karolar tarafından oluşturulan B uzunluğunda bir köprü düşünün . Örneğin, B 41 olsaydı, şöyle olurdu:

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

Şimdi köprüyü geçen T uzunluğunda bir tren hayal edin . Trenin en sol noktası X konumunda başlar (1 endeksli). Sorunu daha iyi anlamak için, B = 41, T = 10, X = 10 ile olayın bir şemasını yapalım . Tren eşit işaretler ( =) ve çizgiler kullanılarak çizilir :

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

Tren, her adımda, üzerinde bulunduğu benzersiz karoların toplamı ile ilerleyebilir. Örneğin, trenin üzerinde durduğu [1, 0, 1, 1, 1, 2, 1, 3, 1, 4]karolar şunlardır: benzersiz (tekilleştirilmiş) karolar: [1, 0, 2, 3, 4]ve toplamları 10. Böylece tren 10fayanslarla ilerleyebilir . Onu tekrar çizmeli ve trenin en sol noktası son döşemeyi geçene kadar işlemi tekrarlamalıyız:

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

Benzersiz karoların toplamı: 1 + 5 + 6 + 7 + 8 + 9 = 36. Tren 36 karo ile ilerliyor ...

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

Tren açıkça köprüyü tamamen aştı, bu yüzden şimdi durmalıyız.

İçerideki insanlar sıkıldığından, trenin her seferinde ilerlediği karoları sayarlar. Bu özel durumda 10ve 36. Her şeyi özetleyerek, tren 46köprüyü geçmeden önce hareket etti.

Görev

B (köprü uzunluğu), T (tren uzunluğu) ve X (başlangıç ​​konumu, 1 endeksli ) olmak üzere üç pozitif tamsayı verildiğinde , göreviniz trenin kuralları takip ederek köprüyü geçene kadar kaç karo hareket ettiğini belirlemektir. yukarıda.

• Şunu varsayabilirsiniz:
  • B , T'den daha yüksektir .
  • X , B'den düşüktür .
  • T en az 2'dir .
  • Tren sonunda köprüyü geçer.
• Tüm standart kurallarımız geçerlidir.
• Bu kod golf, bayt cinsinden en kısa kod kazanır!

Test senaryoları

Giriş ([B, T, X]) -> Çıkış

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

Son test vakası için işe yarayan bir başka örnek:

Köprü 50 uzunluğunda, tren 6 ve başlangıç ​​pozisyonu 11'dir.

          ______
          | ==== |
          | ==== |
--------------------------------------------------
12345678910111213141516171819202122232425262728293

Benzersiz fayanslar: [0, 1, 2]. Toplam: 3.

             ______
             | ==== |
             | ==== |
--------------------------------------------------
12345678910111213141516171819202122232425262728293

Benzersiz fayanslar: [1, 2, 3, 4]. Toplam: 10.

                       ______
                       | ==== |
                       | ==== |
--------------------------------------------------
12345678910111213141516171819202122232425262728293

Benzersiz fayanslar: [1, 7, 8, 9]. Toplam: 25.

                                                ______
                                                | ==== |
                                                | ==== |
--------------------------------------------------
12345678910111213141516171819202122232425262728293

Benzersiz fayanslar: [9, 3]. Toplam: 12.
                                                            ______
                                                            | ==== |
                                                            | ==== |
--------------------------------------------------
12345678910111213141516171819202122232425262728293

Tren köprüsü var. Toplam toplam: 3 + 10 + 25 + 12 = 50.

Kabuk , 20 bayt

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

Çevrimiçi deneyin!

T , B , X sırasıyla üç argüman alır .

açıklama

ṁ←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

Piton 2 , 110 105 104 103 100 97 96 bayt

• Bay Xcoder sayesinde beş bayt tasarruf etti ; gereksiz atama kaldırıldı, olumsuzlama kullanılabilir boşluğa taşındı.
• Bay Xcoder sayesinde bir bayt kurtardı ; golfed [~-x:x+~-t]için[~-x:][:t] .
• Bir bayt kaydedildi; golfed ...range(1,-~b)))[:b]için ...range(b)))[1:-~b].
• Üç bayt kaydedildi; golfed [1:-~b][~-x:]için [:-~b][x:].
• Üç bayt kaydedildi; golfed [:-~b][x:]için [x:-~b].
• Lynn sayesinde bir bayt kurtardı ; whilebir execifadeye döngü golf .

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

Çevrimiçi deneyin!

Haskell, 106102 bayt

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)

Çevrimiçi deneyin!

(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 bayt

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}

Sadece açıklanan algoritmayı uygular.

R iplerde oldukça korkunç.

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
}

Çevrimiçi deneyin!

Jöle ,  22  21 bayt

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

Üç argüman alan tam bir program - sonuç B , X , T'dir - sonucu yazdırır.

Çevrimiçi deneyin!

Nasıl?

ḣ⁵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 bayt

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

Bir çift özyinelemeli fonksiyon:

1. f() trenin hareketlerini toplar.
2. g() sayı dizesi oluşturur.

Daha az 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 bayt

<?$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;

Çevrimiçi deneyin!

PHP'nin alt sürümleriyle uyumlu hale getirmek [,$p,$q,$r]=için list(,$p,$q,$r)=(+4 bayt) olarak değiştirin.

<?
[,$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