Considere un puente de longitud B formado por mosaicos etiquetados con los dígitos de los enteros positivos concatenados. Por ejemplo, si B era 41, entonces se vería así:

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

Ahora imagine un tren de longitud T cruzando el puente. El punto más a la izquierda del tren comienza en la posición X (1 indexado). Para comprender mejor el problema, hagamos un esquema del evento, con B = 41, T = 10, X = 10 . El tren se dibuja usando signos iguales ( =) y líneas:

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

El tren puede avanzar, en cada paso, por la suma de las fichas únicas en las que se encuentra. Por ejemplo, los mosaicos en los que se encuentra el tren arriba son:, [1, 0, 1, 1, 1, 2, 1, 3, 1, 4]los mosaicos únicos (deduplicados) son: [1, 0, 2, 3, 4]y su suma es 10. Por lo tanto, el tren puede avanzar por 10fichas. Deberíamos dibujarlo nuevamente y repetir el proceso hasta que el punto más a la izquierda del tren haya pasado el último mosaico:

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

Suma de fichas únicas: 1 + 5 + 6 + 7 + 8 + 9 = 36. El tren avanza en 36 fichas ...

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

El tren obviamente cruzó el puente por completo, así que deberíamos parar ahora.

Como las personas que están dentro están aburridas, cuentan las fichas que el tren ha avanzado cada vez. En este caso específico, 10y 36. Resumiendo todo, el tren se movió 46antes de pasar el puente.

Tarea

Dados tres enteros positivos, B (la longitud del puente), T (la longitud del tren) y X (la posición inicial, indexada en 1 ), su tarea es determinar cuántas fichas ha movido el tren hasta que cruzó el puente siguiendo las reglas encima.

• Puedes asumir que:
  • B es mayor que T .
  • X es menor que B .
  • T es al menos 2 .
  • El tren finalmente cruza el puente.
• Se aplican todas nuestras reglas estándar.
• Este es el código de golf , por lo que gana el código más corto en bytes.

Casos de prueba

Entrada ([B, T, X]) -> Salida

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

Otro ejemplo trabajado para el último caso de prueba:

El puente tiene una longitud 50, el tren 6 y la posición inicial es 11.

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

Fichas únicas: [0, 1, 2]. Suma: 3.

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

Fichas únicas: [1, 2, 3, 4]. Suma: 10.

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

Fichas únicas: [1, 7, 8, 9]. Suma: 25.

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

Fichas únicas: [9, 3]. Suma: 12.
                                                            ______
                                                            | ==== |
                                                            | ==== |
--------------------------------------------------
12345678910111213141516171819202122232425262728293

El tren existe el puente. Suma total: 3 + 10 + 25 + 12 = 50.

Casco , 20 bytes

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

Pruébalo en línea!

Toma tres argumentos en orden T , B , X .

Explicación

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

• Ahorré cinco bytes gracias al Sr. Xcoder ; eliminó la asignación innecesaria, movió la negación al espacio en blanco disponible.
• Ahorré un byte gracias al Sr. Xcoder ; golf [~-x:x+~-t]a [~-x:][:t].
• Guardado un byte; golf ...range(1,-~b)))[:b]a ...range(b)))[1:-~b].
• Guardado tres bytes; golf [1:-~b][~-x:]a [:-~b][x:].
• Guardado tres bytes; golf [:-~b][x:]a [x:-~b].
• Salvó un byte gracias a Lynn ; Golfing el whilebucle a una execdeclaración.

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

Pruébalo en línea!

Haskell, 106 102 bytes

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)

Pruébalo en línea!

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

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}

Solo implementa el algoritmo descrito.

R es bastante terrible en las cuerdas.

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
}

Pruébalo en línea!

Jalea ,  22  21 bytes

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

Un programa completo que toma tres argumentos: el orden es B , X , T , que imprime el resultado.

Pruébalo en línea!

¿Cómo?

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

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

Un par de funciones recursivas:

1. f() suma los movimientos del tren.
2. g() crea la cadena de números.

Menos golfizado:

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 bytes

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

Pruébalo en línea!

Para hacerlo compatible con versiones anteriores de PHP, cambie [,$p,$q,$r]=a list(,$p,$q,$r)=(+4 bytes).

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