Lenum

:Note that lenum is typically lowercased except, often, at the start of a sentence.
Lenum (as in letter-number) is an esolang designed to be much harder to program in than it looks. It is created by User:Iddi01.
At first sight it looks much easier than bf, but it's actually incomparably more difficult and complex. (See Bf loop equivalent.)
== Description ==
Every single command in lenum consists of two characters. The first must be a letter, while the second can be either a letter or a number. Comments of even lengths made of other characters are ignored. For ease of implementation, it is recommended to not include newlines, spaces or odd-length comments in a program.
Here are the commands:
Command	Description
ix 	increase variable x by 1
dx 	decrease variable x by 1
bx 	go x instructions back
fx 	go x instructions forward
vx 	specify variable x to be used with next instruction
sx 	set specified variable to x. Must be used to "define" the variable before doing anything else with it.
ou 	output specified variable as a number
oc 	output specified variable as a character
if 	begin if statement
eq 	check if preceding and succeeding variable are equal
ne 	check if preceding and succeeding variable are not equal
gt 	check if preceding variable is greater than succeeding variable
lt 	check if preceding variable is lesser than succeeding variable
ex 	followed by an if statement, if the statement only has one variable, then if it is zero, skip the following instruction. If the statement has two variables and one of the four commands above between them, then if the statement is false, skip the following instruction.
Note that for 'vx', 'if', 'eq', 'ne', 'gt', and 'lt', only at the command after them are they actually executed. This is important to know when using b or f.
A variant with better readability is to separate commands with a space. Interpreters can be trivially altered to support this variant.
Since the 'x' in commands can only be a digit, this esolang is restrictive in many ways, such as allowing at most ten variables. Still, it's Turing-complete since all bf commands can be implemented and variables can be arbitrarily large through the 'i' command.
== Examples ==
=== Bf loop equivalent ===
v0s1v9s0ifv0eqv9exf8i0v0ouf2b6ifv0exb4
The "f2b6" in the code is called a "relay point". Relay points are essential if you want your loop to contain more than a few commands. They are basically f or b commands that won't be triggered by normal code execution but will be targeted and executed by other f or b commands. The simplest way is following them by an 'f2'.
The bf equivalent of the above code is (surprisingly) +[+.].
=== Increment by nine ===
(Assuming v0 is already defined)
v2s9d2i0ifv2exb5
This code only optimized size from pure i0's by 1 command. If you're optimizing for speed, then it makes no sense to try this.
=== Hello, World! ===
 v0s9v2s9d2i0ifv2exb5v2s9d2i0ifv2exb5v2s9d2i0ifv2exb5v2s9d2i0ifv2exb5v2s9d2i0ifv2exb5v2s9d2i0ifv2exb5v2s9d2i0ifv2exb5v0ocv2s9d2i0ifv2exb5v2s9d2i0ifv2exb5v2s9d2i0ifv2exb5i0i0v0oci0i0i0i0i0i0i0
 v0ocv0oci0i0i0v0ocv1s9v2s9d2i1ifv2exb5v2s9d2i1ifv2exb5v2s9d2i1ifv2exb5i1i1i1i1i1i1i1i1v1ocv2s9d2d1ifv2exb5d1d1d1v1ocv2s9d2d0ifv2exb5v2s9d2d0ifv2exb5d0d0d0d0d0d0v0ocv2s9d2i0ifv2exb5v2s9d2i0ifv2
 exb5i0i0i0i0i0i0v0oci0i0i0v0ocd0d0d0d0d0d0v0ocd0d0d0d0d0d0d0d0v0oci1v1oc
(Remove the newlines and spaces when actually running)
=== Cat program ===
(Assuming input is already stored at variables 0-9)
v0ocv1ocv2ocv3ocv4ocv5ocv6ocv7ocv8ocv9oc
=== Truth machine ===
(Assuming v0 is already defined)
v9s0ifv0eqv9exf5v0oub2v0ou
=== Looping counter ===
 v3s1v0s9i0v1s9v2s9d2i1ifv2exb5v2s9d2i1ifv2exb5v2s9d2i1ifv2exb5v2s9d2i1ifv2exb5i1i1i1v4s0d3v1oci4f2b7ifv3exb9i3f2b7d4i3ifv4exb5f2b8v0ocb3
=== Fibonacci sequence generator ===
 v0s1v1s1v2s0v3s0v0ouv1oud0i2ifv0exb5f2b7d1i3ifv1exb5f2b8d2i1ifv2exb5f2b8d3i0i1ifv3exb6f2b9v1oub3
== Implementation ==
Here's a moderate Python implementation:
 program = input("Program: ")
 letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
 numbers = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
 variables = {}
 lastcomms = []
 loc = 0
 while True:
 try: chars = program[loc*2:loc*2+2].lower()
 except IndexError: break
 if len(chars) < 2: break
 if chars[0] in letters:
 try: 
 if chars[0] == 'i':
 if chars != 'if':
 variables[chars[1]] += 1
 elif chars[0] == 'd':
 variables[chars[1]] -= 1
 elif chars[0] == 's':
 if lastcomms[0][0] == 'v':
 variables[lastcomms[0][1]] = int(chars[1])
 elif chars[0] == 'b':
 loc -= int(chars[1])# + 1
 lastcomms = []
 if loc > 0:lastcomms.append(program[loc*2-2:loc*2].lower())
 if loc > 1:lastcomms.append(program[loc*2-4:loc*2-2].lower())
 if loc > 2:lastcomms.append(program[loc*2-6:loc*2-4].lower())
 if loc > 3:lastcomms.append(program[loc*2-8:loc*2-6].lower())
 elif chars[0] == 'f':
 #print(lastcomms)
 loc += int(chars[1])# - 1
 lastcomms = []
 lastcomms.append(program[loc*2-2:loc*2].lower())
 lastcomms.append(program[loc*2-4:loc*2-2].lower())
 lastcomms.append(program[loc*2-6:loc*2-4].lower())
 lastcomms.append(program[loc*2-8:loc*2-6].lower())
 elif chars == 'ex':
 if lastcomms[1] == 'if':
 if variables[lastcomms[0][1]] == 0:
 loc += 1
 elif lastcomms[3] == 'if':
 if lastcomms[1] == 'eq':
 if variables[lastcomms[0][1]] != variables[lastcomms[2][1]]:
 loc += 1
 elif lastcomms[1] == 'ne':
 if variables[lastcomms[0][1]] == variables[lastcomms[2][1]]:
 loc += 1
 elif lastcomms[1] == 'gt':
 if variables[lastcomms[0][1]] >= variables[lastcomms[2][1]]:
 loc += 1
 elif lastcomms[1] == 'lt':
 if variables[lastcomms[0][1]] <= variables[lastcomms[2][1]]:
 loc += 1
 elif chars == 'ou':
 if lastcomms[0][0] == 'v':
 print(variables[lastcomms[0][1]])
 elif chars == 'oc':
 if lastcomms[0][0] == 'v':
 print(chr(variables[lastcomms[0][1]]), end="")
 if chars[0] not in ['b', 'f']:
 lastcomms.insert(0, chars)
 loc += 1
 except:
 print("Error at instruction %d" % loc)
 break
Category:Languages
Category:Turing_complete
Category:Low-level
Category:Implemented