Su SE sconcertante ci sono quelli che vengono chiamati "problemi di fiammifero" in cui la matematica è scritta in fiammiferi e ti è permesso di spostarne un certo numero per ottenere una certa proprietà.

In questa domanda considereremo solo numeri interi rappresentati in un formato di visualizzazione a 7 segmenti. Ecco tutte le 10 cifre in quel formato:

 __          __   __          __    __    __    __    __
|  |     |   __|  __|  |__|  |__   |__      |  |__|  |__|
|__|     |  |__   __|     |   __|  |__|     |  |__|   __|    

Ogni segmento del display è un "fiammifero" che può essere spostato indipendentemente dal resto del numero. I fiammiferi sono indivisibili e indistruttibili, non possono essere rotti o rimossi in alcun modo.

Un enigma comune è prendere un numero indicato nella base 10 e provare a rendere il numero più grande possibile in un dato numero di mosse. Una mossa è considerata come un movimento di un fiammifero da qualsiasi slot occupato a qualsiasi altro slot non occupato. Hai perfettamente il permesso di fare nuove cifre su entrambi i lati del numero, ad esempio 0 può essere trasformato in 77 per dare 3 mosse

 __      __  __      __   __      __   __
|  |    |  |        |  |    |       |    |
|__| ,   __|     ,     |      ,     |    |

Tuttavia, non è possibile creare uno slot in 2 o creare nuovi slot tra quelli esistenti, ad esempio trasformando un 4 in un 11 nel mezzo di un numero o inserendo nuove cifre tra quelle esistenti. Ogni mossa non deve necessariamente essere un numero corretto, ma il risultato finale dovrebbe essere un numero corretto nel display a sette segmenti di base 10. Non è necessario utilizzare ogni mossa se non lo si desidera. A differenza di quanto sia enigmatico, questa è una [tag: domanda a risposta chiusa] che non è possibile utilizzare alcun operatore (moltiplicazione, esponenziale, ecc.) O costanti matematiche (Pi, il numero di Graham, ecc.) Nelle risposte.

Compito

Scrivi un programma o una funzione che accetta un numero e un numero di mosse come input e restituisce il numero più grande che può essere fatto con quel numero di mosse sul numero originale.

Questa è una domanda di code-golf, quindi le risposte verranno classificate in byte, con meno byte migliori.

Casi test

n, moves -> max
0, 1     -> 9
0, 3     -> 77
0, 4     -> 111
8, 3     -> 74
220, 1   -> 320
220, 2   -> 520
220, 3   -> 7227
220, 4   -> 22111
220, 5   -> 32111
747, 1   -> 747
747, 2   -> 7171
747, 3   -> 7711

Relazionato

JavaScript (ES6), 297 286 279 267 byte

Accetta input nella sintassi del curry (s)(k), dove s è una matrice di caratteri numerici e k è il numero di mosse (numero intero).

s=>k=>(B=(n,b=0)=>n?B(n^n&-n,b+1):b,b=[...p='u"[k,iy#}m'].map(c=>c.charCodeAt()+2),r=[],g=(n,d='')=>n?n>0&&b.map((v,i)=>g(n-B(v),d+i)):r.push(d))(s.reduce((s,c)=>s+B(b[c]),M=0))&&b.map((_,j)=>r.map(n=>M=[...n+p].reduce((t,d,i)=>t+B(b[d]^b[s[i-j]]),0)>k*2|+n<M?M:n))|M

Casi test

let f=

s=>k=>(B=(n,b=0)=>n?B(n^n&-n,b+1):b,b=[...p='u"[k,iy#}m'].map(c=>c.charCodeAt()+2),r=[],g=(n,d='')=>n?n>0&&b.map((v,i)=>g(n-B(v),d+i)):r.push(d))(s.reduce((s,c)=>s+B(b[c]),M=0))&&b.map((_,j)=>r.map(n=>M=[...n+p].reduce((t,d,i)=>t+B(b[d]^b[s[i-j]]),0)>k*2|+n<M?M:n))|M

console.log("0   / 1 -> " + f([..."0"  ])(1)) // -> 9
console.log("0   / 3 -> " + f([..."0"  ])(3)) // -> 77
console.log("0   / 4 -> " + f([..."0"  ])(4)) // -> 111
console.log("8   / 3 -> " + f([..."8"  ])(3)) // -> 74
console.log("220 / 1 -> " + f([..."220"])(1)) // -> 320
console.log("220 / 2 -> " + f([..."220"])(2)) // -> 520
console.log("220 / 3 -> " + f([..."220"])(3)) // -> 7227
console.log("220 / 4 -> " + f([..."220"])(4)) // -> 22111
console.log("220 / 5 -> " + f([..."220"])(5)) // -> 32111
console.log("747 / 1 -> " + f([..."747"])(1)) // -> 747
console.log("747 / 2 -> " + f([..."747"])(2)) // -> 7171
console.log("747 / 3 -> " + f([..."747"])(3)) // -> 7711

Come?

Dati di forma e funzione di aiuto

• La matrice b descrive le forme delle cifre come numeri interi a 7 bit, dove ogni bit è un segmento:

  

  Ad esempio, la forma di "7" è 0b0100101 = 37.

• La funzione helper B () restituisce il numero di 1 nella rappresentazione binaria di un dato numero:

  B = (n, b = 0) => n ? B(n ^ n & -n, b + 1) : b

Passo 1

Per prima cosa contiamo il numero di fiammiferi utilizzati nel numero di input:

s.reduce((s, c) => s + B(b[c]), 0)

Passo 2

Passiamo questo valore alla funzione ricorsiva g () , che popola un elenco r con tutti i numeri che possono essere costruiti esattamente con questo numero di fiammiferi:

g = (n, d = '') =>
  n ?
    n > 0 &&
    b.map((v, i) => g(n - B(v), d + i))
  :
    r.push(d)

Ad esempio, g (5) verrà caricato [ '17', '2', '3', '5', '71' ]in r .

Passaggio n. 3

Ora dobbiamo selezionare il numero più alto M in r che può effettivamente essere ottenuto dal numero di input, entro il numero consentito di mosse k .

Poiché ogni numero n in r utilizza esattamente altrettanti fiammiferi quanti i numeri di input s , il numero di mosse necessarie per trasformare s in n è uguale alla metà del numero di differenze di segmento tra ciascuna delle loro cifre.

Il numero di differenze di segmento tra due cifre x ed y è dato dal numero di 1 nella rappresentazione binaria di b [x] XOR b [y] .

Infine, è importante notare che dobbiamo provare diversi possibili allineamenti di cifre, poiché la prima cifra di s non è necessariamente mappata alla prima cifra di n . Lo spostamento tra le cifre è dato dalla variabile j nel codice.

Mathematica, 188 197 200 203 170 174 byte

NOTA: il codice è ancora tipo di bug. Ci sto lavorando.

+30 byte per bug

(p=PadLeft;q=IntegerDigits;g=Join@@(#~q~2~p~7&/@ToCharacterCode["w$]m.k{% o"][[1+q@#]])&;h=(v=g@#2~#~96-g@i~#~96;Tr@v==0&&Tr@Abs@v<=2#3)&;For[i=10^Tr@g@#,!h[p,##]&&!h[PadRight,##],--i];i)&

Il personaggio tra %e odovrebbe essere 0x7Fma SE non lo permetterà. È possibile fare clic sul collegamento pastebin per copiare il codice originale.

Il codice impiega molto tempo quando ci sono più di 6-7 stick. (È possibile modificare il valore iniziale di iin un numero più piccolo per testarlo)

Spiegazione

gè una funzione di aiuto che converte le cifre in un elenco di rappresentazioni stick (secondo qui ), come {1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1}per 220.

h è una funzione di aiuto per gestire il padding sinistro e padding destro tra due numeri.

fscorre da 10^Tr@g@#(limite superiore) a 1cercare un numero intero la cui rappresentazione in stick ha una stessa quantità 1 -> 0e 0 -> 1rispetto al numero originale e la quantità è inferiore o uguale al secondo argomento.