User:Iddi01
Jump to navigation
Jump to search
(My other nick: NDusN, due to how some Redcode software display теsт)
The username was originally without meaning, but you can consider it as a recursive acronym, iddi01 dislikes Discord indefinitely.
I'm an expert in uniсode and errology (i know how to make unimaginably long errors from very compact code, although updates to Python limits the possibilities).
I never publish esolangs unless they're unique in some way and i've implemented them (and i encourage everyone else to do that as well!)
Execode/Exechars
Genetic
IP
emit
Mеmоrу
Rеlаng
I nearly stopped creating esolangs because it's impossible to bring attention to a language by only creating a page on this wiki, and what fun it is to create languages that nobody will ever know of?
Programming games
I am a big fan of programming games ever since i met brainfUck (a.k.a BF joust), which unfortunately almost went dead due to the same reason as Core War, which is that the programs (warriors) are becoming too strong to even think about making for a beginner, and so people will lose interest in it.
And BF joust is the easy one, and i mean easy. The Beginner's hill for Core War is about as easy as the only hill for BF joust. So BF joust should be the game to introduce programming games to beginners.
Everybody, please make more and better beginner resources (including hills) for BF joust and Core War, so that they will become popular once again.
My brainfUck (not bf!) programs
You can get an idea of how the three works by visiting the strategy guide and then scrolling to the bottom of BF Joust champions.
This program is a champion called β (i still wish the hill could allow non-ASCII characters), although it is #22 at time of writing:
(>+)*4>[<<<<(+)*5<(-)*15(>)*5(>[+[+[---[-[(-[{(+)*15(+[{(+)*92(+.)*24(>[(+)*113(+.)*27>])*-1}])%13}])%11]]]]])*21]+
>[<<<<(+)*5<(-)*7<(-)*15(>)*6(>[+[+[---[-[(-[{(+)*15(+[{(+)*92(+.)*24(>[(+)*113(+.)*27>])*-1}])%13}])%11]]]]])*21]+
>[<<<<(+)*5<(-)*7<(+)*16<(-)*15(>)*7(>[+[+[---[-[(-[{(+)*15(+[{(+)*92(+.)*24(>[(+)*113(+.)*27>])*-1}])%13}])%11]]]]])*21]+
>[<<<<(+)*5<(-)*7<(+)*16<(-)*17<(-)*15(>)*8(>[+[+[---[-[(-[{(+)*15(+[{(+)*92(+.)*24(>[(+)*113(+.)*27>])*-1}])%13}])%11]]]]])*21]+
(<)*4
>-[<++++<(-)*17<(+)*97<(-)*132<(-)*16(>)*11(>[+[+[---[-[(-[{(+)*22(+[{(+)*92(+.)*24(>[(+)*113(+.)*27>])*-1}])%20}])%18]]]]])*21]+
>-[<++++<(-)*17<(+)*65<(-)*97<(+)*132<(-)*16(>)*12(>[+[+[---[-[(-[{(+)*22(+[{(+)*92(+.)*24(>[(+)*113(+.)*27>])*-1}])%20}])%18]]]]])*21]+
>-[<++++<(-)*17<(+)*65<(-)*97<(+)*97<(-)*132<(-)*16(>)*13(>[+[+[---[-[(-[{(+)*22(+[{(+)*92(+.)*24(>[(+)*113(+.)*27>])*-1}])%20}])%18]]]]])*21]+
>-[<++++<(-)*17<(+)*65<(-)*97<(+)*97<(-)*132<(+)*132<(-)*16(>)*14(>[+[+[---[-[(-[{(+)*22(+[{(+)*92(+.)*24(>[(+)*113(+.)*27>])*-1}])%20}])%18]]]]])*21]+
(<)*7
(-[(>)*9(>[+[+[---[-[(-[{(+)*21(+[{(+)*89(+.)*27(>[(+)*113(+.)*27>])*-1}])%19}])%17]]]]]-)*21](+)*65>)*8
(>[([+[+[---[-[(-[{(+)*25(+[{(+)*93([+{[+-+]}[++-[++-]]>(+)*117])%5000[++-[++-]](>[(+)*117([+{[+-+]}[++-[++-]]>(+)*117])%5000[++-[++-]]>])*-1}])%23}])%21]]]]]+>)*21](+)*21)*21
I always thought i'm only good at offensive programs, but then i made a one-line defensive program (clock) which made #1, unfortunately not as original as the above:
>>>+<-<-(>(-)*128<+[<(-)*111(>)*9(+)*111(+.)*33(<)*9(-)*111(>)*10(+)*111(+.)*33(<)*10(---+)*-1]-)*8>+[-((-)*256<+[<(---+)*-1]->)*8(-)*96431<(+)*65(>)*9(>[(+)*111(+.)*32>])*19](+)*21<(-)*33(>)*11([(-)*106[-.][--+[--+]]>]>)*21
Later, i made ε, a rush program which came first despite two_thirds winning against everything else:
>+>-(>)*6(>[-[-[-[++++[+[+([(+[{(-)*11(-[{(-)*97([-{[-+-]}[++-]>])%2000[++-]>}])%13}])%9]>)*21]]]]]])*5
(<-<+)*5<+[<<(-)*132(>)*13(>[-[+([(+[{(-)*12(-[{(-)*97([-{[-+-]}[++-]>])%2000[++-]>}])%14}])%12]>)*21]])*16]
-<-[<(-)*132(>)*13(>[-[+([(+[{(-)*12(-[{(-)*97([-{[-+-]}[++-]>])%2000[++-]>}])%14}])%12]>)*21]])*16]+((+)*5>(-)*5>)*6
(<(-)*7<(+)*7)*6<(+)*43>((+)*17>(-)*17>)*4>>>>>
((>[-[+([(+[{(-)*16(-[{([-{[-+-]}[++-]>])%5000[++-]>}])%18}])%16]+>)*21]](+)*11)*2>)*4
([(+[{(-)*16(-[{([-{[-+-]}[++-]>])%5000[++-]>}])%18}])%16]>)*-1
My Redcode programs
;redcode-94nop
;name lzma2
;or rather, Epsilon. This is actually totally unrelated to lzma, but it shares
;the same core feature: deadly against imps.
;author NDusN
;which is how CoreWin display теsт
;strategy q, Very anti-imp paper and ordinary stone
;This warrior is somewhat ordinary, and not nearly as original as lzma
;assert CORESIZE == 8000
org qscan;from Core Warrior #92
qm equ 3722
qm2 equ 2681
qa1 equ ((qtab1-1-found)*qm2+1)
qa2 equ ((qtab1-found)*qm2+1)
qb1 equ ((qtab2-1-found)*qm2+1)
qb2 equ ((qtab2-found)*qm2+1)
qb3 equ ((qtab2+1-found)*qm2+1)
qc equ ((qtab3-found)*qm2+1)
dat 7, qb1
qtab2 dat 7, qb2
dat 7, qb3
for 11
dat 0, 0
rof
cnt equ 3358
step equ 3039
step1 equ 7848
step2 equ 2566
step3 equ 3201
step4 equ 2167
step5 equ 4081
boot spl 2, {1111
spl 2, {2222
spl 1, }0
spl 1, {3333
mov <1, {1
spl step5, data+2
spl *-1, {4444
mov <1, {1
jmp step4, data2+1
spl @0, >step1
mov }-1, >-1
spl @0, >step3
mov }-1, >-1
mov data2, >4063
mov data2, >1102
mov {-4, <1
djn @0, <step2
data2 dat <2667, <5334
spl #0
mov data, @atk
hit add #step*2, atk
atk mov data, }hit-step*cnt
djn.f -3, >hit-step*cnt
dat 0, 0
dat 0, 0
data dat >step, >1
for 12
dat 0, 0
rof
qtab3 dat >-90, >qc
for 5
dat 0, 0
rof
dat 0, qa1
qtab1 dat -1, qa2
for 5
dat 0, 0
rof
qscan sne found+qm*qc, found+qm*qc+qb2
seq <qtab3, found+qm*(qc-1)+qb2
jmp q0, }q0
sne found+qm*qa1, found+qm*qa1+qb2
seq <(qtab1-1), found+qm*(qa1-1)+qb2
djn.a q0, {q0
sne found+qm*qa2, found+qm*qa2+qb2
seq <qtab1, found+qm*(qa2-1)+qb2
jmp q0, {q0
sne found+qm*qb1, found+qm*qb1+qb1
seq <(qtab2-1), found+qm*(qb1-1)+(qb1-1)
jmp q0, {q2
sne found+qm*qb3, found+qm*qb3+qb3
seq <(qtab2+1), found+qm*(qb3-1)+(qb3-1)
jmp q0, }q2
sne found+qm*qb2, found+qm*qb2+qb2
seq <qtab2, found+qm*(qb2-1)+(qb2-1)
djn.f q0, <found+qm*(qb2-1)+(qb2-1)
seq >found, found+qm+(qb2-1)
jmp q1, <found
seq found+(qm+1)*(qc-1), found+(qm+1)*(qc-1)+(qb2-1)
jmp q0, }q0
seq found+(qm+1)*(qa2-1), found+(qm+1)*(qa2-1)+(qb2-1)
jmp q0, {q0
seq found+(qm+1)*(qa1-1), found+(qm+1)*(qa1-1)+(qb2-1)
djn.a q0, {q0
jmz.f boot, found+(qm+1)*(qb2-1)+(qb2-1)
q0 mul.b *q2, found
q1 sne {qtab1, @found
q2 add.b qtab2, found
mov qtab3, @found
found mov qtab3, }qm
add #5, found
djn -3, #20
djn.f boot, @found
end
;redcode-94nop
;name V.shot
;originally named Veryshot for its specialness; The dot must be read aloud for no good reason ;)
;author NDusN
;which is how CoreWin display теsт
;strategy q and bishot utilizing Lore-style clear
;To my knowledge, the only other published warrior at this time that uses
;this sort of clear is Forgotten Lore II itself. Why haven't anyone else thought
;of using it despite it being handy in several situations
;assert CORESIZE == 8000
org qscan;from Core Warrior #92
qm equ 3722
qm2 equ 2681
qa1 equ ((qtab1-1-found)*qm2+1)
qa2 equ ((qtab1-found)*qm2+1)
qb1 equ ((qtab2-1-found)*qm2+1)
qb2 equ ((qtab2-found)*qm2+1)
qb3 equ ((qtab2+1-found)*qm2+1)
qc equ ((qtab3-found)*qm2+1)
dat 7, qb1
qtab2 dat 7, qb2
dat 7, qb3
for 13
dat 0, 0
rof
step equ 15
step2 equ 4500
off equ 10
boot
i for 6 ;boot clear
mov 12, step2-off
rof
for 5 ;boot scan
mov 12, step2
rof
djn.f boot+step2+6, {3333
;lore-style clear written from scratch because it's actually easy to understand
gate dat step, step
dat <2667, 8
data spl #16, {-2077
mov data, >gate
mov *-1, }gate
jmp -2, <-3
;scanning part
init add gate-off, scan
scan sne 30, 4030
djn.f init, @scan
mov.f scan, gate-off
jmp data-off, {3333
for 13
dat 0, 0
rof
qtab3 dat >-90, >qc
for 5
dat 0, 0
rof
dat 0, qa1
qtab1 dat -1, qa2
for 5
dat 0, 0
rof
qscan sne found+qm*qc, found+qm*qc+qb2
seq <qtab3, found+qm*(qc-1)+qb2
jmp q0, }q0
sne found+qm*qa1, found+qm*qa1+qb2
seq <(qtab1-1), found+qm*(qa1-1)+qb2
djn.a q0, {q0
sne found+qm*qa2, found+qm*qa2+qb2
seq <qtab1, found+qm*(qa2-1)+qb2
jmp q0, {q0
sne found+qm*qb1, found+qm*qb1+qb1
seq <(qtab2-1), found+qm*(qb1-1)+(qb1-1)
jmp q0, {q2
sne found+qm*qb3, found+qm*qb3+qb3
seq <(qtab2+1), found+qm*(qb3-1)+(qb3-1)
jmp q0, }q2
sne found+qm*qb2, found+qm*qb2+qb2
seq <qtab2, found+qm*(qb2-1)+(qb2-1)
djn.f q0, <found+qm*(qb2-1)+(qb2-1)
seq >found, found+qm+(qb2-1)
jmp q1, <found
seq found+(qm+1)*(qc-1), found+(qm+1)*(qc-1)+(qb2-1)
jmp q0, }q0
seq found+(qm+1)*(qa2-1), found+(qm+1)*(qa2-1)+(qb2-1)
jmp q0, {q0
seq found+(qm+1)*(qa1-1), found+(qm+1)*(qa1-1)+(qb2-1)
djn.a q0, {q0
jmz.f boot, found+(qm+1)*(qb2-1)+(qb2-1)
q0 mul.b *q2, found
q1 sne {qtab1, @found
q2 add.b qtab2, found
mov qtab3, @found
found mov qtab3, }qm
add #5, found
djn -3, #20
djn.f boot, @found
end
;redcode-94nop
;name Fort Destruction
;I originally reserved this name for a powerful stone/imp, but...
;author NDusN
;which is how CoreWin display теsт
;strategy Adding some diversity to the KotH hill: airbag and incen. bombs instead of imps
;It was independently developed, but ended up very similar to Behemot...
;assert CORESIZE == 8000
;Placed #4 when entered the nop hill, but did not enter the draft hill :(
;Thanks to Steve Gunnell for providing me with a hill approximation benchmark which this warrior is optimized against
org qscan;from Core Warrior #92
qm equ 3722
qm2 equ 2681
qa1 equ ((qtab1-1-found)*qm2+1)
qa2 equ ((qtab1-found)*qm2+1)
qb1 equ ((qtab2-1-found)*qm2+1)
qb2 equ ((qtab2-found)*qm2+1)
qb3 equ ((qtab2+1-found)*qm2+1)
qc equ ((qtab3-found)*qm2+1)
dat 7, qb1
qtab2 dat 7, qb2
dat 7, qb3
step equ 447
step2 equ 1959
step3 equ step2-65
off equ -109
bmoff equ 1
mov.i {0, #0
init mov jump+off, *2
mov split+off, <1
mov step*2-bmoff, @step-bmoff+1
add *esc, -1
mov }move+off, @-2
jmz.a init, {move+off
esc djn.f clr+step3-step2, {5555
boot mov esc, esc+step2
bdata spl 1, esc+step2
spl 1, clr+step3+4
mov <clr+4, <-1
mov <split+3, <1
mov.i -3, #split+3+step2+off
mov {boot, <bdata
djn.f >bdata, {6666
dat 0, 0
split spl #2, step*2
move mov @0, }-1
jump jmp -step, {1
dat 0, 0
clr spl #step*3, >step*3+1
mov data, >data-16
djn.f -1, >data-16
data dat <2667, #21
for 24
dat 0, 0
rof
qtab3 dat >-90, >qc
for 5
dat 0, 0
rof
dat 0, qa1
qtab1 dat -1, qa2
for 5
dat 0, 0
rof
qscan sne found+qm*qc, found+qm*qc+qb2
seq <qtab3, found+qm*(qc-1)+qb2
jmp q0, }q0
sne found+qm*qa1, found+qm*qa1+qb2
seq <(qtab1-1), found+qm*(qa1-1)+qb2
djn.a q0, {q0
sne found+qm*qa2, found+qm*qa2+qb2
seq <qtab1, found+qm*(qa2-1)+qb2
jmp q0, {q0
sne found+qm*qb1, found+qm*qb1+qb1
seq <(qtab2-1), found+qm*(qb1-1)+(qb1-1)
jmp q0, {q2
sne found+qm*qb3, found+qm*qb3+qb3
seq <(qtab2+1), found+qm*(qb3-1)+(qb3-1)
jmp q0, }q2
sne found+qm*qb2, found+qm*qb2+qb2
seq <qtab2, found+qm*(qb2-1)+(qb2-1)
djn.f q0, <found+qm*(qb2-1)+(qb2-1)
seq >found, found+qm+(qb2-1)
jmp q1, <found
seq found+(qm+1)*(qc-1), found+(qm+1)*(qc-1)+(qb2-1)
jmp q0, }q0
seq found+(qm+1)*(qa2-1), found+(qm+1)*(qa2-1)+(qb2-1)
jmp q0, {q0
seq found+(qm+1)*(qa1-1), found+(qm+1)*(qa1-1)+(qb2-1)
djn.a q0, {q0
jmz.f boot, found+(qm+1)*(qb2-1)+(qb2-1)
q0 mul.b *q2, found
q1 sne {qtab1, @found
q2 add.b qtab2, found
mov qtab3, @found
found mov qtab3, }qm
add #5, found
djn -3, #20
djn.f boot, @found
end
Semi-serious language list
I created the Semi-serious language list, An attempt to distinguish the good esolangs from the others (which is about 99% of esolangs and still increasing). If you're interested, please help out!