Output 256 in many different ways
Challenge
Write as many functions, programs, or snippets of code, that result in 256. Your score is the number of separate solutions submitted in an answer.
The challenge? The characters used in one solution must not appear in any other solution. That is, there is no character used in more than one program.
Notes
- The bytes of the solution, in the encoding used by the interpreter/compiler running the solution, are what is used for distinctness checking. For example, if the answer is scored in UTF-8, one solution containing
ámeans no other can containéas both share the0xC3byte, but an SBCS containing both would allow it. - Solutions must have at least one character (otherwise the empty program giving 256 would result in a score of $\infty$).
- The usage of bytes for scoring means that the maximum score ever achievable is 256 (but getting that would mean having a language where every character prints 256).
- The result can be either a number, that equals to 256 (or differs from it by a maximum of 0.001), or a string representing it in decimal form, possibly ending with
.0. - Each submission can be of a different type (function, program, snippet), and can return in a different format (return value, STDOUT, console, etc.)
- Yes, snippets of code are allowed. So
256is a valid solution in most languages. - Highest score wins!
JavaScript, 11 solutions …
4y ago
Japt, 10 11 13 15 solutions …
3y ago
[Raku], 18 solutions 25 …
4y ago
C, 8 solutions Standard C, …
4y ago
Japt, 27 Solutions This sta …
3y ago
Vyxal, 20 23 24 solutions T …
3y ago
BQN, 14 solutions (SBCS) Ru …
3y ago
[Husk], 9 solutions 1. Clas …
4y ago
[PowerShell], 4 solutions …
3y ago
Scala (`-language:postfixOps`) …
3y ago
[Ruby], 7 solutions ```ruby …
3y ago
Unlambda, 1 solution Since …
3y ago
12 answers
JavaScript, 11 solutions
!``<<!``<<!``<<!``<<!``<<!``<<!``<<!``<<!``
2**2**2*2**2**2
555555555555555555555555555555555555555555555555555555555555555/5/55/55/55/55/55/555/555/5555/5555/5555/55555/55555/55555/55555/55555/55555/555555
a=[],a=a==a,a-=-a,a-=-a,a-=-a,a-=-a,a-=-a,a-=-a,a-=-a,a-=-a
8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8
"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@".length
9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999%999
11111111111111111111111111>>>1111
4444444&444444444444&444444444444444&44444444444444444
3^7^73^333
~(~6666666|66666666666|666666666666666|666666666666666666666666666666)
Japt, 10 11 13 15 solutions
256
Works as you would expect.
8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8
Subtracting negative numbers.
4**4
Power.
9+9+9+9+9+9+9+9+9+9+9+9+9+9+9+9+9+9+9+9+9+9+9+9+9+9+9+7+3+3
Might as well use the rest of the digits.
G²
This evaluates literally to 16 squared.
DÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
Increments 13, 243 times.
HÑÑÑ
32 * 2 * 2 * 2.
Ip)ÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉ
You get the idea... 64**2 - 1, except enough times to reach 256.
[BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB]l
The length of a 256 element array.
;AiJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ iJ Ê
Japt is fun enough we can do the above two ways.
"100000000"Í
Converting from base 2.
A few from Shaggy:
#Ā
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
ÒFÒFÒFÒFÒFÒFÒFÒFÒFÒFÒFÒFÒFÒFÒFÒF
U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´a
Raku, 18 solutions
256
٢٥٦
۲۵۶
߂߅߆
২৫৬
᠒᠕᠖
𑄸𑄻𑄼
4⁴
0x100
ord Q`Ā`
'~~~'~^'LKH'
888-88-88-88-88-88-88-88-8-8
99+99+9+9+9+9+9+9+?9+?9+?9+?9
($_=3333333)&&m|(3)(3)(3)(3)*|&&$3**$3
[[];[];[];[]]×[[];[];[];[]]×[[];[];[];[]]×[[];[];[];[]]
"{"{7%%7%7}{7%7}7"%7}{"{7%%7%7}{7%%7%7}7"%7}{"{7%%7%7}{7%%7%7}{7%%7%7}"%7}"
</ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / />/</ />
q:w!a\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na!.Int
The last solution use newline characters, so the \ns should be replaced by linefeeds. These solutions are mostly helped by Raku's unicode operators and digits, as well as being able to convert from lists or strings to numbers freely, where lists are equal to their length.
1. through 7.
256
٢٥٦
۲۵۶
߂߅߆
২৫৬
᠒᠕᠖
𑄸𑄻𑄼
These are all numeric literals of 256 in different unicode digits (with no bytes overlapping). Yes, Raku supports this. No, I don't know why.
8.
4⁴
Four to the power of 4
9.
0x100
Hexadecimal of 256
10.
ord
Q`Ā`
Get the ordinal value of the 256th character.
11.
'~~~'~^'LKH'
String xor ~~~ with LKH to get 256.
12.
888-88-88-88-88-88-88-88-8-8
Some basic arithmetic to get 256
13.
99+99+9+9+9+9+9+9+?9+?9+?9+?9
More arithmetic, using ? to boolify 9 to True, which then is numerically 1.
14.
($_=3333333)&&m|(3)(3)(3)(3)*|&&$3**$3
Set $_ to 3333333, then match some 3s such that the fourth group is of length 4, then return that group to the power of itself (4**4). This one might be a little iffy, since it relies on the existing $_ variable to be mutable, (which it is by default).
15.
[[];[];[];[]]×[[];[];[];[]]×[[];[];[];[]]×[[];[];[];[]]
Make a list of length 4 and multiply it by itself four times.
16.
"{"{7%%7%7}{7%7}7"%7}{"{7%%7%7}{7%%7%7}7"%7}{"{7%%7%7}{7%%7%7}{7%%7%7}"%7}"
Uses modulo and divisibility operators with string interpolation to generate numbers.
"{"{1}{0}7"%7}{"{1}{1}7"%7}{"{1}{1}{1}"%7}"
= "{2}{5}{6}"
= 256
17.
</ / ... / />/</ />
Create a list with length 512 and divide it by a list with length 2.
18.
q:w!a
a
...
a
a!.Int
Create a list of length 256 using the words quoting construct and then convert it to an integer.
Conclusion
I can certainly save some characters from some solutions to use later, but I've sort of run out operators that can convert them to numbers. I still have carriage returns for whitespace, so maybe there's a function I can still use.
C, 8 solutions
Standard C, no extensions. 1 solution snippet per line:
"llll"[3]^33^333
4*4*4*4
5555-555-555-555-555-555-555-555-555-555-55-55-55-55-55-5-5-5-7-7
6666/26
(int){8<88}<<8
u'\xff'+!!u'\xff'
~0XFFFFFeFF
__LINE__
Somewhat naive solution so far, but the numerical limits of this language are causing me some head ache :) Will likely re-visit this later.
Godbolt test code, to verify that each snippet is correct and also unique, so that no character has been taken already is re-used. No #include is needed for the snippets themselves.
Vyxal, 20 23 24 solutions
Thanks to @Razetime for suggesting using Π, allowing for +1 solution.
The programs are meant to be run individually, so the ,Ṡ_ is just there to output the previous line and clear the stack. You can try any solution individually to verify.
I gave myself the challenge of doing this without looking at any other answers, and I'm pretty happy with how it turned out!
Here's explanations for each program. In the more complicated ones, [stuff] at the end of the line indicates the current stack.
Note: Two programs have a space in them, but that is only for readability and formatting. In either program, the space could be replaced with a linefeed and it would still function the same.
₈ # Push 256
256 # Push 256
₇d # 128 * 2
₆4* # 64 * 4
\Ā # Push 'Ā'
C # To ordinal value
⇧₴ # Increment 2 and print
⇧⇧⇧‹₴ # Increment 6, decrement, and print
⇧⇧⇧₴ # Increment 6 and print
›› # Increment 2 - [2]
S # To string - [`2`]
? # Get input. No input, so push 0 - [`2` 0]
›››››S # Increment 5, to string - [`2` `5`
J # Join with last string - [`25`]
?››››››SJ # Again, incrementing to 6 - [`256`]
8E # 2 ** 8
₀ # Push 10
⇩ # Decrement 2
Ǎ # 2 ** 8
ꜝ # Bitwise not - [-1]
₌ȧȧ # Parallel apply absolute value and absolute value - [1 1]
₌↲↲ # Parallel apply 'a << b' and 'a << b' - [2 2]
~↲ # Do 'a << b' without popping the stack - [2 2 8]
e # Exponentiate - [2 256]
u # Push -1 - [-1]
⌐ # 1 - a - [2]
u⌐u⌐u⌐u⌐u⌐u⌐u⌐ # Several more times - [2 2 2 2 2 2 2 2]
W # Wrap stack - [[2,2,2,2,2,2,2,2]]
Π # Reduce by multiplication - [256]
k¶½ # 512 / 2
¤ # Push empty string - [``]
₁ # Push 100 - [`` 100]
+ # Add - [`100`]
H # Convert from base 16 - [256]
¬ # Not - [1]
: # Duplicate - [1 1]
Ṡ # Sum of stack [2]
:Ṡ # Repeat - [4]
:Ṡ # [8]
:Ṡ # [16]
:Ṡ # [32]
:Ṡ # [64]
:Ṡ # [128]
:Ṡ # [256]
»ƛN» # Push compressed number 332
∆K # Sum of proper divisors
‛λḢ # Push dictionary word 'business'
m # Palindromize - [`businessssenisub`]
mmmm # A few more times - [`BigLongStringOfCharacters`]
L # Length of string - [256]
! # Length of stack - [0]
! # Length of stack - [0 1]
! # Length of stack - [0 1 2]
...Many, many, more...
! # Length of stack - [0 1 2 .. 256]
. # Push 0.5 - [0.5]
. # Push 0.5 - [0.5 0.5]
/ # Divide - [1.0]
I # To int - [1]
øṁ # a + palindromized(a) - [2]
øṁ # Again - [4]
øṁ # [8]
øṁ # [16]
² # Squared - [256]
⁺ṡ # 101 + codepage value of 'ṡ' (0x9B)
ǎ # ath prime - [2]
ǎ # ath prime - [5]
0 # Push 0 - [5 0]
₄ # Push 26 - [5 0 26]
0₄0 1 # Some more numbers - [5 0 26 0 26 0 1]
- # Subtract - [5 0 26 0 26 -1]
- # [5 0 26 0 27]
- # [5 0 26 -27]
- # [5 0 53]
ǎ # ath prime - [5 0 251]
- # Subtract - [5 -251]
- # Subtract - [256]
= # a == b? - [1]
⁽₃ # Push lambda - [1 lambda_
⁽₃ # Push lambda - [1 lambda_ lambda_]
= # a == b? = [1 0]
" # Wrap a and b - [[1,0]]
⁽₃⁽₃=" # Repeat - [[[1,0],0]]
⁽₃⁽₃="⁽₃⁽₃="⁽₃⁽₃="⁽₃⁽₃="⁽₃⁽₃="⁽₃⁽₃=" # Some more - [[[[[[[[[1,0],0],0],0],0],0],0],0]]
f # Flatten list - [[1,0,0,0,0,0,0,0,0]]
B # Convert from base 2 - [256]
`≬„¾⅛` # Push string
`≬‡„↵¼¾⅛□‟₅` # Push other string
β # Convert a from custom base b
«Þ« # Push compressed string - [`e `]
3 # Push 3 - [`e ` 3]
ɽ # Range [1..a) - [`e ` [1,2]]
G # Maximum of a - [`e ` 2]
«ƈ« # Push compressed string - [`e ` 2 `ee`]
3ɽG3ɽG3ɽG # Some more 2s - [`e ` 2 `ee` 2 2 2]
p # Prepend - [`e ` 2 `ee` 2 22]
pppp # A few more times - [`222ee2e `
Ṅ # Separate by spaces - [`2 2 2 e e 2 e `]
Ė # Evaluate as Vyxal code - [256]
79 # Push 79 - [79]
¦ # Cumulative sum - [[7,16]]
¦ # Cumulative sum - [[7,23]]
¦ # Cumulative sum - [[7,30]]
¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦ # A bunch more - [[7,191]]
t # Tail - [191]
¦ # Cumulative sum - [[1,10,11]]
¦¦¦¦¦¦¦¦¦¦¦¦¦¦ # And then some more - [[1,24,256]]
t # Tail - [256]
Japt, 27 Solutions
This started out as a collaboration with Quintec but quickly got very out of hand! Posted with their permission.
More solutions to follow. Hopefully!
256
Just the boring, literal 256.
3^7^73^333
Some bitwise XORing.
4²²
4 raised to the power of 2 twice.
8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8
-8 subtracted from 8 repeatedly until we get to 256.
ÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓÓ9à
9à gives us the number of possible combinations of an array of length 9, which is 511. Ó is the shortcut for ~- so we're getting the bitwise NOT of the negation of 511 until we get back down to 256.
[BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB]è
B is 11, which in itself is irrelevant, what's important is that there are 256 copies of it in the array and è counts the truthy (non-zero) elements in it.
ÒFÒFÒFÒFÒFÒFÒFÒFÒFÒFÒFÒFÒFÒFÒFÒF
F is 15 and Ò is the shortcut for -~ so the first ÒF negates the bitwise NOT of 15, giving us 16 and each subsequent one subtracts the bitwise NOT of 15 from that.
Gp
G is 16 and p is the exponentiation method, with a default parameter of 2 - so 16**2.
HÑÑÑ
H is 32 and Ñ is the shortcut for *2 - so 32*2*2*2.
Iz¼
I is 64, z is the floor division method and ¼ is .25 - so 64/0.25.
100000000sÍ
s converts the 100000000 to a string and Í is the shortcut for n2 which converts that from a binary string back to an integer.
½/½/½/½/½/½/½/½/½/½
Dividing .5 by itself repeatedly until we get to 256.
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
These next few take advantage of the fact that if Japt is expecting a variable at the start of a line then it automatically inserts the first input variable U, which defaults to 0. In this one Ä is the shortcut for +1, so we're adding 1 to U 256 times.
µÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉ
µ is the shortcut for -= and É is the shortcut for -1 so we're decrementing U by -1 256 times.
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
°
° is the shortcut for ++ so we're postfix incrementing U until we get to 256.
U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´,U´a
´ is the shortcut for -- so we're postfix decrementing U until we get to -256, with the comma providing separation so all the -s don't run together and make a mess of things. The a at the end gets the absolute value of the final value of U.
JnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJnJ
J is initially the integer -1 and n is, effectively, inverse subtraction; that is XnY === Y-X. So, starting at the end, we're subtracting -1 from -1 and then subtracting -1 from the result and repeating until we get to 256.
T±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥TT±T¥T
T is initially 0, ±is the shortcut for += and ¥ is the shortcut for == so each block of T±T¥T is testing T for equality with itself, which is always true and then incrementing T by that value, implicitly casting the true to 1.
V+++V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V+V
V is the second input variable, which also defaults to 0. We start by postfix incrementing it and then repeatedly adding it to itself until we get to 256.
!P<<!P<<!P<<!P<<!P<<!P<<!P<<!P<<!P
P is the empty string, which is falsey so negating that gives us true so we just bitshift by !P until we get to 256, implicitly casting the true to 1each time.
SiSiSiSiSiSiSiS q xc
S is the space character and i is the prepend method. We prepend 7 copies of S to itself, then split that string to an array with q and then the x reduces the array by addition after the c first converts each character to its codepoint, 32. The spaces are used to close the (nested) methods.
`Ü?Áÿe`¬ì`
Ü?Áÿe is the compressed string "deeeeeeee" which gets decompressed by the backticks. ¬ is the shortcut for q which, as above, splits the string to a character array. The ì converts the array from a custom digit array to decimal with the custom base being the unprintable (charcode 130) at the end which the last backtick decompresses to ed. (Note to self: Find a pair of characters that compresses better so I can get the Á & e back to potentially use later)
#Ā
# returns the codepoint of the character that follows it.
N³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³l
N is the (empty) array of inputs and ³ is the shortcut for p3 which, when applied to an array, pushes 3 to the array. We do that 256 times and then get the length of the array with l.
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"aa
A string of 257 "a"s with the aa at the end getting the last 0-based index of a in that string.
$'________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________b'$bb
Similar idea to the above; repeat a random character 256 times and add a "b" at the end. The bb then gets the first 0-based index in the string. ' can only be used to quote a single character in Japt and there is no closing ' (e.g., 'b === "b") so we use the $s to switch in and out of plain old JavaScript, allowing the 's to be used as normal.
(¤*(¤*(¤*(¤*(¤*(¤*(¤*(¤
Here's where the real fun begins! ¤ is the shortcut for s2<space> but when we add the ( before it, Japt interprets the whole thing as ("s",2) (with the space serving as the closing bracket). The comma cause the "s" to be ignored in each case, leaving us with the 2s which we then multiply together enough times to give us 256.
BQN, 14 solutions (SBCS)
Run online! This link shows the result of each expression and a table of character intersections. Each expression intersects with itself only, giving a diagonal matrix. The expressions based entirely on repetition have been reduced to 16 reps to improve readability and response time (most are not that bad, but the one starting with ≡ takes at least 2256 operations in an implementation that doesn't cache depth traversal and will definitely DoS you).
2×2×2×2×2×2×2×2
3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬¬3¬3
4⋆4
8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8--8
Four with ordinary arithmetic; nothing exciting about these.
¯16∨16
BQN extends logic operations bilinearly. With these, 256 is ¬¯255 is ¬¯15∧17 (∧ is ×) is (¬¯15)∨(¬17).
⌊5÷÷5÷÷5÷5÷55÷555÷55÷5÷55÷555÷55÷5÷55÷555÷55÷5÷55÷555÷55÷5÷55÷555÷55÷5÷5555÷55555÷55÷5÷55÷55555÷5555÷5÷55÷55555÷5555
⌈7√7∧7∧7∧7∧7∧7∧777777∧777777
Arithmetic approximations.
=≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍≍@
≠↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓∞↓∞
≡↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑0↑0
⊢´⍋"⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋⍋"
<⁼⊏⌽⊒π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π‿π
Various flavors of repetition. The first three create arrays with Rank (=), Length (≠), and Depth (≡) 256: see Solo (≍) and Prefixes and Suffixes (↑ and ↓). After that is one based on Grade (⍋) and one with Occurrence Count (⊒): both of these produce a list that counts up given a list with all elements equal.
⊑⍒»»»»/»»»/»»»/»»»»↕9
'.'+`≢⊔⊔«≢⊔⊔≢⊔⊔««≢⊔⊔≢⊔≢≢≢'⊔'
I don't really know what to say.
0 comment threads
Husk, 9 solutions
1. Classic
256
2. Squaring
□□4
3. Incrementing
→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→1
4. Decrementing
←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←300
5. String Length
L"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
6. Codepoint
c'Ā
7. Powers of ½
\!7tݽ
8. Doubling
DDDDD8
9. Counting zeroes
#¬ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘø
Scala (-language:postfixOps), 4 solutions
1. Just 256:
256
2. Casting a character:
+'Ā'
The character Ā is 256 in decimal, and the unary + turns it into an Int.
3. Hashcode of a string:
""##
There are two backspace characters in the string (\u0008), so the hashcode is 31*8 + 8 = 256. ## is the same as .hashCode. Since we're not using ., enabling postfix operators is required.
4. Bitwise stuff:
(44444&444^444444)&4444
I just messed around for a while until I got this one right. It wastes parentheses and two operators, but I couldn't find anything better.
I don't have a lot right now, especially because I'm not great at bitwise stuff, but I will hopefully find more later.
Because of the ""##, using the flag -language:postfixOps, importing language.postfixOps, or using Scala 2.12 is required.
0 comment threads
Ruby, 7 solutions
256
4**4
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~0
1<<1<<1<<1<<1<<1<<1<<1<<1
[$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$].size
8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8+8
?Ā::ord
0 comment threads
1 comment thread