SR

SR (Seeded Random) is an esolang invented by User:None1 and inspired by Seed.
Every program in SR consists of 5 numbers separated by spaces. Let's say that these numbers are A B C D and E.
When executing an SR program, first output A as character using the charset !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\n (\n is the line feed). Then let A be (A*B+C)%D. This process is repeated E times.
==Examples==
===Print hello===
 72 48588 120650 484115 5
===Nope. interpreter===
 46 63241 17783 257074 5
===Print hi===
 72 40 127 258 2
===Print fuck===
 70 28842 30961 68260 4
==Implementations==
This is a Python implementation, along with a genetic algorithm to generate programs (the examples are all generated using this program), you may need to change the argument when using the algorithm.
import json,gc
from secrets import randbelow
from json import *
def sri(a,b,c,d,e):
 res=''
 strtbl=.join(map(chr,range(32,127)))+'\n'
 for i in range(e):
 res+=strtbl[a%len(strtbl)]
 a=(a*b+c)%d
 return res
def sr(x):
 return sri(*map(int,x.split()))
def srscore(a,b,c,d,e,s):
 cc=sri(a,b,c,d,e)
 res=1
 for i,j in enumerate(cc):
 res+=256-abs(ord(j)-ord(s[i]))
 return res
def gen(s,m):
 strtbl = .join(map(chr, range(32, 127))) + '\n'
 d=randbelow(m-1)+1
 return strtbl.index(s[0]),randbelow(min(m,d)),randbelow(min(m,d)),d,len(s)
GENERATIONS=100000 # Maximum number of generations
CANDIDATES=1000 # Number of genomes
MUTATE_NUM=60 # Bits to XOR when mutating
SHOW=50 # Show every SHOW generations
genomes=[]
scores=[]
pref_sum=[]
new_genomes=[]
temp_genomes=[]
result=None
max_score=-1
def save(s):
 with open('temp.json','w') as f:
 json.dump({'string':s,'genome':genomes,'maxscore':max_score,'result':result},f)
def read(s):
 global genomes,max_score,result
 try:
 with open('temp.json','r') as f:
 t=json.load(f)
 if t['string']!=s:
 return False
 genomes=t['genome']
 max_score=t['maxscore']
 result=t['result']
 except:
 return False
 return True
def select(pref_sum):
 pos=randbelow(pref_sum[-1]+1)
 l,r,ans=0,len(pref_sum)-1,0
 while l<=r:
 mid=(l+r)>>1
 if pref_sum[mid]>=pos:
 ans=mid
 r=mid-1
 else:
 l=mid+1
 return ans
def init(s,m):
 global genomes,new_genomes,pref_sum
 for i in range(CANDIDATES):
 genomes.append(gen(s,m))
def merge_(x,y):
 k=randbelow(4)
 a,b,c,d,e=x
 A,B,C,D,E=y
 return ((a,)+(b,c,d)[:k]+(B,C,D)[k:]+(e,),(a,)+(B,C,D)[:k]+(b,c,d)[k:]+(e,))
def mutate_num(x):
 # return randbelow(MUTATE_NUM*2+1)-MUTATE_NUM+x
 return (x^(1<<randbelow(MUTATE_NUM)) if randbelow(2) else x)
def mutate_(x,m):
 a,b,c,d,e=x
 return a,mutate_num(b)%m,mutate_num(c)%m,mutate_num(d)%m+1,e
def merge():
 global new_genomes
 new_genomes=[]
 fittest = None
 maxscore = -1
 for i, j in enumerate(scores):
 a, b, c, d, e = genomes[i]
 if fittest:
 A, B, C, D, E = fittest
 if (maxscore < j) or (not fittest) or (
 maxscore == j and len(str(a)) + len(str(b)) + len(str(c)) + len(str(d)) + len(str(e)) < len(
 str(A)) + len(str(B)) + len(str(C)) + len(str(D)) + len(str(E))):
 fittest = (a, b, c, d, e)
 maxscore=j
 new_genomes.append(fittest)
 for i in range(CANDIDATES):
 x,y=select(pref_sum),select(pref_sum)
 a,b=merge_(genomes[x],genomes[y])
 new_genomes.append(a),new_genomes.append(b)
def mutate(m):
 global temp_genomes,new_genomes
 temp_genomes=[]
 for i in new_genomes:
 temp_genomes.append(mutate_(i,m))
 new_genomes=temp_genomes[:]
def get_pref_sum(s):
 global scores,genomes,pref_sum
 scores=[]
 pref_sum=[]
 for i in genomes:
 scores.append(srscore(*i,s))
 k=0
 for i in scores:
 k+=i
 pref_sum.append(k)
def record():
 global max_score,result
 sc=max(scores)
 if (not result) or max_score<sc:
 result=genomes[scores.index(sc)]
 max_score=sc
def one_generation(s,m):
 global genomes
 get_pref_sum(s)
 record()
 merge()
 mutate(m)
 genomes=new_genomes[:]
def generate(s,m): # s: target string m: maximum value used
 if not read(s):
 init(s,m)
 for i in range(GENERATIONS):
 one_generation(s, m)
 if (i+1)%50==0:
 print(f'Generation: {i+1}\tMaximum score: {max_score}\tCode: {result}')
 save(s)
 gc.collect()
 if max_score==256*len(s)+1:
 break
 print(f'Generation: {i + 1}\tMaximum score: {max_score}\tCode: {result}')
 print(f'Code: {result}\tScore: {max_score}')
==Note==
It is guessed but not proved that this esolang can produce any output in the charset.
Category:Languages
Category:Output only
Category:Total
Category:2024
Category:Implemented
Category:Zero-dimensional