На головоломки SE є так звані "проблеми з matchstick", в яких математика записується на сірники, і вам дозволяється переміщувати певну їх кількість, щоб отримати певну властивість.

У цьому питанні ми розглянемо лише цілі числа, представлені у 7-сегментному форматі відображення. Ось усі 10 цифр у такому форматі:

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

Кожен сегмент дисплея - це одна "сірник", яку можна переміщувати незалежно від решти числа. Сірники нероздільні і незнищенні, їх неможливо зламати або видалити будь-якими способами.

Загальна головоломка - взяти число, вказане в базі 10, і спробувати зробити якомога більшу кількість за певну кількість рухів. Переміщення вважається одним рухом відповідника від будь-якого займаного гнізда до будь-якого іншого незайнятого слота. Вам цілком дозволено робити нові цифри по обидві сторони від числа, наприклад 0 може бути зроблено в 77 дати 3 ходи

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

Однак ви не можете робити один слот на 2 або створювати нові проміжки між існуючими, наприклад, перетворити 4 на 11 посередині числа або вставити нові цифри між існуючими. Кожен хід не повинен вносити належне число, але кінцевим результатом має бути відповідне число в базовому 10 семи сегментовому дисплеї. Вам не потрібно використовувати кожен хід, якщо цього не бажаєте. На відміну від загадки, це [тег: запитання із закритим завершенням], ви можете не використовувати жодних операторів (множення, експоненцію тощо) або математичних констант (Pi, число Грема тощо) у своїх відповідях.

Завдання

Напишіть програму або функцію, яка приймає число і кількість рухів як вхідних даних і повертає найбільшу кількість, яку можна зробити за допомогою такої кількості ходів за початковим номером.

Це питання з кодовим гольфом, тому відповіді будуть набиратись у байтах, при цьому менше байтів буде кращим.

Випробування

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

Пов'язані

JavaScript (ES6), 297 286 279 267 байт

Приймає введення в синтаксис currying (s)(k), де s - масив знакових знаків і k - кількість ходів (ціле число).

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

Тестові справи

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

Як?

Форма даних та функція помічника

• Масив b описує фігури цифр як 7-бітні цілі числа, де кожен біт є сегментом:

  

  Наприклад, форма "7" дорівнює 0b0100101 = 37.

• Хелперна функція B () повертає число 1 у двійковому поданні даного числа:

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

Крок 1

Спочатку підраховуємо кількість сірників, використаних у вхідному номері:

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

Крок №2

Ми передаємо це значення рекурсивній функції g () , яка заповнює список r із усіма числами, які можна побудувати саме з цією кількістю відповідних рядків:

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

Наприклад, g (5) завантажиться [ '17', '2', '3', '5', '71' ]в r .

Крок №3

Тепер ми маємо вибрати найбільше число M в r, яке фактично можна отримати із вхідного числа, у межах дозволеної кількості ходів k .

Оскільки кожне число n в r використовує рівно стільки відповідних рядків, скільки вхідне число s , кількість ходів, необхідних для перетворення s в n, дорівнює половині кількості різниць сегмента між кожною з їхніх цифр.

Кількість відрізків відрізків між двома цифрами x і y задається числом 1's у двійковому поданні b [x] XOR b [y] .

Нарешті, важливо зазначити, що нам потрібно спробувати декілька можливих вирівнювань цифр, оскільки перша цифра s необов'язково відображається на першій цифрі n . Зсув між цифрами задається змінною j в коді.

Математика, 188 197 200 203 170 174 байти

ПРИМІТКА . Код все ще є непогашеним. Я над цим працюю.

+30 байт для помилки

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

Символ між %і oповинен бути, 0x7Fале SE це не дозволить. Ви можете натиснути посилання на пастину, щоб скопіювати оригінальний код.

Код займає багато часу, коли є більше 6-7 паличок. (Ви можете змінити початкове значення iна менший номер, щоб перевірити його)

Пояснення

g- це допоміжна функція, що перетворює цифри у список подання палиць (відповідно до цього ), наприклад {1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1}для 220.

h є допоміжною функцією для боротьби з лівою та правою накладкою між двома номерами.

fітераціює з 10^Tr@g@#(верхньої межі), щоб 1шукати ціле число, представлення палиці має однакову кількість 1 -> 0і 0 -> 1порівняно з вихідним числом, а кількість менша або дорівнює другому аргументу.