# Print the ASCII table

## brainfuck - ~~169~~ ~~146~~ 142 bytes

```
-[+>+[+<]>+]>+>>,[>,]<[<]<[->>[->]<[<]<]>>>[[<[-<+<+<+>>>]+++++++++[<[-<+>]<<[-<+>>>+<<]<[->+<]>>>>-]]<,<<,>[->>>+<<<]>>>---------->]<-[->.+<]
```

Limitations:

- EOF must be 0
- Requires 8-bit wrapping cells
- Because of ^, mods input by 256

Not the shortest answer here, but hey, brainfuck! This would be a really, really good brainfuck challenge, except for the fact that it requires human readable input without guaranteeing the number of digits. I could have required input to have leading zeroes to make it 3 characters long, but what fun is that? :D One major problem with taking input this way is that brainfuck's only branching or looping structure checks if the current cell is zero or not. When the input can contain zeroes, it can cause your code to take branches it shouldn't be taking. To solve this problem, I store each digit of input **plus 1**, then subtract the excess at the last possible second. That way, I always know where my zeroes are.

I did say that this would have been a great brainfuck challenge without having to parse input. Why is that? Well, let's pretend that we don't take a numeric input. We'll say the challenge is "Given a byte of input, output all ASCII characters below that byte". Here's what my answer would be:

## brainfuck - 8 bytes

```
,[->.+<]
```

It's quite a difference! The real program uses 135 instructions to collect the input (over 95% of the program!), just because it's a human typing it. Store the number as a byte and give *that* to me, and it only takes one.

(Fun fact: If you understood the hypothetical program, then congratulations! You understand brainfuck in its entirety. The whole language has only eight commands, and that program happens to use each one exactly once.)

**Explanation**

```
-[+>+[+<]>+]>+ abuse 8 bit wrapping to put 47 in cell 4
>>,[>,] starting in cell 6; get each character of input
<[<]<[->>[->]<[<]<] subtract the value of cell 4 from each input character
'0' has an ascii value of 47 so subtracting 47 from each
digit gives you that digit's value plus 1
>>>[ if the number is in more than one cell
(when the program first starts this means "if the input has
more than one digit")
[<[-<+<+<+>>>] copy first input cell to 3 new cells
+++++++++[<[-<+>]<< do some fancy addition magic to multiply that value by 10
[-<+>>>+<<]<[->+<]>>>>-]]
<,<<,> clean up a bit (abusing comma to set cells to 0)
[->>>+<<<]>>> add the value to the next cell of input
---------- because we multiplied (the digit plus 1) by 10; the answer
is 10 too high; so subtract 10
>] if the input is still in multiple cells; do the song and
dance again (multiply by 10; add to next cell; subtract 10)
<- we never got a chance to fix the final digit; so it's still 1
too high
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; we have now finished processing input ;;
;; the tape is empty except for the current cell ;;
;; the current cell contains the number that was input ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
[ while the cell containing input != 0
- subtract 1 from it
>.+ go a cell to the right; output that cell; then add 1
<] repeat
```

## CJam, 4 bytes

```
ric,
```

Full program that reads from STDIN (input field in the online interpreter).

This simply executes `range(chr(int(input())))`

, taking advantage of the fact that `,`

gives a return an array of characters if its argument is a character.

I call dibs on `c,`

(2 bytes), just in case that assuming the input is already on the stack turns out to be allowed.

### Pyth, 4 bytes

```
VQCN
```

Basically a translation of the Python 3 program:

```
for N in range(eval(input())):print(chr(N))
```