nyuuzyou/wikis huggingface dataset:
锟斤拷烫烫烫fuck

锟斤拷烫烫烫fuck is a Trivial brainfuck substitution.
== Intro ==
手拿两把锟斤拷
口中疾呼烫烫烫
脚踏千朵屯屯屯
笑看万物锘锘锘
== Intro 2 ==
给大家讲个故事：从前，有一个龘䶛䨻䎱㸞蚮䡶䴞䴝䯬䬛䰕㹚㱎䖘䵈䶁䘔䶑䘓鋱䩳䵷㒪䪉䉥䥸䝟䳮，它䟑䎘䫱䉷䰯䕈䟐龘䶛䨻䎱㸞蚮䡶䴞䴝䯬䬛䰕㹚㱎䖘䵈䶁䘔䶑。首先，䘓鋱䩳䵷㒪䪉䉥䥸䝟䳮䟑䎘䫱䉷䰯䕈䟐䬝䥰龘䰕䘋㽌䇁䵄䵻䬛蟿䆉㖀城龘䶛䨻䎱蚮䡶䴞䴝䯬䬛，然后就䰕㹚㱎䖘䵈䶁䘔䶑䘓鋱䩳䵷㒪䪉䉥䥸䝟䳮䟑䎘䫱䉷䰯䕈䟐䬝龘䶛䨻䎱蚮䡶䴞䴝䯬䬛䰕㹚䯬䬛䰕㹚䥸䝟龘䶛䨻了，它被蚮䡶䴞䴝䯬䬛䰕㹚㱎䖘饢蘿蘿靄饢靨爛驫寵灣龍贏爨瘸驫嚴戀蔞讀鑭鷚豐髏諳馨顏顬饋了，然后变成了饋驕驛餷寵䓠驫煆驫灣爨瘸籮嚴戀鷚鱧髏鬱靈雞懶齲魎燼蠻齲櫞蘿蘿靄饢靨爛贔爨籮饢驫嚴戀蠆讀鑭鸛豐髏諳馨顎顬饋饋驕驏龘䶛䨻䎱㸞蚮，龘䶛䨻䎱㸞蚮䡶䴞䴝䯬䬛䰕㹚㱎䖘䵈䶁䘔䶑䘓鋱䩳䵷㒪䪉䉥䥸䝟䳮䟑䎘䫱䉷䰯䕈䟐龘䶛䨻䎱㸞蚮䡶䴞䴝䯬䬛䰕㹚㱎䖘䵈䶁䘔䶑䘓鋱䩳䵷㒪䪉䉥䥸䝟䳮䟑䎘䫱䉷䰯䕈䟐䬝䥰龘䰕䘋㽌䇁䵄䵻䬛蟿䆉㖀城龘䶛䨻䎱蚮䡶䴞䴝䯬䬛䰕㹚㱎䖘䵈䶁䘔䶑䘓鋱䩳䵷㒪䪉䉥䥸䝟䳮䟑䎘䫱䉷䰯䕈䟐䬝龘䶛䨻䎱蚮䡶䴞䴝䯬䬛䰕㹚䯬䬛䰕㹚䥸䝟龘䶛䨻蚮䡶䴞䴝䯬䬛䰕㹚㱎䖘饢蘿蘿靄饢靨爛驫寵灣龍贏爨瘸驫嚴戀蔞讀鑭鷚豐髏諳馨顏顬饋饋驕驛餷寵䓠驫煆驫灣爨瘸籮嚴戀鷚鱧髏鬱靈雞懶齲魎燼蠻齲櫞蘿蘿靄饢靨爛贔爨籮饢驫嚴戀蠆讀鑭鸛豐髏諳馨顎顬饋饋驕驏龘䶛䨻䎱㸞蚮龘䶛䨻䎱㸞蚮䡶䴞䴝䯬䬛䰕㹚㱎䖘䵈䶁䘔䶑䘓鋱䩳䵷㒪䪉䉥䥸䝟䳮䟑䎘䫱䉷䰯䕈䟐龘䶛䨻䎱㸞蚮䡶䴞䴝䯬䬛䰕㹚㱎䖘䵈䶁䘔䶑䘓鋱䩳䵷㒪䪉䉥䥸䝟䳮䟑䎘䫱䉷䰯䕈䟐䬝䥰龘䰕䘋㽌䇁䵄䵻䬛蟿䆉㖀城龘䶛䨻䎱蚮䡶䴞䴝䯬䬛䰕㹚㱎䖘䵈䶁䘔䶑䘓鋱䩳䵷㒪䪉䉥䥸䝟䳮䟑䎘䫱䉷䰯䕈䟐䬝龘䶛䨻䎱蚮䡶䴞䴝䯬䬛䰕㹚䯬䬛䰕㹚䥸䝟龘䶛䨻蚮䡶䴞䴝䯬䬛䰕㹚㱎䖘饢蘿蘿靄饢靨爛驫寵灣龍贏爨瘸驫嚴戀蔞讀鑭鷚豐髏諳馨顏顬饋饋驕驛餷寵䓠驫煆驫灣爨瘸籮嚴戀鷚鱧髏鬱靈雞懶齲魎燼蠻齲櫞蘿蘿靄饢靨爛贔爨籮饢驫嚴戀蠆讀鑭鸛豐髏諳馨顎顬饋饋驕驏龘䶛䨻䎱㸞蚮龘䶛䨻䎱㸞蚮䡶䴞䴝䯬䬛䰕㹚㱎䖘䵈䶁䘔䶑䘓鋱䩳䵷㒪䪉䉥䥸䝟䳮䟑䎘䫱䉷䰯䕈䟐龘䶛䨻䎱㸞蚮䡶䴞䴝䯬䬛䰕㹚㱎䖘䵈䶁䘔䶑䘓鋱䩳䵷㒪䪉䉥䥸䝟䳮䟑䎘䫱䉷䰯䕈䟐䬝䥰龘䰕䘋㽌䇁䵄䵻䬛蟿䆉㖀城龘䶛䨻䎱蚮䡶䴞䴝䯬䬛䰕㹚㱎䖘䵈䶁䘔䶑䘓鋱䩳䵷㒪䪉䉥䥸䝟䳮䟑䎘䫱䉷䰯䕈䟐䬝龘䶛䨻䎱蚮䡶䴞䴝䯬䬛䰕㹚䯬䬛䰕㹚䥸䝟龘䶛䨻蚮䡶䴞䴝䯬䬛䰕㹚㱎䖘饢蘿蘿靄饢靨爛驫寵灣龍贏爨瘸驫嚴戀蔞讀鑭鷚豐髏諳馨顏顬饋饋驕驛餷寵䓠驫煆驫灣爨瘸籮嚴戀鷚鱧髏鬱靈雞懶齲魎燼蠻齲櫞蘿蘿靄饢靨爛贔爨籮饢驫嚴戀蠆讀鑭鸛豐髏諳馨顎顬饋饋驕驏龘䶛䨻䎱㸞蚮龘䶛䨻䎱㸞蚮䡶䴞䴝䯬䬛䰕㹚㱎䖘䵈䶁䘔䶑䘓鋱䩳䵷㒪䪉䉥䥸䝟䳮䟑䎘䫱䉷䰯䕈䟐龘䶛䨻䎱㸞蚮䡶䴞䴝䯬䬛䰕㹚㱎䖘䵈䶁䘔䶑䘓鋱䩳䵷㒪䪉䉥䥸䝟䳮䟑䎘䫱䉷䰯䕈䟐䬝䥰龘䰕䘋㽌䇁䵄䵻䬛蟿䆉㖀城龘䶛䨻䎱蚮䡶䴞䴝䯬䬛䰕㹚㱎䖘䵈䶁䘔䶑䘓鋱䩳䵷㒪䪉䉥䥸䝟䳮䟑䎘䫱䉷䰯䕈䟐䬝龘䶛䨻䎱蚮䡶䴞䴝䯬䬛䰕㹚䯬䬛䰕㹚䥸䝟龘䶛䨻蚮䡶䴞䴝䯬䬛䰕㹚㱎䖘饢蘿蘿靄饢靨爛驫寵灣龍贏爨瘸驫嚴戀蔞讀鑭鷚豐髏諳馨顏顬饋饋驕驛餷寵䓠驫煆驫灣爨瘸籮嚴戀鷚鱧髏鬱靈雞懶齲魎燼蠻齲櫞蘿蘿靄饢靨爛贔爨籮饢驫嚴戀蠆讀鑭鸛豐髏諳馨顎顬饋饋驕驏龘䶛䨻䎱㸞蚮。
== Syntax ==
Syntax of 锟斤拷烫烫烫fuck: 
 Caption text
锟斤拷烫烫烫fuck 	Brainfuck
龘 	>
齉 	<
爨 	+
靐 	-
麤 	.
靈 	,
鬱 	[
亹 	]
== Program ==
Hello, world
 爨爨爨爨爨爨爨爨鬱靐
 龘爨爨爨爨爨爨爨爨齉
 亹龘爨爨爨爨爨爨爨爨
 麤齉爨爨爨爨爨鬱靐龘
 爨爨爨爨爨齉亹龘爨爨
 爨爨麤爨爨爨爨爨爨爨
 麤麤爨爨爨麤齉爨爨爨
 爨爨爨爨爨鬱靐龘靐靐
 靐靐靐靐靐靐齉亹龘靐
 靐靐麤齉爨爨爨鬱靐龘
 靐靐靐齉亹龘靐靐靐麤
 齉爨爨爨爨爨爨爨爨爨
 鬱靐龘爨爨爨爨爨爨爨
 爨爨齉亹龘爨爨爨爨爨
 爨麤靐靐靐靐靐靐靐靐
 麤爨爨爨麤靐靐靐靐靐
 靐麤靐靐靐靐靐靐靐靐
 麤齉爨爨爨爨爨爨爨爨
 鬱靐龘靐靐靐靐靐靐靐
 靐齉亹龘靐靐靐麤齉
A+B Problem
 TOO LONG
== Interpreter in Python ==
 import sys
 def interpretion(code):
 s=[]
 matches={}
 tape=[0]*1000000
 for i,j in enumerate(code):
 if j=='鬱':
 s.append(i)
 if j=='亹':
 m=s.pop()
 matches[m]=i
 matches[i]=m
 cp=0
 p=0
 while cp<len(code):
 if code[cp]=='爨':
 tape[p]=(tape[p]+1)%256
 if code[cp]=='靐':
 tape[p]=(tape[p]-1)%256
 if code[cp]=='靈':
 c=sys.stdin.read(1)
 tape[p]=(ord(c) if c else 0)%256
 if code[cp]=='麤':
 print(chr(tape[p]),end=)
 if code[cp]=='龘':
 p-=1
 if code[cp]=='齉':
 p+=1
 if code[cp]=='鬱':
 if not tape[p]:
 cp=matches[cp]
 if code[cp]=='亹':
 if tape[p]:
 cp=matches[cp]
 cp+=1
 interpretion(sys.stdin.read())
== See also ==
Brainf凵ck
== Categories ==
Category:Languages Category:Brainfuck derivatives Category:Brainfuck equivalents Category:Implemented Category:CJK Category:Pseudonatural Category:Turing complete Category:Turing tarpits Category:Cell-based Category:Low-level
靈符

靈符 is designed by PSTF and his ChatGPT.
== Commands ==
The language operates on a tape of cells, each containing an integer.
The program consists of a series of Chinese characters, each representing a different operation.
Instructions:
#移 (Yí) - Move the data pointer to the next cell to the right.
#靈 (Líng) - Move the data pointer to the next cell to the left.
#增 (Zēng) - Increment the value at the current cell by 1.
#減 (Jiǎn) - Decrement the value at the current cell by 1.
#若 (Ruò) - If the value at the current cell is 0, jump forward to the character after the matching 則 (Zé).
#則 (Zé) - Go back to the matching 若 (Ruò) if the value at the current cell is not zero.
#輸 (Shū) - Output the ASCII character represented by the value at the current cell.
#讀 (Dú) - Input a character and store its ASCII value at the current cell.
(This is just a Brainfuck deriative!)
== Example(Written by myself) ==
=== Hello, World! ===
增增增增增增增增增增增若移增增增增增增移增增增增增
增增增增移增增增增增增增增移增增增增移增增增移增靈
靈靈靈靈靈減則移增增增增增增輸移增增輸增增增增增增
增輸輸增增增輸移移輸移減輸靈靈減輸靈輸增增增輸減減
減減減減輸減減減減減減減減輸移移移增輸移減輸
=== Cat program ===
讀若輸讀則
== Implementation ==
import sys
def lingfu(code):
 s=[]
 matches={}
 tape=[0]*1000000
 for i,j in enumerate(code):
 if j=='若':
 s.append(i)
 if j=='則':
 m=s.pop()
 matches[m]=i
 matches[i]=m
 cp=0
 p=0
 while cp<len(code):
 if code[cp]=='增':
 tape[p]=(tape[p]+1)%256
 if code[cp]=='減':
 tape[p]=(tape[p]-1)%256
 if code[cp]=='輸':
 c=sys.stdin.read(1)
 tape[p]=(ord(c) if c else 0)%256
 if code[cp]=='讀':
 print(chr(tape[p]),end=)
 if code[cp]=='靈':
 p-=1
 if code[cp]=='移':
 p+=1
 if code[cp]=='若':
 if not tape[p]:
 cp=matches[cp]
 if code[cp]=='則':
 if tape[p]:
 cp=matches[cp]
 cp+=1
lingfu(sys.stdin.read())
== See also ==
* 脑子爆掉
== Categories ==
Category:Languages
Category:2024
Category:Brainfuck equivalents
Category:Turing complete
Category:Brainfuck derivatives
Category:Implemented
Category:Generated by AI
驫鶭

驫鶭, or BiaoFang, is invented by PSTF.
== Sources of inspiration ==
# BFInfinity
# Befreege
# BrainChina
== Requirements for more commands ==
# CJKV Unified Ideograms only(Such as 你我他(Basic)㐀㐂㚵(Ext.A)䶅(Ext.B) and so on, not requires only Basic area)
# No joke commands
# No commands that NEVER IMPLEMENT
== Original commands ==
 Caption text
This Esolang 	Mean
左 	See < in Brainfuck.
右 	See > in Brainfuck.
增 	See + in Brainfuck.
缩 	See - in Brainfuck.
读 	See , in Brainfuck.
写 	See . in Brainfuck.
始 	See [ in Brainfuck.
终 	See ] in Brainfuck.
上 	See ^ in Brainfuck+3.
下 	See v in Brainfuck+3.
入 	Input a hexadecimal and store it into current cell.
出 	Output the data under pointer as hexadecimal.
杀 	Kill the program.
听 	Read an integer and store it into the current cell.
说 	Output the data under the pointer as an integer.
空 	Set the data under pointer to 32.
虚 	Set the data under pointer to 0.
删 	Set the data under pointer to 127.
(The corresponding control character) 	Set the data under pointer to Their Unicode minus 0x2400.
(Full-width ASCII) 	Set the data under pointer to Their Unicode minus 0xFEE0.
尸[language]==========================code========================== 	Executes the program between two boundaries. If language is nothing, executes the program as Brainfuck.
吔 	Print "Hello, world!".
== Examples ==
=== Hello, world! ===
Simplest version:
 吔
Original version:
增增增增增增增增
始
 缩右增增增增增增增增左
终
右增增增增增增增增写
左增增增增增
始
 缩右增增增增增左
终右增增增增写
增增增增增增增写
写
增增增写
左增增增增增增增增
始
 缩右缩缩缩缩缩缩缩缩左
终
右缩缩缩写
左增增增
始
 缩右缩缩缩左
终
右缩缩缩写
左增增增增增增增增增
始
 缩右增增增增增增增增增左
终
右增增增增增增写
缩缩缩缩缩缩缩缩写
增增增写
缩缩缩缩缩缩写
缩缩缩缩缩缩缩缩写
左增增增增增增增增
始
 缩右缩缩缩缩缩缩缩缩左
终
右缩缩缩写
左
Readable Version:
Ｈ写ｅ写ｌ写ｌ写ｏ写，写空写ｗ写ｏ写ｒ写ｌ写ｄ写！写␍写␊写
=== A+B Problem ===
 听右听
 始
 左上右下
 终
 左写
==Categories==
Category:Languages Category:Brainfuck derivatives Category:Brainfuck equivalents Category:CJK Category:Pseudonatural Category:Turing complete Category:Turing tarpits Category:Cell-based Category:2024
한국어

한국어 is a language based on Hangul letters(Korean).
== Syntax ==
 Syntax
한국어 	Mean
출력 (comment) $(format)$ 	Print comment (with format).
입력할 (something) $(format)$ 	Input something (with format).
면 (식) {구획} 	If 식 is true, do 구획.
그렇지 않으 면 (식2) {구획} 	If 식1 is false but 식2 is true, do 구획.
다른 {구획} 	If none of the above conditional expressions are true, do 구획.
10 회 반복 	Repeat for 10 time.
식 이 참이 아닐 때까지 반복합니다 	Repeat until 식 isn't true.
A 를 type 로 정의합니다 	Define A as a type.
B 를 정의하고 10 으로 설정합니다. 	Define B and set it to 10.
C 를 10 으로 설정합니다. 	Set C to 10.
함수 정의 func 	Define a function and name it as func.
인수는 arg1, arg2 및 kwarg1=114514 입니다 	Give function with arguments *args or **kwargs.
돌아오다 0 	Return 0.
주기 (제어 변수 초기화 표현식; 조건식; 증분 표현식) 	for(Control variable initialization expression;Conditional expression;Incremental expressions)
 Operators
한국어 	Mean
안 	Logical not.
비트 안 	Bitwise not.
같음 	Equality.
같지 않음 	Non-equality.
보다 큼 	Greater than.
미만 	Less than.
보다 적지 않음 	Greater or equal.
보다 크지 않음 	Less or equal.
비트 고 	Bitwise and.
고 	Logical and.
이나 	Logical or.
비트 이나 	Bitwise or.
더할 	+
뺄 	-
곱하기 	×
나누기 기준 	÷
A 를 B승으로 	A^B
모듈로 	Modulo
치우치 증가 	s++ (Even C++ scripting has been figured out, right?)
치우치 줄다 	s--
and so on.
== Programs ==
=== Hello, world ===
출력 "전 세계 여러분 안녕하세요!\n"
=== Kiyeok+Nieun Problem* ===
기연, 니은, 티케우트 를 긴 정수 로 정의합니다
입력할 기연, 니은 "%d %d"
티케우트 를 기연 더할 니은 으로 설정합니다
출력 티케우트
*Why does it is not A+B Problem? 'Cause Kiyeok in Korean is A and Nieun is B.
=== 99 bottles of beers ===
주기 (색인 를 긴 정수 로 정의합니다; 색인 보다 큼 0; 색인 줄다)
{
 출력.판("벽에 걸린 맥주 %d 병,\n맥주 %d병.\n맥주 1 병을 내려 벽에, 벽에 걸린 맥주 %d 병.\n", 색인, 색인, 색인 뺄 1)
 1 초 동안 기다립니다
}
출력("벽에 걸린 맥주병은 더 이상 없고, \n더 이상 맥주 한 병이 없습니다.\n가게에 가서 좀 더 사세요, \n벽에 걸린 맥주 99병.")
or:
주기 (색인 를 긴 정수 로 정의합니다; 색인 보다 큼 0; 색인 줄다)
{
 출력.판("%d bottles of the beers on the wall, \n%d bottles of beer. \nTake 1 down, pass it around, \n%d bottles of the beers on the wall.", 색인, 색인, 색인 뺄 1)
 1 초 동안 기다립니다
}
출력("No more bottles of beer on the wall, \nno more bottles of beer. \nGo to the store and buy some more, \n99 bottles of beer on the wall.")
=== Cat program ===
문자열1 를 문자열 로 정의합니다
입력할 문자열1
출력 문자열1
=== Truth Machine ===
이응 를 불리언 로 정의합니다
입력할 이응
면 (안 이응) 
{
 출력 "영\n"
}
다른 
{
 (참) 이 참이 아닐 때까지 반복합니다
 {
 출력 "한\n"
 }
}
== Categories ==
Category:Languages Category:Pseudonatural Category:CJK Category:High-level
！中文

！中文, or !Chinese, is designed by PSTF. It is COMPLETELY based on Chinese.
== Syntax ==
Chinese grammar must be strictly followed. It is important to accurately describe how the entire program works. You can use rhetoric if you 're allowed.
== Programs ==
There is a large amount of programs. They are in ！中文/程序.
== Categories ==
Category:Languages
Category:CJK
Category:2024
Category:Unimplemented
Category:High-level
Category:Pseudonatural
！中文/程序

Main Page: ！中文
== Hello, world! ==
 输出“問天地好在。”。
== A+B Problem ==
 读入两个整数，输出它们的和。
== 99 x bottles of beers(Take y down version) ==
以“请输入初始数值：”作为提示输入 x 。
以“请输入\“增量\”：”作为提示输入 y 。
将 i 初始化为 x 。
清空屏幕。
重复执行以下代码直至 i 不大于 0 ：
{
 输出“%1 bottles of beers on the wall, \n%1 bottles of beers.\n”。%1将被 i 替代。
 将 i 减去 y 。
 输出“Take %1 down and pass it around,\n %2 bottles of beers on the wall.\n\n”。%1将被 y 替代，%2将被 i 替代。
}
输出“No more bottles of beers on the wall, \nNo more bottles of beers. \n”。
输出“Go to the store and buy some more, \n%1 bottles of beers on the wall.”。%1将被 x 替代。
== Roll the dice 10000 times ==
从《混沌》库中导入所有定义和声明。
定义一个列表 list ，它将用来存储一些东西。
重复执行以下代码一万次：
{
 在 list 的末尾加入一个从 1 到 6 的随机数。
}
输出 list 。
== Fizzbuzz ==
从 1 一直输出到 1000 。对于每个数字 n，有：
如果 n mod 3 = 0，则输出“Fizz”。
如果 n mod 5 = 0，则输出“Buzz”。
但是，如果 n 同时是 3 和 5 的倍数（即 n mod 15 = 0），输出“FizzBuzz”。
否则，输出 n 的值。
== Befunge Interpreter ==
输入来自用户的字符串，并将其分配给 SRC。
对于 SRC 中的每个字符，有：
> → 将指针向右移动。
< → 将指针向左移动。
^ → 将指针向上移动。
v → 将指针向下移动。
? → 随机移动指针。
_ → 弹出一个值；如果它是零，则将方向设置为右，否则设置为左。
| → 弹出一个值；如果它是零，则将方向设置为下，否则设置为上。
“ → 将所有字符读取为这个方向，直到下一个引号。
: → 从堆栈中复制顶部元素并将其入栈。
\ → 交换堆栈的两个顶部元素。
$ → 从堆栈中弹出顶部元素，然后将其扔进垃圾桶（开玩笑的，严肃地讲应该是不再使用该值）。
+ → 弹出 a 和 b，然后压入 a+b。
- → 弹出 a 和 b，然后压入 b-a。
* → 弹出 a 和 b，然后压入 a×b。
/ → 弹出 a 和 b，然后压入 b÷a。特别地，如果 a 是 0，则引发一个错误：“你让我做什么？！
% → 弹出 a 和 b，然后压入 mod(b, a)。特别地，如果 a 是 0，压入 0 。
! → 弹出 a，如果 a=0，则压入 1，否则压入 0。
' → 弹出 a 和 b，如果 b>a，则压入 1，否则压入 0。
. → 弹出 a，然后以整数形式输出 a。
，→ 弹出 a，然后以字符形式输出 a。
& → 从用户输入一个整数并将其入栈。
~ → 从用户输入一个字符并将其 Unicode 值（十进制）入栈。
（例如，半角感叹号将压入三十三，而汉字“一”压入一万九千九百六十八。）
0123456789 → 将值直接入栈。
# 或空格标记 → 占位符。
@ → 结束程序。
p → “put”调用（一种存储值以供以后使用的方法）。
弹出三个值 y、x 和 v，然后将程序中位置 （x，y） 处的字符更改为 Unicode 为 v 的字符。
g → “get”调用（一种在存储中检索数据的方法）。
弹出两个值 y 和 x，然后在程序中将字符的 Unicode 值入栈。如果 （x，y） 超出边界，则压入 0。
== Truth Machine ==
从用户读入一个整数并将其转化为布尔值。
如果结果为假，输出 0 ，然后结束。
如果结果为真，则一直输出 1 ，直到用户按下 P 键，然后按 Ctrl+C （不是复制），再然后按 Y 。
== Speed-up sort ==
————————快————————速————————排————————序————————
首先从数列中选择一个基准数，然后通过一趟排序将待排记录分割成独立的两部分，
其中一部分的所有数据都比另一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，
整个排序过程可以递归进行，以此达到整个数据变成有序序列。
————————快————————速————————排————————序————————
从用户读入一个整数并将其赋值给 N ，然后从用户读入一个长度为 N 的整数序列。
将这个整数序列快速排序，然后输出排序结果。
== 非也。 interpreter ==
从用户端读入一串字符串，然后把它撅了扔进垃圾桶，再然后输出“非也。”，没有换行。
== Other ==
即将推出，敬请等待。
== Categories ==
Category:Examples
Ａｅｓｔｈｅｔｉｃｓ

a e s t h e t i c s, or Ａ Ｅ Ｓ Ｔ Ｈ Ｅ Ｔ Ｉ Ｃ S (stylized forms of Ａｅｓｔｈｅｔｉｃｓ) a joke language but not.
ａｅｓｔｈｅｔｉｃｓ is a esoteric programming language in which programs look like abstract chatbots and hikikomori users. 
ａｅｓｔｈｅｔｉｃｓ was invented by Wallace Dutra a.k.a. @_wallacedutra, inspired in Vaporwave subculture, and its goddess, Vektroid a.k.a. MACINTOSH PLUS, in Floral Shoppe album.
ａｅｓｔｈｅｔｉｃｓ it is inspired in visual art and music which typically include Japanese and unknown lettering and nostalgic themes from 1980s and 1990s computer operating systems and video game consoles.
リサフランク420 / 現代のコンピュー! [Hello World!]
 Instructions:
Instruction 	What it does
リサフランク420 / 現代のコンピュー! 	Prints 'Hello,World!'
Ａｅｓｔｈｅｔｉｃｓ 	Prints the lyrics to 99 bottles of beer
ＭＡＣＩＮＴＯＳＨ　ＰＬＵＳ 	Quine
蒸気波 	Increment a hidden accumulator
Thus we can treat this language as HQ9+ derivative.
==Examples==
===Facility Test===
This program serves the endeictic purpose of invoking all four available instructions:
 リサフランク420 / 現代のコンピュー!
 Ａｅｓｔｈｅｔｉｃｓ
 ＭＡＣＩＮＴＯＳＨ　ＰＬＵＳ
 蒸気波
==Interpreter==
* Common Lisp implementation of the Ａｅｓｔｈｅｔｉｃｓ programming language. Please note that the concrete character set deployed constitutes a dependency on the Common Lisp implementation; in corollary, Unicode support may or may not be a feature incorporated in the personal environment. The interpreter at hand has been developed and tested with Steel Bank Common Lisp (SBCL) version 1.1.4 as part of the Lisp Cabinet 0.3.5 bundle.
Category:LanguagesCategory:ThematicCategory:ImplementedCategory:CJKCategory:Joke languages
＿

_ is an esolang by User:PythonshellDebugwindow.
==Commands==
Command 	Effect
% 	Pop a character from the end of the source code
$ 	Pop a character from the end of the source code and set the next character in the source to the popped character
^ 	Skip the next command if the last character in the source code is 0
\ 	Append the next character to the end of the source code and skip it
Anything else	Append the character to the end of the source code
==Examples==
===Infinite loop===
 0
===Truth-machine===
Replace 1 with 0 for input 0.
 ^1
==External resources==
* An interpreter on GitHub
Category:Languages Category:2020 Category:Self-modifying Category:Push-down automata Category:Implemented Category:String-rewriting paradigm Category:No IO
｢Zero Existance⇩｣

｢Zero Existance⇩｣ is a language that comes with a README.txt for how to use a slightly modified version of Burn and the only compiler that actually works for that version. However the program only works when the current user as an existence level of zero or less. Meaning the current user has:
* Been completely forgotten by everyone
* Died
* Not had any records.
Basically, there is no way to know who the user was, and ONLY then would the compiler work.
If the current user exists in ANY way. The compiler auto-deletes itself.
(Also this program is technically Turing complete and is 2D like Burn, but I will not put that there due to the unusable it is. In fact I put uncomputable since a computer cannot really know if a user exists without waiting a billion years.)
(Also ⇩ is the bad way of saying "or definitely less than" in the place someone thought this was a good idea, which basically means arbitrary notation. Also this is obviously based off of ( )
Category:Joke languages Category:Languages Category:2022 Category:Unusable for programming Category:Unimplemented Category:Uncomputable
𝔹oxƒ⊙ck

𝔹oxƒ⊙ck is a esolang based on boolean modification using Functions with the only logic gate XNOR written using unicode box drawing.
=== booleans ===
To create a boolean:
 ▓ is 1 and ░ is 0
Booleans are sent through wires(the box drawing) like this:
 ┷
 ▓┠ ┨▓ ▓ ▓
 ┯
To apply the XNOR:
 └╥┘
 ┌╨┐
The result passes through the left wire and the opposite passes through the right one. To save a variable:
 ╒═╗
 ┤A║
 ╘═╝
Here the name is A but it can be as long as you want. The left input is what its set to. To refrence it:
 ┏━┓
 ┨A┠
 ┗━┛
The variable will pass through both wires.
=== wires ===
A wire is any unicode box drawing thats not used as a command is not a double or heavy and is not a t junction
=== functions ===
A function is stored in a specific to section box. The top section is the name and the lower one is the function itself:
 ┌─┐
 │A│
 ┟─┧
 ┠─┨
 ┗━┛
All the left t junctions are the function inputs and the single uppermost t junction to the right is the output. To reference this function:
 ┌─┐
 │A├┬
 └─┘
The downwards part of the t junctions is the input. The top input of the function creation is the leftmost input of the reference. The output is the vertical
=== other ===
To copy A and delete B:
 B
 A┼A
 A
To do a crossing without this:
 A
 │
 B─▒─B
 │
 A
If A is 0 send B, Else send 0:
 A┬B
 C
=== useful functions ===
NOT function:
 ┌───┐
 │NOT│
 ┟───┧
 ┃ ░ ┃
 ┠┐┯┌┨
 ┃│╞╡┃
 ┃└┘└┨
 ┗━━━┛
XOR function:
 ┌─────┐
 │XOR │
 ┟─────┧
 ┠┐┌┐┌─┨
 ┃╞╡└▒─┨
 ┠┘└─┘ ┃
 ┗━━━━━┛
AND:
 ┌───────────┐
 │AND │
 ┟───────────┧
 ┃┌───┐ ┃
 ┃│NOT├┬┐ ┃
 ┃└───┘││┌┐┌─┨
 ┠─────┘╞╡└▒─┨ 
 ┃┌───┐ │└─┘ ┃
 ┃│NOT├┬┘ ┃
 ┃└───┘│ ┃
 ┠─────┘ ┃
 ┗━━━━━━━━━━━┛
NAND:
 ┌──────────────┐
 │NAND │
 ┟──────────────┧
 ┃┌───┐ ┌───┐ ┃
 ┃│AND├┬┬┐│NOT├┬┨
 ┃└───┘│││└───┘│┃
 ┠─────┘│└─────┘┃
 ┠──────┘ ┃
 ┗━━━━━━━━━━━━━━┛
== See also ==
* Funciton
Category:Languages Category:Two-dimensional languages Category:Thematic
𝕃𝔸𝕄𝔹𝔻𝔸♯

𝕃𝔸𝕄𝔹𝔻𝔸♯ is a programming language based off of Lambda Calculus made by User:Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff. All functions must be named after whole numbers, and functions can have multiple arguments without the need for currying. The ℕ symbol is a generalized function definition. It creates a function for every number. Curly brackets are used in function bodies. Also minus sign is for negative numbers, and subtracting. Functions use polish notation. Also the function name is after the lambda.
== Programs ==
input is used as a placeholder for user to input something, and the final program state is the output
=== Calculator ===
 λ 1 2 3 { - 2 - 0 3 } λ -1 2 3 { - 2 3 } input input input
The first input is the operation, 1 is plus, -1 is minus.
=== truth-machine ===
 λ 1 { 1 } λ 0 { } input
=== counter ===
 λ ℕ { - ℕ -1 } 0
== computation class ==
since its just lambda calculus but with numbers, it is turing complete
== quirks ==
λ 2 { 2 } is a identity function, while λ 2 { - 3 1 } always returns 2.
Category:Turing complete Category:Turing tarpits Category:No IO Category:Languages Category:Functional paradigm Category:Unimplemented
🅿🅸🅴🆃

🅿🅸🅴🆃 is a programming language inspired by Piet. It is a text-based equivalent of Piet.
==Execution==
The colors in 🅿🅸🅴🆃 are shown below:
White ⚪ (U+26AA) 	White ⚪ (U+26AA) 	White ⚪ (U+26AA) 	White ⚪ (U+26AA) 	White ⚪ (U+26AA) 	White ⚪ (U+26AA)
Light red ❤ (U+2764) 	Light yellow 🧡 (U+1F9E1)	Light green 💛 (U+1F49B)	Light cyan 💚 (U+1F49A)	Light blue 💙 (U+1F499)	Light magenta 💜 (U+1F49C)
Red 🔴 (U+1F534) 	Yellow 🟠 (U+1F7E0) 	Green 🟡 (U+1F7E1) 	Cyan 🟢 (U+1F7E2) 	Blue 🔵 (U+1F535) 	Magenta 🟣 (U+1F7E3)
Dark red 🟥 (U+1F7E5)	Dark yellow 🟧 (U+1F7E7) 	Dark green 🟨 (U+1F7E8) 	Dark cyan 🟩 (U+1F7E9) 	Dark blue 🟦 (U+1F7E6) 	Dark magenta 🟪 (U+1F7EA)
Black ⚫ (U+26AB) 	Black ⚫ (U+26AB) 	Black ⚫ (U+26AB) 	Black ⚫ (U+26AB) 	Black ⚫ (U+26AB) 	Black ⚫ (U+26AB)
Black ⚫ (U+26AA) and white ⚪ (U+26AB) do not fall into either cycle.
You can also use 🖤⬛ for black or 🤍⬜ for white, but please remember that a "black" symbol of one "shape" can not restrict the pointer sliding in a "white" block of another shape, and that a "white" symbol of one shape will restrict the pointer sliding in a "white" block of another shape unless the pointer sees non- "white" symbols on both its left (port) and its right (starboard). Therefore, it is better to just use ⚫ and ⚪ rather than the other "black" or "white" shapes in your program.
Brown (🤎🟤🟫) is considered undefined behavior.
Some compilers may feature an additional symbol, the "grey circle" 🔘 (U+1F518). Every time the pointer encounters this grey circle, it randomly decides whether it is treated as ⚫ or ⚪, allowing a "random number generator" to be created.
Some compilers treat ♥ (U+9829) the same as ❤, though this is not recommended.
Newline characters are used to separate lines. It is recommended that all lines in the program be of the same length. If not all lines are of the same length, it is considered undefined behavior, though simply appending ⚫ or ⚪ to the end of the shorter lines may help. Characters not mentioned above at the end of each line are ignored. If such "undefined characters" appears in the middle of a line (or at the beginning), they are either ignored or treated as ⚫ or ⚪, depending on the implementation.
Commands are the same as commands in Piet.
==See also==
* Piet++
Piet emoji
Piet emoji
Piet emoji
🆂🆀🆄🅰🆁🅴.🅹🆂

🆂🆀🆄🅰🆁🅴.🅹🆂 is a joke language. 
== Commands ==
Every single one of JavaScript.
== Examples ==
===Hello, World!===
🅲🅾🅽🆂🅾🅻🅴.🅻🅾🅶("🅷🅴🅻🅻🅾, 🆆🅾🆁🅻🅳")
===Hello, World! (alert())===
🅰🅻🅴🆁🆃.🅻🅾🅶("🅷🅴🅻🅻🅾, 🆆🅾🆁🅻🅳")
=== Fibonacci ===
🆅🅰🆁 🅸;
🆅🅰🆁 🅵🅸🅱 = [0, 1]; // 🅸🅽🅸🆃🅸🅰🅻🅸🆉🅴 🅰🆁🆁🅰🆈!
🅵🅾🆁 (🅸 = 2; 🅸 <= 10; 🅸++) {
 // 🅽🅴🆇🆃 🅵🅸🅱🅾🅽🅰🅲🅲🅸 🅽🆄🅼🅱🅴🆁 = 🅿🆁🅴🆅🅸🅾🆄🆂 + 🅾🅽🅴 🅱🅴🅵🅾🆁🅴 🅿🆁🅴🆅🅸🅾🆄🆂
 // 🆃🆁🅰🅽🆂🅻🅰🆃🅴🅳 🆃🅾 🅹🅰🆅🅰🆂🅲🆁🅸🅿🆃:
 🅵🅸🅱[🅸] = 🅵🅸🅱[🅸 - 2] + 🅵🅸🅱[🅸 - 1];
 🅲🅾🅽🆂🅾🅻🅴.🅻🅾🅶(🅵🅸🅱[🅸]);
}
==Interpreter==
https://codepen.io/PatoFlamejanteTV/pen/PwYYZpV
Input (🆀🆆🅴...)
<textarea id="inputField" rows="4" cols="50"></textarea>
<button onclick="mapAndExecute()">Map & Execute</button>
Output (js code)
<textarea id="outputField" rows="4" cols="50" readonly></textarea>
function mapAndExecute() {
 // Reversed Mapping object: special characters to standard keyboard characters
 const charMap = {
 '🆀': 'q', '🆆': 'w', '🅴': 'e', '🆁': 'r', '🆃': 't', '🆈': 'y', '🆄': 'u', '🅸': 'i', '🅾': 'o', '🅿': 'p',
 '🅰': 'a', '🆂': 's', '🅳': 'd', '🅵': 'f', '🅶': 'g', '🅷': 'h', '🅹': 'j', '🅺': 'k', '🅻': 'l',
 '🆉': 'z', '🆇': 'x', '🅲': 'c', '🆅': 'v', '🅱': 'b', '🅽': 'n', '🅼': 'm'
 };
 // Get the input field value
 const inputField = document.getElementById("inputField");
 const inputValue = inputField.value;
 // Map special characters back to standard characters
 let jsCode = ;
 for (let char of inputValue) {
 jsCode += charMap[char] || char; // If char is not in map, use original char
 }
 // Display the JS code
 document.getElementById("outputField").value = jsCode;
 // **WARNING: USING EVAL() WITH UNSAFE INPUT CAN BE DANGEROUS**
 // Execute the JS code (for demonstration purposes only)
 try {
 eval(jsCode);
 } catch (e) {
 console.error("Error executing JS code:", e);
 alert("Error executing JS code. Check console for details.");
 }
}
Category:Languages Category:Joke languages Category:Implemented Category:2024 Category:Turing complete Category:High-level