In vari giochi di Super Mario le conchiglie Koopa Troopa verdi e rosse possono scivolare senza attrito su superfici piane e distruggere blocchi di mattoni che si trovano sulla loro strada. Quando una shell colpisce un blocco di mattoni, il blocco si rompe, trasformandolo in uno spazio vuoto e la shell Koopa inverte la direzione. Ad esempio, guarda qui la conchiglia rossa .

Supponiamo che un livello di Super Mario sia alto solo un blocco e che ogni cella della griglia sia un mattone o uno spazio vuoto, ad eccezione della cella più a sinistra che contiene un guscio mobile verso destra. Anche il livello è periodico , quindi se la shell esce dal bordo destro o sinistro del livello, rientrerà dal lato opposto. In questa situazione la shell continuerà a rimbalzare e rompere tutti i blocchi di mattoni nel livello fino a quando non ce ne sono più. Fino a che punto la shell avrà viaggiato dopo la rottura dell'ultimo mattone?

Sfida

Scrivi un programma o una funzione che accetta un numero intero decimale non negativo. Questo numero, espresso in binario senza zeri iniziali (l'unica eccezione è lo stesso 0), codifica il layout di livello alto un blocco. A 1è un blocco di mattoni e a 0è spazio vuoto.

La Koopa Shell è inserita all'estremità sinistra del livello e inizialmente si sta muovendo a destra. Ad esempio, il livello associato all'input 39è

>100111

perché 100111è 39 in binario >e <rappresenta rispettivamente le shell mobili destra e sinistra.

È necessario stampare o restituire la distanza totale percorsa dalla shell una volta che l'ultimo blocco di mattoni (aka 1) è stato rotto.

L'output di 39è 7e le modifiche al livello sono simili alle seguenti:

Level      Cumulative Distance
>100111    0
<000111    0
>000110    0
0>00110    1
00>0110    2
000>110    3
000<010    3
00<0010    4
0<00010    5
<000010    6
000001<    7
000000>    7  <-- output

Allo stesso modo, l'output per 6è 1:

Level    Cumulative Distance
>110     0
<010     0
001<     1
000>     1  <-- output

Vince il codice più breve in byte.

Per riferimento, ecco le uscite per gli ingressi 0a 20:

0 0
1 0
2 0
3 0
4 0
5 0
6 1
7 1
8 0
9 0
10 1
11 2
12 2
13 1
14 3
15 3
16 0
17 0
18 1
19 3
20 2

E qui ci sono le uscite fino all'input 1000.

CJam, 29 26 24 byte

Grazie a Sp3000 per aver salvato 3 byte.

q~2b{_1&}{W\({%}*0+}w],(

Suite di test. (Questo stampa tutti i risultati da 0 all'intero dato su STDIN.)

Spiegazione

Questo trasforma un po 'la specifica sulla sua testa: invece di spostare la shell attraverso la stringa binaria, spostiamo e invertiamo la stringa binaria in modo che la shell sia sempre in primo piano, puntando a destra:

q~      e# Read and evaluate the input.
2b      e# Convert to base-2 to get the "level".
{_1&}{  e# While there is a 1 in the level...
  W\    e#   Put a -1 below the level.
  (     e#   Pull off the first digit, i.e. the cell the shell is pointing at.
  {     e#   If it's a 1 (i.e. a brick)...
    %   e#     Reverse the level, consuming the -1. This isequivalent to reversing the 
        e#     shell in place.
  }*
  0+    e#   Append a zero. If the cell was a brick, this just replaces it with an empty
        e#   cell. Otherwise, this rotates the level by one cell. This is equivalent 
        e#   to moving the shell one cell through the periodic level.
        e#   Note that if the leading cell was 0, the -1 remains on the stack.
}w
],(     e# Wrap the stack in an array, get its length and decrement.

Pyth, 24 byte

&.WsH_XZeaYxZ1 0jQ2ssPBY

Provalo online: Dimostrazione o Test Suite

Anche il seguente codice di 22 byte dovrebbe essere utile. Al momento non funziona a causa di un bug nel compilatore Pyth.

&u_XGeaYxG1ZjQ2)ssPBPY

modifica: bug corretto, ma ovviamente la soluzione non conta.

Provalo online: Dimostrazione o Test Suite

Spiegazione:

In alternanza dalla parte anteriore e posteriore faccio quanto segue:

• Cerco un 1
• Ricorda questo indice inserendolo in un elenco
• Aggiorna questo 1 su uno 0

Quando non sono rimasti 1 secondi, calcolo la distanza. Importante: la shell sposta ogni distanza nell'elenco due volte (avanti e indietro), tranne l'ultima distanza.

&.WsH_XZeaYxZ1 0jQ2ssPBY   implicit: Y = empty list
                jQ2        convert input number to binary
 .WsH                      start with Z=^; 
                           while the sum(Z) > 0, apply the the following to Z:
           xZ1                index of 1 in Z
         aY                   append this to Y
        e                     take the last element of Y (=this index)
      XZ       0              set this 1 (at index ^) in Z to 0
     _                        and revert the order of Z
                           this returns a list of zeros
&                          don't print ^, print the next thing
                     PBY   creates the list [Y, Y[:-1]]
                    s      combine these lists
                   s       sum up the distances