[Question]
  [
Closely related: [How high can you count?](https://codegolf.stackexchange.com/q/124362/78410)
## Challenge
In your programming language of choice, write as many different identity programs/functions as possible, under the following constraints:
* Each program should be a function or full program that is one of the following:
	+ A function that takes a single positive integer and returns it unchanged
	+ A function that takes a single string of printable ASCII (codepoints 32 to 126 inclusive) and returns it unchanged
	+ A full program that takes a single positive integer from stdin and prints to stdout unchanged, with an optional trailing newline (and possibly other outputs that cannot be suppressed in your language)
	+ A full program that takes a single line of printable ASCII from stdin and prints to stdout unchanged, with an optional trailing newline (and possibly other outputs that cannot be suppressed in your language)
* Different programs using different I/O methods is acceptable.
* **Any single byte cannot appear in two or more programs**, though it may appear more than once in a single program. You may freely use multi-byte characters, as long as every byte value consisting of each multi-byte character follows this exact rule.
* The programs must be independent of each other.
* If an empty program satisfies the condition above, you can include it only once in your answer.
* Symbol independent languages such as [Lenguage](https://esolangs.org/wiki/Lenguage) (including partially independent ones such as [Headsecks](https://esolangs.org/wiki/Headsecks)) are disallowed.
* If your language accepts flags, all programs in an answer must use a single combination of flags (e.g. one answer for "Keg" programs without flags, a separate answer for "Keg `-hr`" programs). According to [this meta](https://codegolf.meta.stackexchange.com/questions/14337/command-line-flags-on-front-ends), a language with different flag combination is a different language.
## Examples
In Python 3, all of `lambda a:a`, `print(input())`, `int`, and `str` are valid identity programs independently, but only two of them can be used in an answer since the last three programs share the character `t`.
## Scoring
The submission with the largest number of programs wins.
  
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~130~~ ~~133~~ ~~144~~ ~~148~~ ~~150~~ ~~151~~ ~~155~~ ~~156~~ ~~157~~ 159 programs
Uses the custom [05AB1E encoding](https://github.com/Adriandmen/05AB1E/wiki/Codepage) for all programs.  
All programs are a TIO-link to verify them.
**Either type of input is fine:**
1) [(empty program)](https://tio.run/##yy9OTMpM/Q8EJanFJQA): Implicit input is output implicitly  
2,3)  [(a space)](https://tio.run/##yy9OTMpM/f9f4f//ktTiEgA), [`\n` (a newline)](https://tio.run/##yy9OTMpM/f@f6///ktTiEgA): The whitespaces are ignored; implicit input is output implicitly (with trailing newline)  
4) [`w`](https://tio.run/##yy9OTMpM/f@//P//ktTiEgA): Unbound no-op; implicit input is output implicitly (with trailing newline)  
5) [`I`](https://tio.run/##yy9OTMpM/f/f8///ktTiEgA): Explicit input is output implicitly (with trailing newline)  
6) [`¹`](https://tio.run/##yy9OTMpM/f//0M7//0tSi0sA): Explicit first input is output implicitly (with trailing newline)  
7) [`$`](https://tio.run/##yy9OTMpM/f9f5f//ktTiEgA): Push 1 and the input, after which the top input is output implicitly (with trailing newline)  
8) [`Î`](https://tio.run/##yy9OTMpM/f//cN///yWpxSUA): Push 0 and the input, after which the top input is output implicitly (with trailing newline)  
9) [`,`](https://tio.run/##yy9OTMpM/f9f5///ktTiEgA): Implicit input is output explicitly with trailing newline  
10) [`=`](https://tio.run/##yy9OTMpM/f/f9v//ktTiEgA): Implicit input is output explicitly with trailing newline (without popping)  
11) [`?`](https://tio.run/##yy9OTMpM/f/f/v//ktTiEgA): Implicit input is output explicitly without trailing newline  
12) [`q`](https://tio.run/##yy9OTMpM/f@/8P//ktTiEgA): Exit program; implicit input is output implicitly (with trailing newline)  
13,14) [`D`](https://tio.run/##yy9OTMpM/f/f5f//ktTiEgA), [`Ð`](https://tio.run/##yy9OTMpM/f//8IT//0tSi0sA): Duplicate / triplicate the implicit input and output the top implicitly (with trailing newline)  
15) [`r`](https://tio.run/##yy9OTMpM/f@/6P//ktTiEgA): Reverse the values on the stack (which is empty); implicit input is output implicitly (with trailing newline)  
16,17) [`s`](https://tio.run/##yy9OTMpM/f@/@P//ktTiEgA), [`Š`](https://tio.run/##yy9OTMpM/f//6IL//0tSi0sA): Swap / triple swap two / three implicit inputs; the top is output implicitly (with trailing newline)  
18) [`Δ`](https://tio.run/##yy9OTMpM/f//3JT//0tSi0sA): Loop until the result no longer changes; the implicit input is used, it loops twice, and the unmodified input is output implicitly (with trailing newline)  
19) [`:`](https://tio.run/##yy9OTMpM/f/f6v//ktTiEgA): Replace the implicit input-string with the implicit input-string, after which the unmodified input is output implicitly (with trailing newline)  
20,21,22,23) [`J`](https://tio.run/##yy9OTMpM/f/f6///ktTiEgA), [`»`](https://tio.run/##yy9OTMpM/f//0O7//0tSi0sA), [`O`](https://tio.run/##yy9OTMpM/f/f////ktTiEgA), [`P`](https://tio.run/##yy9OTMpM/f8/4P//ktTiEgA): Join the empty stack without delimiter / join the empty stack with newline delimiter / sum the empty stack / take the product of the empty stack, after which the implicit input is output implicitly (with trailing newline)  
24,25) [`U`](https://tio.run/##yy9OTMpM/f8/9P//ktTiEgA), [`V`](https://tio.run/##yy9OTMpM/f8/7P//ktTiEgA): Pop the implicit input, and store it in variable `X` or `Y` respectively, after which the implicit input is output implicitly (with trailing newline)  
26) [`©`](https://tio.run/##yy9OTMpM/f//0Mr//0tSi0sA): Store the implicit input in variable `®` (without popping), after which it is output implicitly (with trailing newline)  
27) [`ˆ`](https://tio.run/##yy9OTMpM/f//dNv//yWpxSUA): Pop the implicit input, and add it to the global array, after which the implicit input is output implicitly (with trailing newline)  
28) [`i`](https://tio.run/##yy9OTMpM/f8/8///ktTiEgA): If-statement, if the (implicit) input is 1 it enters it. But whether the input is 1 and it enters the if-statement or not, the implicit input is output implicitly (with trailing newline) either way  
29) [`v`](https://tio.run/##yy9OTMpM/f@/7P//ktTiEgA): For-each over each character/digit of the implicit input (but don't push any, since we don't use `y`). After the loop, the implicit input is output implicitly (with trailing newline)  
30,31) [`}`](https://tio.run/##yy9OTMpM/f@/9v//ktTiEgA), [`]`](https://tio.run/##yy9OTMpM/f8/9v//ktTiEgA): Close the inner-most or all if-statement(s)/loop(s), for which there are none right now. The implicit input is output implicitly (with trailing newline)  
32) [`†`](https://tio.run/##yy9OTMpM/f//UcOC//9LUotLAA): Filter the implicit input to the front of the implicit input; it will remain unmodified and is output implicitly (with trailing newline)  
33) [`‡`](https://tio.run/##yy9OTMpM/f//UcPC//9LUotLAA): Transliterate the characters of the implicit input to the characters of the implicit input; it will remain unmodified and is output implicitly (with trailing newline)  
34) [`´`](https://tio.run/##yy9OTMpM/f//0Jb//0tSi0sA): Clear the global array (which is already empty). After which the implicit input is output implicitly (with trailing newline)  
35) [`§`](https://tio.run/##yy9OTMpM/f//0PL//0tSi0sA): Cast the implicit input to a string, after which it is output implicitly (with trailing newline)  
36) [`Ã`](https://tio.run/##yy9OTMpM/f//cPP//yWpxSUA): Keep all values of the implicit input in the implicit input, after which the unmodified result is output implicitly (with trailing newline)  
37) [`é`](https://tio.run/##yy9OTMpM/f//8Mr//0tSi0sA): Sort the implicit input by length. Since it's a single string/integer, the characters/digits will remain at the same position, after which the unmodified input is output implicitly (with trailing newline)  
38,39) [`.`](https://tio.run/##yy9OTMpM/f9f7///ktTiEgA), [`Å`](https://tio.run/##yy9OTMpM/f//cOv//yWpxSUA), [`ž`](https://tio.run/##yy9OTMpM/f//6L7//0tSi0sA): All three are used to open up more 2-byte operations, but on their own they're unbound no-ops. So the implicit input is output implicitly (with trailing newline).  
40) [`\`](https://tio.run/##yy9OTMpM/f8/5v//ktTiEgA): Discard the top item on the stack (which is already empty), after which the implicit input is output implicitly (with trailing newline)  
41) [`¼`](https://tio.run/##yy9OTMpM/f//0J7//0tSi0sA): Increase the counter\_variable by 1. After which the implicit input is output implicitly (with trailing newline)  
42) [`½`](https://tio.run/##yy9OTMpM/f//0N7//0tSi0sA): If the implicit input is `1`, increase the counter\_variable by 1. After which the implicit input is output implicitly (with trailing newline)  
43) [`ë`](https://tio.run/##yy9OTMpM/f//8Or//0tSi0sA): Else-statement, which is a no-op without if-statement. So the implicit input is output implicitly (with trailing newline)  
44) [`ÿ`](https://tio.run/##yy9OTMpM/f//8P7//0tSi0sA): Used for string interpolation; outside of a string it's a no-op. So the implicit input is output implicitly (with trailing newline)  
45) [`šн`](https://tio.run/##yy9OTMpM/f//6MILe///L0ktLgEA): Convert the implicit input implicitly to a character-list, and prepend the implicit input at the front. Then pop and push the first item of this list, which is output implicitly (with trailing newline).  
46) [`ªθ`](https://tio.run/##yy9OTMpM/f//0KpzO/7/L0ktLgEA): Convert the implicit input implicitly to a character-list, and append the implicit input at the end. Then pop and push the last item of this list, which is output implicitly (with trailing newline).  
47) [`η¤`](https://tio.run/##yy9OTMpM/f//3PZDS/7/L0ktLgEA): Get all prefixed of the implicit input. Push its last item (without popping), after which the top of the stack is output implicitly (with trailing newline).  
48) [`ðý`](https://tio.run/##yy9OTMpM/f//8IbDe///L0ktLgEA): Join the empty stack with space delimiter, after which the implicit input is output implicitly (with trailing newline).  
49) [`õK`](https://tio.run/##yy9OTMpM/f//8Fbv//9LUotLAA): Remove all empty strings from the implicit input, after which the unmodified result is output implicitly (with trailing newline).  
50) [`¸``](https://tio.run/##yy9OTMpM/f//0I6E//9LUotLAA) : Wrap the implicit input into a list, and then pop and dump the contents of that list to the stack, after which it is output implicitly (with trailing newline)  
51) [`ʒX`](https://tio.run/##yy9OTMpM/f//1KSI//9LUotLAA): Start a filter, and push variable `X`, which is 1 (truthy) by default. So all characters/digits in the implicit input will remain, and the unmodified input is output implicitly (with trailing newline)  
52) [`RR`](https://tio.run/##yy9OTMpM/f8/KOj//5LU4hIA): Reverse the implicit input, and reverse it back. After which the unmodified input is output implicitly (with trailing newline).  
53) [`ÂÂ`](https://tio.run/##yy9OTMpM/f//cNPhpv//S1KLSwA): Bifurcate (short for Duplicate & Reverse copy) twice, after which the unmodified input at the top of the stack is output implicitly (with trailing newline)  
54) [`ÁÀ`](https://tio.run/##yy9OTMpM/f//cOPhhv//S1KLSwA): Rotate the implicit input once towards the right, and then back towards the left. After which the unmodified input is output implicitly (with trailing newline).  
55) [`Ć¨`](https://tio.run/##yy9OTMpM/f//SNuhFf//l6QWlwAA): Enclose the implicit input, appending its own first character/digit, and then remove the last character/digit again. After which the unmodified input is output implicitly (with trailing newline).  
56) [`Σ9`](https://tio.run/##yy9OTMpM/f//3GLL//9LUotLAA): Sort the characters/digits in the implicit input by 9 (so they'll all stay at the same positions), after which the unmodified input is output implicitly (with trailing newline).  
57) [`8ì¦`](https://tio.run/##yy9OTMpM/f/f4vCaQ8v@/y9JLS4BAA): Prepend an `8` in front of the implicit input, and then remove the first character again. After which the unmodified input is output implicitly (with trailing newline)  
58) [`āĀÏ`](https://tio.run/##yy9OTMpM/f//SOORhsP9//@XpBaXAAA): Push a list in the range [1, implicit input-length] (without popping). Python-style truthify each value in this list (so they'll all becomes 1s). Only keep the characters/digits of the implicit input at the truthy (1) indices, after which the unmodified result is output implicitly (with trailing newline).  
59) [`""«`](https://tio.run/##yy9OTMpM/f9fSenQ6v//S1KLSwA): Append an empty string to the implicit input, after which the unmodified input is output implicitly (with trailing newline).  
60,61) [`‘‘Û`](https://tio.run/##yy9OTMpM/f//UcMMIDo8@///ktTiEgA), [`’’Ü`](https://tio.run/##yy9OTMpM/f//UcNMIDo85///ktTiEgA): Trim all leading / trailing empty strings of the implicit input, after which the unmodified input is output implicitly (with trailing newline).  
62) [`““¡`](https://tio.run/##yy9OTMpM/f//UcMcIDq08P//ktTiEgA): Split the implicit input on an empty string, after which the unmodified input is output implicitly (with trailing newline).  
63) [`₆¢`](https://tio.run/##yy9OTMpM/f//UVPboUX//5ekFpcYm4FIAA): Count the amount of 36 in the implicit input. Not sure why, but when using a multi-character value with the count, there seems to be a bug and it results in the unmodified string, instead of the actual amount of `36` substrings in the string I was expecting.. So this will output the unmodified input implicitly (with trailing newline).
**Only string input:**
64 through 125) [`ǝαβив!%&(*+-/÷;<>BLbcefhjmnoptxz~‰£°±·¿ÃÆÈÉÌÍÑÒÓÕÖ×ØÝãäçèîôöùú`](https://tio.run/##AYEAfv9vc2FiaWX//yLHnc6xzrLQuNCyISUmKCorLS/Dtzs8PkJMYmNlZmhqbW5vcHR4en7igLDCo8KwwrHCt8K/w4PDhsOIw4nDjMONw5HDksOTw5XDlsOXw5jDncOjw6TDp8Oow67DtMO2w7nDuiJ2eT8iIOKGkiAiP3kuViz//3Rlc3Q): All these are integer operations (see the Wiki-page linked in the title to see what each does). They are no-ops for the (implicit) input-string(s); after which the unmodified input at the top of the stack is output implicitly.  
126) [`∍`](https://tio.run/##yy9OTMpM/f//UUfv//8lqcUlAA): Extend/shorten the implicit input-string to a size equal to the implicit input-string, after which it is output implicitly (with trailing newline).  
127) [`δ`](https://tio.run/##yy9OTMpM/f//3Jb//0tSi0sA): Apply double-vectorized. For integer inputs, it will implicitly convert to a \$[1, a]\$ range before applying double-vectorized. For strings, the implicit input is output implicitly.  
128) [`Λ`](https://tio.run/##yy9OTMpM/f//3Oz//0tSi0sA): Apply the Canvas with three options. For the digits `0` through `7`, it will output the digit in [a certain direction and length](https://codegolf.stackexchange.com/a/175520/52210), depending on the input. For any other input, it will be a no-op outputting the implicit input implicitly (with trailing newline).  
129) [`–`](https://tio.run/##yy9OTMpM/f//UcPk//9LUotLAA): If the top of the stack is `1`, it will print index `N`. So this will output `0` for input `1`, but will output the implicit input itself implicitly (with trailing newline) for any other input.  
130) [`—`](https://tio.run/##yy9OTMpM/f//UcOU//9LUotLAA): If the top of the stack is `1`, it will print item `y`. So this will output an empty string for input `1`, but will output the implicit input itself implicitly (with trailing newline) for any other input.  
131) [`œW`](https://tio.run/##yy9OTMpM/f//6OTw//9LUotLAA): Get all permutations of the implicit input-string. Then push the minimum (without popping), which for string inputs will simply use the very first string. Then output this unmodified input at the top of the stack implicitly (with trailing newline).
**Only string input, and the output is a character-list:**
132) [`S`](https://tio.run/##yy9OTMpM/f8/@P//ktTiEgA): Convert the implicit input to a list of characters and output it implicitly (with trailing newline).  
133,134) [`ε`](https://tio.run/##yy9OTMpM/f//3Nb//0tSi0sA), [`€`](https://tio.run/##yy9OTMpM/f//UdOa//9LUotLAA): Map over each character in the implicit input, and output the resulting character-list implicitly (with trailing newline).  
135) [`gι`](https://tio.run/##yy9OTMpM/f8//dzO//9LUotLAA): Push the length of the implicit input. Uninterleave the implicit input using this length as block-size. After which the resulting character-list is output implicitly (with trailing newline).  
136) [`øøø¬`](https://tio.run/##yy9OTMpM/f//8A4QPLTm//@S1OISAA): Zip/transpose three times; swapping rows/columns. If it's a matrix, it will do as expected. If it's a string or list, it will use the implicit input as a pair-and-zip/tranpose. Since we're doing it three times, the following will happen: `"abc"` → `["aa","bb","cc"]` → `[["a","aa"],["b","bb"],["c","cc"]]` → `[["a","b","c"], ["aa","bb","cc"]]`. Then we'll push the first inner list (without popping), after which this list at the top of the stack is output implicitly (with trailing newline).  
137) [`ü1`](https://tio.run/##yy9OTMpM/f//8B7D//9LUotLAA): `ü` is the overlapping builtin. It can be used with any other builtin to execute that builtin on every overlapping pair. But it can also be used with a single digit to create overlapping pair (2), triplets (3), quartets (4), etc. Apparently it also works with 1 to just convert the (implicit) input-string into a character-list, which is output implicitly (with trailing newline).
**Only character-list input:**
138) [`í`](https://tio.run/##yy9OTMpM/f//8Nr//6OVSpR0lFKBuBiIS5RiAQ): Reverse each character in the implicit input-list, after which the unmodified input-list is output implicitly (with trailing newline).  
139) [`˜`](https://tio.run/##yy9OTMpM/f//9Jz//6OVSpR0lFKBuBiIS5RiAQ): Flatten the implicit input-list, after which the unmodified input-list is output implicitly (with trailing newline).  
140) [`ζζΩ`](https://tio.run/##yy9OTMpM/f//3DYgXPn/f7RSiZKOUioQFwNxiVIsAA): Zip/transpose the (implicit) input-list twice: `["a","b","c"]` → `[["a","a"],["b","b"],["c","c"]]` → `[["a","b","c"],["a","b","c"]]`. And then pop and push a random item of this list of lists, which are both the unmodified input-list. After which it will be output implicitly (with trailing newline).
**Only integer input:**
141,142,143,144) [`E`](https://tio.run/##yy9OTMpM/f/f9f9/QyNTAA), [`F`](https://tio.run/##yy9OTMpM/f/f7f9/QyNTAA), [`G`](https://tio.run/##yy9OTMpM/f/f/f9/QyNTAA), [`ƒ`](https://tio.run/##yy9OTMpM/f//2KT//w2NTAE): Start a ranged loop with the implicit input (`E` = \$[1, a]\$; `F` = \$[0, a)\$; `G` = \$[1, a)\$; `ƒ` = \$[0, a]\$), and output the implicit input implicitly (with trailing newline) afterwards.  
145) [`ï`](https://tio.run/##yy9OTMpM/f//8Pr//w2NTAE): Convert the implicit input to an integer, after which the unmodified input is output implicitly (with trailing newline).  
146) [`ò`](https://tio.run/##yy9OTMpM/f//8Kb//w2NTAE): Round to the nearest integer (which it already is), after which the unmodified input is output implicitly (with trailing newline).  
147) [`þ`](https://tio.run/##yy9OTMpM/f//8L7//w2NTAE): Only keep the digits of the implicit input-integer, after which the unmodified input is output implicitly (with trailing newline).  
148) [`#`](https://tio.run/##yy9OTMpM/f9f@f9/QyNTAA): Split the implicit input-integer by spaces (it has none), after which the unmodified input is output implicitly (with trailing newline).  
149,150,151) [`u`](https://tio.run/##yy9OTMpM/f@/9P9/QyNTAA), [`l`](https://tio.run/##yy9OTMpM/f8/5/9/QyNTAA), [`™`](https://tio.run/##yy9OTMpM/f//Ucui//8NjUwB): Convert the implicit input-integer to uppercase / lowercase / titlecase, after which the unmodified input is output implicitly (with trailing newline).  
152) [`¶м`](https://tio.run/##yy9OTMpM/f//0LYLe/7/NzQyBQA): Remove all newline characters of the implicit input-integer, after which the unmodified input is output implicitly (with trailing newline).  
153) [`‚ß`](https://tio.run/##yy9OTMpM/f//UcOsw/P//zc0MgUA): Pair the implicit input-integer with the implicit input-integer, and then pop and push its minimum. After which it is output implicitly (with trailing newline).  
154) [`AÚ`](https://tio.run/##yy9OTMpM/f/f8fCs//8NjUwB): Trim leading and trailing lowercase alphabets of the implicit input-integer, after which the unmodified input is output implicitly (with trailing newline).  
155) [`|M`](https://tio.run/##yy9OTMpM/f@/xvf/f0MjUwA): Push all inputs as list. Push the largest value on the stack (including in all inner lists/matrices). After which the top of the stack is output implicitly (with trailing newline).  
156) [`∞@0k`](https://tio.run/##yy9OTMpM/f//Ucc8B4Ps//8NjUwB): Push an infinite positive list [1,2,3,...]. Check for each value if the (implicit) input is larger than or equal to this value (1 if truthy; 0 if falsey). And then get the 0-based index of the first 0 in this infinite list. After which it is output implicitly (with trailing newline).  
157) [`µ¾Ê`](https://tio.run/##yy9OTMpM/f//0NZD@w53/f9vaGQKAA): Continue looping until the counter\_variable (default 0) is equal to the implicit input-integer. Push the counter\_variable each iteration, and check that it's NOT equal to the implicit input-integer. If this is truthy, the counter\_variable will implicitly be increased by 1 after every iteration. When it becomes falsey, it means it's equal to the input-integer, and thus the loops stops, after which the counter\_variable is output implicitly (with trailing newline) as result.  
158) [`Œà`](https://tio.run/##yy9OTMpM/f//6KTDC/7/NzQyBQA): Push all substrings of the implicit input-integer, and then pop and push its maximum. After which this top of the stack is output implicitly (with trailing newline).  
159) [`Z)Z`](https://tio.run/##yy9OTMpM/f8/SjPq/39DI1MA): Get the largest digit of the implicit input-integer (without popping). Then wrap all values on the stack into a list, which is the input itself and its max digit. And then get the maximum again of this integer-pair (without popping), which will be the input itself. Then output the input at the top of the stack implicitly (with trailing newline).
**Unused characters / builtins:**
I'm pretty sure nothing useful is left anymore now..
```
Integer constants: 234567Tт₁₂₃₄₅Y®N•
Empty list constant: ¯
Empty string constant (if used twice): ”
(Partially) uniquify / sort builtins: Ù{êÔγ
Convert from binary/hexadecimal to integer (which works on any input unfortunately): CH
Checks resulting in truthy/falsey (0/1): Θ≠Qad›‹Ëå
Recursive environment (which I can't close without `}` nor `]`): λ
Infinite loop (which I can't stop without `#` nor `q`): [
(Compressed) string/integer builtins, which result in errors on their own: '„…ƵŽ
Ord (convert to codepoint integers): Ç
Convert to a list and cycle infinitely: Þ
Only leave the letters (which won't work if the input contains anything else): á
Get the second or third input (we are only allowed to take a single input): ²³
Palindrome / mirror: ûº
Cartesian product: â
```
[Answer]
# perl -pe, 85 86 87 programs
```
perl -pe 000
perl -pe 111
    ...
perl -pe 999
perl -pe aaa
perl -pe bbb
    ...
perl -pe zzz
perl -pe AAA
perl -pe BBB
    ...
perl -pe ZZZ
perl -pe '__'
perl -pe '$$'
perl -pe '%%'
perl -pe '@@'
perl -pe ';;'
perl -pe '**'
perl -pe '##'
perl -pe '""'
perl -pe "''"
perl -pe '``'
perl -pe '//'
perl -pe '::'
perl -pe '??'    #  Only if your perl is old enough (pre 5.22)
perl -pe '  '    #  Spaces (or tabs, or newlines, etc)
perl -pe '()'
perl -pe '[]'
perl -pe '<>'
perl -pe '{}'
perl -pe '\&\'
perl -pe ''      #  Empty program
```
They all copy their input to output.
## How does it work?
`perl -pe` reads the input line by line, and executes the given program, where `$_` contains the read line. After executing the program, it prints whatever is left in `$_`. None of the given programs modify `$_`, all statements are just noops.
In short, all digits, all upper case letters and all but 3 lower case letters can used single (or double, triple, etc). They're either numbers or strings in void context. Since `m`, `s`, and `q` used single may be commands, (and for `q`, this is also the case when used double), using them all as triples will do.
Many other characters can be used, sometimes single, or otherwise double. But if we can use them single, double will work too, hence we used doubles. `__` is just a string. `$$`, `@@`, `%%`, and `**` are variables. `;;` are two command separators. `""` is an empty string, and so is `''`. Double backticks just execs a empty command. `##` is a comment. `::` is an alternative way of spelling the package `main`. `//` is an empty regexp. `??` is the weird regexp operator you never needed, or probably never knew about (it repeats the last successful match).
Any of the whitespace characters (space, newline, tab, etc) can use used as well.
This leaves a few characters I could not use by themselves, and I had to pair them with another: `[]` is an empty array. `()` is an empty list. `<>` reads line from the input. `{}` is an empty block.
`\&\` is a reference to (non-existing, but Perl is fine with that) subroutine named `\`.
And of course, the empty program qualifies as well (thanks to David G. for pointing that out).
This leaves `!`, `+`, `,`, `-`, `.`, `=`, `^`, `|`, `~` as an exercise for the reader.
That's 10 (digits) + 52 (lower + upper case letters) + 6 (white space) + 13 (other characters used by themselves) + 5 (programs with 2 different characters) + 1 (empty program) = 87 programs.
[Answer]
# R, ~~11~~15 programs
This is a very interesting challenge for R, we get to use lots of different features of the language!
firstly, in R, any expression that isn't assigned somewhere is printed by default, so the empty program counts (it will return an integer unchanged, for example)
`c` can be treated as a function of one argument that will return it unchanged.
`I` adds a class attribute, but this does not affect the printing.
`t` will return its argument as a 1x1 matrix (I hope this counts as "unchanged" for the purposes of the problem).
`min` will return its argument unchanged if that is a single integer.
`as.raw` will return a hexadecimal integer unchanged (from my reading of the problem, I *think* that's acceptable.)
`+` as a unary function of one integer will return it unchanged.
`1*` as a program will then generate a prompt for the second argument: entering it will return the entered integer unchanged.
`--`, similarly to `1*`, will generate a prompt for a number which is then negated twice and therefore printed unchanged. (Edit: `T%x%` will do the same, taking the Kronecker product of the entered number with `TRUE==1` --- thanks Robin Ryder)
`(` and `'{'` both return their argument (they are formal functions in R). They need the quotes to function, but luckily R lets you use different kinds of quotes.
`"\u73\u75\u6D"` will also work as a function; the escapes evaluate to "s", "u" and "m" respectively which gives `sum`, which will return its argument unchanged if it is a single integer.
Lastly, everyone always forgets about complex numbers but `Re` and `Mod` will return the real part and modulus of the argument respectively. If that argument is a positive integer then they are no-ops.
Thanks to Giuseppe for the `min` and brackets ideas and to Robin Ryder for some other suggestions!
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 252 programs
The first 5 programs are:
```
[]
()
<><>
#{}
```
and the empty string. These programs have 9 unique characters total.
Each of the remaining 247 programs consist of an individual byte other than `(){}<>{}#`. 
## How?
In brain-flak, an empty program prints it's input. Any character other than `#(){}[]<>` has no affect on the behavior of the program.
[Try it online!](https://tio.run/#brain-flak)
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~12~~ 15 programs
Edit: Added three more programs which are no-ops only on numeric input.
```
↧
```
[Try it online!](https://tio.run/##S85ILErOT8z5//9R2/L//w0A "Charcoal – Try It Online") Lowercases the implicit input, which has no effect for numeric input.
```
↥
```
[Try it online!](https://tio.run/##S85ILErOT8z5//9R29L//w0A "Charcoal – Try It Online") Uppercases the implicit input, which has no effect for numeric input.
```
θ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRKNQ0/r/f4P/umU5AA "Charcoal – Try It Online") Link is to verbose version of code. Prints the default input.
```
Ｓ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMMzr6C0JLgEyE7X0NS0/v/f4L9uWQ4A "Charcoal – Try It Online") Link is to verbose version of code. Prints the explicit string input.
```
Ａ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMMzr6C0RENT0/r/f4P/umU5AA "Charcoal – Try It Online") Link is to verbose version of code. Prints the explicit input.
```
ＩＮ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM5sbhEwzOvoLTErzQ3KbVIQ1NT0/r/f4P/umU5AA "Charcoal – Try It Online") Link is to verbose version of code. Casts the explicit numeric input to string so that it can be printed.
```
∨⁰
```
[Try it online!](https://tio.run/##S85ILErOT8z5//9Rx4pHjRv@/zcAAA "Charcoal – Try It Online") Prints the logical OR of 0 and the implicit input.
```
∧χ
```
[Try it online!](https://tio.run/##S85ILErOT8z5//9Rx/Lz7f//GwAA "Charcoal – Try It Online") Prints the logical AND of 10 and the implicit input.
```
⮌⮌
```
[Try it online!](https://tio.run/##S85ILErOT8z5///Ruh4g@v/fAAA "Charcoal – Try It Online") Prints the implicit input reversed twice.
```
⁺ω
```
[Try it online!](https://tio.run/##S85ILErOT8z5//9R467znf//GwAA "Charcoal – Try It Online") Prints the empty string concatenated with the implicit input.
```
×¹
```
[Try it online!](https://tio.run/##S85ILErOT8z5///w9EM7//83AAA "Charcoal – Try It Online") Prints the implicit input repeated once.
```
﹪%s
```
[Try it online!](https://tio.run/##S85ILErOT8z5///9zlWqxf//GwAA "Charcoal – Try It Online") Formats the implicit input as a string.
```
⊟⊞Ｏυ
```
[Try it online!](https://tio.run/##S85ILErOT8z5//9R1/xHXfPe71l/vvX/fwMA "Charcoal – Try It Online") Pushes and pops the implicit input to a list before printing it.
```
⎇℅ψφ
```
[Try it online!](https://tio.run/##S85ILErOT8z5//9RX/ujltbzHefb/v83AAA "Charcoal – Try It Online") Prints the implicit input if the null byte's ordinal is zero.
```
⭆⊖²⊖⊕
```
[Try it online!](https://tio.run/##S85ILErOT8z5///R2rZHXdMObQISj7qm/v9vAAA "Charcoal – Try It Online") Increments and decrements one implicit (numeric) input, then joins the results together.
[Answer]
# Brachylog, 88 programs
I doubt this is the longest I can get it, as I'm only posting this now because I need to take a break from making more of these, and if character lists are admissible for strings I know this can be expanded even further. The reason so many one-character solutions exist is that Brachylog has a lot of variables, constraint predicates, and flow control commands, plus a fair number of nondet predicates that happen to have the exact input as their *first* output.
1. The empty program, for integers or strings.
2 - 27. Any uppercase ASCII letter, for integers or strings.
28. `İ` for integers.
29. `Ṡ` for strings.
30 - 42. Any one of `ȦḂḞĠḢṄṖṘẆẊẎŻ`, for integers or strings.
43. A space, for integers or strings.
44. A newline, for integers or strings.
45. `?`, for integers or strings.
46. `.`, for integers or strings.
47. `&`, for integers or strings.
48. `|`, for integers or strings.
49. `≜`, for integers.
50. `w`, printing an integer from stdin.
51. `ẉ`, printing an integer from stdin with a trailing newline.
52. `p`, for strings.
53. `s`, for strings.
54. `≡`, for integers or strings.
55. `!`, for integers or strings.
56. A backtick, for integers or strings.
57. `⊆`, for strings.
58. `⊇`, for strings.
59. `()`, for integers or strings.
60. `{}`, for integers or strings.
61. `↔↔`, for strings.
62. `↺↻`, for strings.
63. `∈h`, for strings.
64. `,Ė`, for strings.
65. `ṅṅ`, for integers.
66. `gṛ`, for integers or strings.
67. `ℤ`, for integers. (can't believe I forgot this earlier, but I can't be bothered to renumber everything)
68. `ḋ×`, for integers.
69. `+₀`, for integers.
70. `ℕ`, for integers. (I didn't notice the restriction to positive!)
71. `ȧ`, for integers. (again, specifically positive)
72. `ṫị`, for integers.
73. `ċ₂`, for strings.
74. `÷↙Ḋ`, for integers.
75. `ḅc`, for strings.
76. `<<<-₃`, for integers.
77. `aʰ`, for strings.
78. `f⌉`, for integers.
79. `dᵗ`, for strings.
80. `=ᵐ`, for strings.
81. `≠ˢ`, for strings.
82. `;1/`, for integers.
83. `^₁`, for integers.
84. `jḍt`, for strings.
85. `~⌋⌋`, for integers or strings.
86. `⟦bl`, for integers.
87. `⟧k∋ᶜ`, for integers.
88. `≤`, for integers.
[Answer]
# [APL (dzaima/APL)](https://github.com/dzaima/APL), 38 functions/programs
The code to be counted is parenthesised below. The first two entries are full programs, the rest are tacit prefix functions, except `{⍵}` which is a prefix lambda.
```
(⎕) ⍝ prompt for numeric input and implicitly print it
(⍞) ⍝ prompt for string and implicitly print it
(⍮)I ⍝ 1-element with (no visual difference on simple scalar)
(⌷)S ⍝ materialise (no-op on anything but certain objects)
(∧)I ⍝ LCM reduction (no-op on scalar)
(∨)I ⍝ GCD reduction (no-op on scalar)
(⌽)I ⍝ mirror (no-op on scalar)
(⍉)I ⍝ transpose (no-op on scalar; TIO's version has a bug that has since been fixed)
(⊖)I ⍝ flip (no-op on scalar)
(+)I ⍝ complex conjugate (no-op on real number)
(∊)S ⍝ enlist (no-op on strings)
(↑)S ⍝ mix (no-op on simple arrays)
(↓)I ⍝ split (no-op on simple scalars)
(⊢)S ⍝ identity
(⊣)S ⍝ identity
(⌈)I ⍝ ceiling (no-op on integer)
(⌊)I ⍝ floor (no-op on integer)
(⍕)I ⍝ stringify (no-op on string)
(⊂)I ⍝ enclose (no-op on simple scalar)
(⊃)I ⍝ first (no-op on simple scalar)
(∪)I ⍝ unique (no-op on simple scalar)
(|)I ⍝ absolute value (no-op on positive numbers)
(,)I ⍝ ravel (no-op on strings)
(⍪)I ⍝ table (no visual difference on scalars)
(⍷/)I ⍝ use find (arbitrary otherwise unused function) to reduce (no-op on scalar)
(1⌿)S ⍝ replicate all elements to 1 copy each (no-op on string)
(9○)I ⍝ real part (no-op on real number)
(⍟*)I ⍝ natural logarithm of e to the power
(⍬,)S ⍝ prepend the empty list (no-op on string)
(⊥⊤)I ⍝ the base-2 evaluation of the base-2 representation
(--)I ⍝ negate the negation
(÷÷)I ⍝ reciprocate the reciprocal
(~∘8)S ⍝ remove all occurences of number 8 (no-op on string)
({⍵})S ⍝ user-defined identity function
(!⍣0)I ⍝ apply the factorial zero times
(''⍴)I ⍝ reshape to 0D (no-op on scalar)
(.5×2×)I ⍝ half the double
(⍳∘≢⍛⊇⍨)S ⍝ use all the indices to permute the argument (this one is supposed to say ⍤ instead of ∘ but TIO isn't updated)
```
[Try it online!](https://tio.run/##jVZNbxxFEL3nVzSn9ZIsxBaREuWYSMgSiEP4A7UzNTsd9XQ3/bH2hI8DSGGz2UEgFIyEIFI@RIQQF0A@IQ7@J/NHTPVs987Yzsac1ut@r7rq1avqBS0m@QPgFZzutw@/fW/vyj36GJUohGIHyoh8dNp@84T@t0MfY9Y2PzNtVKUdK5Rh0ldoeMa41N4xkDnjlRY8407UhOPSMe6upADNLxcCWEeg2eXMP8b7HXV3ggIrpNMD7kq2IxWbc@tBsJwXBRqUGTIlmQ3RkNkMBJjxJs7qeHyvi1OBo8RBcIshyETpwAJZuzLkM6VqMjQOuGRqeh8zZ/sgi19jMh/c@ZAZzH3mOJH7MOdvXbyKhPfv3P1fhNU/kVBxY0il7cjmUUQ6A9JqdaacNfg2@3j/o5FlczQ2XFuCZUAVzpgrwXVfLQ@yTRElK/gh5n385Q8xfiG43p7H1YjKVJD9kD7lfT8jjQcUg9QlMswUh9IsY0NQUi/c8IbOGQPZH36XescPh7h1p8EYqIfo72NKllzlLuLXBQwIy2cxPM/JXtzV/cnzbSerRaobuQi@6a8hA@NsWOlquVFSnWnpBWTzJKXeScCL@oIsg7S/jGByvjjX/tfPwPKrlAg31l2OX/wW8V7yT/zlF3wW4TC1SniywBzEGRq5lDs@x2iGvgfXItPAHMWbrNCklBxMBb5hC5xvcnP8biqGpCo4rZ0dMFNO02NqplyJ5iCsBC/pPGeFl92ojplT68HF7TOw267@jUYxGFZZsD8IweLGsiHILo2GrhlCVm5v6q326HGSIgyNBuMuG6Tm6duRIsF5QwihZmBoSVZMFQzD5VQeiX@Apmf9fi2mrClnJDkCBmk71@y18ziw0ct2@SK1gUhTsDjZYxi6Dd1@o2sHBxTfoCUdusMUZjJJWWO3LgKh@3OAOTk@Od7IkXF6PbIE3XwXCfxFu/jx5qYNlZqve6CyzHe2sCGttXjs5vbyPm2bvz@PYcgKZpIjuYUskXbAxhuJ8VbbPL@erK81vWIhwQIyp8JDwx6goQ7wCm1ijEZt89emMFuC7rp0/e52j71z4@Ro7@QokkoQa4lz5WkO@q7@SSK0j561zU/t8uu2edUX0okRKGR9HtSgCzWaykdBwcx897zu0ENIWklC0vvgdXha8oC2UFOwFxTAOoQ8yEm3dS8mvTOEliPHvM6pRfn49JR@UQx@TPwH "APL (dzaima/APL) – Try It Online")
[Answer]
## Haskell, ~~5~~ 6 programs
### 1:
```
id
```
Haskell has an identity function, so that is a good start. It uses `i` and `d` which are not terribly valuable anyway.
### 2:
```
k x=x
```
A simple definition of an identity. It uses `=` which is going to make it hard for us to define any new functions (instead we will have to build them). And it also uses the space which is would be useful otherwise.
### 3:
```
\z->z
```
This is a lambda of the last version. This marks the end of the straight forward identities.
### 4:
```
(*1)
```
Multiplies the input by 1, which is an identity for members of the `Num` class. This uses up the very valuable parentheses.
### 5:
```
abs
```
As pointed out by H.PWiz since the input is positive `abs` is an identity
### 6:
```
fromEnum
```
This is an identity on integers.
---
At this point we still have a lot of room we could use `<$>` or `$` (replacement for space or parentheses), however I can't get anything to fit the `t` in `Just` is a problem for things like `subtract`, `const` and `repeat` which would be useful.
[Answer]
# Husk, 1 program + 24 functions
* 8 functions by [@Zgarb](https://codegolf.stackexchange.com/users/32014/zgarb)!
* 4 functions by [@Razetime](https://codegolf.stackexchange.com/users/80214/razetime)
Programs:
1. `ḟ=⁰N` - Find an element that equals the last command-line argument in the infinite list of natural numbers. [Try it online](https://tio.run/##yygtzv7//@GO@baPGjf4/f//3wQA)
Functions:
1. `I` - the identity function
2. `+0` - Add 0
3. `*1` - Multiply by 1
4. `D½` - Double and then halve
5. `ĠK` - Scan right without an initial value. The `K` combinator just discards the second argument, so the list remains the same.
6. `←;` - Make a singleton list, then get the first element. [Try it online](https://tio.run/##yygtzv7//1HbBGvL//8B)
7. `__` - Negate twice
8. `⌉` - Ceiling (identity for integers)
9. `⌋` - Floor (identity for integers)
10. `i` - Round (identity for integers)
11. `a` - Absolute value (identity for positive numbers)
12. `√□` - Square root of square
13. ```` - Swap arguments of binary function twice
14. `\\` - Reciprocal twice ([Try it online!](https://tio.run/##yygtzv7/Pybm////xgA))
15. `LR"3"` - Repeat `"3"` `n` times, then take the length, giving back n. Can be something other than 3
16. `-ø` - Remove the empty list ([Try it online!](https://tio.run/##yygtzv7/X/fwjv///0cb6hjFAgA))
17. `cc` - Convert integer to character, convert character back to integer
18. `dd` - `d` can both get the base 10 digits or interpret digits in base 10
19. `n¹` - Bitwise and with itself
20. `tΘ` - Prepend default value, then get tail
21. `s` - Show (for strings)
22. `↔↔` - Swap pair/reverse list/reverse digits twice
23. `!4∞` - Get fourth (arbitrary) element of infinite list of copies of argument
24. `ΣC2` - Cut into sublists of size 2, concatenate them (for lists of size > 1)
[Answer]
# [Stack Cats](https://github.com/m-ender/stackcats), 19 programs
All programs that are exactly mirrored in Stack Cats function exactly as cat programs. Therefore, we can score one program for each valid symmetric character by having there be two of them, and we can score one program for each pair of matching characters. These character sets are:
```
!"*+-:=ITX^_|
(){}[]<>\/
```
Unfortunately, most other characters cause syntax errors in the existing interpreters. However, the empty program is also symmetric, so it also produces a cat program.
Sample symmetric program:
```
II
```
[Try it online!](https://tio.run/##Ky5JTM5OTiwp/v/f0/P/f0cnZxcA "Stack Cats – Try It Online")
Sample matching program:
```
{}
```
[Try it online!](https://tio.run/##Ky5JTM5OTiwp/v@/uvb/f0cnZxcA "Stack Cats – Try It Online")
Empty program example:
[Try it online!](https://tio.run/##Ky5JTM5OTiwp/g8Ejk7OLgA "Stack Cats – Try It Online")
[Answer]
# [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), ~~21~~ ~~22~~ ~~24~~ ~~25~~ ~~26~~ 27 programs
*Edit: thanks to Abigail for duplicate-letter-spotting, for the suggestion that led to `l^l`!, and for ~~+2~~ +3 more programs; and thanks to cnamejj for +1 program*
Awk will print the input line by default if a condition evaluates to TRUE.
non-zero values that evaluate to TRUE:
```
1
2
3
4
5
6
7
8
9
```
experessions that evaluate to TRUE:
```
$0 # only if input is not equal to the digit zero (so Ok for positive integer)
a~a
c==r
d---d
++f
!h
"j"
'k'
// 
m^m
q**q
```
built-in variables that evaluate to TRUE:
```
NR
OFMT
SUBSEP
```
functions that evaluate to TRUE
```
log
exp
int i
sub(v,v)
```
[Try it online!](https://tio.run/##dY/JTsNAEETv9RVNjBRQZIV9k8IBKdwgKMsHjJ223diaMTM9Yfl5M@FMjiXVU9Uzn@0wZGSdzX/YO9qZLnIgbYwS74NRJnW0Xm7mDzjHBS5xhWvc4BZ3uEdG/NWz5xDE2YPc8Rll5Gz3TVKR2D4qSUijqfsRTbcvasO0lVqU/n6cBEeLlirnqXdBVHacQOWa/SmK2axE9ZjnNSaTBkeC0fsI43aM6ZTSpSJKp7nYZOPFFN1hodclFs8va6w2T6v5W0KraEv9X0V9ZHhjt8NgivIX "AWK – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 4 programs
Python turned out to be much harder than I thought, with only 4 so far.
```
int
abs
repr
(1).__mul__
```
[Try it online!](https://tio.run/##RYxNCsIwEIX3OcWQTWaoFGp3Qq5Quq8SqkSM1ElIIujpYyKIq@/x/sI73zyPpcygYVGOs9qBWs@pIdoQG3Gg3pjHczNGncTVR3DgGOaDAPuyF5SmjiV01e5AHjnE@oMGh/1IJEmIqeZK9XfvGH9MNqMjgv8diTUlGzNslnEi0PqrWnEiKuUD "Python 3 – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 4 programs
```
->x{x}
```
The basic stabby lambda form. [Try it online!](https://tio.run/##KypNqvyfZhvzX9euorqi9n@0oY6CUkamUqxeamJyhkJKvkJNZg2XgkJBaUmxglJatGpBrIKtgmqBkmp0po5CWnRmbCxXal7KfwA "Ruby – Try It Online")
```
def f e;e;end
```
The classic way of defining functions in Ruby. [Try it online!](https://tio.run/##KypNqvz/PyU1TSFNIdUaCPNS/kcb6igoZWQqxeqlJiZnKKTkK9Rk1nApKBSUlhQrKKVFqxbEKtgqqBYoqUZn6iikaWRqxnKB9AEA "Ruby – Try It Online")
```
puts(ARGF.to_a.sum(""))
```
Takes the input stream `ARGF` (points to STDIN if no program arguments are present), turns it into an array, combines it again (using `sum` because `join` shares an `n` with the previous program) and outputs it. [Try it online!](https://tio.run/##KypNqvz/v6C0pFjDMcjdTa8kPz5Rr7g0V0NJSVPz/3@P1JycfB2F8vyinBRFAA "Ruby – Try It Online")
```
b=*$<
STDOUT<<b*''
```
`$<` is an alias for `ARGF`. Same as above, but uses the splat operator `*` to turn it into an array, and joins it using the array join operator `*`. [Try it online!](https://tio.run/##KypNqvz/P8lWS8WGKzjExT80xMYmSUtd/f9/j9ScnHwdhfL8opwURQA "Ruby – Try It Online")
[Answer]
# [Keg](https://github.com/JonoCode9374/Keg), `-hr`, `-lp` 17 programs
There'll be more soon.
```
#
```
[Try it online!](https://tio.run/##y05N//9f@f9/QyPj/7oZRf91cwoA "Keg – Try It Online")
```
,
```
[Try it online!](https://tio.run/##y05N//9f5/9/Ryfn/7oZRf91cwoA "Keg – Try It Online")
```
.
```
[Try it online!](https://tio.run/##y05N//9f7/9/QyPj/7oZRf91cwoA "Keg – Try It Online")
[Try it online!](https://tio.run/##y05N/w8EhkbG/3Uziv7r5hQAAA "Keg – Try It Online")
```
0+
```
[Try it online!](https://tio.run/##y05N///fQPv/fyMD4/@6GUUA "Keg – Try It Online")
```
1*
```
[Try it online!](https://tio.run/##y05N///fUOv/fyMD4/@6GUUA "Keg – Try It Online")
```
¿
```
[Try it online!](https://tio.run/##y05N////0P7//40MjP/rZhQBAA "Keg – Try It Online")
```
᠀
```
[Try it online!](https://tio.run/##y05N////4YKG//@NDIwB "Keg – Try It Online")
```
∑)
```
[Try it online!](https://tio.run/##y05N////UcdEzf//jQyM/@vmFPzXzSgCAA "Keg – Try It Online")
```
:
```
[Try it online!](https://tio.run/##y05N///f6v9/IwPj/7oZRQA "Keg – Try It Online")
```
"
```
[Try it online!](https://tio.run/##y05N//9f6f9/IwPj/7oZRQA "Keg – Try It Online")
```
±±
```
[Try it online!](https://tio.run/##y05N////0MZDG///NzIw/q@bUQQA "Keg – Try It Online")
```
⅍
```
[Try it online!](https://tio.run/##y05N////UWvv//9GBsYA "Keg – Try It Online")
```
;⑨
```
[Try it online!](https://tio.run/##y05N///f@tHEFf//GxkY/9fNKAIA "Keg – Try It Online")
```
⑵½
```
[Try it online!](https://tio.run/##y05N////0cSth/b@/29kYPxfN6MIAA "Keg – Try It Online")
```
④_
```
[Try it online!](https://tio.run/##y05N////0cTF8f//GxkYAwA "Keg – Try It Online")
```
⑩᠈
```
[Try it online!](https://tio.run/##y05N////0cSVDxd0/P@fmJT8XzejCAA "Keg – Try It Online")
[Answer]
# Scala, 9 functions
```
x=>x
```
A lambda function.
```
math.abs
```
A utility function from the math package.
For the following functions, we use the fact that methods on objects can be converted to functions if no arguments are given.
```
1*
0+
2-2|      // bitwise or with (2-2)
~(8&4)&   // bitwise and with ~(8&4)
3^3^      // bitwise xor with (3^3)
Nil:::    // concat with an empty sequence
```
```
_ ##
```
Here, the underscore is syntactic sugar for a lambda argument. It calls the method `##` on it, which calculates a hash code, but is an identity function for integers.
[Answer]
# [Brainetry](https://github.com/RojerGS/brainetry), 1 program
1 is the maximum score attainable by the [Brainetry](https://github.com/RojerGS/brainetry) programming language. The programs below are cat programs, they take any user input and output it unchanged.
```
a b c d e f
a b c d e f g h
a b c d e f g
a b c d e f
a b c d e f g h i
```
[Brainetry](https://github.com/RojerGS/brainetry) is partially symbol independent but it needs spaces to understand what instruction each line refers to, so a program with no spaces can only be composed of empty lines and lines with one word, corresponding to the `«` and `»` instructions, which are not useful for this challenge.
The program above was golfed from this other program:
```
This program you are currently reading
has the particularity of explaining itself. In fact,
this program has one simple mission :
Take some input provided by you
and throw it right back at your face !!!
```
[Answer]
# [PHP](https://php.net/), 6 programs (functions)
```
abs
fn($n)=>$n
iNtvAl
chop
HeBreV
TRIm
```
[Try it online!](https://tio.run/##LYwxC8IwEIX3/IqjBC4BEapjTEUnXRxEXGqHWBJTqGloaxfxt8eE9oa77917PG992O193NR8XD2AhBJQPQdcARrHqOOyoC6p5jJOhzZRbTuf7kkfe31PdLue3wiVIKbrtaotW9rUADPxL4E4elItQ2okwnpxIqBALmY/Vsc/a9yYklT1r6nMK85jKnu4TJBfCCHfbP8 "PHP – Try It Online")
We're taking advantage of PHP looseness about functions lower/upper case and types (all these fall into first case: taking an integer and return it unchanged), still searching for more
[Answer]
# Clojure, 8 functions
They are:
```
+
*
/
->
do
max
str
(fn[n]n)
```
Arithmetic operations in Clojure are variadic functions that when given only one argument return it unchanged, and thus work as identity functions for numerics.
Minus is an exception, because with one argument it becomes unary negation. But in its place we can use threading macro `->`, which with no further functions to apply returns the supplied value as is.
`do` is a special form that is normally used to group several expressions into one and returns the value of the last one (in our case - the only one).
`max` of one entry is obviously equal to the entry itself.
`str` converts the argument to string, and so is the identity for strings.
Finally, the last one is an explicitly written out identity function.
Many important letters are now exhausted, and with `()` used up we aren't going anywhere further in a Lisp. I haven't included several other possible functions because they collide with those above:
```
identity
min
and
or
```
[Answer]
# Rust, 2 functions
```
|x|x
i8::abs
```
Sadly, the colon is needed for all other ways to define a function.
[Answer]
# [Zsh](https://www.zsh.org/), 4 functions/math functions
```
()((argv))                 # bind as a math function
int                        # math function from zsh/mathfunc
echo -E - $@               # string arg to stdout
<&0                        # stdin to stdout
```
[Try it online!](https://tio.run/##HYy9CsMgAIR3n@IGITqE0lBaurVDx75BFvNjFKIGtSVN6bNbDQfHfRx3W1BpM26YnRiwBXUwIir5sj0pFrWzAfUTBscsQ4hpE@OMCT@9OSfSeUgLZiC6AFmsH/UMObvcaBtLEpF/CYCxVw6UMVBp2anhyAe/RKulXS9Nu56vNlaoaVUwB9Ab2Sf1Y4eU7r7T0Qv/QYhe2@kP "Zsh – Try It Online")
This is with `zmodload zsh/mathfunc` for `int`.
This is not the only combination of 4 functions, but it is the shortest set I found that only uses a single `zsh/mathfunc` function.
Either `echo` or `print` can use `$'\xHH'` notation to replace conflicting characters, in which case `ceil` can also be substituted in place of `int`.
[Answer]
# J, 13 functions
## Either
`[` and `]` return their arguments.
`>` removes their argument from a box. Strings and integers don't have boxes.
## Rank 0 Array
(characters or integers)
`=/` acts on a more than length 1 array. Rank 0 arrays are always length 1.
## Positive Integers
`|` is magnitude, which is `abs(x)` in Python. Does nothing for positive integers.
`+` is complex conjugate, which negates the imaginary part. 
`----` negates the number 4 times.
`%%%%` takes the reciprocal of the number 4 times.
`**` is a hook that becomes `y*(*y)`. For positive integers, `*y` always returns 1. That means `(**)y` is `y*1`.
`^#` is a hook that becomes `y^(#y)`. For rank 0 arrays, `#y` always returns 1. That means `(^#)y` is `y^1`.
`<.` rounds down a number to the nearest integer. The nearest integer from an integer is the integer itself.
`1&!` returns how many ways you can pick 1 ball from a bag of `y` balls, which is `y`.
`0}~` works.
[Answer]
# Vyxal, 108 bytes, 67 answers
1. (Empty) [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=&inputs=1&header=&footer=)
2. (Space) [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%20&inputs=1&header=&footer=)
3. (Newline) [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%0A&inputs=1&header=&footer=)
4. `#` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=#&inputs=1&header=&footer=).
5. `?` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=?&inputs=1&header=&footer=).
6. `_` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=_&inputs=1&header=&footer=).
7. `:` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=:&inputs=1&header=&footer=).
8. `D` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=D&inputs=1&header=&footer=).
9. `∑` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E2%88%91&inputs=1&header=&footer=).
10. `£` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%C2%A3&inputs=1&header=&footer=).
11. `∴` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E2%88%B4&inputs=1&header=&footer=).
12. `∵` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E2%88%B5&inputs=1&header=&footer=).
13. `ṅ` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E1%B9%85&inputs=1&header=&footer=).
14. `¤j` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%C2%A4j&inputs=1&header=&footer=)
15. `÷Ṡ` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%C3%B7%E1%B9%A0&inputs=Hello%2C%20world!&header=&footer=).
16. `1/` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=1/&inputs=14&header=&footer=).
17. `⁰` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E2%81%B0&inputs=14&header=&footer=)
18. `¹` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%C2%B9&inputs=14&header=&footer=)
19. `d½` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=d%C2%BD&inputs=14&header=&footer=)
20. `ƒh` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%C6%92h&inputs=14&header=&footer=)
21. `²√ṙ` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%C2%B2%E2%88%9A%E1%B9%99&inputs=14&header=&footer=)
22. `‹›` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E2%80%B9%E2%80%BA&inputs=14&header=&footer=)
23. `ɾL` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%C9%BEL&inputs=14&header=&footer=)
24. `øCĖ` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%C3%B8C%C4%96&inputs=153&header=&footer=)
25. `→` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E2%86%92&inputs=153&header=&footer=)
26. `±` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%C2%B1&inputs=Hello%2C%20world!&header=&footer=)
27. `⅛` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E2%85%9B&inputs=14&header=&footer=)
28. `ɖt` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%C9%96t&inputs=4&header=&footer=)
29. `₴` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E2%82%B4&inputs=153&header=&footer=)
30. `,` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%2C&inputs=153&header=&footer=)
31. `…` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E2%80%A6&inputs=4&header=&footer=)
32. `ḣJ` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E1%B8%A3J&inputs=Hello&header=&footer=)
33. `ṫ+` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E1%B9%AB%2B&inputs=Hello&header=&footer=)
34. `v` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=v&inputs=Hello&header=&footer=)
35. `↔` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E2%86%94&inputs=Hello&header=&footer=)
36. `•` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E2%80%A2&inputs=Hello&header=&footer=)
37. `(₈)!` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%28%E2%82%88%29!&inputs=9&header=&footer=)
38. `I` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=I&inputs=9&header=&footer=)
39. `$` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%24&inputs=9&header=&footer=)
40. `Ŀ` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%C4%BF&inputs=Hello%2C%20world!&header=&footer=)
41. `NN` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=NN&inputs=9&header=&footer=)
42. `S` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=S&inputs=Hello%2C%20world!&header=&footer=)
43. `V` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=V&inputs=9&header=&footer=)
44. `Yy` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=Yy&inputs=Hello%2C%20world!&header=&footer=)
45. `^` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%5E&inputs=Hello%2C%20world!&header=&footer=)
46. `ei` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=ei&inputs=Hello%2C%20world!&header=&footer=)
47. `g` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=g&inputs=5&header=&footer=)
48. `G` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=G&inputs=5&header=&footer=)
49. `s` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=s&inputs=5&header=&footer=)
50. `⌈` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E2%8C%88&inputs=5&header=&footer=)
51. `⌊` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E2%8C%8A&inputs=5&header=&footer=)
52. `ȧ` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%C8%A7&inputs=5&header=&footer=)
53. `ġ` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%C4%A1&inputs=5&header=&footer=)
54. `ṁ` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E1%B9%81&inputs=5&header=&footer=)
55. `0ȯ` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=0%C8%AF&inputs=5&header=&footer=)
56. `@a|` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%40a%7C&inputs=5&header=&footer=)
57. `Aẋ` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=A%E1%BA%8B&inputs=Hello%2C%20world!&header=&footer=)
58. `§` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%C2%A7&inputs=Hello%2C%20world!&header=&footer=)
59. `ε` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%CE%B5&inputs=Hello%2C%20world!&header=&footer=)
60. `µ` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%C2%B5&inputs=5&header=&footer=)
61. `wṄ` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=w%E1%B9%84&inputs=Hello&header=&footer=)
62. `↵⁋` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E2%86%B5%E2%81%8B&inputs=Hello&header=&footer=)
63. `ṘṘ` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E1%B9%98%E1%B9%98&inputs=Hello%2C%20world!&header=&footer=)
64. `Ḃ` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E1%B8%82&inputs=4&header=&footer=)
65. `Π` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%CE%A0&inputs=5&header=&footer=)
66. `„` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E2%80%9E&inputs=5&header=&footer=)
67. `‟` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E2%80%9F&inputs=5&header=&footer=)
68. `[` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%5B&inputs=5&header=&footer=)
69. `∇` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E2%88%87&inputs=5&header=&footer=)
70. `⋎` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E2%8B%8E&inputs=5&header=&footer=)
71. `⋏` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E2%8B%8F&inputs=5&header=&footer=)
72. `ꜝꜝ` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%EA%9C%9D%EA%9C%9D&inputs=5&header=&footer=)
73. `⇧⇩` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E2%87%A7%E2%87%A9&inputs=5&header=&footer=)
74. `¬Ǔ` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%C2%AC%C7%93&inputs=Hello&header=&footer=)
75. `¥ǔ` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%C2%A5%C7%94&inputs=Hello&header=&footer=)
76. `꘍꘍` [Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%EA%98%8D%EA%98%8D&inputs=54&header=&footer=)
This took well over two hours.
[Answer]
# [str](https://github.com/ConorOBrien-Foxx/str), 19 programs
This is a very flexible language, because the empty program works, and there are a lot of no-op functions, or things that can be combined into no-ops. All of these are programs taking strings as input.
1. The empty program
2. A space character
3. A tab character
4. A newline character
5. `.` (this and the whitespace above explicitly do nothing)
6. `;` (the `;` character is used as a separator and does nothing by itself)
7. `3~` (push a value, then swap it. The language only pays attention to the top value of the stack for each character)
8. `2$` (push a value, then discard it)
9. `e:` (concatenate each character with the empty string)
10. `oq` (explicitly print each character, then tell the language not to implicitly print it)
11. `1x` (repeat each character one time)
12. `bu` (move each character to the buffer, then back to the stak)
13. `yc` (convert to a number, then back to a string)
14. `m` (convert to a string, which it already is)
15. `XY` (increment by one codepoint, then decrement again)
16. `w` (unlike all the above programs, this adds a trailing newline. I have no idea why this works)
17. `0-` (subtracts 0 from each character)
18. `_` (`_` is the reverse function, except it operates on each character individually, so does nothing here)
19. `d` (duplicates each character, but the implicit output only prints one character per input, so this amounts to nothing)
[Answer]
# Python 3, 5 solutions (a program, three functions and a default-value variable)
I see there's already a Python 3 answer, but I thought I'd try and make another one anyway. Or should it have been a comment?
* `exec("p\x72\x69\x6e\x74(\x69\x6epu\x74())")` # reads a line from standard input and writes it to standard output, the code has most letters escaped so they aren't directly included, and then the quotes unescape them and exec runs them
* `str` # returns an argument as a string
* `lambda a:a` # returns an argument
* `''.join` # returns a string with nothing inserted between the characters
* `_` equals the previous line (this one only works in the interactive interpreter, but the other ones work there too, so it should probably be okay). I think I saw some solution to another puzzle here using a default variable like that as an input, so hope that's okay. Otherwise this is four solutions, like the other answer.
[Answer]
# [><>](http://esolangs.org/wiki/Fish), 3 programs
><> has exactly two characters that can be used for output. `n` prints an integer.
Program 1:
`n;`
The other output character is `o`, printing an ascii character. Since we have already spent the program terminator `;` and programs are required to halt, we can trigger the "something smells fishy..." by division by zero
Program 2:
`io00,`
But yet another program is still possible. A `n` or `o` character can be obtained by reflection, which only `p` can perform.
Program 3:
`ab*aa-:p4f*1-1aa-p`
The useable IO instructions in ><> are then depleted.
[Answer]
# Elixir, 5 functions
```
+
abs
round
ceil
&(&1)
```
Well, unary `+` is technically an operator, but I think it should count, as it really quacks like a function in Elixir. For instance, it can be captured and passed as an argument to a higher-order function in the same way as a named function, and even the syntax for overriding unary operators is like defining normal functions.
The next three are numerical functions that work as identity for positive integers. These are all defined in `Kernel` module (`ceil` available from version 1.8+), which is imported by default, and thus callable directly without qualifying the module name.
Finally, the last one is a shorthand form of the explicit identity function.
As always, there are other unused candidates that share characters with those above. In particular, the letter `n` is rather "popular":
```
floor
trunc
to_string
Function.identity
fn n->n end
```
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), 1 function and 9 programs
Functions:
1. [`λ;`](http://lyxal.pythonanywhere.com?flags=&code=%CE%BB%3BM&inputs=%5B0%2C1%2C2%2C3%5D&header=&footer=) - A lambda that does nothing.
Programs:
1. [The empty program](http://lyxal.pythonanywhere.com?flags=&code=&inputs=%5B0%2C1%2C2%2C3%5D&header=&footer=) - Nothing happens to the input, so it remains on top of the stack (and gets popped off at the end).
2. [`#`](http://lyxal.pythonanywhere.com?flags=&code=%23&inputs=10.4&header=&footer=) - Basically the same as the empty program, except it has an (empty) comment too.
3. [`:`](http://lyxal.pythonanywhere.com?flags=&code=%3A&inputs=%5B0%2C1%2C2%2C3%5D&header=&footer=) - Duplicate the input. Since we only care about the top of the stack, this can be treated as an identity function even though it leaves trash behind.
4. [`D`](http://lyxal.pythonanywhere.com?flags=&code=D&inputs=%5B0%2C1%2C2%2C3%5D&header=&footer=) - In the same vein as the previous program, this triplicates the input.
5. [`SE`](http://lyxal.pythonanywhere.com?flags=&code=SE&inputs=%5B0%2C1%2C2%2C3%5D&header=&footer=) - Convert to string, then evaluate.
6. [`d½`](http://lyxal.pythonanywhere.com?flags=&code=d%C2%BD&inputs=10.4&header=&footer=) - Double, then halve.
7. [`,`](http://lyxal.pythonanywhere.com?flags=&code=%2C&inputs=10.4&header=&footer=) - Print the input.
8. [`¤$F`](http://lyxal.pythonanywhere.com?flags=&code=%C2%A4%24F&inputs=foobarbaz&header=&footer=) - Finally, an almost non-trivial program! This one pushes the empty string, swaps with the input, then keeps all the characters in the input that aren't in the empty string (which is all of them). It also works with normal lists, but errors.
9. [`ṙ`](http://lyxal.pythonanywhere.com?flags=&code=%E1%B9%99&inputs=10&header=&footer=) - Round an integer.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~14~~ ~~15~~ 16 functions
Verify: [with `Re`](https://tio.run/##y00syUjNTSzJTE78n1aal1ySmZ9XbKukrMal8n7SQhWuqhpduyqutHh9/TTbNK6YGAMTYxBhxvWop@tRT/fjhlme2p4KQPi4YTaXhoahuiYIa0ZHG6pHG8bGxnK5cPlx@RdxOealcPk4@3IF55dzuVZklnAF5JQWcwWlKv1PqixJLbb1yy/KTczRdwguKcrMSw/JdwKKOhYVJVbChIILcjJLouFO1FGKyVOK5QoASpXoO4DNgHCiIeaF5gFVQSWgyqJdSoFmJCeWpLoVpaYGRnvlZ@Y5QFXE/v8PAA) or [with `Ramp`](https://tio.run/##y00syUjNTSzJTE78n1aal1ySmZ9XbKukrMal8n7SQhWuqhpduyqutHh9/TTbNK6YGAMTYxBhxvWop@tRT/fjhlme2p4KQPi4YTaXhoahuiYIa0ZHG6pHG8bGxnK5cPlx@RdxOealcPk4@3IF55dzuVZklnAF5JQWcwUl5hYo/U@qLEkttvXLL8pNzNF3CC4pysxLD8l3Aoo6FhUlVsKEggtyMkui4Y7UUYrJU4rlCgBKleg7gM2AcKIh5oXmAVVBJaDKol1KgWYkJ5akuhWlpgZGe@Vn5jlAVcT@/w8A)
Mathematica only has so many ways to define a function.
1. [`#&`](https://tio.run/##DcO9CoAgEADgvdcQWjLQoLEwaI4oaBGH648O8gS7nt/64PPA1@GBcYN0Nknkad6A7BiR2IqyPY1wucx00a2PmcJLu5mA9uAXiAh82CFED3ePD0dcX8ZAVisl/8rJqnYufQ "Wolfram Language (Mathematica) – Try It Online").
A function that returns its first argument.
2. [`$$`](https://tio.run/##y00syUjNTSzJTE78n2b7X@X9pIUq/4OTE/OiA4oy80qilXXt0hyUY9V0uAy1HZOKHYLyS/NSHIIS81Lyc8MSizITS1Kj/fKLchNzXDKLS4oyk0pLMvPzog0NDHSA2CBWx8g0NvY/AA "Wolfram Language (Mathematica) – Try It Online").
A function of one variable that returns that variable. `` is [U+F4A1](https://reference.wolfram.com/language/ref/character/Function.html).
3. `z|->z`. Identical to #2. `|->` was [added in 12.2](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn122#411725539).
4. [`f_//f=f`](https://tio.run/##DcPBCoQgEADQe78RdMnQFva4i0HniIK9iCxTKQ3kCDZ9v/XgBeDdBWBcIWf/l9J/fJ5XIDMmJDZl8/W6tJUo2rpbTj3FizY9AW0x/CAhsDNDTAGOHk9OuFyMkUyrlHgqK15va/MN "Wolfram Language (Mathematica) – Try It Online").
Defines a function `f` that returns its argument.
5. [`\043\046`](https://tio.run/##y00syUjNTSzJTE78n2b7P8bAxBiIzf4HJyfmRQcUZeaVRCvr2qU5KMeq6XAZajsmFTsE5ZfmpTgEJeal5OeGJRZlJpakRvvlF@Um5rhkFpcUZSaVlmTm50UbGhjoALFBrI6RaWzsfwA "Wolfram Language (Mathematica) – Try It Online").
Escape sequences for `#&`.
6. [`⌊⌋〚I+I I I〛`](https://tio.run/##y00syUjNTSzJTE78n2b7/1FP16Oe7scNszy1PRWA8HHD7P/ByYl50QFFmXkl0cq6dmkOyrFqOlyG2o5JxQ5B@aV5KQ5BiXkp@blhiUWZiSWp0X75RbmJOS6ZxSVFmUmlJZn5edGGBgY6QGwQq2NkGhv7HwA "Wolfram Language (Mathematica) – Try It Online").
The floor function `Floor[][[0]]` = `Floor`. `⌊⌋〚〛` are [U+230A](https://reference.wolfram.com/language/ref/character/LeftFloor.html), [U+230B](https://reference.wolfram.com/language/ref/character/RightFloor.html), [U+301A](https://reference.wolfram.com/language/ref/character/LeftDoubleBracket.html), and [U+301B](https://reference.wolfram.com/language/ref/character/RightDoubleBracket.html), respectively.
7. [`((1')(1'))[[1'[1]]]`](https://tio.run/##Fcy9CsIwEADg3dco2BYj5ARHJYKzSAWX44brHx6YC6TX5491@NYvsn2myCYDl/lSmgbq9q9FhBqBiMprYMVnFjWsjtc5VLR3Ozjc@iV0adUxdKxjim/OwjbhI@XI37sslqVfTZIieO82ntzpvIU/ "Wolfram Language (Mathematica) – Try It Online")
The exponent function `Times[1', 1'][[1'[1]]]` = `Power[0&, 2][[0]]` = `Power`. Returns the argument when called with only one argument.
---
But there are also a good number of built-ins up to the task.
8. [`D`](https://tio.run/##DcNBC0AwFADgu7@hXEyNcqQpZ4lyWTs8bHllbzXP7x9ffR74sh4YD0iuS2NaDyA9RyTWedU7lZtCZHU57I9awkunWoDO4DeICGz1FKKHe8SHI@4vYyBdSyn@0oimNSZ9 "Wolfram Language (Mathematica) – Try It Online").
Computes the [derivative](https://reference.wolfram.com/language/ref/D.html), but acts as identity when passed only one argument.
9. [`N`](https://tio.run/##DcNBC0AwFADgu7@hXEyNcqQpZ4lyWTu8DXllbzXP7x9ffR74OjwwOkhnl6a0OiA9RyTWedWfKjeFyOpysI9awku7WoD24DeICHzoKUQP94gPR7QvYyBdSyn@0oimNSZ9 "Wolfram Language (Mathematica) – Try It Online").
Converts the argument to a numeric (approximate) value. For `Integer`s, returns the `Rational` corresponding to that integer.
10. [`Or`](https://tio.run/##y00syUjNTSzJTE78n2b737/of3ByYl50QFFmXkm0sq5dmoNyrJoOl6G2Y1KxQ1B@aV6KQ1BiXkp@blhiUWZiSWq0X35RbmKOS2ZxSVFmUmlJZn5etKGBgQ4QG8TqGJnGxv4HAA "Wolfram Language (Mathematica) – Try It Online").
Logical or. Returns the argument when called with only one argument.
11. [`And`](https://tio.run/##DcNBC0AwFADgu7@hXExtypGmnCXKZe3wGHllbzXP7x9ffR74Ojww7pDONvXk0rIDmSkiscmr7tS5LUSmyn579BxecnoGcsGvEBH4MGOIHu4BH464vYyBjJJS/KUVdWNt@gA "Wolfram Language (Mathematica) – Try It Online").
Logical and. Returns the argument when called with only one argument.
12. [`LCM`](https://tio.run/##y00syUjNTSzJTE78n2b738fZ939wcmJedEBRZl5JtLKuXZqDcqyaDpehtmNSsUNQfmleikNQYl5Kfm5YYlFmYklqtF9@UW5ijktmcUlRZlJpSWZ@XrShgYEOEBvE6hiZxsb@BwA "Wolfram Language (Mathematica) – Try It Online").
Computes the least common multiple of its arguments.
13. [`Sow`](https://tio.run/##y00syUjNTSzJTE78n2b7Pzi//H9wcmJedEBRZl5JtLKuXZqDcqyaDpehtmNSsUNQfmleikNQYl5Kfm5YYlFmYklqtF9@UW5ijktmcUlRZlJpSWZ@XrShgYEOEBvE6hiZxsb@BwA "Wolfram Language (Mathematica) – Try It Online").
Returns its argument. Additionally, allows that value to be collected by an enclosing `Reap`.
14. [`Exit`](https://tio.run/##NU5NC4JAFLz7KxaDTooW2K3YoA5dIiy6yEIvXe2Buytv31L/3hTqMIf5YGYM8EsbYKxhrF2jt/F4/CCPcZZdmdB2N0ITsTZDD6y3P@1HZfx2fUtgfE04sEjbYGtGZ8XjIVKPnQUOpMXJsu40iRSo85MXRwdXXaYmrhbprgxW/geq@UOyUNm62Kil3D@9LF2wjSzBNs7cgXBOnR0Z6A/opzvPMC9WqzxPJuRKJVGhxi8 "Wolfram Language (Mathematica) – Try It Online"). A function that returns an integer via exit code.
Note that `Run` returns 256\*(return code) on TIO instead. [Try it online!](https://tio.run/##y00syUjNTSzJTE78/z@oNC9aqaCyJCM/T0E3WUE9tSKzRMNQU10pVl8/oCgzr@T/fwA "Wolfram Language (Mathematica) – Try It Online")
[![Exit[927] on Mathematica 12.1 for Windows](https://i.stack.imgur.com/fseEJ.png)](https://i.stack.imgur.com/fseEJ.png)
15. [`Plus`](https://tio.run/##DcO9CoAgEADgvdcIWjKwoLEwaI4oaBGH648O8gQ9n9/64LPAz2WB8YB0d2l@Y0jrAaRnj8Q6r/pb5aYQWV0Oe1CLi3SqBeh0dgOPwJeenLfwjhjY4x4ZHelaSvGXRjStMekD "Wolfram Language (Mathematica) – Try It Online").
Returns the sum of its arguments.
---
[Answer]
# [Julia](http://julialang.org/), 12 functions
```
X->X
==(==)=(==)
*
+
&
|
⊻
Real
sum
prod
big
Int
```
[Try it online!](https://tio.run/##yyrNyUw0rPjvo2CrEP0/QtcugkvD1haINMGEtSaXFpc2lxpXDdejrt1cQamJOVzFpblcBUX5KVxJmelcnnkl/2O50vKLFNIUMvMUfLgUgKCgKDOvJCdPI03DxEhTkys1L@U/AA "Julia 1.0 – Try It Online")
[More identity functions!](https://tio.run/##PY9NSgNBEIXXvlO0GdAZxUDU7bgZEHThQjchu57@mXTo7hr6J0zAAwSv5G1ykbGThbUo6j2ox/d22Rq@muZ5/fCyxvWm3eAO97jBN04/v5gogMsdGZ@QAvdxpKhgpPLJpAO@UjB@wJtPV3i1xNPTI3ozIJrBK4lA2UtoSyVFKGPBozAG5zjwPkKbEBMEjQdYXi5XfMcnxOwwBpJQe27hs1OBp5JRkbcHVqbySsnI3s/wbLV8RrXnYXG7gBUOg5D4VOXxI7teBXTkRqsmdGLLi5KUe6vQnSt1lgp@F7cUEnT2IhnytW6YZqqQ15ppCkUYz1bNUv8bp@Pxotu2btvmsub5Dw "Julia 1.0 – Try It Online")
[Answer]
# Java, 2 functions
```
x->x
```
A lambda function.
```
Function.identity()
```
This returns the identity function.
Without the letters *e* and *t*, we can't use any of the `{byte,char,short,int,long}Value`, `valueOf` or `toString` methods.
]