Pada membingungkan SE ada apa yang disebut "masalah batang korek api" di mana matematika ditulis dalam batang korek api dan Anda diizinkan untuk memindahkan sejumlah tertentu dari mereka untuk mendapatkan properti tertentu.

Dalam pertanyaan ini, kami hanya akan mempertimbangkan bilangan bulat yang direpresentasikan dalam format tampilan 7-segmen. Berikut ini semua 10 digit dalam format itu:

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

Setiap segmen layar adalah satu "korek api" yang dapat dipindahkan secara independen dari sisa nomor tersebut. Batang korek api tidak dapat dibagi dan dihancurkan, yang tidak dapat dipatahkan atau dihilangkan dengan cara apa pun.

Teka-teki yang umum adalah mengambil nomor yang diberikan pada basis 10 dan mencoba membuat jumlah sebanyak mungkin dalam jumlah gerakan tertentu. Suatu gerakan dianggap sebagai satu gerakan batang korek api dari slot yang ditempati ke slot yang tidak diduduki lainnya. Anda benar-benar diizinkan untuk membuat angka baru di kedua sisi nomor, misalnya 0 dapat dibuat menjadi 77 memberi 3 gerakan

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

Namun Anda tidak boleh membuat satu slot menjadi 2 atau membuat slot baru di antara yang sudah ada, misalnya mengubah 4 menjadi 11 di tengah angka atau memasukkan angka baru di antara yang ada. Setiap gerakan tidak perlu membuat angka yang tepat, tetapi hasil akhir harus menjadi angka yang tepat di layar basis tujuh tujuh. Anda tidak perlu menggunakan setiap gerakan jika tidak ingin. Tidak seperti membingungkan, ini adalah [tag: pertanyaan berakhir] Anda tidak boleh menggunakan operator apa pun (perkalian, eksponensial, dll.) Atau konstanta matematika (Pi, nomor Graham, dll.) Dalam jawaban Anda.

Tugas

Tulis program atau fungsi yang mengambil angka dan sejumlah gerakan sebagai input dan mengembalikan angka terbesar yang dapat dibuat dengan banyak gerakan pada angka asli.

Ini adalah pertanyaan kode-golf sehingga jawaban akan dinilai dalam byte, dengan lebih sedikit byte lebih baik.

Uji Kasus

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

Terkait

JavaScript (ES6), 297 286 279 267 byte

Mengambil input dalam sintaks currying (s)(k), di mana s adalah array karakter digit dan k adalah jumlah gerakan (integer).

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

Uji kasus

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

Bagaimana?

Bentuk data dan fungsi pembantu

• Array b menggambarkan bentuk digit sebagai bilangan bulat 7-bit, di mana setiap bit adalah segmen:

  

  Misalnya, bentuk "7" adalah 0b0100101 = 37.

• Fungsi helper B () mengembalikan angka 1 dalam representasi biner dari angka yang diberikan:

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

Langkah 1

Kami pertama menghitung jumlah korek api yang digunakan dalam nomor input:

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

Langkah 2

Kami meneruskan nilai ini ke fungsi rekursif g () , yang mengisi daftar r dengan semua angka yang dapat dibangun dengan tepat jumlah korek api ini:

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

Misalnya, g (5) akan dimuat [ '17', '2', '3', '5', '71' ]ke r .

Langkah # 3

Kita sekarang harus memilih angka M tertinggi dalam r yang sebenarnya dapat diperoleh dari nomor input, dalam jumlah gerakan yang diizinkan k .

Karena setiap angka n dalam r menggunakan tepat sama banyak korek api sebagai jumlah input s , jumlah gerakan yang diperlukan untuk mengubah s menjadi n sama dengan setengah jumlah perbedaan segmen antara masing-masing digit mereka.

Jumlah perbedaan segmen antara dua digit x dan y diberikan oleh angka 1 dalam representasi biner dari b [x] XOR b [y] .

Akhirnya, penting untuk dicatat bahwa kita perlu mencoba beberapa kemungkinan penyejajaran digit, karena digit pertama s belum tentu dipetakan ke digit pertama n . Pergeseran di antara digit diberikan oleh variabel j dalam kode.

Mathematica, 188 197 200 203 170 174 byte

CATATAN: Kode masih agak bermasalah. Saya sedang mengerjakannya.

+30 byte untuk 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)&

Karakter antara %dan oseharusnya 0x7Ftetapi SE tidak akan mengizinkannya. Anda bisa mengklik tautan pastebin untuk menyalin kode asli.

Kode membutuhkan banyak waktu ketika ada lebih dari 6-7 batang. (Anda dapat mengubah nilai awal dari ike jumlah yang lebih kecil untuk mengujinya)

Penjelasan

gadalah fungsi pembantu mengubah digit menjadi daftar representasi tongkat (menurut sini ), seperti {1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1}untuk 220.

h adalah fungsi pembantu untuk menangani padding kiri dan padding kanan antara dua angka.

fberalih dari 10^Tr@g@#(batas atas) untuk 1mencari bilangan bulat yang representasi tongkatnya memiliki jumlah yang sama 1 -> 0dan 0 -> 1dibandingkan dengan angka asli dan jumlahnya lebih kecil atau sama dengan argumen kedua.