# N times program for the N-th number

## Perl 5 -p, generates Perl 5 -p, overhead 1917 13

-1 thanks to @Dom Hastings

The score for one input will be length of the input + 13. Can obviously be improved by generating self-decompressing programs for larger inputs, but I won't bother.

Give the input array separated by commas on one line on STDIN.

#!/usr/bin/perl -p
chomp;$_="}{\$_=($_)[\$%++]"


Try it online!

Run the output concatenated n times with no input (e.g. redirect from /dev/null)

Sample way to run it for input 2,6,4,7 and the resulting program repeated 4 times:

perl -p '}{$_=(3,6,4,7)[$%++]}{$_=(3,6,4,7)[$%++]}{$_=(3,6,4,7)[$%++]}{$_=(3,6,4,7)[$%++]' < /dev/null


Try it online!

If you don't like the resulting program trying to read from STDIN use this version with overhead 17:

#!/usr/bin/perl -p
chomp;$_="1/!say+($_)[\$-++],"  Try it online! Sample way to run it for input 2,6,4,7 and the resulting program repeated 4 times: perl -E '1/!say+(2,6,4,7)[$-++],1/!say+(2,6,4,7)[$-++],1/!say+(2,6,4,7)[$-++],1/!say+(2,6,4,7)[$-++],'  Try it online! This version crashes after printing the required output ## Python 3, generates Stax This uses a variety of strategies. Most strategies only apply under certain conditions, but there's one fallback strategy that is always usable. At the end, the smallest candidate program is selected.  from functools import reduce from math import sqrt symbols = " !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_abcdefghijklmnopqrstuvwxyz{|}"

def uncycle(arr):
for size in range(1, len(arr)):
if all(e == arr[i % size] for (i, e) in enumerate(arr)):
return arr[:size]
return arr

def constant(val):
return "A" if val == 10 else str(val)

def shift(val):
if not val: return ""
return constant(abs(val)) + "+-"[val < 0]

def encode(a, offsetMode):
result = "";
if offsetMode:
for i in range(len(a) - 1, 0, -1):
a[i] -= a[i - 1]
for i in range(len(a)):
parts = []
signBit = (a[i] < 0) * 2
continuing = (offsetMode and i == len(a) - 1) * 1
remain = abs(a[i])
while remain > 22:
parts.insert(0, remain % 46 * 2 + continuing);
remain //= 46
continuing = 1

parts.insert(0, remain * 4 + signBit + continuing)
result += "".join(symbols[p] for p in parts)

return result

def cram(arr):
flat = encode(arr, False)
offset = encode(arr, True)
return offset if len(offset) < len(flat) else flat;

def issquare(num):
root = int(sqrt(num))
return root * root == num

def isgeometric(arr):
r = arr
return all(r ** (i + 1) == e for (i,e) in enumerate(arr))

def generateProgram(arr):
candidates = []
rotated = uncycle(arr)
rotated = rotated[-1:] + rotated[:-1]

deltas = [b - a for a,b in zip(arr, arr[1:])]

# single constant strategy
if len(arr) == 1:
candidates.append(constant(arr))

# repeated constant
elif len(set(arr)) == 1:
num = arr
if num == 10: candidates.append("A")
if num % 2 == 0: candidates.append(constant(num // 2) + "H")
if issquare(num): candidates.append(str(int(sqrt(num))) + "J")
candidates.append(constant(num - 1) +  "^")

# repdigit
if len(arr) == 2 and 10 < arr == arr * 11 < 100:
candidates.append(str(arr) + "p")

# single digits
if max(arr) < 10:
candidates.append("".join(map(str, rotated)) + "E|X@")

# max 10
if max(arr) == 10 and rotated != 1:
candidates.append("".join(str(e - 1) for e in rotated) + "E|X@^")

fns = [
("", lambda x: x),
("H", lambda x: 2 * x),
("^", lambda x: x + 1),
("J", lambda x: x * x),
("Hv", lambda x: 2 * x - 1),
("H^", lambda x: 2 * x + 1),
("^H", lambda x: 2 * x + 2),
("HJ", lambda x: 4 * x * x),
("JH", lambda x: 2 * x * x),
(":T", lambda x: x * (x + 1) / 2),
("|F", lambda x: reduce(lambda a, b: a*b, range(1, x+1))),
("J^", lambda x: x * x + 1),
("^J", lambda x: x * x + 2 * x + 1),
]
for (stax, fn) in fns:
if all(fn(i + 1) == e for (i,e) in enumerate(arr)):
candidates.append("|X" + stax)

# fixed delta
if len(set(deltas)) == 1:
delta = deltas
start = arr - delta
if start == 0:
candidates.append(shift(delta))
if delta == 1:
candidates.append("|X" + shift(start))
elif delta == -1:
candidates.append("|x" + shift(start))
elif delta > 1:
candidates.append("|X" + constant(delta) + "*" + shift(start))
elif delta < -1:
candidates.append("|x" + constant(-delta) + "*" + shift(start))

# geometric series
if isgeometric(arr):
candidates.append(constant(arr) + "*")

# prefix
if len(arr) == 2 and arr // 10 == arr < 10:
candidates.append("." + str(arr) + "|X(")

# suffix
if len(arr) == 2 and arr % 10 == arr < 10:
candidates.append("." + "".join(map(str, arr)) + "|X)")

# uncycled cram
candidates.append('"' + cram(rotated) + '"!|X@')

candidates.sort(key=len)
return candidates

while True:
arr = eval(input())
prog = generateProgram(arr)
print(prog)



Try it online!

Update: Validation It will be time consuming to execute each multiplicity of each program separately. It's possible to run them all at the same time. In order to do this, a small piece of code must be used. It's responsible for a few things.

1. Do implicit output if any. Normally, at the end of a stax program, the top of stack is printed if there has been no other output. When running multiple programs in the same source file, this must be done explicitly.

2. Clear both stacks.

3. Reset registers. For these programs only the x register is used.

This boilerplate should be applied after every individual program to be executed.

|d{P}{zP}?0XLd


For example, the input [5,2,7,3] produces the stax program 3527E|X@. All four multiplicities can be tested at once.

3527E|X@
|d{P}{zP}?0XLd

3527E|X@3527E|X@
|d{P}{zP}?0XLd

3527E|X@3527E|X@3527E|X@
|d{P}{zP}?0XLd

3527E|X@3527E|X@3527E|X@3527E|X@
|d{P}{zP}?0XLd


Try it online!

In this way, it's possible to test all the multiplicities of all the program in the same run, assuming nothing breaks. It would probably be the largest stax program ever executed if all 500 are done.

## 05AB1E, generates 05AB1E

¸»“"ÿ"#.g<“ƵƒçJ


Try it online!

The generated program for the input [5,17,7,13,2] is "5 17 7 13 2"#.g<è.

Test suite for [5,17,7,13,2]

The length of the generated program is len(input) + 5