Na łamigłówce SE występują tak zwane „problemy z zapałkami”, w których matematyka zapisywana jest w zapałkach i możesz przesuwać określoną liczbę z nich, aby uzyskać określoną właściwość.

W tym pytaniu rozważymy tylko liczby całkowite reprezentowane w 7-segmentowym formacie wyświetlania. Oto wszystkie 10 cyfr w tym formacie:

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

Każdy segment wyświetlacza to jeden „zapałka”, który można przesuwać niezależnie od reszty numeru. Zapałki są niepodzielne i niezniszczalne, nie można ich w żaden sposób złamać ani usunąć.

Powszechną łamigłówką jest pobranie liczby podanej w bazie 10 i próba uzyskania jak największej liczby w danej liczbie ruchów. Ruch uważa się za jeden ruch zapałki z dowolnego zajętego pola do dowolnego innego niezajętego pola. Zezwala się na tworzenie nowych cyfr po obu stronach numeru, na przykład 0 można przekształcić w 77, co daje 3 ruchy

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

Jednak nie możesz zamienić jednego pola na 2 ani tworzyć nowych pól między istniejącymi, na przykład zamieniając 4 na 11 w środku liczby lub wstawiając nowe cyfry między istniejącymi. Każdy ruch nie musi zawierać poprawnej liczby, ale końcowy wynik powinien być poprawną liczbą na podstawowym wyświetlaczu siedmiosegmentowym. Nie musisz używać każdego ruchu, jeśli nie chcesz. W przeciwieństwie do łamigłówek, jest to [tag: zamknięte pytanie], w odpowiedziach nie można używać żadnych operatorów (mnożenie, potęgowanie itp.) Ani stałych matematycznych (Pi, liczba Grahama itp.).

Zadanie

Napisz program lub funkcję, która pobiera liczbę i liczbę ruchów jako dane wejściowe i zwraca największą liczbę, jaką można wykonać przy tylu ruchach na pierwotnej liczbie.

To jest pytanie w golfa kodu, więc odpowiedzi będą liczone w bajtach, przy czym mniej bajtów będzie lepszych.

Przypadki testowe

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

Związane z

JavaScript (ES6), 297 286 279 267 bajtów

Pobiera dane wejściowe w składni curry (s)(k), gdzie s to tablica cyfr, a k to liczba ruchów (liczba całkowita).

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

Przypadki testowe

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

W jaki sposób?

Dane kształtu i funkcja pomocnicza

• Tablica b opisuje kształty cyfr jako 7-bitowe liczby całkowite, gdzie każdy bit jest segmentem:

  

  Na przykład kształt „7” to 0b0100101 = 37.

• Funkcja pomocnicza B () zwraca liczbę 1 w reprezentacji binarnej podanej liczby:

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

Krok 1

Najpierw liczymy liczbę zapałek użytych w numerze wejściowym:

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

Krok 2

Przekazujemy tę wartość do funkcji rekurencyjnej g () , która zapełnia listę r wszystkimi liczbami, które można zbudować z dokładnie taką liczbą zapałek:

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

Na przykład g (5) załaduje się [ '17', '2', '3', '5', '71' ]do r .

Krok 3

Mamy teraz do wyboru największą liczbą M w R , który w rzeczywistości może być uzyskany z liczby wejściowej, w dozwolonym liczbie ruchów k .

Ponieważ każda liczba n w r zastosowań dokładnie tyle zapałek jako numer wejście s , liczba ruchów wymagane do przekształcenia s do n równa połowie liczby różnic między każdym z segmentów swoich cyfr.

Liczba różnic pomiędzy dwoma segmentami cyfr x i y jest przez liczbę 1 IN binarnej reprezentacji B [x] XOR b [t] .

Na koniec należy zauważyć, że musimy wypróbować kilka możliwych wyrównań cyfr, ponieważ pierwsza cyfra s niekoniecznie jest odwzorowana na pierwszą cyfrę n . Przesunięcie między cyframi daje zmienna j w kodzie.

Mathematica, 188 197 200 203 170 174 bajty

UWAGA: Kod nadal jest trochę błędny. Pracuję nad tym.

+30 bajtów na błąd

(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)&

Znak pomiędzy %i opowinien być, 0x7Fale SE na to nie pozwoli. Możesz kliknąć link pastebin, aby skopiować oryginalny kod.

Kod zajmuje dużo czasu, gdy jest więcej niż 6-7 drążków. (Możesz zmodyfikować wartość początkową ido mniejszej liczby, aby ją przetestować)

Wyjaśnienie

gto funkcja pomocnicza konwertująca cyfry na listę reprezentacji drążka (zgodnie z tutaj ), na przykład {1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1}dla 220.

h jest funkcją pomocniczą do radzenia sobie z lewą i lewą wyściółką między dwiema liczbami.

fiteruje od 10^Tr@g@#(górnego limitu), aby 1szukać liczby całkowitej, której reprezentacja sztyftu ma taką samą ilość 1 -> 0i jest 0 -> 1porównywana z liczbą oryginalną, a ilość ta jest mniejsza lub równa niż drugi argument.