พิจารณาสะพานที่มีความยาวB ที่เกิดขึ้นจากการเรียงต่อกันที่มีป้ายกำกับด้วยตัวเลขของจำนวนเต็มบวก ตัวอย่างเช่นถ้าBเป็น 41 แล้วมันจะมีลักษณะเช่นนี้:

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

ทีนี้ลองนึกภาพรถไฟที่มีความยาวTข้ามสะพาน จุดซ้ายสุดของรถไฟเริ่มต้นที่ตำแหน่งX (ดัชนี 1 ตำแหน่ง) ที่จะได้รับความเข้าใจที่ดีขึ้นของปัญหาที่เกิดขึ้นขอให้โครงการของเหตุการณ์ที่มีB = 41, T = 10, X = 10 รถไฟถูกลากโดยใช้เครื่องหมายเท่ากับ ( =) และเส้น:

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

รถไฟสามารถเลื่อนในแต่ละขั้นตอนโดยรวมของกระเบื้องที่ไม่ซ้ำกันที่ตั้งอยู่บน ยกตัวอย่างเช่นกระเบื้องรถไฟยืนอยู่บนข้างต้นเป็น: [1, 0, 1, 1, 1, 2, 1, 3, 1, 4]ที่ไม่ซ้ำกัน (ซ้ำ) กระเบื้อง: และผลรวมของพวกเขาคือ[1, 0, 2, 3, 4] 10ดังนั้นรถไฟสามารถเลื่อนด้วย10กระเบื้อง เราควรวาดอีกครั้งและทำซ้ำจนกว่าจุดซ้ายสุดของรถไฟผ่านกระเบื้องสุดท้าย:

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

ผลรวมของไพ่ที่ไม่ซ้ำกัน: 1 + 5 + 6 + 7 + 8 + 9 = 36 ขบวนรถไฟก้าวหน้าโดย 36 แผ่น ...

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

เห็นได้ชัดว่ารถไฟข้ามสะพานอย่างสมบูรณ์ดังนั้นเราควรหยุดตอนนี้

เนื่องจากผู้คนที่อยู่ข้างในรู้สึกเบื่อพวกเขาจึงนับไพ่ที่รถไฟแล่นได้ในแต่ละครั้ง ในกรณีนี้โดยเฉพาะและ10 36เมื่อสรุปทุกอย่างแล้วรถไฟก็ขยับ46ก่อนที่จะผ่านสะพาน

งาน

เมื่อได้รับจำนวนเต็มบวกสามตัวคือB (ความยาวสะพาน), T (ความยาวรถไฟ) และX (ตำแหน่งเริ่มต้น, ดัชนี 1ตำแหน่ง) งานของคุณคือกำหนดจำนวนกระเบื้องที่รถไฟเคลื่อนที่จนกว่าจะข้ามสะพานตามกฎ ข้างบน.

• คุณสามารถสันนิษฐานได้ว่า:
  • Bสูงกว่าT
  • Xต่ำกว่าB
  • Tอย่างน้อย2
  • ในที่สุดรถไฟก็ข้ามสะพาน
• ใช้กฎมาตรฐานทั้งหมดของเรา
• นี่คือ รหัสกอล์ฟดังนั้นรหัสที่สั้นที่สุดในหน่วยไบต์ชนะ!

กรณีทดสอบ

อินพุต ([B, T, X]) -> เอาต์พุต

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

อีกตัวอย่างการทำงานสำหรับกรณีทดสอบล่าสุด:

สะพานมีความยาว 50, รถไฟ 6, และตำแหน่งเริ่มต้นคือ 11

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

แผ่นที่ไม่ซ้ำกัน: [0, 1, 2] รวม: 3

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

แผ่นที่ไม่ซ้ำกัน: [1, 2, 3, 4] รวม: 10

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

แผ่นที่ไม่ซ้ำกัน: [1, 7, 8, 9] รวม: 25

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

กระเบื้องที่ไม่ซ้ำกัน: [9, 3] รวม: 12
                                                            ______
                                                            | ==== |
                                                            | ==== |
--------------------------------------------------
12345678910111213141516171819202122232425262728293

รถไฟมีสะพาน ผลรวมทั้งหมด: 3 + 10 + 25 + 12 = 50

Husk , 20 ไบต์

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

ลองออนไลน์!

ใช้เวลาสามข้อโต้แย้งในการสั่งซื้อT , B , X

คำอธิบาย

ṁ←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 ไบต์

• บันทึกห้าไบต์ต้องขอบคุณMr. Xcoder ; นำการมอบหมายที่ไม่จำเป็นออกแล้วย้ายการปฏิเสธไปยังช่องว่างที่มีอยู่
• บันทึกเป็นไบต์ขอบคุณMr. Xcoder ; แข็งแรงเล่นกอล์ฟไป[~-x:x+~-t][~-x:][:t]
• บันทึกเป็นไบต์ แข็งแรงเล่นกอล์ฟไป...range(1,-~b)))[:b]...range(b)))[1:-~b]
• บันทึกสามไบต์ แข็งแรงเล่นกอล์ฟไป[1:-~b][~-x:][:-~b][x:]
• บันทึกสามไบต์ แข็งแรงเล่นกอล์ฟไป[:-~b][x:][x:-~b]
• บันทึกขอบคุณไบต์ลินน์ ; กอล์ฟwhileวงไปยังexecคำสั่ง

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

ลองออนไลน์!

Haskell, 106 102 ไบต์

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)

ลองออนไลน์!

(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 ไบต์

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}

เพียงใช้อัลกอริทึมที่อธิบายไว้

R ค่อนข้างแย่ในสายอักขระ

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
}

ลองออนไลน์!

เยลลี่ ,  22  21 ไบต์

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

โปรแกรมเต็มรูปแบบที่รับสามอาร์กิวเมนต์ - คำสั่งซื้อคือB , X , T - ซึ่งพิมพ์ผลลัพธ์

ลองออนไลน์!

อย่างไร?

ḣ⁵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 ไบต์

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

ฟังก์ชั่นวนซ้ำ:

1. f() ผลรวมของการเคลื่อนไหวของรถไฟ
2. g() สร้างสตริงของตัวเลข

หักกอล์ฟ:

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 ไบต์

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

ลองออนไลน์!

เพื่อให้เข้ากันได้กับ PHP เวอร์ชันที่ต่ำกว่าให้เปลี่ยน[,$p,$q,$r]=เป็นlist(,$p,$q,$r)=(+4 ไบต์)

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