nyuuzyou/wikis huggingface dataset:
Golf/Feature golf

Feature golf is a program form. Its goal is to to write a short program that uses up all of the possible commands in a programming language without including dead code. Every instruction should be executed at least once. It was intended to present new users an overview of all of the commands in a language.
==Examples==
===brainfuck===
+-><.,[]
===deadfish===
idso
===ACL===
D012459A6378BCEDF
===Rook===
FT
==Competitive usage==
In addition to using up all commands, a restricted Feature golf must present everything that is possible in a language. For example, if you are posting a solution in brainfuck (which supports nested loops and non-instruction comments), a brainfuck post must contain all instructions as well as at least 1 nested loop and non-instruction comment. Also, people should require users to do a specific thing in addition to inclucing all of the commands.
==Examples==
===brainfuck===
,[.-[-
>+<]>+]
==See also==
Golf
Category:Program forms
GolfJoke

GolfJoke is a joke esolang, where the file is empty for 1, one byte for 2 to 257, two byte for 258 to 65793. Whatever number it is, is the anarchy golf problem of that number in base-255, which is what that program is supposed to be, rather than necessarily what it actually is. (In some problems, there are special restrictions for the code, like the fact that the code must be a palindrome, making it impossible.)
Category:Joke languages Category:Languages Category:Golfing language
GolfScratch

GolfScratch - language for Code Golfing Made By User:ChuckEsoteric08
==Commands==
'Word' is an command or argument
 PUSH - Push Something To The Stack (If It Is The ACC Push Accumulator)
 POP - Pop From Top of The Stack
 PRINT - Print Top of The Stack
 INP Get Input And Push It To The Stack
 GOTO [x] - Goto word [x]
 IF [x] [y] [z] - If Top Of The Stack == [x] Goto word [y] Else Goto word [z]
 (space) - Seperate commands and arguments
 CH. - Increment ACC by Top Of The Stack
==Examples==
===Hello World===
 PUSH Hello,_World PRINT
NOTE:Spaces are used to split Commands so, strings with spaces cannot be printed.
===Print 1 Forever===
 PUSH 1 PRINT GOTO 1
===Cat program===
 INP PRINT GOTO 1
==Computation Class==
Maybe This is Turing Complete, Because You Can Make Infinity Loop,and the stack is unbounded. Due to its use of only 7 commands, this language would also be considered a Turing tarpit if so.
==External links==
Interpreter In Scratch
Github Repositpry
Category:Languages Category:Pseudonatural Category:Golfing language Category:Implemented Category:Stack-based
GolfSpace

GolfSpace is a joke esolang invented by User:A inspired by Golf Cheat and GolfJoke. It is essentially GolfJoke, except the question number is encoded as backspaces and Deletes as binary strings. Since these two characters remove characters(counting as negative characters), it is possible to have a submission with a negative bytecount.
Category:Joke languages Category:Languages Category:Golfing language Category:Zero-dimensional
Golf Cheat

In Golf Cheat, a zero bit program solves the current problem in the golf competition you are currently competing in.
A one bit program solves either the previous or next problem in the competition. A two bit program solves one of the two problems prior to the previous problem or one the two problems after the next problem. Larger programs analogously solve problems further in the past or future.
Some crazy genius might use Golf Cheat's narrow window into the future for some nefarious ends.
==Examples==
Solve your current golfing problem (0 bits):
:(empty)
Category:Languages
Category:Uncomputable
Category:Turing complete
Category:Golfing language
Category:Joke languages
Category:2017
Golfed!

Golfed! is a esolang created by Mihai Popa. It's designed for code golfers, as it has many commands.
== Commands ==
 Command table
Command	Meaning
h 	Prints "Hello!" to the console.
w 	Prints "Hello, world!" to the console.
9 	Prints the lyrics of the song 99 Bottles of Beer to the console.
f 	Executes the "Fizz Buzz" program
c 	Executes the cat program
q 	Prints "q" to the console. Could also be used as a quine.
t 	Executes the Truth Machine program
r 	Prints the lyrics of the song Never Gonna Give You Up to the console.
b 	Executes the Brainfuck interpreter
s 	Executes the SquidScript interpreter
8 	Executes the Befunge-98 interpreter
3 	Executes the Befunge-93 interpreter
m 	Executes the Malbolge interpreter
i 	Executes the self interpreter
== Examples ==
=== Hello, world! ===
w
=== Cat ===
c
=== Quine ===
q
=== Fizz Buzz ===
f
=== 99 Bottles of Beer ===
9
=== Truth Machine ===
t
Category:Languages
Category:2023
Category:Unimplemented
Category:Golfing language
Golficator

Golficator is a computational model invented by User:Hakerh400. This computational model is designed to be able to convert any Turing-complete language into a golfing language.
== Overview ==
Given a Turing-complete language L, we describe the process of constructing a new language L'.
First create the list of all syntactically valid programs in L sorted in some way. Each program in the list represents a mapping from strings to strings.
Then remove from the list all programs that throw an error for at least one input or do not halt for at least one input. Then remove duplicates, that is, remove each program whose input-output mapping is identical to some program that appears before in the list.
The list now contains unique programs. Each program in the list halts for all inputs and each program represents a unique input-output mapping.
Each program in L' consists of a single non-negative integer that represents the index in the list. We simply pick the program for that index and execute it as an L program.
== Computational class ==
The process of constructing L' is uncomputable. However, L' itself is computable, but since all programs halt, it is a total language so it is not Turing-complete.
== Characteristics ==
Language L' is much more suitable for golfing purposes, because useless programs are removed (the ones that throw an error or do no halt). Also, there are no duplicate programs, so each program can do some new useful stuff. Since the integer in L' can be represented in any way, we can encode it as an array of bytes to make it more compact.
== Implementation ==
Unfortunately, Golficator is unimplementable on a Turing-machine. However, assuming the consistency of some mathematical system and picking a good L to start with, we can more-or-less manually construct the beginning of the list, so we can actually do the computation for some short programs.
Category:Computational models
Golfrun

Golfrun is a stack oriented esoteric programming language derived by GolfScript. Indeed, Golfrun was born as a C interpreter for GolfScript (removing the possibility to escape GolfScript itself and use Ruby), but soon it started to mutate.
Golfrun is mostly compatible with GolfScript and current C interpreter has a "try to be more GolfScript compatible" switch.
Golfrun is still suitable for code-golfing, though likely GolfScript allows for more dirty tricks and thus shorter code. Since Golfrun is under development and (personal) formal definition process, it is doomed to change a bit, even if the core features and concepts will stay the same.
==External resources==
* Golfrun sourceforge project page
* Golfrun web site hosted at Sourceforge
* Golfrun incomplete tutorial that could contain errors...
Category:Languages
Category:2012
Category:Implemented
Category:Turing complete
Category:Stack-based
Golfuck

golfuck is an extension of brainfuck invented by User:A. It is created in order to write short programs.
In addition to brainfuck, golfuck adds a stack.
=Commands added(still extending)=
{}:repeat while the top of the stack is not "0".
$:starts an infinite loop
%:ends an infinite loop
: input a string and push it into the stack.
; output the top of the stack.
' output the whole line. This command is specifically for printing hello, world. It will only execute after every other code is executed.
! pop the stack
* duplicate the top of the stack
| set the current pointing byte as the top of the stack
^ pop the top value of the stack to the current pointing byte
@ push the current pointing value into the stack
` swap 2 top elements
? concentrates the top 2 elements of the stack if the two elements are strings; add them if they are integers.
# execute the top element of the stack as the program, then pop the stack
(x) push the string x into the stack
r replace all the *s in a string, and all the **s as *.
"" replace the output using regular expressions. E.g. "a,"+1",b" finds "a", sets the replacing at one character behind, and replaces the characters equal length as the first search as "b".
9 prints the 99 bottles of beer lyrics.
=Example programs=
==Hello, world!==
 'Hello, world!
==Cat program==
 $:;%
==Quine(Directly translated from GolfScript)==
 (*#)*#
==Truth-machine==
 :{;};
==99 bottles of beer program==
 (* bottles of beer on the wall,
 * bottles of beer.
 Take one down and pass it around,)
 (* bottles of beer on the wall.)(99)=|![`*r;!-`*r;!]"1,"+9",""0,"+0",no more"
Another cheating way:
 9
=Computational class=
golfuck is Turing-complete, as it can be shown to be computationally equivalent to Underload: the golfuck commands `*!?()# correspond to the TC subset of Underload commands ~:!*()^.
=Partial implementation in C++=
Temporarily written here because it is short. This is a part of it with the brainfuck commands and the commands (, ), ', *, ":" and ";" .
#include<stdio.h>
#include<string>
#include<iostream>
#include<stack>
#include<stdlib.h>
using namespace std;
int c,d[999999],a[999999],i,p,l,it;//c:char; d:code; a:array; i:iterator; p:pointer; l:level
//it: int temp
stack<string> s;
//s:stack
string t,t2;
int main(int j,char *k[]){//j:argc; k:argv
	ios::sync_with_stdio(false);//make it faster
	FILE *f=fopen(k[1],"r");
	for(;(c=fgetc(f))!=EOF;i++)d[i]=c;
	for(i=0;d[i]>0;i++){
		if(d[i]==43)a[p]++;//+
		if(d[i]==45)a[p]--;//-
		if(d[i]==62)p++;//>
		if(d[i]==60)p--;//<
		if(d[i]==46)putchar(a[p]);//.
		if(d[i]==44)a[p]=getchar();//,
		if(d[i]==91&&!a[p])//[
			for(l=0;i++;){
				if(d[i]==93&&!l)break;
				if(d[i]==91)l++;
				if(d[i]==93)l--;
			}//]
		if(d[i]==93&&a[p])
			for(l=0;i--;){
				if(d[i]==91&&!l)break;
				if(d[i]==93)l++;
				if(d[i]==91)l--;
			}
		if(d[i]=='%')
			while(d[i]!='$')i--;
		if(d[i]==':')
			cin>>t;
			s.push(t);
		if(d[i]==';')
			cout<
Category:2019
Category:Stack-based
Category:Unimplemented
Category:Turing complete
Category:Brainfuck derivatives
Category:Languages
Golunar

Golunar is a derivative of Unary, which is itself a derivative of Brainfuck. It is thus even further removed from usability.
Golunar was derived by Peter Berg in 2013. The name is a mix of "Unary" and "logarithm."
== Instructions ==
A valid Golunar program is constructed by writing, in decimal, the number of zeroes in the equivalent Unary program.
==Examples==
=== Program that gets a single character and outputs it again ===
108
=== Cat program, EOF returns 0 ===
56623
=== Translator ===
The following shell script can be used to convert from brainfuck to Golunar. For best results, it should be run as BC_LINE_LENGTH=0 sh bf2gl.sh FILE.
 bf='><+\-.,[]'
 echo "ibase=2; 1`cat $1 | tr -cd $bf | tr $bf '\0-\7' | xxd -b -c1 | cut -d\ -f2 | sed s/00000// | paste -sd '\0'`" | bc
Category:Languages
Category:Turing tarpits
Category:Brainfuck derivatives
Category:Brainfuck equivalents
Category:Low-level
Category:Joke languages
Category:2013
Category:Turing complete
Category:Implemented
Category:Cell-based
Good writing, bad execution

good writing, bad execution or GWBE, is a language that, even though its function is not TC, its error checking is TC (i think)
== esolang ==
the language is made up of three bracket types:
 () the inside is looped forever
 [] the inside loops once
 {} the inside loops until the left and inner -most loop end
if the brackets arent matched then the program returns a true as an output else it returns a true and runs. thats it
== is it TC? ==
i heard that any langauge that can make sure all brackets are matched with the three brackets is TC. so the error checking is TC to implement if thats true
Goofy Ahh Esolang

A stack-based esolang created by User:Dominicentek where every time you execute an instruction a goofy ahh sound plays based on the instruction. There's a 500ms delay between each instruction.
== Instructions ==
Instruction	Sound 	Description
if 	huh 	Skips over the next instruction if the number on top of the stack is 0. Pops.
goto 	slip 	Moves the instruction pointer to a line number, the line number is defined as an instruction argument
reverse 	boing 	Reverses the stack
copy 	piano 	Duplicates the value on top of the stack and pushes it
pop 	vine boom 	Pops the stack and discards the number
printstr 	fard 	Prints the number on top of the stack as an ASCII character. Pops.
printnum 	nerd 	Prints the number on top of the stack as-is. Pops.
add 	raaar 	Adds 2 numbers together on top of the stack (B + A) and pushes the result. Pops the 2 operands.
subtract 	dry bones 	Subtracts 2 numbers together on top of the stack (B - A) and pushes the result. Pops the 2 operands.
multiply 	bell 	Multiplies 2 numbers together on top of the stack (B * A) and pushes the result. Pops the 2 operands.
divide 	omg 	Divides 2 numbers together on top of the stack (B / A) and pushes the result. Pops the 2 operands.
0 	alarm 	Pushes the number 0 on top of the stack
1 	what the hell	Pushes the number 1 on top of the stack
2 	aw hell nah 	Pushes the number 2 on top of the stack
3 	notification 	Pushes the number 3 on top of the stack
4 	21 	Pushes the number 4 on top of the stack
5 	laugh 	Pushes the number 5 on top of the stack
6 	pizza here 	Pushes the number 6 on top of the stack
7 	pablo 	Pushes the number 7 on top of the stack
8 	metal pipe 	Pushes the number 8 on top of the stack
9 	saul nokia 	Pushes the number 9 on top of the stack
== Example programs ==
=== Hello World ===
8
9
multiply
9
1
add
9
1
add
multiply
1
add
9
1
add
9
1
add
multiply
8
add
copy
4
4
multiply
7
multiply
1
subtract
9
2
add
4
multiply
8
4
multiply
9
9
multiply
6
add
4
4
multiply
7
multiply
1
subtract
4
4
multiply
7
multiply
2
add
9
1
add
9
1
add
multiply
8
add
9
1
add
9
1
add
multiply
8
4
multiply
1
add
reverse
printstr
printstr
printstr
printstr
printstr
printstr
printstr
printstr
printstr
printstr
printstr
printstr
printstr
=== truth-machine ===
Since this esolang doesn't have a way to get user input, change the top-most value.
1
copy
if
goto 7
printnum
goto 999
copy
printnum
goto 7
== Interpreter ==
Source code and download
Category:Implemented Category:Languages Category:2023 Category:Stack-based
Gopher

Gopher is an esoteric language created to be similar in some ways to brainfuck but at the same time being its own thing.
Current Version: 1.0
An online Interpreter can be found at Gopher Language Interpreter on GitHub.
Gopher uses a single character pointer to point to a character on the Unicode table using the functions listed below you can move this pointer. The only limitation of this language is that you can not reset the pointer with a single function.
How to use the language:
+: +1 to the char pointer
- -1 from the char pointer
× +4 to the char pointer (Unicode ×)
÷ -4 from the char pointer (Unicode ÷)
^ +8 to the char pointer
@ -8 from the char pointer
? +16 to the char pointer
! -16 from the char pointer
& +32 to the char pointer
% -32 from the char pointer
$ +64 to the char pointer
# -64 from the char pointer
: +128 to the char pointer
; -128 from the char pointer
[ Start a Multiplication loop
, Sepereate a set of instructions to be multiplied by a number chosen by more instructions
] End a Multiplication loop
' Double the Pointer Value
. Halve the pointer Value
< Push the character onto the stack which is where the char pointer is pointing
= Output the code to the user
Hello World Example (44 Characters)
'&++<'×<&÷+<^-<<×-<#!+<'?^-<?^<×-<÷--<@<.!<=
Hello World Example (42 Characters)
&++<'×<&÷+<^-<<×-<#!+<$@-<&@<×-<@++<@<.!<=
Quine Example (1 Character)
=
Category:Languages
Category:Implemented
Category:2016
Goruby

goruby is a modification of the ruby programming language to make it somewhat more suitable to code golf. It is implemented by the files goruby.c and golf_prelude.c which are distributed with the ruby source code. The most important changes to ruby are that it allows you to use abbreviated method names and finds the matching method automatically, puts Array's methods (such as join) to Enumerable, and makes integers Enumerable.
Category:Languages
Category:Implemented
Got a match?

Got a match? is a trivial sorting algorithm invented by User:A.
==Algorithm (in Natural language)==
While the next modified state is different from the previous state:
 Search from right to left for a matching item that is equal to the leftmost item
 Put that leftmost item after this matching item
 Delete that leftmost item
If the end of the item list is less than the beginning of the item list:
 Reverse-cat the item list
==Examples==
321321
 213321
 133221
 332211
*HALT*
Category:Program forms
Category:2019
Goto

The Goto programming language is an esoteric language by User:Rdococ in which there are only goto statements, and goto statements can have multiple line numbers, which then the user specifies which one to go to.
== Structure ==
Every instruction is of the form:
GOTO 1 3 5 ...
If the GOTO statement has multiple arguments, the user is asked to input a number from 1 to the total number of statements and the program jumps to the corresponding argument. If the program jumps to a non-positive line, the negation of that number is printed to output and the program terminates immediately.
== Computational Class ==
GOTO statements are states and its arguments are the transitions. Goto programs are therefore finite state automata.
Goto programs are able to recognize regular expressions. Map each symbol in the alphabet to a consecutive integer and non-positive line numbers to output states, then write down each state and its transitions to other states.
== Examples ==
=== Truth-machine ===
If you input 1, then the program halts. If you input 2, the program will never halt.
GOTO 0 2
GOTO 2
== Implementations ==
* (no output)
Category:Implemented
Category:Languages
Category:Finite state automata
GotoFuck

GotoFuck (also known as GotoF, GotoF***) is a brainfuck derivative by VilgotanL, It is identical to brainfuck except that uses a conditional goto instead of the regular while-loop.
== Instructions ==
+ 	Increment the cell at the pointer
- 	Decrement the cell at the pointer
> 	Move the pointer right
< 	Move the pointer left
. 	Print the value of the cell at the pointer as an ascii character
, 	Take one character of input and place its ASCII code into the cell at the pointer, 0 on EOF
:n	If the value of the cell at the pointer is 0, goto the line n with line numbers starting at 1, if n is omitted, invalid, or out of range, the program ends if the cell at the pointer is 0
Any other instructions are ignored.
== Examples ==
=== Cat program ===
,:.>
:1
=== Hello World (slightly optimized, transpiled from brainfuck) ===
>>++++++:3>
<-<<++++++++++++>>:3>:2
<<.>>++++:5>
<-<<+++++++>>:5>:4
<<+.+++++++..+++.:7>
<-:7>:6
>>++++:9>
<-<<+++++++++++>>:9>:8
<<.------------.>>++++++++:11>
<-<<+++++++++++>>:11>:10
<<-.--------.+++.------.--------.:13>
<-:13>:12
>>++++:15>
<-<<++++++++>>:15>:14
<<+.:17>
<-:17>:16
++++++++++.:19>
<-:19>:18
=== Truth-machine ===
,.:3>
<->>+>>+<<<<:3>:2
++++++:5>
<->>--------<<:5>:4
>>:7>
<>>.<<:7>:6
== Computational class ==
GotoFuck is Turing-complete since brainfuck can be transpiled to it using the following translation table:
Brainfuck	GotoFuck
> 	>>
< 	<<
[ 	
:n>
< where n is the line number after the transpiled code of the matching ]
] 	
:after>:n where after is the line number after this line, and where n is the line number after the transpiled code of the matching [, (the line with the <)
All other instructions are the same.
This can be shown in action in this transpiler.
== Implementations ==
Interpreter by the creator
==See also==
* Jumplang
Category:Languages
Category:Brainfuck_derivatives
Category:Turing_complete
Category:Turing_tarpits
Category:2021
Category:Implemented
Category:Cell-based
GotoLang

This is an esolang created by islptng.
In this esolang, the only command is Goto(with a few add-ons).
== Syntax ==
Only one command:
 label:goto
Self-explanatory.
However, general "match" (just "add-ons") is supported. It can match any integer in [].
In the following example, foo[2]bar[6]baz will go to foo[16]bar[1]baz. 
The priority is at the bottom, so foo[11]bar[11]baz will go to exit, instead of foo[21]bar[10]baz.
 foo[11]bar[11]baz: exit
 foo{a}bar{b}baz: foo{b+10}bar{a-1}baz
== Computational model ==
Turing Complete, because it can simulate Minsky machines. 
== Implementation ==
I need someone to make one.
Category:Languages Category:Unimplemented Category:2024 Category:Low-level
GotoStart

GotoStart is an esolang by User:ChuckEsoteric08 and is Turing complete descendant of UBLANG.
==Specification==
GotoStart uses registers (0-indexed) to store data. Language requires at least 3 registers to be Turing-complete
Instruction	Description
+(x) 	Increment register x.
-(x) 	Decrement register x if it is bigger than 0.
=(x:y) 	Set register x to y.
.(x) 	Output register x.
?(x=y>abc) 	If registerx is equal to y execute instructions abc.Note that parenthesis should match to make nested if statements possible.
^ 	Go to the start of the program.
==Infinite GotoStart==
Programs in this version of GotoStart always end with ^ and ^ is not allowed to appear elsewhere. Despite this, the language still remains Turing-complete.
==GotoStartpocalypse==
In this version if statements always looks like ?(x=0>^) and ^ is not allowed everywhere else, and the command =(x:y) is also removed. That would make it almost equivalent to the Brainpocalypse II and Subtractpocalypse, also making it Turing-complete
==Examples==
===Repeating Counter===
This GotoStart and Infinite GotoStart program counts from one (1) up to inclusive three (3), and perpetually repeats the process, printing each stage to the standard output:
 ?(0=0>+(0).(0))
 ?(0=1>+(0).(0))
 ?(0=2>+(0).(0))
 ?(0=3>=(0:0))
 ^
==Computational class==
See GotoStart Turing-completness proof
==Interpreter==
* Common Lisp implementation of the GotoStart and Infinite GotoStart programming languages.
Category:Languages Category:Turing complete Category:Turing tarpits Category:Output only Category:2023 Category:Implemented