Sfida del numero di serpenti

Mi chiedo quanti numeri serpeggianti ci siano tra 1 e 50.000?

I numeri serpeggianti, in questo gioco, sono numeri che possono essere digitati su un tastierino numerico tradizionale (formato sotto) spostando un tasto verso l'alto, il basso, a sinistra o a destra.

7 8 9
4 5 6
1 2 3
 0

Ad esempio, se inizi con il numero 5, puoi selezionare 4, 6, 8 o 2 come prossima mossa valida, tuttavia 7, 3, 9 e 1 sono off-limits in quanto sono posizionati in diagonale rispetto al tasto corrente . Pertanto, se si dispone di 5, quindi 2, le scelte chiave successive successive sono nuovamente 0, 1, 3 o 5.

In questo esercizio di Code Golf, dovrai produrre un elenco di tutti i numeri di serpente positivi tra 1 e 50k, insieme a un conteggio finale di tutti i numeri che soddisfano il criterio.

Regole

1. I numeri non possono iniziare con uno zero.
2. I numeri devono essere numeri interi interi positivi.
3. Ogni numero consecutivo, letto da sinistra a destra, deve "scorrere" attorno al tastierino numerico.
4. Il serpente non può viaggiare in diagonale tra i tasti
5. È possibile accedere al numero 0 da entrambi i numeri 1 e 2
6. I numeri non possono essere associati (ad es. 22)

Esempi di numeri di serpenti validi:

12369
45201
1254
10102
1
12
987

Esempi di numeri non validi

1238 - 8 is not connected
0001 - multiple leading 0s
0101 - leading 0
159  - snake cannot travel diagonally
4556 - duplicate 5

Come da normali Code Golf, l'obiettivo è il minor numero di byte!

Secondo la mia matematica e le mie regole, dovresti avere 670 numeri di serpenti validi nella tua lista, più 670 stessi stampati come ultimo numero.

K (ngn / k) , 60 57 byte

(x;#x:{*/1=3!5&+/x*x:+1_-':(+0 1,'2*!3 3)@10\x}#1+!50000)

Provalo online!

!50000elenco di 0..49999

1+ aggiungi 1 a tutti

{ }# filtro con la funzione in { }

10\x cifre decimali dell'argomento

( )@ usa come indici in ...

• !3 3 una coppia di liste: (0 0 0 1 1 1 2 2 2;0 1 2 0 1 2 0 1 2)

• 2* moltiplicare tutto per 2

• 0 1,'anteporre 0al primo elenco e 1al secondo

• +trasporre (coppia di liste -> lista di coppie). questo ci dà le coordinate dei pulsanti circa.

-':sottrarre da ciascuna coppia la coppia precedente. usare 0 0come elemento immaginario prima del primo.

1_ rilascia il primo

+ trasporre

x*x:quadrato (assegnare a xe moltiplicare per x). ecco xun paio di liste - ∆xs e ∆ys

+/ sommare le due liste (elemento per elemento)

5& min con 5

3! mod 3

1= elenco booleano di dove è uguale a 1

*/ prodotto (booleano "e")

(x;#x: )crea una coppia del risultato e la lunghezza ( #) del risultato

Gelatina ,  24  23 byte

5ȷ4µDo1.’d3ZIASĊ’ẸµÐḟṄL

Un programma completo che stampa un elenco di tutti i risultati e quindi il numero di risultati.

Provalo online!

Come?

5ȷ4µDo1.’d3ZIASĊ’ẸµÐḟṄL - Main Link: no arguments
5ȷ4                     - 5*10^4 = 50000
   µ              µÐḟ   - filter discard those for which this is truthy:
                        -                  e.g.: 8520        ... or           4559 
    D                   -   decimal digits       [8,5,2,0]                    [4,5,5,9]
      1.                -   literal 1.5
     o                  -   logical OR           [8,5,2,1.5]                  [4,5,5,9]
        ’               -   decrement            [7,4,1,0.5]                  [3,4,4,8]
         d3             -   div-mod by 3         [[2,1],[1,1],[0,1],[0,0.5]]  [[1,0],[1,1],[1,1],[2,2]]
           Z            -   transpose            [[2,1,0,0],[1,1,1,0.5]]      [[1,1,1,2],[0,1,1,2]]
            I           -   deltas               [[-1,-1,0],[0,0,-0.5]]       [[0,0,1],[1,0,1]]
             A          -   absolute value       [[1,1,0],[0,0,0.5]]          [[0,0,1],[1,0,1]]
              S         -   sum (vectorises)     [1,1,0.5]                    [1,0,2]
               Ċ        -   ceiling              [1,1,1]                      [1,0,2]
                ’       -   decrement            [0,0,0]                      [0,-1,1]
                 Ẹ      -   any?                 0 (i.e. keep)                1 (i.e. discard)
                     Ṅ  - print and yield
                      L - length
                        - implicit print

Python 3 , 140 byte

f=lambda s:''==s[1:]or s[1]in'10021234562216565878 43 749 9   5  8'[int(s[0])::10]and f(s[1:])
print(*filter(f,map(str,range(1,50000))),670)

Provalo online!

Sono sicuro che qualcuno sarà in grado di farlo con un'espressione anziché una stringa di ricerca.

Python 2 , 101 byte

print[n for n in range(1,50000)if all(`n`[i:i+2]in`0x20b33ec8bc49a10589e76b15`for i in range(4))],670

Provalo online!

Il numero esadecimale è decimale 10120214525632365878969854741, che codifica per ogni coppia ordinata di cifre che possono apparire adiacenti l'una all'altra.

JavaScript (V8) ,  112106  104 byte

Salvato 2 byte grazie a @NahuelFouilleul

Un programma completo.

for(n=0;++n<5e4;)[...n+''].every(x=>'6589632145201478'.match(x+p+'|'+p+(p=x)),p='')&&print(n)
print(670)

Provalo online!

O 96 byte se possiamo generare i numeri in ordine inverso:

for(n=5e4;n--;)[...n+''].every(x=>'6589632145201478'.match(x+p+'|'+p+(p=x)),p='')&&print(n||670)

Provalo online!

Stax , 37 35 byte

ü╞╡~▄ⁿ♪eµïê◙ü╔ï▼ΔJr¥æ≤PH╟♀I♣Δz8─¶Γ╞Ç▓

Eseguilo e esegui il debug su staxlang.xyz!

Era così bello e corto, fino a quando non lo era.

Spacchettato (42 byte) e spiegazione

49999{E2B{{om"#qYY>!(AFI"%A|E2B{{om-C_Qf%p
49999{                                 f      Filter range [1..49999]:
      E2B                                       All adjacent pairs of digits
         {{om                                   Each sorted
             "#qYY>!(AFI"%A|                    Literal 2012365478963258741
                            E2B{{om             Pairs of digits, each sorted
                                   -            Set difference
                                    C           Cancel block execution if any remain
                                     _Q         Print current value
                                        %p    Print length

2012365478963258741 codifica la tastiera. Guarda le coppie di cifre adiacenti. Forse se potessi ottenere un'alternativa abbastanza breve che vada in entrambe le direzioni per ogni coppia, potrei tagliare gli otto byte di {{om.

Senza quel 670 finale, basterebbe un semplice filtro: f..!invece di {..C_Qf%p. Potrebbe esserci un modo migliore per gestire questa irregolarità. In entrambi i casi, questo comportamento della gamma di filtri non è documentato.

PHP , 145 byte

for(;$i++<5e4;$f&&print$i._)for($f=1,$l=b;''<$d=("$i")[$$i++];$l=$d)$f&=$l>a||strstr([12,240,1053,26,157,2468,359,48,579,68][$l],$d)>'';echo 670;

Provalo online!

Per ogni numero compreso tra 1 e 50.000, controlla ogni cifra di quel numero da sinistra a destra. Se tutte le cifre sono nell'elenco delle cifre valide della cifra precedente, quel numero viene stampato. Alla fine stampa un hard coded 670 poiché richiede meno byte rispetto al conteggio effettivo.

05AB1E , 23 byte

ŽÅKLʒSÌYX;:3‰üαï€OP}=g=

Provalo online!

La risposta della gelatina di Port of Jonathan Allan .

Perl 5 ( -M5.01), 96 , 92 byte

-4 byte grazie a @Xcali

$r=join"|",map$t++."[^$_]",12,240,1350,26,157,2648,359,48,579,68;map/$r/||say,1..5e4;say 670

TIO

JavaScript (SpiderMonkey) , 179 173 151 129 byte

[12,240,1350,26,157,2468,359,48,579,68].map((_,i,l)=>i&&(f=(v,t)=>print(v)|v<5e3&&[...l[t]+''].map(k=>f(v+k,k)))(i,i)),print(670)

Provalo online!

-22 byte grazie ad Arnauld -22 byte grazie a dana

spiegazione:

[12,240,1350,26,157,2468,359,48,579,68] 
// an array where keys are current position and values, the possible destinations
.map((_,i,l)=>                    // loop over it
    i&&(                          // if key is not 0
        f=(v,t)=>                 // create a function
                 print(v)|        // which print the value
                          v<5e3&& // and if the limit is not attained
                                 [...l[t]+''].map(k=>f(v+k,k)) 
                    // recurcively call itself with for each destinations
                                                              )(i,i)),
                    // make the first call with each digit
print(670) // finally print 670

@dana ha anche fornito una soluzione di 123 byte se prima possiamo stampare 670

[21,420,5310,62,751,8642,953,84,975,86].map((_,i,a)=>(f=(v,t)=>print(i?v:640)|i&v<5e3&&[...a[t]+''].map(k=>f(v+k,k)))(i,i))

Rubino , 99 byte

1.upto(5e4){|n|w,*x=n.digits;x.all?{|d|[6,21,43,68,162,340,552,272,672,320][w][w=d]>0}&&p(n)}
p 670

Provalo online!

Stax , 28 26 byte

Δh┤♣É╦&·é╝n$K»à¶▲v═NÆ;↨m≥8

Esegui ed esegui il debug

Disimballato, non golfato e commentato, sembra così.

G               Call to unbalanced trailing '}', then resume here
670P            Print 670
}               Call target
219J            219 squared (47961)
f               Filter 1-based range by the rest of the program; implicitly output
  $2B           Convert to string and get adjacent pairs; e.g. 213 -> ["21", "13"]
  O             Push 1 under list of pairs
  F             Iterate over pairs, using the rest of the program
    o           Order each pair; e.g. "21" -> "12"
    "{<f:[/T8Z" string literal with code points [123 60 102 58 91 47 84 56 90]
    $           concate as string i.e. "12360102589147845690"
    s#          How many times does the current pair appear in the constant string?
    *           Multiply this by running total.  Any zero will cause the result to be zero.

Esegui questo

La salsa segreta è nella stringa letterale "{<f:[/T8Z". Dopo aver inceppato tutti i punti di codice insieme, ottieni 12360102589147845690. Le coppie ascendenti in questa stringa sono le mosse valide del serpente.

Haskell , 118 byte

(filter(and.(zipWith elem.tail<*>map f).show)[1..50000],670)
f c=words"12 024 0135 26 157 2468 359 48 579 68"!!read[c]

Provalo online!

Un primo passaggio; Non sono bravo a compressione.

Il s=non conta, dal momento che non abbiamo effettivamente bisogno di legare il risultato.

Codice Ungolfed .

Carbone , 42 byte

≔ΦＩ…·¹×⁵⁰φ⬤ι№”)¶∧XRτ_ΠＧêＲ⁵m⎇λ”✂ιμ⁺²μ¹θθＩＬθ

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

≔ΦＩ…·¹×⁵⁰φ

Elabora l'intervallo compreso da 1a 50,000cast a string.

⬤ι№”)¶∧XRτ_ΠＧêＲ⁵m⎇λ”✂ιμ⁺²μ¹θ

Filtra quelli che hanno coppie di cifre non contenute nella stringa compressa 01478963202125458565236987410.

θＩＬθ

Emette l'array rimanente e la sua lunghezza.

Japt , 34 byte

5e4õs f_ä@"-Pì[/Z8"mc øZñÃe
pUl

Provalo

Perl 6 , 64 byte

{670,grep {[+&](:36<12HGX91H8VCL3MG0FDVQ>X+>m:ov/../)%2},1..5e4}

Provalo online!

Spiegazione

{670,grep {...},1..5e4}  # Meet questionable output requirements

# Actual decision problem

     :36<12HGX91H8VCL3MG0FDVQ>  # Bit field of allowed transitions
                                # encoded in base 36
                                 m:ov/../  # All 2-digit substrings
                              X+>  # Right shift by each substring
                                   # (implicitly converted to an integer)
[+&](                                    )  # Binary and
                                          %2  # Modulo 2

Pyth , 68 65 45 byte

l
f.Am}dCtB+J`65874589632012541_PJCtB`TS50000

Provalo online!

L'ispirazione per il processo di ricerca rivisto è venuta dalla risposta Stax di Khuldraeseth na'Barya , vai a dare loro un voto!

Modifica 2: riscritto per salvare un mucchio di byte, versione precedente:

l
f.Am}ed@c"12 024 0135 26 157 2468 359 48 579 68";shdCtB`TS50000

Modifica: golfato 3 byte utilizzando ricerche di stringhe, versione precedente:

l
f.Am}ed@sMMc"12 024 0135 26 157 2468 359 48 579 68";hdCtBjT;S50000