nyuuzyou/wikis huggingface dataset:
Print Function Deluxe

Print Function Deluxe is an esolang made by Cortex designed to have very small code and many useful commands, but the only way to see what it actually did through the whole thing is with the p command.
== Commands ==
Character	What it does
p 	Print the next 3 characters. Prints numbers in base 10.
$ 	When before a function character, use a value from input as the argument for it.
% 	Set the accumulator to the next 3 characters as a base 36 number.
^ 	Similar to $, but use the accumulator instead.
= 	If the accumulator is even, go forward [the next character as a base 36 number] lines. Otherwise, proceed.
+ 	Increment the accumulator by the next character as a base 36 number.
- 	+, but decrement the accumulator instead.
* 	Double the accumulator.
? 	Set the accumulator to a random number.
& 	Set the accumulator to the next character as a base 36 number.
@ 	Go to line [the next character as a base 36 number].
. 	End the program (it automatically ends at the end of the program, too).
== Examples ==
=== Hello, World! ===
pHelplo,p Woprldp! 
=== Cat program ===
A one-time cat program is the following:
$p
An infinitely repeating version comprises:
$p@1
=== Truth-machine ===
$&=1@3
p0 .
p1 @3
==Interpreter==
* Common Lisp implementation of the Print Function Deluxe programming language.
Category:2019 Category:Implemented Category:Languages
Printf

printf is a simple programming language invented by User:A.
==Syntax==
It is really VERY simple.
It is a subset of C in which you can't use any of the keywords and there is only a function called "printf". (You can only define 1 function, main, and you can't call it.)
==Computational class==
It is Turing-complete, as proved here.
Category:Esoteric subset
Category:Implemented
Category:Turing complete
Category:Turing tarpits
Category:Low-level
Category:Languages
Printscript

Printscript is an esoteric programming language invented by User:A. It is inspired by Lua. This programming language supports the "print" function and many others.
==Syntax==
The syntax of the print function is:
print "some string"
Only ONE space should be put behind the "print" so that it will print as the programmer would expect.
Small secret: any character can substitute space, like printf"hello, world".
Note that Printscript supports multi-line strings like:
print "Line 1
Line 2
Line 3"
The output is:
Line 1
Line 2
Line 3
Multiple “print”'s are supported:
print "aaa
"print "bbb
"print "ccc"
Output:
aaa
bbb
ccc
If no spaces are added behind the "print", the output would skip the first character and print the rest of the characters if the string is not less than 2 characters.
A new characteristic is added in Version 2. It can print various unsupported characters using \.
Example. print "print"
print "\p\r\i\n\t"
Output:
print
Example. Print a "
print "\""
Output:
"
Version 4 adds variable support.
Variables can only be one-char. However, it can be any char in the ASCII code.
Set: command used for setting a variable into a value
Example for setting a variable to char 3 (ASCII code 51)
set / 3
print /
Output:
3
Sev: command used for setting a variable into a variable.
Example:
set @ 2
print @
print "
"
sev % @
print %
Output:
2
2
==Example Programs==
Hello, world! program
print "Hello, world!"
This prints spaces until there is no enough space.
print"
or
print""
The programs above prints spaces until there is no more space for code.
How it works: The interpreter scans for the matching " while printing everything.
Version 3 fixes this problem. An error will print if the string is not matched.
print"
Output
Unfinished string.
==Interpreter(in C)==
Usage: ps your_program.ps
These programs are tested on Tiny C Compiler, but these not yet tested on other compilers.
Version 1
Version 2
Version 3
Version 4
Category:Languages
Category:Output only
Category:Implemented
Category:2019
==See Also==
Version 5 and later. Created because I forgot that I can use the pastebin.
* Printscript 5
* Printscript 9
* Printscript 13
Printscript 13

Printscript 13 is invented by User:A.
There is a problem in loops(it seems to terminate early).
Version 13 modifies the arithematic functions to make it support variable modifying.
The original functions are modified as variable modifying:
set a !
set b !
add a b
pint a
Output:
66
New functions:
inv dev muv dvv mov
These are the original functions.
Version 14 fixes sev, and adds four functions: max, min, abs, and neg.
-example
set a 1
set b 2
max a b-set a to the maximum value of a and b
print a-> 2
set b 1
min a b-set a to the minmum value of a and b
print a->1
set a 1
set b 2
dec a b
pint a->-1
abs a->1 Set a to the absolute value of a
neg a-Let a be a*-1
pint a->-1
Version 15 adds comparison functions: ==v ~=v >v <v >=v <=v
Currently they can only operate with values.
==v	Check if the variables are equal. 	 	
~=v	Check if the variables are not equal.	>=v	Check if the former variable is greater than or equal to the latter variable.
And etc...
Version 16 adds the case statement.
input a
case a- use a to compare equality
	if 1-if a is equal to '1'
		print "This is 1"
	end
	if 2-if a is equal to '2'
		print "This is 2"
	end
done
==Implementation==
Version 13
Version 14
Version 15
Version 16
==See Also==
* Printscript
* Printscript 5
* Printscript 9
Category:Languages
Category:Implemented
Category:2019
Printscript 5

Printscript 5 is invented by User:A.
==New Syntax==
Printscript Version 5 supports comments(both one-line and multi-line).
One line comment example:
-This is a one-line comment.
-print "asdf"
print "The previous 2 lines are skipped."
Output:
The previous 2 lines are skipped.
Multi-line comment:
-[This is
a multi-line
comment.]
print "Multi-line comment skipped."
Output:
Multi-line comment skipped.
Printscript Version 6 adds input.
It is fairly easy to use(Cat program beta. Limited to characters. Also only interpreted once.):
input a
print a
Input:
3
Output:
3
Version 7 supports logic operations.(and,or,and not)
The result goes to the former variable. (These only supports variables.)
Every logic operation is performed after subtracting each character by 48.
set a 0
set b 0
and a b
print a
set b 1
and a b
print a
set c 0
set d 0
or c d
print c
set d 1
or c d
print c
set e 0
not e
print e
Output:
00011
Version 8 now supports the if command. (Finally!)
if syntax: followed by a variable. Checks if the ASCII value of the variable is greater than '0'. Terminated by 'end'.
else syntax: followed by a variable. Checks if the ASCII value of the variable is equal to '0'. Terminated by 'end'. 
Here is a conditional example:
input a
if a
	print a
end
else a
	print "a is not 1!"
end
Input 1:
0
Output 1:
a is not 1!
Input 2:
1
Output 2:
1
==Interpreter(in C)==
Version 5
Version 6
Version 7
Version 8
==See also==
* Printscript
* Printscript 9
* Printscript 13
Category:Languages
Category:Output only
Category:Implemented
Category:2019
Note that after version 6(including version 6), Printscript is not output only anymore.
Printscript 9

Printscript 9 is invented by User:A.
==New Syntax==
Loops are added. However, there is a problem.
Check out the example program:
set a 1
while a
	print "a"
end
Output:
This program prints many 'a' s.
Now the Cat program and the Truth-machine can be implemented:
set a 1
while a
	input b
	print b
end
Truth Machine:
input a
print a
while a
	print a
end
but they are still in beta.
However, Version 10 fixes this. Maybe this is very close to being general-purpose.
Printscript 11 adds 2 functions: pint and inc.
inc increments the first value by the second parameter.
pint prints an integer instead of a character.
-pint example
set a !
pint a
Output:
33
-inc example
set a !
inc a !
pint a
Output:
66
This version also extends the print function. The symbol ".." can be used to print various things.
- .. example
print "This " .. "string"
-or
print " is ".."linked."
Output:
This string is linked.
Printscript version 12 completes the arithematic functions: add, sub, mul, div, and mod.
Mod is the remainder when a number is divided by another one.
These are similar to the add function, so examples are not necessary.
==Implementation==
Version 9
Version 10
Version 11
Version 12
==See also==
* Printscript
* Printscript 5
* Printscript 13
Category:Languages
Category:Implemented
Category:2019
Probabilistic combinatory logic

In an ongoing attempt to formulate a Quantum combinatory logic, User:Hppavilion1 started by formulating probabilistic combinatory logic.
== Difference from traditional combinatory logic ==
Probabilistic combinatory logic adds one new combinator: τ. τ accepts two arguments via currying and returns one of them at random (with 50/50 probability).
=== Derived Combinators ===
The author's first idea, the O combinator was really just stupid: Oxy=xy|yx. However, if one needs to use it, it maybe can easily be derived from the C combinator from the B,C,K,W system; however, the author is too stupid to figure that out. To define it, you simply need to define the =xy combinator that tells if its arguments are equal, then to do some conditionals mumble mumble and voila! You have the R combinator!
== Computational Class ==
PCL is clearly TC by trivial reduction to combinatory logic; however, additionally, PCL is equivalent to a Probabilistic Turing Machine, if the author is correct, by nature.
Category:Computational models Category:Concepts Category:Turing complete
Probablyfuck

Probablyfuck is a variant of brainfuck inspired by the ideas of stochastic computing. Cell values are probabilistic bit streams (also known as Bernoulli processes), which you can operate on with brainfuck-like instructions.
== Details ==
The tape is initialized with an infinite number of random bit streams, each with a probability of 0.5. Individual cells can be forced to take on a value of 0 with [!]. boolfuck programs can be converted to probablyfuck in this manner, but program size can be greatly reduced by taking advantage of probabilistic features.
The program is ran an infinite number of times, each time with the next bit from each bit stream. At the end of every run, each cell has a probability of being 0 or 1 based on how each run changes it, and the resulting tape of probabilities is the result of the probablyfuck program.
== Instructions ==
Instruction	Behaviour
! 	Inverts the current bit.
# 	Fetches the next bit from the current bit stream.
<> 	Moves the cell pointer left or right.
[...] 	Runs the code within while the current bit stream returned 1 on this specific run.
== Examples ==
=== Multiplication ===
[>[>!>]]
If the tape is initialized with two independent streams with probabilities of p and q, and a third and fourth stream are both set to 0, this will give the third stream a probability of pq. At the end of the program, the cell pointer has a pq probability of being on the fourth cell, and a 1 - pq probability of remaining at the first cell.
Here is an alternate method, which guarantees that the cell pointer returns to the first cell, but destroys the operands in the process.
[!>[!>!<]<]
=== Squaring ===
A naive implementation of squaring might look like this.
[[>!>]]
This is the same as multiplication, but it checks the first bit stream twice instead of checking two different bit streams. The problem with this is that, because the same bit is checked twice regardless of whether it's 0 or 1, the output will simply be the input bit stream, instead of actually multiplying the probabilities together.
This is solved by the # operator, which can be used to delay the bit stream after the first check. The operator decorrelates the two values, allowing the multiplication to give the correct result.
[#[>!>]]
Category: Languages
Category: Brainfuck derivatives
Category: 2020
Category: Turing complete
Category: Turing tarpits
Category: Cell-based
Category: Low-level
Category: Probabilistic
Category: No IO
Category: Unimplemented
Proce

Proce (pronounced like the first syllable of the verb "process"—Brit. /prəʊs/, U.S. /prɑs/) is an esoteric programming language by Tanner Swett.
A program consists of a series of statements, delimited by line breaks. If a number sign appears anywhere within a line, the remainder of the line is ignored. The syntax for a statement is:
 <line> ::= name "=" <signal>
 <signal> ::= name | number | "(" <signal> ")"
 | (number "*" | "d!" | "i!" | "r!") <signal>
 | <signal> ("+" | "-") <signal>
A "name" is a sequence of letters and underscores. A "number" is a decimal literal, consisting of digits and optionally a period and/or a hyphen. Whitespace between tokens is ignored; note that the strings "d!", "i!", and "r!" are each a single token. Unary operations (including multiplication) take precedence over binary operations.
There exists a positive real number δ called the resolution. This real number is defined by the interpreter, and must be no larger than 1/44100. Each signal consists of a function taking the time t, a non-negative integer multiple of δ, and returning a real number. Executing a program consists of evaluating all signals mentioned in the program at 0, then at δ, then at 2δ, and so on.
The signals are defined as follows:
* (x * f)(t) = x * f(t)
* (d!f)(t) = (f(t) - f(t-δ))/δ
* (i!f)(t) = (i!f)(t-δ) + f(t)*δ
* (r!f)(t) = f(t) (if f(t) > 0), 0 (otherwise)
* (f+g)(t) = f(t) + g(t)
* (f-g)(t) = f(t) - g(t)
A numeric literal represents a constant signal. A named signal is equal to 0 at all non-positive values of t, and for all positive integers n, the signal at t = nδ is equal to the right-hand side of its definition, evaluated at t = (n-1)δ. However, slew rate is limited to 44100: the difference between a signal's value at time nδ and its value at time (n-1)δ is clamped to the interval [-44100δ, 44100δ].
The following program defines sin as an approximation of the sine function. The approximation can be made arbitrarily good by decreasing δ:
 sin = i!(1 - i!sin)
Computation in Proce may be possible, but it is not obvious how to implement it.
Category:Languages
Category:2008
Category:Unknown computational class
Category:No IO
Category:Unimplemented
Processor.txt

processor.txt was made by Miles Poland, on Friday, June 18, 2021. It is inspired by the RISC style of processors, hence the name. The .txt part is because the original specs were written in a .txt file. It is also somewhat of an Esoteric processor.
== Instruction set ==
This is for v1.1
! => Logical NOT of DATA, writes to DATA
& => Logical AND between selected register and DATA, writes to DATA
^ => Logical XOR between selected register and DATA, writes to DATA
, => Copy DATA to a (selects a)
$ => Pops a to DATA (doesn't erase a)
. => Copy DATA to b (selects b)
* => Pops b to DATA (does erase b)
/ => Copy DATA to c (selects c)
? => Pops c to DATA (does erase c)
; => Copy DATA to d (selects d)
: => Pops d to DATA (does erase d)
@ => Copy DATA to e (selects e)
# => Pops e to DATA (does erase e)
[ => Copy DATA to f (selects f)
{ => Pops f to DATA (does erase f)
] => Copy DATA to g (selects g)
} => Pops g to DATA (does erase g)
\ => Copy DATA to h (selects h)
| => Pops h to DATA (does erase h)
> => Moves DATA to the RIGHT
< => Moves DATA to the LEFT
+ => Increment DATA
- => Decrement DATA
~ => Print DATA to STDOUT
( => Target for ')'
) => If DATA is zero, jump to the most recent '('. Otherwise, do nothing.
% => bitshift DATA left
_ => bitshift DATA right, mod 256
` => nop
For a real life implementation of processor.txt, the characters would be replaced with their hex codes, and the hex codes used as opcodes.
== Example Programs ==
=== Printing my username (has to be run with command line switch "-a"): ===
++++++++++++++++++++++++++++++++++++++++++++++++++++~++++++++++++++++~----------------~++++~---~-----~
$ clears out data because it copies zeros to where the DATA pointer is. That isn't in 
this program, however, because it isn't needed in this case.
Shorter (and more clever) version:
+%+%%+%%~$+%%%%+%%~$+%+%%+%%~$+%+%+%%%~$+%+%%+%%+~$+%+%%%%~
% is one of the bitshift operators.
Let's translate one of the printing blocks.
+%+%%+%%~$. + means to increment DATA by one. % means 'shift DATA to the left one bit.' ~ means to print DATA. and $ means to set DATA to a. Also, -a means to print out DATA as ASCII. so, the printing block means 'Make the binary number "00110100", print it out as ASCII, than clear DATA.'
=== Cat program: ===
Impossible, because processor.txt lacks support for STDIN. https://github.com/4D4850/processor.txt
=== Quine: ===
I haven't found one yet, feel free to edit one in.
== Ok, what is wrong with comments?! And what does DATA mean? ==
The interpreter only checks the first line for code, which means that other lines are just comments. Hopefully. DATA refers typically to the data under the data pointer, except for > and <, where it refers to the data pointer itself.
== Computational Class ==
In theory, v1.1 would be Turing complete with an infinite data tape. Currently, since v1.1 of the python interpreter is limited to 1KiB of DATA, it isn't turing complete, but in theory could be if DATA dynamically expanded in both directions. However, in its current state, it is just an FSA.
== References ==
Category:Finite state automata Category:Output only Category:Implemented Category:2021 Category:Languages
ProgFk

ProgFk is a language created by User:David.werecat using nibbles as instructions and having theoretically infinite bitwise memory.
==Instructions==
#	Description
0	NOP
1	Increments the pointer by 1 bit
2	Decrements the pointer by 1 bit
3	Sets the bit to 0
4	Sets the bit to 1
5	If the bit is 0, skip the next instruction
6	If the bit is 1, skip the next instruction
7	Output the ASCII value of the 8 bits following the pointer
8	Sets the 8 bits following the pointer to the input key
9	Sets the goto flag to the current instruction
A	Jumps to the goto flag
B	Jumps ahead 1 instruction
C	Jumps ahead 10 instructions
D	Performs a NOT on the current bit
E	Next instruction is an extended instruction
F	Ends the program
== Extended instructions ==
#	Description
0	NOP
1	Performs an AND on the current bit and the next bit and stores it in the current bit
2	Performs an OR on the current bit and the next bit and stores it in the current bit
3	Performs a XOR on the current bit and the next bit and stores it in the current bit
4	Stores the value of the current bit
5	Sets the current bit to the stored value
6	Swaps the current bit and the next bit
7	Swaps the current bit and the last bit
8	Waits one second
9	Beeps
A	Clears output
B	Jumps ahead 1 instruction
C	Jumps ahead 10 instruections
D	Clears the stored bit
E	NOP
F	Ends the program
== External resources ==
* Visual Basic .NET interpreter and sample programs
Category:Languages
Category:2012
Category:Unknown computational class
Category:Implemented
Category:Low-level
Category:Cell-based
Category:Binary
Project Euler/1

The first problem from Project Euler is a problem very similar to FizzBuzz. The major differences are:
* FizzBuzz usually counts to 100, while Project Euler counts to 999 (Not one thousand!).
* FizzBuzz prints the numbers and replaces the multiples of 3 and 5 with certain words, while Project Euler adds the multiples of 3 and 5 up, and prints that sum.
==Implementations==
===Aheui===
This program needs reduction due to no-op chains.
바싹밣발발발따따뚜
루벌루벋뻐터너벌벌
우뽀처빠쑥사빠아초희멍
처아아오삭도오어샥여오여
===AsciiDots===
This program unfortunately fails on Try It Online, probably because Try It Online does not allow setting the value to 0.
`,` /-------\
`,` .->---{+}-~-$#&
`,` /------->-----^ |
`,` /*\ /*\ | |
`,` /---~-+\/---~-+\ | |
`,` | ! ||| ! || | |
`,` .-#1000->*-{-}-*#3[%]|\*#5[%]|\*#0/ |
`,` |\#1/ \---/ | \---/ | | |
`,` | \------->->-----*
`,` \----------------------------/
===C===
 #include <stdio.h>
 i=0,r=0;main(){while(i++<999)if(i%3==0||i%5==0)r+=i;printf("%d",r);}
===Python===
By User:None1:
 print(sum(filter(lambda x:x%3==0 or x%5==0,range(1,1000))))
By User:PrySigneToFry: 
Note that I've intergrated two programs.
i = 999
j = 0
for k in range(1, i + 1, 1):
 if k % 15 == 0:
 print("FizzBuzz")
 j += k
 elif k % 5 == 0:
 print("Buzz")
 j += k
 elif k % 3 == 0:
 print("Fizz")
 j += k
 else:
 print(k)
 j += 0
print(f"The sum of all multiples of 3, 5, and 15 within a thousand is {j}.")
===Shakespeare===
This code may be shortened using the operators "cube" and "remainder".
The Euler Plan.
Hamlet, who adds everything up.
Juliet, who always counts down.
Act I:a.
Scene I: define constant.
[ enter Hamlet and Juliet ]
Hamlet: You are twice twice twice the sum of the sum of a big big big big big big big cat and a big pig and a pig.
Scene II: start loop.
Hamlet: you are the sum of you and a pig.
Hamlet: Are you as good as the product of the quotient between you and the sum of a big cat and a cat and the sum of a big cat and a cat?
If so, let us proceed to Scene III.
Hamlet: Are you as good as the product of the quotient between you and the sum of a big big cat and a cat and the sum of a big big cat and a cat?
If so, let us proceed to Scene III.
If not, let us proceed to Scene II.
Scene III: Add numbers.
Juliet: You are the sum of you and me.
Hamlet: Are you as good as nothing? If not, let us proceed to Scene II.
Juliet: Open your heart.
[ exeunt ]
===Wenyan===
Warning: This program contains English letters. Code may be defective.
有數零。名之曰「H」。
有數千。名之曰「J」。
恆為是。若「J」等於零者乃止也。
 減「J」以一。昔之「J」者。今其是矣。
	除「J」以三。所餘幾何。
	若其等於零者。
	 加「H」以「J」。昔之「H」者。今其是矣。
	若非。
	 除「J」以五。所餘幾何。
	 若其等於零者。
	 加「H」以「J」。昔之「H」者。今其是矣。
	 云云。
	云云。
云云。
吾有一數。曰「H」。書之。
==See also==
==External resources==
* Multiple on Wolfram Mathworld
* Problem 1 on Project Euler Official Website (not available)
* Problem 1 on Project Euler Mirror
Project Euler/10

Project Euler Problem 10 is a problem related to prime numbers. The task is to find the sum of all prime numbers below 2000000.
== Implementations ==
=== Python ===
primes=[]
sieve=[0]*2000005
for i in range(2,2000000):
 if not sieve[i]:
 primes.append(i)
 for j in primes:
 if j*i>=2000000:
 break
 sieve[j*i]=1
 if not i%j:
 break
print(sum(primes))
This does not work on the answer checking in Project Euler Mirror due to a bug in that site's source that makes it literally impossible to get a correct answer.
Project Euler/12

Project Euler Problem 12 is a problem related to triangular numbers. The task is to find the smallest triangular number with over 500 divisors.
== Implementations ==
=== Python ===
from math import *
def divisors(x):
 r=0
 for i in range(1,int(sqrt(x))+1):
 if x%i==0:
 if i*i==x:
 r+=1
 else:
 r+=2
 return r
x=1
while divisors(x*(x+1)//2)<=500:
 x+=1
print(x*(x+1)//2)
==External resources==
* Wikipedia:Project Euler
Category:Implementations
Project Euler/15

Project Euler Problem 15 is a problem related to the Pascal's triangle. The problem mentions a type of routes that starts from the top left and ends at the bottom right of the lattice, and can only move right or down. It requires you to count the number of such routes on a 20 by 20 lattice.
Mathigon Dec 1 2021 is a similar problem that goes on a 4 by 4 lattice instead of 20 by 20. If you want to get the solution to that problem, try replacing 20 with 4 in the codes below.
==Implementations==
===Aheui===
Works on Try it Online; Fails on AheuiChem.
밣발따발발나싹빠밤발따투망희
불떠벓벊서떠석토쎡뻐뻐처속
붆싹삭나사발발노
냐토다펴
==External resources==
* Problem 15 on Project Euler Official Website (not available)
* Dec 1 2021 on Mathigon
* Problem 15 on Project Euler Mirror