Hai bloccato la bici con un lucchetto a combinazione di 3 cifre. Ora vuoi fare un giro e devi sbloccarlo con l'aiuto del seguente programma.

Ingresso

1o parametro

La combinazione di cifre del blocco in stato bloccato . Deve essere diverso dal secondo parametro (= la combinazione di stato sbloccato ). (Oppure la tua bici potrebbe essere rubata!)

Gamma 000..999. Gli zeri iniziali non devono essere omessi.

2o parametro

La combinazione di cifre del blocco in stato sbloccato . Questo valore è il tuo obiettivo.

Gamma 000..999. Gli zeri iniziali non devono essere omessi.

Produzione

Un elenco di ciascuno stato del blocco della combinazione dopo ogni "rotazione" incluso lo stato iniziale (che è sempre il primo parametro) e l'ultimo passaggio (che è sempre il secondo parametro).

Algoritmo

Inizi a "ruotare" la prima cifra una alla volta fino a raggiungere la cifra corretta in stato sbloccato . Tuttavia, poiché si è a conoscenza dell'intero codice di sblocco, si ruota la cifra nella direzione in cui è necessario il minor numero di rotazioni per raggiungere la cifra in stato sbloccato . In caso di pareggio puoi scegliere la direzione che preferisci.

Quando hai raggiunto la prima cifra corretta, inizi la stessa procedura con la seconda e poi con la terza.

L'ordine delle cifre è capire come un cerchio:

... 9 0 1 2 3 4 5 6 7 8 9 0 1 2 ...

Ciò significa che il minor numero di rotazioni da 1 a 9 non lo è

1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 = 8

ma

1 -> 0 -> 9 = 2.

Gli appunti

• Puoi fare affidamento su regole I / O predefinite
• È possibile modificare l'ordine dei parametri.

Esempi

Esempio 1, corretto

Input: 999 001

Output:
999
099
009
000
001

Esempio 2, corretto

Input: 000 292

Output:
000
100
200
290
291
292

Esempio 3, output errato

Input: 999 121

Wrong output:
999
899 // Wrong because wrong rotation direction.
799
699
...

Correct output:
999
099
199
109
119
129
120
121

Esempio 4, input errato

Input: 1 212 // Wrong because no leading zeros.

Questo è code-golf vince la risposta più breve.

Python 2 , 113 107 105 99 95 byte

a,b=input()
i=0
print a
for x in a:
 while x-b[i]:a[i]=x=(x+(x-b[i])%10/5*2-1)%10;print a
 i+=1

Provalo online!

Accetta input come elenchi di numeri interi

Salvato:

• -6 byte, grazie a Joel
• -4 byte, grazie a Jitse

Gelatina , 15 byte

_æ%5ḣT$ṂṠ⁸_%⁵ðƬ

$[0,9]$

Provalo online!

Come?

_æ%5ḣT$ṂṠ⁸_%⁵ðƬ - Link: list of integers, s; list of integers, t
              Ƭ - collect up values until a fixed point is reached applying:
             ð  -   the dyadic chain:  (i.e. f(x, t) where x starts off as s)
_               -     subtract (t from x) (vectorises) - i.e. [ta-xa, tb-xb, tc-xc]
   5            -     literal five
 æ%             -     symmetric modulo (vectorises) - i.e. [[-4..5][ta-xa], [-4..5][tb-xb], [-4..5][tc-xc]]
      $         -     last two links as a monad:
     T          -       truthy indices  - e.g. [0,-4,1]->[2,3]
    ḣ           -       head to index (vectorises)       [[0,-4],[0,-4,1]]
       Ṃ        -     minimum                            [0,-4]
        Ṡ       -     sign (vectorises)                  [0,-1]
         ⁸      -     chain's left argument (x)
          _     -     subtract (vectorises) - i.e. move the single spindle one in the chosen direction
            ⁵   -     literal ten
           %    -     modulo (since 9+1=10 not 0)

JavaScript (ES6),  73 72  70 byte

Salvato 2 byte grazie a @tsh

Accetta input come 2 matrici di cifre nella sintassi curry (a)(b). Restituisce una stringa.

a=>g=b=>b.some(x=>d=x-(a[++i]%=10),i=-1)?a+`
`+g(b,a[i]+=d/5<5/d||9):b

Provalo online!

Commentate

a =>                  // a[] = initial combination
g = b =>              // b[] = target combination
  b.some(x =>         // for each digit x in b[]:
    d =               //   compute the difference d:
      x -             //     between x
      (a[++i] %= 10), //     and the corresponding digit in a[]
                      //     we apply a mod 10, because it may have exceed 9
                      //     during the previous iteration
    i = -1            //   start with i = -1
  ) ?                 // end of some(); if it's truthy:
    a + `\n` +        //   append a[] followed by a line feed
    g(                //   followed by the result of a recursive call:
      b,              //     pass b[] unchanged
      a[i] +=         //     add either 1 or 9 to a[i]:
        d / 5 < 5 / d //       add 1 if d / 5 < 5 / d
        || 9          //       otherwise, add 9
    )                 //   end of recursive call
  :                   // else:
    b                 //   stop recursion and return b[]

Gelatina , 25 byte

_æ%5+⁹⁹rḊ€%⁵J;Ɱ"$ẎṄḢ}⁺¦¥ƒ

Provalo online!

Programma completo.

Python 2 , 101 97 byte

a,c=input()
print a
for i in 0,1,2:
 while a[i]!=c[i]:a[i]=(a[i]+(a[i]-c[i])%10/5*2-1)%10;print a

Provalo online!

3 byte grazie a Joel .

Accetta input come elenchi di ints.

Gelatina , 30 byte

_ż+¥⁵AÞḢṠxAƊ×€ʋ"JṬ€$$Ẏ;@W}+\%⁵

Provalo online!

Un collegamento diadico che assume come argomento di sinistra il codice di sblocco e che a destra lo stato di blocco corrente, entrambi come elenchi di numeri interi.

Sembra troppo lungo!

PHP , 114 byte

for([,$a,$b]=$argv;$i<3;($x=$a[$i]-$b[$i])?(print$a._).$a[$i]=($y=$a[$i]+(5/$x>$x/5?-1:1))<0?9:$y%10:++$i);echo$b;

Provalo online!

La mia soluzione probabilmente fa schifo, ma è la migliore che mi viene in mente per ora!

Carbone , 48 byte

θ≔ＥθＩιθＦ³«≔⁻﹪⁺⁻Ｉ§ηι§θι⁵χ⁵ζＦ↔櫧≔θι﹪⁺§θι÷ζ↔ζχ⸿⪫θω

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

θ

Stampa la posizione iniziale.

≔ＥθＩιθ

Modificare la stringa di posizione iniziale in una matrice di cifre numeriche a scopo di calcolo.

Ｆ³«

Passa sopra ogni cifra a turno.

≔⁻﹪⁺⁻Ｉ§ηι§θι⁵χ⁵ζ

Calcola il numero di rotazioni necessarie per sbloccare quella cifra. Questo è un numero da -5a 4cui -5mezzi 5 rotazioni verso il basso e 4mezzi 4 rotazioni verso l'alto.

Ｆ↔ζ«

Passa sopra ogni rotazione.

§≔θι﹪⁺§θι÷ζ↔ζχ

Aggiorna la cifra in base al segno della rotazione.

⸿⪫θω

Emette le cifre come una stringa su una nuova riga.

T-SQL 2008, 170 byte

Ho aggiunto alcune interruzioni di riga per renderlo leggibile

DECLARE @1 char(3)='123',@2 char(3)='956'

DECLARE @r int,@s int,@ int=0
g:SET @+=1
h:SELECT @r=substring(@1,@,1)+9,@s=@r-substring(@2+'1',@,1)
IF @s=9GOTO g
PRINT @1
SET @1=stuff(@1,@,1,(@r+@s/5%2*2)%10)
IF @<4GOTO h

Provalo online

C # (compilatore interattivo Visual C #) , 101 byte

a=>b=>{for(int i=0;i<3;i++)for(;a[i]!=b[i];a[i]+=(a[i]-b[i]+10)%10<5?9:1,a[i]%=10)Print(a);Print(a);}

Provalo online!

J , 36 byte

10|[+/\@,#:@4 2 1#~[:>&|/`]}10|-,:-~

Provalo online!

Aggiungerò una spiegazione domani.

MATLAB, 100 89 byte

Un approccio diverso (utilizzando l'espansione implicita per creare una matrice di sottrazione) riduce 11 byte:

function f(a,b);c = mod(a-b+5,10)-5;a,mod(a-cumsum(repelem(eye(3).*sign(c),abs(c),1)),10)

[Soluzione originale da 100 byte]

function f(a,b);c=mod(a-b+5,10)-5;a,for n=1:3;for r=1:abs(c(n));a(n)=mod(a(n)-sign(c(n)),10),end;end

Entrambi chiamati passando gli ingressi come matrici a 3 elementi, ad es f([9 1 1], [2 3 2])

Java (JDK) , 139 byte

a->b->{for(int i;;a[i]+=(a[i]-b[i]+10)%10<5?9:1,a[i]%=10){System.out.println(""+a[i=0]+a[1]+a[2]);for(;i<3&&a[i]==b[i];i++);if(i>2)break;}}

Provalo online!

Stesso algoritmo di tutti, implementato diversamente perché quello di Java System.out.printlnè piuttosto costoso!

C (clang) , 125 byte

t,*d;f(*a,*b){for(t=d=a;t?printf("%d%d%d\n",*a,a[1],a[2]):d++,t=*d-b[d-a],d-a<3;*d=(*d+=!~*d*10)%10)t?*d+=(t+10)/5&1?1:-1:0;}

Provalo online!

Kotlin , 162 byte

{s:Array<Int>,e:Array<Int>->var i=0
o@while(i<3){println(""+s[0]+s[1]+s[2])
while(s[i]==e[i]){if(i>1)break@o
i++}
s[i]=(s[i]+if((e[i]-s[i]+10)%10>5)9 else 1)%10}}

Provalo online!