Фон

Эта головоломка является вариацией головоломки « четыре четверки» (сама тема прошлого вопроса ). Как и в этой головоломке, цель состоит в том, чтобы найти математические выражения для различных целых чисел, используя только четыре цифры и определенные математические операторы. В этом случае, однако, допустимыми цифрами являются только 2, 0, 1 и 5 . Каждый должен появиться точно один раз в решении и в правильном порядке. Удивительно много целых чисел можно представить таким образом. Решающим рекомендуется сначала попробовать решить их вручную, так как это странно приятно.

правила

Константы могут состоять из одной или нескольких цифр:

• Целые числа: например, 2, 0, 15 и т. Д.
• Десятичные дроби: например .2, .01, 1.5 и т. Д.
• Повторяющиеся десятичные дроби : например .2 ~ (= 0,222 ...), 0,15 ~ (= 0,1555 ...), 20,15 ~~ (= 20,1515 ...)

Разрешены следующие унарные операции:

• Одинарное отрицание: -x
• Квадратный корень: sqrt (x)
• Целочисленный факториал: х!

Разрешены следующие двоичные операции:

• Стандартные арифметические операторы: x + y, xy, x * y и x / y
• Произвольное возведение в степень: x ^ y
• Произвольные корни: rt [x] (y) (= x'ый корень y)

задача

Ваша программа должна распечатать выражения для максимально возможного числа целых чисел от 0 до 100, а затем вывести количество произведенных выражений.

• Решения должны быть напечатаны по порядку в формате n = [expr].
• В выражениях должны использоваться все цифры 2, 0, 1, 5, по одному в каждом порядке.
• Выражения должны быть напечатаны с использованием обозначений, описанных выше. Ненужные скобки разрешены, но не обязательны, как и пробел. Порядок приоритета операторов: унарное отрицание, факториал, возведение в степень, умножение / деление и сложение / вычитание.
• Программа не должна возвращать решения для всех чисел. Программа, которая просто выводит 0, следовательно, действительна; Тем не менее, см. раздел оценки ниже.
• Программа должна работать менее чем за 15 минут на современном компьютере.

Вы можете написать программу или функцию. Выражения должны быть напечатаны в STDOUT (или ближайшую альтернативу). Количество выражений может быть напечатано в STDOUT или возвращено как целое число. Применяются стандартные ограничения гольфа.

Пример вывода

0=2*0*1*5
10=20*1*.5
42=((2+0!)!+1)!/5!
100=20*1*5
4

счет

Обновление : @orlp отметил недостаток в системе подсчета очков. См. Http://meta.codegolf.stackexchange.com/questions/5106/way-of-salvaging-two-zero-one-five-puzzle-challenge для обсуждения того, как или следует ли это исправить.

Решения оцениваются сначала по количеству производимых выражений, а затем по длине кода в байтах. Следовательно, 1000-байтовая программа, которая выдает 80 результатов, превзойдет 100-байтовую программу, которая выдает только 79 (хотя последняя может быть легко расширена для включения отсутствующих результатов).

Для тех, кому нужна мотивирующая цель, ниже приведена нижняя граница числа выражений, которые могут быть представлены. Я не планирую подавать заявку, поэтому вполне возможно выиграть с меньшими затратами!

Как минимум 85 (из 101), хотя вполне может быть и выше.

Табло

В качестве дополнительного стимула, вот краткая информация о прогрессе оценки. Всякий раз, когда вы набираете наивысший балл, не стесняйтесь, чтобы добавить себя в верхней части таблицы (или попросить кого-то еще).

• 0 выражений, 1 байт (Pyth): реализация, которая просто выводит 0

85 ~ 2400 байт

Мне немного грустно, что это проблема кода в гольф, так как я чувствую, что все мои предыдущие усилия были довольно бесполезны теперь, когда я опубликую это:

  0 = ((2*0)^15)
  1 = ((2^0)^15)
  2 = (2-(0^15))
  3 = (20*.15)
  4 = (20*(1/5))
  5 = (20-15)
  6 = ((.20+1)*5)
  7 = ((20*.1)+5)
  8 = (2*((0-1)+5))
  9 = ((.20/.1~)*5)
 10 = (20/(1/.5))
 11 = ((((2-0)+1))!+5)
 12 = (20*(.1+.5))
 13 = ((-(2)-0)+15)
 14 = (20-(1+5))
 15 = ((2*0)+15)
 16 = ((2^0)+15)
 17 = ((2-0)+15)
 18 = (20-(1/.5))
 19 = (20-(1^5))
 20 = (20^(1^5))
 21 = (20+(1^5))
 22 = (20+(1/.5))
 23 = (((2-0)/.1~)+5)
 24 = ((20-1)+5)
 25 = ((20^1)+5)
 26 = ((20+1)+5)
 27 = (rt[.2](((0)!+1))-5)
 28 = (2*(-((0)!)+15))
 29 = ((((2+(0)!)+1))!+5)
 30 = ((2-0)*15)
 31 = (20+sqrt((1+(5)!)))
 32 = ((20*.1)^5)
 33 = ((.2^-((0)!))/.15~~)
 34 = (2+(((0)!+1)^5))
 35 = (20+15)
 36 = (20*(1/.5~))
 37 = (rt[.2](((0)!+1))+5)
 38 = ((20-1)/.5)
 39 = (-((2^0))+(sqrt(.1~)*(5)!))
 40 = (20*(1/.5))
 41 = (((.2~^-((0)!))/.1~)+.5)
 42 = ((20+1)/.5)
 43 = (-(2)+(((0)!/.1~)*5))
 44 = (20+((-(1)+5))!)
 45 = (20/(1-.5~))
 46 = ((.2+((0)!/.1~))*5)
 47 = (2+(((0)!/.1~)*5))
 48 = (2*(((0-1)+5))!)
 49 = ((((2+(0)!))!/.1~)-5)
 50 = (((2^0)/.1)*5)
 51 = ((.2+((0)!/.1))*5)
 52 = (2+(((0)!/.1)*5))
 54 = (((2+(0)!)/.1)/.5~)
 55 = ((2+((0)!/.1~))*5)
 56 = (((.2-(0)!)+sqrt(.1~))*-((5)!))
 58 = (-(2)+sqrt((((((0)!/sqrt(.1~)))!)!*5)))
 59 = ((((2+(0)!))!/.1~)+5)
 60 = (20/(.1~^.5))
 62 = (2*(-((0)!)+sqrt(rt[-(.1)](.5))))
 64 = ((2-0)^(1+5))
 65 = ((20/sqrt(.1~))+5)
 66 = ((-(((2+(0)!))!)/.1~)+(5)!)
 67 = (((((2+(0)!))!)!*.1)-5)
 69 = ((2^(((0)!/sqrt(.1~)))!)+5)
 70 = (((.2^-((0)!))/-(.1))+(5)!)
 72 = ((2+(0)!)*((-(1)+5))!)
 75 = ((.2^-((0)!))*15)
 76 = (rt[(-(2)^-((0)!))](.1~)-5)
 77 = (((((2+(0)!))!)!*.1)+5)
 78 = (2*(-((0)!)+(sqrt(.1~)*(5)!)))
 80 = (-(20)*(1-5))
 81 = (201-(5)!)
 82 = (2*((0)!+(sqrt(.1~)*(5)!)))
 84 = (((.2-(0)!)+.1)*-((5)!))
 85 = (((((2+(0)!))!)!*.1~)+5)
 86 = (rt[(-(2)^-((0)!))](.1~)+5)
 88 = (rt[.2]((-((0)!)-1))+(5)!)
 90 = ((20/.1~)*.5)
 93 = (((2+(0)!)/-(.1~))+(5)!)
 95 = ((20-1)*5)
 96 = ((.20-1)*-((5)!))
 98 = (-(20)*(.1-5))
 99 = ((-(20)-1)+(5)!)
100 = (20/(1/5))
85

С этого момента это просто проблема сжатия. Может быть, я буду соревноваться позже, может быть, я не буду. Для меня большая часть удовольствия заключалась в том, чтобы найти больше формул.

Подсказка для тех, кто пытается написать решатель - время выполнения не должно быть проблемой. Если у вас слишком много формул для проверки, вам нужна лучшая эвристика, чтобы отбрасывать безнадежные решения и дубликаты. Код, который я написал для генерации вышеописанного, работает на Python за ~ 5 секунд.