[Question]
  [
If you visit Code Golf often, you may have heard of [Kolmogorov complexity](https://en.wikipedia.org/wiki/Kolmogorov_complexity). It's usually defined as the amount of bytes required to express some string in a programming language.
Here the Kolmogorov-complexity of a natural number is defined similarly: the number of bytes required to represent it in a programming language.
A number is Kolmogorov-simple if it's **more** space-efficient to represent it with the programming language, then with simply storing it in binary (base-256). In other words, if \$b\$ is the Kolmogorov-complexity of a number \$n\$, \$n\$ is Kolmogorov-simple iff \$b\lt\log\_{256}(n+1)\$. Every Turing-complete language has infinitely many Kolmogorov-simple numbers.
Your task is to find the smallest Kolmogorov-simple number. In other words, output the smallest number \$n\$ in \$b\$ bytes, such that \$b<\log\_{256}(n+1)\$.
## Rules
* If you express the number \$n\$, your program has to be at most \$\lceil \log\_{256}(n+1)\rceil-1\$ bytes long.
* The number has to be a positive whole number
* Use a **reasonable** IO format. These *may* include: printing to stdout, expressions, functions, storing the number to a variable, pushing the number to stack or taking a number as input and comparing it the represented number. Try to stick to the [convention](https://codegolf.meta.stackexchange.com/questions/2419/default-for-code-golf-program-function-or-snippet/2422). Floating point numbers, complex numbers and fractions are allowed, as long as it's **exactly** an integer.
* If you use a text-based format, your output should match this regex: `((\d+(\.\d*)?)|(\d*\.\d+))(e[+-]?\d+)?`. That is, it should be a decimal number. Trailing newlines etc. are allowed.
Smallest number outputted (i.e. the value \$n\$) per language wins!
  
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 0 bytes, outputs `1`
[Try it online!](https://tio.run/##K0otycxLNPwPBAA "Retina – Try It Online")
Outputs `1`, and \$\log\_{256} 2 = 0.125 > 0\$
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 1 byte, outputs `256`
```
⁹
```
[Try it online!](https://tio.run/##y0rNyan8//9R487//wE "Jelly – Try It Online")
This outputs `256` in one byte, and \$\log\_{256} (257) \approx 1.0007 > 1\$
[Answer]
# [R](https://www.r-project.org/) (& likely polyglot), 3 bytes, outputs 16777216 = 256\$^3\$
```
8^8
```
[Try it online!](https://tio.run/##K/r/3yLO4v9/AA "R – Try It Online")
[Answer]
# [1+](https://codegolf.stackexchange.com/q/209529), 20 bytes, outputs \$2^{160}\$
*Reduced from \$2^{2^8}\$ due to @null*
```
11+"*"*"+"*"*"*"*"*:
```
[Try it online!](https://tio.run/##jVVLb5tAEL7zKybkAMQYgxMlDQ2XHCr1YlVWeiIUrWFtUIGlu@smUdvf7s6CscEOao2F9vHNN@@hfpMZq64/1Hy3u4RMylr4s9kmF9LZ5DLbrpyElbMvhCfF2/SJvNJi5q6Se5re3SXz9e2auvSGJvd3t@m1N/fo9Y1LtLysGZcg3oS25qyEhBUFTWTOKgH7u5T@2FJNEzaIFIJ2a1o2/PqjaSldA6toXWyFKRAbwAK3lq8B/vI1VAy5uWz3@7OCVibqcwjf/LTgIoD58Vr9ap5X0tS/CrKhPugwgQ4duhHudAjXeUFBMlhRoK802UqaRro1YFEy9DWXpnc8z6saLWR1z4DQi2wwuHEEcfKCIIQ6nJLUHEg7ScEE3Z/RQqB9LRx9bM6aV1basLRhJaQNjzYs8D6MVLzsY/Bc/DfgNeOQILciGoQpgSAAwzSGwXmESQDe4Aj1OKRGp1JzYZ0zWGcM01OGZag4alabVqRSOLhEokd4AHfI0kvU53JFClIlNIUVJ8l3KsXFSTIGCZm/Y@SlAaRKURFuXB8j@I5Hi6PrjU0XQd@o/zPm1IjmtbAhKVXtYlI@Ecxqc/qSqSJboOuqYDE71lEZU3WER@Ei6vuiqh2Z/NP4KTg66Rk@iM4xzxpBTfoo0WZF9UC7GpO6ek/q6l9S@kAqnHrRGHLWIDmTRNJx25@f@7DpKO5bA6OvUukN90banbWjRjz0zXXVRefpw2GluhJGFV8ig@rHrOy0RiNIp6@LrISpygtHwFaaRrUtV5T72FvWaGjtvjzjaSebZATrUrbiONBGCXwkaIv6EB@kCnR9TOCj0oj1LWTKttJ54TnmIMl4Jz@qKUTBtgGe@JaOgE4HUTMqZdX1AVao5y@xHyKnJlzm6gtiGr@N8zmAlCiHcxetTUO1dCM1ddRqHp3BD1@XA/acUmV02e/FZjSPOBIdvD32em@8aIiM44qUNI4VXo/jkuRVHOstYWePtdt53kS/wqd9N4@/c5o8O@j/Xw)
The fastest way to get big numbers in 1+ (of which I am its creator) is to repeatedly square. \$\lceil\log\_{256}(2^{160}+1)\rceil-1=20\$.
[Answer]
## Batch, 38 bytes, outputs ≈2³⁰⁴
```
@for /l %%a in (1,1,92)do @cmd/cset/a3
```
`log₂₅₆(33...33) ≈ 38.004`
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 24 bytes, outputs (1063-1)/3
```
+[+++++>+<]++++[++++>.<]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fO1obBOy0bWJBNJhnp2cT@/8/AA "brainfuck – Try It Online")
This creates 51, the ASCII value of `3`, as 255/5, and then outputs it 63=252/4 times.
`+[+++++>+>+<<]>[->.<]` falls just short of working: in 21 bytes, it outputs `3` 51 times for ≈3.33×1050, while 25621≈3.74×1050.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `H`, 0 bytes
```
```
The `H` flag pre-sets the stack to 100.
$$log\_{256}\;101 = 0.83227643534397 > 0$$
[Try it Online!](https://lyxal.pythonanywhere.com?flags=H&code=&inputs=&header=&footer=)
For a program without flags, you can use `₈` to output 256, similar to
[caird coinheringaahing's Jelly answer.](https://codegolf.stackexchange.com/a/239759/45220)
[Answer]
# [BQN](https://mlochbaum.github.io/BQN/), 3 bytes, outputs `16777216`
```
8⋆8
```
[Run online!](https://mlochbaum.github.io/BQN/try.html#code=eCDihpAgOOKLhjgKeOKLiDI1NuKLhuKBvDEreA==)
$$\log\_{256}\left(8^8+1\right) > \log\_{256}\left(8^8\right) = 3$$
[Answer]
# [Husk](https://github.com/barbuz/Husk), 2 bytes, outputs 9! = 362880 = 256^2.3
```
Π9
```
[Try it online!](https://tio.run/##yygtzv7//9wCy///AQ "Husk – Try It Online")
[Answer]
# JavaScript (ES7), 8 bytes, `27368747340080914432`
(displayed as `27368747340080914000`)
```
_=>7**23
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/e1s5cS8vI@H9yfl5xfk6qXk5@ukaahqbmfwA "JavaScript (Node.js) – Try It Online")
The actual value of \$7^{23}\$ is \$27368747340080916343\$ but we get \$27368747340080914432\$ because of IEEE-754 loss of precision.
We have \$\log\_{256}(27368747340080914432+1)\approx 8.07\$
[Answer]
# x86-64 machine code, 7 bytes, outputs \$2^{56}\$
```
6A 01 58 48 0F C8 C3
```
[Try it online!](https://tio.run/##TVDLasMwEDxbX7FVMEjNg/RBD0ndS8699FRocpBlyRbIkrFsImPy63XXfYRelh1mdmZY2TTrUsppEqEGBm@UkU1pfS4saKJ3SdOHCu5I0vgGWhFJkoez@F1b1RFOge@Jip1qHdADhbF3wZROFWC9K3@GcR1oxvcXQhbGSdsXCp5DVxi/qV4ImelaGMc4GTGpRawZTRfWxqOjq/kUM67E0b0KWRmnQPpC7ejMzRYRMtiuYEBYeBj/5JBu79/RZcgYu3aTlWhvueYfcbk8YTE4V8YqYAPcoEk8PPwPBJYayIdOBf7dJyJ5maZPqa0ow7Sunx5x4AMz1Cv7BQ "C++ (gcc) – Try It Online")
Returns a value in RAX, as is standard.
In assembly:
```
.global f
f:  push 1      # (2 bytes) Push 1 onto the stack.
    pop rax     # (1 byte)  Pop it out into RAX.
    bswap rax   # (3 bytes) Reverse the order of the bytes in RAX.
    ret         # (1 byte)  Return.
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 3 bytes, outputs `100000000`
```
8|A
```
[Run and debug it](https://staxlang.xyz/#c=8%7CA&i=&m=2)
$$\left \lceil{\log\_{256}\left(10^8+1\right)}\right\rceil - 1= 3$$
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 3 bytes, outputs `22222222`.
```
×⁸2
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRCMkMze1WMNCR0HJSElT0/r///@6ZTkA "Charcoal – Try It Online") Link is to verbose version of code. `log₂₅₆(22222222) ≈ 3.05` Explanation: Charcoal only prints strings by default, so something like `φ` (`Print(f);`) prints 1000 `-`s instead of `1000`; casting to string costs a byte, meaning we now need a value of at least `65536`, however no predefined variable now holds a suitable value. This means we now need to look for a 3-byte answer that prints at least `16777216`, which can most easily be achieved in a number of ways by repeating the character `2`.
[Answer]
# [Python 2](https://docs.python.org/2/), 11 bytes, outputs `5704427701027032306735164424192`
```
print 9<<99
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v6AoM69EwdLGxtLy/38A "Python 2 – Try It Online")
$$\log\_{256}(5704427701027032306735164424192+1)-1 = 11.77$$
[Answer]
# [Python 3](https://docs.python.org/3/), 13 bytes, outputs `20282409603651670423947251286016`
```
print(16**26)
```
[Try it online!](https://tio.run/##K6gsycjPM/7/v6AoM69Ew9BMS8vITPP/fwA "Python 3 – Try It Online")
From what I can understand, this is the *absolute minimum* for a 13 byte program - it prints 256\*\*13, the minimum number that needs 13 bytes to store. Good luck getting anything below this in Python 3.
Bonuses I found:
```
print(18**25) # 19% bigger than the actual answer
```
```
print(27**22) # 52% bigger than the actual answer
```
```
print(15**27) # 2.8x as big as the actual answer
```
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 5 bytes, outputs 2565 = 420 = `1099511627776`
```
4 20?
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/30TByMD@/38A "GolfScript – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 12 bytes, outputs `79228162514264337593543950336`
```
print(4**48)
```
Inspired by [this](https://codegolf.stackexchange.com/a/242352/112488) answer.
Explanation:
```
4**48 == 16**24 == 256**12
```
[Try it online!](https://tio.run/##K6gsycjPM/7/v6AoM69Ew0RLy8RC8/9/AA "Python 3 – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/en/), 7 bytes, outputs `150094635296999121`
```
p 3**36
```
Similar to other answers, uses `p` to debug print the number. Fortunately for numbers the debug print value is the same as the normal output would be.
$$\left \lceil{\log\_{256}\left(3^{36}+1\right)}\right\rceil - 1= 7$$
[Answer]
# [Excel](https://support.microsoft.com/en-us/excel), 5 bytes, outputs `1,09951E+21` ≈ 240 = 2565
```
=2^40
```
[Answer]
# APL, 2 bytes
```
!9
```
The program prints factorial of 9 = 362880. Validation of allowed length:
```
      1-⍨⌈256⍟1+!9
2
```
]