nyuuzyou/wikis huggingface dataset:
DDR/Python Implementation

import sys
 
 DDRcode="""code goes here"""
 DDRcode=DDRcode.split("\n")
 if not all(arrow in DDRcode[0] for arrow in "<v^>"):
 raise SyntaxError('Code does not start with "<v^>"')
 DDRcode=DDRcode[1:] #removing initial <v^>
 
 ncode=[0]*len(DDRcode)
 for i in range(len(DDRcode)): #convert lines to numbers
 if "<" in DDRcode[i]: #note: only detects if each symbol
 ncode[i]+=8 #is in each line, thus lines do not
 if "v" in DDRcode[i]: #need to exactly match commands,
 ncode[i]+=4 #and allows comments
 if "^" in DDRcode[i]:
 ncode[i]+=2
 if ">" in DDRcode[i]:
 ncode[i]+=1
 
 print("DDR Interpreter")
 print("Input uses one character at a time, and")
 print(" asks again when each character has been used\n")
 
 cp=0
 tape=[0]
 tp=0
 brackets=[]
 function=[]
 fp=0
 var=0
 
 def run_DDR(code,cp,tape,tp,func,fp,brcts,var):
 while cp < len(code):
 if code[cp] == 0: #noop
 pass
 elif code[cp] == 1: # >
 tp+=1
 if tp==len(tape):
 tape+=[0]
 elif code[cp] == 8: # <
 tp-=1
 assert tp>=0, "Attempted to access negative index"
 elif code[cp] == 2: # +
 tape[tp]+=1
 tape[tp]%=256
 elif code[cp] == 4: # -
 tape[tp]-=1
 tape[tp]%=256
 elif code[cp] == 6: # .
 print(chr(tape[tp]), end="")
 elif code[cp] == 12: # ,
 tape[tp]=ord(sys.stdin.read(1))
 elif code[cp] == 10: # [
 if tape[tp]==0:
 while code[cp] != 3:
 if code[cp] == 9:
 cp+=2
 cp+=1
 assert cp < len(code), 'Could not find matching " v>"'
 else:
 brcts+=[cp-1]
 elif code[cp] == 5: # ]
 cp=brcts[-1]
 del brcts[-1]
 elif code[cp] == 3: # . (num)
 print(tape[tp], end="")
 elif code[cp] == 14: # var=
 var=tape[tp]
 elif code[cp] == 7: # =var
 tape[tp]=var
 elif code[cp] == 9: # " "
 tape[tp]=code[cp+1]*16+code[cp+2]
 cp+=2
 elif code[cp] == 11: # def func():
 cp+=1
 func=[]
 while code[cp] != 13:
 func+=[code[cp]]
 if code[cp] == 9:
 cp+=2
 cp+=1
 assert cp < len(code), "Could not find function end"
 print(func)
 elif code[cp] == 13: # call func()
 nfunc=[]
 nfp=0
 run_DDR(func,fp,tape,tp,nfunc,nfp,brcts,var)
 elif code[cp] == 15: # halt
 break
 cp+=1
 
 run_DDR(ncode,cp,tape,tp,function,fp,brackets,var)
Category:Implementations
DDuuaall

DDuuaall is a language invented by User:A, inspired by Vyxal's zipmap.
== Special Arity Rules ==
The so-called complement is usually number negation for numbers, or reversing for strings/lists.
=== Nilads ===
You push a nilad along with its complement, the complement is pushed after the original nilad.
=== Monads ===
You apply the defined operation, along with a "complement-operation". The result of the complement operation is pushed after the intended operation.
=== Dyads ===
With two list operands, it vectorizes, if possible (unless the instruction defines otherwise). When the TOS is a list operand, it reduces the dyad by the list.
With a list operand on the bottom and a number operand on the top, the instruction implements its own method of evaluation.
== Instruction list ==
Instruction 	Main behavior 	Complement behavior
\ (Triad) 	Triple swap: a b c -> c a b 	-
= (Dyad) 	Vectorizing equality 	-
+ (Dyad) 	Vectorizing addition/string concatenation 	-
- (Dyad) 	Vectorizing subtraction 	-
* (Dyad) 	Vectorizing Multiplication/string repeat 	-
/ (Dyad) 	Vectorizing division 	-
$ (Dyad) 	Swap two items on the stack 	-
% (Dyad) 	Vectorizing modulus 	-
~ (Dyad) 	Remove items 	-
L (Dyad) 	Return the top operand, pop the second-to-top operand 	-
R (Monad) 	1-range, reverse for lists 	Reverse 1-range, identity for lists
~ (Monad) 	Remove the last item of the list 	Remove the first item of the list
_ (Monad) 	Pop the stack 	Duplicate the stack
O (Monad) 	Pops + Outputs TOS, disables implicit output. (exception to the monad rule)	-
"xyz" (Nilad)	Push "xyz" 	Push "xyz" reversed
0-9 (Nilad) 	Push the number formed by the construction 	Push the negative of the number formed by the construction
I (Nilad) 	Push the input (exception to the nilad rule) 	-
== I/O Specifications ==
There's implicit input, but you can also take explicit input via I.
The whole stack's content is joined and outputted at the end of the program.
== Example programs ==
=== Is it odd or even? ===
R=+
==== Explanation ====
Assume the input = 3 right now.
R 1-range. Push [1, 2, 3] (original function) and [3, 2, 1] (complement function)
 = Vectorizing equality. Push [0, 1, 0]
 + Sum the list. Push 1 (If the stack only has one list item, DDuuaall reduces over the list by the dyadic operation)
=== Hello, World! ===
"Hello, World!"0+*+
==== Explanation ====
"Hello, World!" String literal. Push "Hello, World!" (original) and "!dlroW, olleH" (complement)
 0 Number literal. Push 0 and -0 (aka push 2 0's)
 + Add the two copies of 0.
 * Repeat the complement string by 0.
 + Join the empty string by the original string.
=== Primalty Tester ===
RL~UI$L$%0+=+0
==== Explanation ====
Assume input = 4 here.
R Range. [1, 2, 3, 4] and [4, 3, 2, 1]
 L Left. [1, 2, 3, 4]
 ~ Pop. [1, 2, 3] and [2, 3, 4]
 U Intersect. [2, 3]
 I Input. [2, 3], 4, -4
 $ Swap. [2, 3], -4, 4
 L Left. [2, 3], 4
 $ Swap. 4, [2, 3]
 % Mod. [1, 0]
 0 Zero. [1, 0], 0, 0
 + Add. [1, 0], 0
 = Equals?[0, 1]
 + Sum 1
 0 Output. OUT:1
Category:Languages
Category:Stack-based
Category:2020
Category:Unimplemented
DFS

DFS here doesn't stand for "Depth First Search", it stands for "Deadfish", the author named it DFS because the name DF is already taken by DateFuck.
DFS is Deadfish extended by User:None1, char I/O is added.
==Commands==
Here are the commands in DFS.
i increment
d decrement
s square
o output
O char output
l input
L char input
Note that the accumulator in DFS is a byte, which wraps when overflows.
==Example Programs==
===Hello World===
iiisdsiiiiiiiiOiiiiiiiiiiiiiiiiiiiiiiiiiiiiiOiiiiiiiOOiiiO
dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddOddddddddddddO
dddddddddddddddddddddsddOddddddddOiiiOddddddOddddddddO
dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddO
==Interpreter==
===C===
#include<stdio.h>
int main(){
 char x=0,c;
 while((c=getchar())!=EOF){
 if(c=='i') x++;
 if(c=='d') x--;
 if(c=='o') printf("%d",(int)x);
 if(c=='s') x=x*x;
 if(c=='O') putchar(x);
 if(c=='l') scanf("%d",&x);
 if(c=='L') x=getchar();
 }
 return 0;
}
Category:Languages
Category:Implemented
Category:Deadfish derivatives
DG

DG (named after a great computer-science teacher) is a language designed with principles known from lisp.
All programms are written in normal text-files.
== Basic syntax ==
DG is interpreted line by line, meaning that one line doesn't affect another (besides variables).
Every line is structured like this:
 operator parameter1 parameter2
From this it becomes clear, that every operator takes in exactly 2 parameters, which in some cases can be extended.
All parameters are seperated using spaces (" ").
When more than 2 parameters are required, parameters are connected through ",".
DG also doesn't have infix-operators.
== Operators ==
 + | adds 2 parameters (numbers or variables) together (+ 4 5) and writes them to a variable
 - | subtracts 2 parameters (numbers or variables) (- 4 5) and writes them to a variable
 * | multiplies 2 parameters (numbers or variables) (* 4 5) and writes them to a variable
 / | devides 2 parameters (numbers or variables) together (/ 4 5) and writes them to a variable
 ^ | raises 2 parameters (numbers or variables) to eachothers power (^ 4 5) and writes them to a variable
 % | takes the modulo of 2 parameters (numbers or variables) (% 5 4) and writes them to a variable
 v | sets a variable to a value (v a 5 sets a to 5 and v b a sets b to a(5))
 | when the second parameter is "o" the variable is set to the output of an operation (v a o + 4 b sets a to 4 + b) (takes +-*/%g)
 | when the second parameter is "[]" an array is created (v b [])
 a | append a value to an array (a b 12 sets b = [12])
 s | sets the element at an index to a value (let b = [4, 5, 7]; v b 0,15 sets b = [15, 5, 7])
 g | prints element of array at index (g b 0 prints b[0] (in this case 4))
 p | prints a string with variables (p "test {} {}" a,4 prints "test a 4")
 ; | comment (start line with ; (; I'm a comment))
 > | executes code if condition is true ( > a 1 v b o / 1 a sets b to 1 / a, if a > 1)
 < | executes code if condition is true ( < a 1 v b o / 1 a sets b to 1 / a, if a < 1)
 = | executes code if condition is true ( = a 1 v b o / 1 a sets b to 1 / a, if a == 1)
 ! | executes code if condition is true ( ! a 1 v b o / 1 a sets b to 1 / a, if a != 1)
 l | for-loop (l 1,10,2 i&v b o * i 2&p "i: {} b: {}" i,b (for i from 1 to nine, 1,3,5,7,9 prints i and 2 * i))
 | do not put spaces befor or after the "& 
== Example: calculating e ==
The following code approximates e for (1 + 1/n)^n 
 l 1,1000000,1 i&v a o / 1 i&v a o + a 1&v a o ^ a i&p "e: {}" a
== External recources ==
Github: 
Category:Languages Category:Output only
DIACRITIC

DIACRITIC is a language by User:ChuckEsoteric08, that has diacritics as commands and based on ABCDXYZ
==Description==
It has 2 variables that hold integers and 1 variable that hold string. Commands are diffirent in states. There is three of them:
*A
*I
*U
Initial State is A.
===Commands===
Command	Name 	A 	I 	U
̀ 	low 	increment variable 1 	increment variabe 2 	add symbol 1 to end of a string
̄ 	long 	decrement variable 1 	decrement variable 2 	add symbol 0 to end of a string
̃ 	nasal 	Switch State to State 2 	Switch State to State 3 	Switch State to State 1
̥ 	voiceless	Start a while loop until variable 1 become zero	Start a while loop until variable 2 become zero	Start a while loop until number of 1 and 0 will be equal
̬ 	voiced 	End loop 	End loop 	End loop
̩ 	syllabic 	NOP 	NOP 	ask for input
́ 	high 	NOP 	NOP 	print input
==Examples==
===Infinity loop===
 ̥̬̀
By using names:
 low
 voiceless
 voiced
===Cat===
 ̥̩̃̃́
By using names:
 nasal
 nasal
 voicless
 syllabic
 high
 voiced
==Computational class==
It is possible to translate every ALWCIDFEC program in it
ALWCIDFEC	DIACRITIC 	By using names
+ 	̀ 	low
* 	̃̀̃̃ 	nasal, nasal, low
4 	̃̃̀̃ 	nasal, nasal, nasal, low
-, /, 1 	Like +, *, 4, but long instead of low 	
[, (, { 	Like +, *, 4, but voiceless instead of low	
], ), } 	Like +, *, 4, but voiced instead of low 	
==External resources==
Site where you can type diactritics used in the language]
Category:Languages Category:Turing complete Category:Unimplemented
DINAC/STDLIB

DINAC STDLIB is a library of functions you can use in your DINAC code. They are grouped together for ease of access, and from there the individual functions are arranged alphabetically. Overloads are listed in no specific order. Any functions required by other functions are listed.
==Arithmetic==
 DEF/00 add a:00 b:00
 WHILE b
 a . a+
 b . b-
 GIVE a
 # Requires add, and, less, mul
 DEF/00 factorial a:00
 IF less(a,2)
 GIVE 01
 ELSE
 GIVE mul(n,factorial(n-))
 # Requires less, sub
 DEF/00 floordiv a:00 b:00
 SET res:00
 WHILE ~less(a,b)
 a . sub(a,b)
 res . res+
 GIVE res
 # Requires add
 DEF/00 mul a:00 b:00
 SET res:00
 WHILE b
 res . add(res,a)
 b . b-
 GIVE res
 # Requires add, mul
 DEF/00 pow a:00 b:00
 SET res:01
 WHILE b
 res . mul(res,a)
 b . b-
 GIVE res
 DEF/00 sub a:00 b:00
 WHILE b
 a . a-
 b . b-
 GIVE a
==Boolean==
 DEF/00 and a:00 b:00
 IF a
 GIVE ~~b
 ELSE
 GIVE 00
 DEF/00 or a:00 b:00
 IF a
 GIVE 01
 ELSE
 GIVE ~~b
 # Requires and, or
 DEF/00 xor a:00 b:00
 GIVE and(~and(a,b),or(a,b))
==Comparison==
 # Requires and
 DEF/00 greater a:00 b:00
 WHILE and(a,b)
 a . a-
 b . b-
 GIVE ~~a
 # Requires and
 DEF/00 greq a:00 b:00
 WHILE and(a,b)
 a . a-
 b . b-
 GIVE ~b
 # Requires and
 DEF/00 less a:00 b:00
 WHILE and(a,b)
 a . a-
 b . b-
 GIVE ~~b
 # Requires and
 DEF/00 lseq a:00 b:00
 WHILE and(a,b)
 a . a-
 b . b-
 GIVE ~a
==Conversion==
 DEF/00 ascharToWubyte a:\0
 SET w:00
 WHILE a
 w . w+
 a . a-
 GIVE w
 DEF/00 wubyteToAschar w:00
 SET a:\0
 WHILE w
 a . a+
 w . w-
 GIVE a
==Other==
 DEF/00 ternary cond:00 a:00 b:00
 IF cond
 GIVE a
 ELSE
 GIVE b
 DEF/\0 ternary cond:00 a:\0 b:\0
 IF cond
 GIVE a
 ELSE
 GIVE b
Category:Examples
DIVSPL

Dustin Ingram's Very Special Programming Language, or DIVSPL, is a declarative wikipedia:domain-specific language for solving the FizzBuzz problem.
== Examples ==
The original FizzBuzz problem can be expressed in DIVSPL as:
 1...15
 fizz=3
 buzz=5
Using the conventions on the FizzBuzz page:
 1...15
 Fizz=3
 Buzz=5
The author's motivation was to make the following example easy to express:
 1...105
 fizz=3
 buzz=5
 fuzz=7
== Implementations ==
* Dustin Ingram's implementation in RPython
* Corbin has written two versions: v0 in Python 3 and v1 in RPython
== See also ==
* FizzLang
Category:Implemented
Category:Output only
Category:2016
Category:Declarative paradigm
Category:Total
Category:Unusable for programming
DJN OISC

DJN (Decrement and jump if not zero) is an OISC. Its instruction
 X Y
uses Y as a pointer into memory. 1 is subtracted from the value stored at location Y. If the result is non-zero, DJN jumps to X.
DJN is less practical than Subleq type languages since its execution is of O(n) to the values it operates on (exponential to the representation size of the operands).
DJN is also a popular instruction in Redcode, the origin of the instruction.
==External resources==
Link to the original article.
==See also==
* Redcode, the origin of the DJN instruction
* Subleq
* Addleq
* P1eq
* OISC
* Decleq
Category: Languages Category: OISC Category: Turing complete Category: Turing tarpits Category: Implemented Category: Low-level
DL

DL is an esoteric programming language, created and implemented by User:Disa. DL source files can be compiled to Windows Executable files.
==Language overview==
DL is an imperative language, statically typed. 
Example of usage:
Command 	Description
say(text) 	Print text on console output
Var String @str 	Declare @str as string variable
@str = Read() 	Put console input to @str
@sum = #1+2 	Calculate sum of 1 and 2 and write it to @sum
@str = abc 	Define value of variable
For(10)say(abc)$$$ 	Put to console "abc" 10 times
@result = Cmp(1,1)Alternative:@result = #1?1	@result = true if 1 = 1
==Examples==
===Hello, World!===
This program prints out the words Hello World!:
 DL Start
 say(Hello World!)
 DL End
===Cat===
A cat program writes its input directly to its output. 
 DL Start
 Var String @input
 @input = Read()
 say(@input)
 DL End
===Fibonacci sequence===
 DL Start
 Var Integer @prev1
 Var Integer @prev2
 Var Integer @val
 Var Integer @curr
 Var Integer @step
 say(Enter n: )
 @val = Read()
 NL()
 
 For(@val)
 say(F(@step)
 say() = )
 If(#@step?0)
 	say(0)
 	NL()
 	@prev2 = 0
 ###
 If(#@step?1)
 	say(1)
 	NL()
 	@prev1 = 0
 	@prev2 = 1
 ###
 If(#@step>1)
 	@curr = #@prev1+@prev2
 	say(@curr)
 	NL()
 	@prev1 = @prev2
 	@prev2 = @curr
 ###
 @step = #@step+1
 $$$
 @curr = Add(@prev1,@prev2)
 say(F(@val)
 say() = @curr)
 DL End
===Deadfish interpreter===
Command per line.
 DL Start
 Var Integer @x
 Var String @cmd
 Var Bool @bool
 Var Integer @pos
 Var Integer @tmp2
 Tag(@again)
 @cmd = Read()
 Tag(@nextcomm)
 @pos = StrPos(@cmd,i)
 If(Cmp(@pos,1))
 @x = Add(@x,1)
 ###
 @pos = StrPos(@cmd,d)
 If(Cmp(@pos,1))
 @x = Sub(@x,1)
 ###
 @pos = StrPos(@cmd,s)
 If(Cmp(@pos,1))
 @x = Mul(@x,@x)
 ###
 @pos = StrPos(@cmd,o)
 If(Cmp(@pos,1))
 say(@x)
 NL()
 ###
 If(Cmp(@x,-1))
 @x = 0
 ###
 If(Cmp(@x,256))
 @x = 0
 ###
 @tmp2 = Len(@cmd)
 @tmp2 = Sub(@tmp2,1)
 IfNot(Cmp(@tmp2,0))
 @cmd = SubStr(@cmd,1,@tmp2)
 Goto(@nextcomm)
 ###
 Goto(@again)
 DL End
==Computational class==
DL is probably Turing-complete, meaning that it is in the same computational class as universal Turing machines.
==External resources==
* User:Disa's DL webpage contains a functions list, N++ language definition and a couple of interesting programs.
** DLI – Interpreter written by author of language in Visual Basic.
** DLC – Compiler written by author of language.
** IDE – with syntax highlighting and some Intelli-sense features.
Category:Implemented 
Category:Languages
Category:2013
Category:High-level
DML

DML - Directed Multigraph Language, is an esoteric programming language. DML may be considered a cellular automaton, though the underlying topology is not a grid of squares, but rather a graph - a directed multigraph. 
DML is a visual programming language, meaning that a DML program is simply a graphical representation of the graph. We consider this graphical representation as primary, and any necessary text representation as secondary.
Vertices in the graph are marked 1 (black) or 0 (white). 
=== Neighborhood ===
The neighbors of a vertex X are those vertices for which there is an edge which links from that vertex to X. 
=== Operation ===
The DML program defines the initial state of the automaton. The automaton evolves by proceeding though cycles, with the initial state being cycle 0, and the following states 1, 2, 3 etc. 
With each cycle, we calculate the new state of each vertex, based on the old states of its neighbors, specifically if exactly one neighbor of X is in state 1, then the new state of X is 1, otherwise the state is 0. 
=== I/O ===
A DML program can accept input and produce output. Two special vertices are defined - the left-most vertex on the graph is called R (read), while the rightmost vertex is called W (write). 
TODO: I/O description.
Settings
The following settings are defined (how?). 
 bits_per_byte - number of bits that make up a byte
 cycles_per_bit - number of cycles that make up a bit
 cycles - number of cycles that the program will run
TODO: Settings Description
=== Examples ===
==== Program Fragments ====
==== Programs ====
- adder
Category:Languages
Category:Cellular automata
DO

DO is a programming language that is based off of recursion made by User:Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff. Every program has one input. also multithreaded
== Commands ==
DO only has a few commands:
 Commands
Command	what does it DO
DO 	does that value in the accumulator as a DO program
S} 	end this program. (note that this goes one level back in recursion)
A? 	checks if this code is equal to the accumulator, if it is, skip to the next NP
NP 	print its first letter, then delete it
RC 	checks if the recursion depth > accumulator's length / 2, if it is, skip to the next NP,
JM 	jump to nearest next letters, then move forward 1
00 	check if accumulator is the empty string, if yes, skip to the nearest next command (except that one) and add the string "Hello, World"
99 	print one verse of the 99 bottles of beer song using the accumulator as the number
AD 	add the recursion depth as a character to the accumulator, if it's 0, set the accumulator to ""
++ 	add the recursion depth as a number balanced mod 80 to the accumulator (balanced mod is æ% in Jelly)
{} 	if depth = 1, then set accumulator to input, if its 2, subtract the last digit, if its 0, set accumulator to this code
2{ 	Do this code, starting right here.
}{ 	subtract recursion depth from accumulator
other commands are comments; newlines are ignored
== programs ==
=== hello world ===
 00gogoloNP00opJMloop
=== Quine ===
 {}NP00{}
=== Truth-machine ===
 2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{AD{}}{S}S}
 S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}00zron2{++S}NPAD00onzr++NP
=== crash ===
 {}DO
=== ℒight Interpreter ===
 READ2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{2{
 ADS}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}S}NP
 00RE
=== infinite loop ===
 LOAD00LO
Category:Languages Category:Unknown computational class Category:Unimplemented
DOGO

DOGO is one of the lesser known programming languages. In the original Usenet post, DOGO was described as follows:
:Developed at the Massachusetts Institute of Obedience Training, DOGO heralds a new era of computer-literate pets. DOGO commands include SIT, STAY, HEEL, and ROLL OVER. An innovative feature of DOGO is "puppy graphics," a small cocker spaniel that occasionally leaves a deposit as he travels across the screen.
An actual language has been created resembling DOGO, although it does not implement puppy graphics.
The facilities are equipollent to that of brainfuck, however, merely the navigational instructions SIT, which mimics [, and STAY, an equivalent of ], are expressed directly; the other six commands must be activated by aid of an internally managed operation, manipulated using ROLL-OVER and invoked with HEEL.
The commands for this language are:
Command 	Effect
SIT 	If the value of the current memory cell is 0, jump to STAY.
STAY 	If the value of the current memory cell is not 0, jump to SIT.
ROLL-OVER	Select the next operation in the operation list.
HEEL 	Execute the currently selected operation.
The operations are:
Operation	Effect 	brainfuck equivalent
0 	Increment the current memory cell. 	+
1 	Decrement the current memory cell. 	-
2 	Move the pointer to the next memory cell. 	>
3 	Move the pointer to the previous memory cell. 	<
4 	Input a byte and store its ASCII code in the current memory cell.	,
5 	Output the current memory cell as ASCII. 	.
== See also ==
* M?!, another esoteric programming language which barters explicit commands for a mode.
== External resources ==
* 
Category:Joke languages
Category:Implemented
Category:Brainfuck equivalents
Category:Languages
DONT YOU LECTURE ME WITH YOUR THIRTY DOLLAR LANGUAGE

DONT YOU LECTURE ME WITH YOUR THIRTY DOLLAR LANGUAGE is a language made by User:Masalt in Python 3.
==Example Programs==
===Hello World===
 DONT YOU LECTURE ME WITH YOUR THIRTY DOLLAR HAIRCUT
 🗿Hello, World!🗿
 🖨
===Truth Machine===
 DONT YOU LECTURE ME WITH YOUR THIRTY DOLLAR HAIRCUT
 ⌨🗿110🗿
 ⁉🖨⬅
===Cat Program===
 DONT YOU LECTURE ME WITH YOUR THIRTY DOLLAR HAIRCUT
 ☠⌨
 🖨☠🗿2🗿
 ⏲💀
 ☠🗿16🗿⬅
===User:Yes's Rundown of the language===
====What I can make out so far====
It appears that a 🗿 will push a string onto a Queue of some sort. Now, I say queue, as if it were a Stack, the string in the Hello World program would be backwards, due to stacks popping and getting values from the topmost, and queues removing and getting values from the bottommost. Then it appears that a 🖨 will print the complete string as it appears that the string is pushed as one whole value onto the queue.
Category:Languages
DQ

DQ is a esolang about duplicate and discard
==esolang overview==
===alphabet===
DQ uses a minimal stack-based approach. The only symbols are:
 symbols:
symbol	description
0 	make the stack empty
1 	pushes a 1 onto the stack
D 	duplicates the top element on the stack
Q 	discards the top element on the stack
===execution model===
* Start with an empty stack.
* Read the DQ program character by character in random order.
* After processing the entire program, the final stack contents represent the output.
===examples===
 11DQ
execution: 
* 1: Push a 1 onto the stack (stack: 1).
* 1: Push another 1 onto the stack (stack: 1, 1).
* D: Duplicate the top 1 (stack: 1, 1, 1, 1).
* Q: Discard the top element (stack: 1, 1, 1).
Final output: 1, 1, 1 (if it goes in right direction).
===Key Features:===
* Duplication: The D instruction effectively doubles the size of the stack (up to the current stack pointer) at a specific point.
* Discarding: The Q instruction removes the top element, allowing for selective removal and manipulation of stack contents.
* All operations happen in a random order
==Interpreter==
Written in JavaScript.
function dq(program)
{
 const stack = [];
 const randomisedProgram = program.split("").sort(() => Math.random() - 0.5);
 for(const character of randomisedProgram)
 {
 switch(character)
 {
 case "0":
 stack.length = 0;
 break;
 case "1":
 stack.push(1);
 break;
 case "D":
 if(stack.length > 0)
 stack.push(stack[stack.length - 1]);
 break;
 case "Q":
 stack.pop();
 break;
 }
 }
 console.log(...stack);
}
==See also==
* ℕDQ
Category:Joke languages
Category:Nondeterministic
Category:Unusable for programming
Category:Output only
Category:Languages
Category:Total
Category:Stack-based
Category:Implemented