Print the ASCII table

Question

The task is to display n characters of the ASCII table.

You may write a function (or a program that takes the argument as a parameter, STDIN is allowed as well) that takes a parameter n, which will be the index of the last character to print.

The task is quite simple, so as an example here's a possible implementation in Python 2.7:

(lambda n:map(chr, range(n)))(256)

As I said it's a simple task. So this is code-golf and the shortest codes wins!

EDIT

As some of you pointed out this code doesn't print the result. It's just an example since I might struggle explaining the problem in english ;-).

EDIT2

Feel free to post the answer in any programming language, even if it's not the shortest code. Maybe there are some interesting implementations out there!

EDIT3

Fixed the example so it prints the result.

Answer 1

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.

Answer 2

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

Answer 3

Pyth, 4 bytes

VQCN

Basically a translation of the Python 3 program:

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

Answer 4

Befunge 93 - 23 21

&> :#v_,>:#,_@
 ^-1:<

Befunge 93 - 15 13 (by Ingo Bürk)

This one prints the list in reverse, but OP only said we need to print the first n characters, not that it has to be in order.

&>::>v
@^-1,_

Might not be golfable any further without moving on to Befunge98 (for the ";" operator, see @Kasran's answer)

Try it here:

function BefungeBoard(source, constraints) {
    constraints = constraints || {
        width: 80,
        height: 25
    };

    this.constraints = constraints;
    this.grid = source.split(/\r\n|[\n\v\f\r\x85\u2028\u2029]/).map(function (line) {
        return (line + String.repeat(' ', constraints.width - line.length)).split('');
    });
    for (var i = this.grid.length; i < constraints.height; i++) {
        this.grid[i] = String.repeat(' ', constraints.width).split('');
    }

    this.pointer = {
        x: 0,
        y: 0
    };

    this.direction = Direction.RIGHT;
}

BefungeBoard.prototype.nextPosition = function () {
    var vector = this.direction.toVector(),
        nextPosition = {
            x: this.pointer.x + vector[0],
            y: this.pointer.y + vector[1]
        };

    nextPosition.x = nextPosition.x < 0 ? this.constraints.width - 1 : nextPosition.x;
    nextPosition.y = nextPosition.y < 0 ? this.constraints.height - 1 : nextPosition.y;

    nextPosition.x = nextPosition.x >= this.constraints.width ? 0 : nextPosition.x;
    nextPosition.y = nextPosition.y >= this.constraints.height ? 0 : nextPosition.y;

    return nextPosition;
};

BefungeBoard.prototype.advance = function () {
    this.pointer = this.nextPosition();
    if (this.onAdvance) {
        this.onAdvance.call(null, this.pointer);
    }
};

BefungeBoard.prototype.currentToken = function () {
    return this.grid[this.pointer.y][this.pointer.x];
};

BefungeBoard.prototype.nextToken = function () {
    var nextPosition = this.nextPosition();
    return this.grid[nextPosition.y][nextPosition.x];
};

var Direction = (function () {
    var vectors = [
        [1, 0],
        [-1, 0],
        [0, -1],
        [0, 1]
    ];

    function Direction(value) {
        this.value = value;
    }

    Direction.prototype.toVector = function () {
        return vectors[this.value];
    };

    return {
        UP: new Direction(2),
        DOWN: new Direction(3),
        RIGHT: new Direction(0),
        LEFT: new Direction(1)
    };
})();

function BefungeStack() {
    this.stack = [];
}

BefungeStack.prototype.pushAscii = function (item) {
    this.pushNumber(item.charCodeAt());
};

BefungeStack.prototype.pushNumber = function (item) {
    if (isNaN(+item)) {
        throw new Error(typeof item + " | " + item + " is not a number");
    }

    this.stack.push(+item);
};

BefungeStack.prototype.popAscii = function () {
    return String.fromCharCode(this.popNumber());
};

BefungeStack.prototype.popNumber = function () {
    return this.stack.length === 0 ? 0 : this.stack.pop();
};

function Befunge(source, constraints) {
    this.board = new BefungeBoard(source, constraints);
    this.stack = new BefungeStack();
    this.stringMode = false;
    this.terminated = false;

    this.digits = "0123456789".split('');
}

Befunge.prototype.run = function () {
    for (var i = 1; i <= (this.stepsPerTick || 10); i++) {
        this.step();
        if (this.terminated) {
            return;
        }
    }

    requestAnimationFrame(this.run.bind(this));
};

Befunge.prototype.step = function () {
    this.processCurrentToken();
    this.board.advance();
};

Befunge.prototype.processCurrentToken = function () {
    var token = this.board.currentToken();
    if (this.stringMode && token !== '"') {
        return this.stack.pushAscii(token);
    }

    if (this.digits.indexOf(token) !== -1) {
        return this.stack.pushNumber(token);
    }

    switch (token) {
        case ' ':
            while ((token = this.board.nextToken()) == ' ') {
                this.board.advance();
            }
            return;
        case '+':
            return this.stack.pushNumber(this.stack.popNumber() + this.stack.popNumber());
        case '-':
            return this.stack.pushNumber(-this.stack.popNumber() + this.stack.popNumber());
        case '*':
            return this.stack.pushNumber(this.stack.popNumber() * this.stack.popNumber());
        case '/':
            var denominator = this.stack.popNumber(),
                numerator = this.stack.popNumber(),
                result;
            if (denominator === 0) {
                result = +prompt("Illegal division by zero. Please enter the result to use:");
            } else {
                result = Math.floor(numerator / denominator);
            }

            return this.stack.pushNumber(result);
        case '%':
            var modulus = this.stack.popNumber(),
                numerator = this.stack.popNumber(),
                result;
            if (modulus === 0) {
                result = +prompt("Illegal division by zero. Please enter the result to use:");
            } else {
                result = Math.floor(numerator / modulus);
            }

            return this.stack.pushNumber(result);
        case '!':
            return this.stack.pushNumber(this.stack.popNumber() === 0 ? 1 : 0);
        case '`':
            return this.stack.pushNumber(this.stack.popNumber() < this.stack.popNumber() ? 1 : 0);
        case '>':
            this.board.direction = Direction.RIGHT;
            return;
        case '<':
            this.board.direction = Direction.LEFT;
            return;
        case '^':
            this.board.direction = Direction.UP;
            return;
        case 'v':
            this.board.direction = Direction.DOWN;
            return;
        case '?':
            this.board.direction = [Direction.RIGHT, Direction.UP, Direction.LEFT, Direction.DOWN][Math.floor(4 * Math.random())];
            return;
        case '_':
            this.board.direction = this.stack.popNumber() === 0 ? Direction.RIGHT : Direction.LEFT;
            return;
        case '|':
            this.board.direction = this.stack.popNumber() === 0 ? Direction.DOWN : Direction.UP;
            return;
        case '"':
            this.stringMode = !this.stringMode;
            return;
        case ':':
            var top = this.stack.popNumber();
            this.stack.pushNumber(top);
            return this.stack.pushNumber(top);
        case '\\':
            var first = this.stack.popNumber(),
                second = this.stack.popNumber();
            this.stack.pushNumber(first);
            return this.stack.pushNumber(second);
        case '$':
            return this.stack.popNumber();
        case '#':
            return this.board.advance();
        case 'p':
            return this.board.grid[this.stack.popNumber()][this.stack.popNumber()] = this.stack.popAscii();
        case 'g':
            return this.stack.pushAscii(this.board.grid[this.stack.popNumber()][this.stack.popNumber()]);
        case '&':
            return this.stack.pushNumber(+prompt("Please enter a number:"));
        case '~':
            return this.stack.pushAscii(prompt("Please enter a character:")[0]);
        case '.':
            return this.print(this.stack.popNumber());
        case ',':
            return this.print(this.stack.popAscii());
        case '@':
            this.terminated = true;
            return;
    }
};

Befunge.prototype.withStdout = function (printer) {
    this.print = printer;
    return this;
};

Befunge.prototype.withOnAdvance = function (onAdvance) {
    this.board.onAdvance = onAdvance;
    return this;
};

String.repeat = function (str, count) {
    var repeated = "";
    for (var i = 1; i <= count; i++) {
        repeated += str;
    }

    return repeated;
};

window['requestAnimationFrame'] = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || function (callback) {
    window.setTimeout(callback, 1000 / 60);
};

(function () {
    var currentInstance = null;

    function resetInstance() {
        currentInstance = null;
    }

    function getOrCreateInstance() {
        if (currentInstance !== null && currentInstance.terminated) {
            resetInstance();
        }

        if (currentInstance === null) {
            var boardSize = Editor.getBoardSize();
            currentInstance = new Befunge(Editor.getSource(), {
                width: boardSize.width,
                height: boardSize.height
            });
            currentInstance.stepsPerTick = Editor.getStepsPerTick();

            currentInstance.withStdout(Editor.append);
            currentInstance.withOnAdvance(function (position) {
                Editor.highlight(currentInstance.board.grid, position.x, position.y);
            });
        }

        return currentInstance;
    }

    var Editor = (function (onExecute, onStep, onReset) {
        var source = document.getElementById('source'),
            sourceDisplay = document.getElementById('source-display'),
            sourceDisplayWrapper = document.getElementById('source-display-wrapper'),
            stdout = document.getElementById('stdout');
        var execute = document.getElementById('execute'),
            step = document.getElementById('step'),
            reset = document.getElementById('reset');
        var boardWidth = document.getElementById('board-width'),
            boardHeight = document.getElementById('board-height'),
            stepsPerTick = document.getElementById('steps-per-tick');

        function showEditor() {
            source.style.display = "block";
            sourceDisplayWrapper.style.display = "none";
            source.focus();
        }

        function hideEditor() {
            source.style.display = "none";
            sourceDisplayWrapper.style.display = "block";

            var computedHeight = getComputedStyle(source).height;
            sourceDisplayWrapper.style.minHeight = computedHeight;
            sourceDisplayWrapper.style.maxHeight = computedHeight;

            sourceDisplay.textContent = source.value;
        }

        function resetOutput() {
            stdout.value = null;
        }

        function escapeEntities(input) {
            return input.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
        }

        sourceDisplayWrapper.onclick = function () {
            resetOutput();
            showEditor();
            onReset && onReset.call(null);
        };
        execute.onclick = function () {
            resetOutput();
            hideEditor();
            onExecute && onExecute.call(null);
        };
        step.onclick = function () {
            hideEditor();
            onStep && onStep.call(null);
        };
        reset.onclick = function () {
            resetOutput();
            showEditor();
            onReset && onReset.call(null);
        };

        return {
            getSource: function () {
                return source.value;
            },

            append: function (content) {
                stdout.value = stdout.value + content;
            },

            highlight: function (grid, x, y) {
                var highlighted = [];
                for (var row = 0; row < grid.length; row++) {
                    highlighted[row] = [];
                    for (var column = 0; column < grid[row].length; column++) {
                        highlighted[row][column] = escapeEntities(grid[row][column]);
                    }
                }

                highlighted[y][x] = '<span class="activeToken">' + highlighted[y][x] + '</span>';
                sourceDisplay.innerHTML = highlighted.map(function (lineTokens) {
                    return lineTokens.join('');
                }).join('\n');
            },

            getBoardSize: function () {
                return {
                    width: +boardWidth.innerHTML,
                    height: +boardHeight.innerHTML
                };
            },

            getStepsPerTick: function () {
                return +stepsPerTick.innerHTML;
            }
        };
    })(function () {
        getOrCreateInstance().run();
    }, function () {
        getOrCreateInstance().step();
    }, resetInstance);
})();

.container {
    width: 100%;
}
.so-box {
    font-family:'Helvetica Neue', Arial, sans-serif;
    font-weight: bold;
    color: #fff;
    text-align: center;
    padding: .3em .7em;
    font-size: 1em;
    line-height: 1.1;
    border: 1px solid #c47b07;
    -webkit-box-shadow: 0 2px 2px rgba(0, 0, 0, 0.3), 0 2px 0 rgba(255, 255, 255, 0.15) inset;
    text-shadow: 0 0 2px rgba(0, 0, 0, 0.5);
    background: #f88912;
    box-shadow: 0 2px 2px rgba(0, 0, 0, 0.3), 0 2px 0 rgba(255, 255, 255, 0.15) inset;
}
.control {
    display: inline-block;
    border-radius: 6px;
    float: left;
    margin-right: 25px;
    cursor: pointer;
}
.option {
    padding: 10px 20px;
    margin-right: 25px;
    float: left;
}
input, textarea {
    box-sizing: border-box;
}
textarea {
    display: block;
    white-space: pre;
    overflow: auto;
    height: 75px;
    width: 100%;
    max-width: 100%;
    min-height: 25px;
}
span[contenteditable] {
    padding: 2px 6px;
    background: #cc7801;
    color: #fff;
}
#controls-container, #options-container {
    height: auto;
    padding: 6px 0;
}
#stdout {
    height: 50px;
}
#reset {
    float: right;
}
#source-display-wrapper {
    display: none;
    width: 100%;
    height: 100%;
    overflow: auto;
    border: 1px solid black;
    box-sizing: border-box;
}
#source-display {
    font-family: monospace;
    white-space: pre;
    padding: 2px;
}
.activeToken {
    background: #f88912;
}
.clearfix:after {
    content:".";
    display: block;
    height: 0;
    clear: both;
    visibility: hidden;
}
.clearfix {
    display: inline-block;
}
* html .clearfix {
    height: 1%;
}
.clearfix {
    display: block;
}

<div class="container">
    <textarea id="source" placeholder="Enter your Befunge-93 program here" wrap="off">&> :#v_,>:#,_@
 ^-1:<</textarea>
    <div id="source-display-wrapper">
        <div id="source-display"></div>
    </div>
</div>
<div id="controls-container" class="container clearfix">
    <input type="button" id="execute" class="control so-box" value="► Execute" />
    <input type="button" id="step" class="control so-box" value="Step" />
    <input type="button" id="reset" class="control so-box" value="Reset" />
</div>
<div id="stdout-container" class="container">
    <textarea id="stdout" placeholder="Output" wrap="off" readonly></textarea>
</div>
<div id="options-container" class="container">
    <div class="option so-box">Steps per Tick: <span id="steps-per-tick" contenteditable>500</span>

    </div>
    <div class="option so-box">Board Size: <span id="board-width" contenteditable>80</span> x <span id="board-height" contenteditable>25</span>

    </div>
</div>

Answer 5

Java, 151 128 77 62 56 bytes

First try at code-golfing.

void f(int n){for(char i=0;++i<=n;System.out.print(i));}

Usage:

import java.util.Scanner;
class A {

    public static void main(String[] a) {
        int num = new Scanner(System.in).nextInt();
        new A().f(num);
    }

    void f(int n) {
        for (char i = 0; ++i <= n; System.out.print(i));
    }
}

Thanks to @Shujal, @flawr, @Ingo Bürk and @Loovjo for the serious byte reduction.

Answer 6

APL,5

⎕UCS⍳

Example usage:

⎕UCS⍳256

Answer 7

JavaScript, ES6 - 52 58 56 53 44 42 bytes

n=>String.fromCharCode(...Array(n).keys())

Paste this into the Firefox console. Run as f(NUM).

Had to make it longer because the first didn't properly accept input.

Down 3, thanks edc65! Down to 44 thanks to Swivel!

Answer 8

Haskell, 17 23 bytes

flip take['\0'..]

Not sure if it is possible to do any better without imports.

Edit

My first solution didn't actually print the result, so allow 6 more chars for that:

print.flip take['\0'..]

Also, not shorter (25 chars with printing, 19 without), but an interesting alternate approach (it requires 'Data.List', though):

print.((inits['\0'..])!!)

Answer 9

Bash+BSD common utilities, 9 bytes

jot -c $1

GNU dc, 20 bytes

?sc_1[1+dPdlc>m]dsmx

Answer 10

Perl, 17 bytes

say chr for 0..$_

Answer 11

C, 31 30 28 27

k;f(n){putch(k++)<n&&f(n);}

Since putch is nonstandard, here's the fully compliant version:

k;f(n){putchar(k++)<n&&f(n);}

Must be called from main:

main(){f(255);}

EDIT: Improved by taking advantage of putchar return value
EDIT 2: Reduced by another character through recursion

Answer 12

Brainfuck, 44 bytes

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

Expects a decimal string without a trailing newline.

Try it online.

Reading integers in the range [0, max_cell_size] in brainfuck is not difficult. I encourage you to invent a clean method on your own. I consider this a beginner level exercise. (The reverse operation of printing a cell's numeric value is more involved, and could be considered an intermediate level task.)

Here's a 58-byte version that can handle 256 on 8-bit implementations:

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

Answer 13

CJam, 3

,:c

I assumed the argument to be the top stack element.

Example usage:

256,:c

ri,:c

Answer 14

Ruby, 30 characters

puts (0..$*[0].to_i).map &:chr

Answer 15

J - 5 bytes

{.&a.

{. is Head, a. is Alphabet ( a list of all chars) and & Bonds them, generating a monadic verb called like:

{.&a. 100 NB. first 100 characters

Note: It seems this does not work interactively: Jconsole and jQt seems to set up a translation, outputting box characters instead of some control characters. In a script or from the commandline, it does work though:

  ijconsole <<< '127 {. a.' | hd

Answer 16

awk - 27

{while(i<$0)printf"%c",i++}

To give the parameter on stdin run it like:

awk '{while(i<$0)printf"%c",i++}' <<<96

---

Just for fun: The "think positive version" starting with a definitive yes:

yes|head -96|awk '{printf"%c",NR-1}'

NR-1 is needed to print (char)0 for NR==1.    :-(

And why don't we have a no command? That's kinda mean!

Answer 17

gs2, 2 bytes

V.

This should be competing, I think! It would’ve worked even in the early days of gs2. Try it here.

Answer 18

Keg, 4 bytes (SBCS)

¿ï(,

TIO

Push input, output ASCII table.

Answer 19

Golfscript - 5

Thanks to @Dennis

~,''+

Answer 20

Lua - 43 41 Bytes

for i=1,arg[1]do print(string.char(i))end

Answer 21

Befunge 98, 22

&:00pv>0gk,@
0::-1<^j`

Kind of sad that this is so long.

&:00p        ; gets numerical input, stores a copy at cell (0,0)               ;
     v       ; IP goes down                                                    ;

     <       ; IP goes left, so I execute 1-::0`j^                             ;
 ::-1        ; (1-::) subtract one from our number and duplicate it twice      ;
0       `    ; (0`) compare the number with 0, push 1 if greater else 0        ;
     <^j     ; if the result was 0, go up, otherwise continue going left       ;

      >0gk,  ; get the value at cell (0,0), print that many numbers from stack ;
           @ ; terminate program                                               ;

Answer 22

T-SQL: 68 63

As a print loop

DECLARE @i INT=64,@ INT=0A:PRINT CHAR(@)SET @+=1IF @<=@i GOTO A

T-SQL: 95 86

As a query

DECLARE @ INT=64SELECT TOP(@+1)CHAR(ROW_NUMBER()OVER(ORDER BY 0/0)-1)FROM sys.messages

Edit: Made changes and fixes pointed out by Muqo. Thanks. Fixes and golfing suggested by @t-clausen.dk

Answer 23

Ruby, 23

f=->n{puts *?\0..n.chr}

Explanation

• Input is taken as the argument to a lambda. It expects an Integer.
• The "destructuring operator" (*) invokes #to_ary on the Range to print every character on its own line.

Answer 24

Python 3.4 - 36 bytes / 43 bytes

print(*map(chr,range(int(input()))))
print(*map(chr,range(int(input()))),sep='')

255 input()

How this works is:

1. Get upper limit of range
2. Generate a range of the table.
3. Map the range to chr function ( takes int, returns ascii ).
4. Consume the map via splat argument expansion ( number -> character -> print! )

The second one just removes the space separating each character in exchange for 7 bytes.

Answer 25

Pascal 87

program _;var c:char;n:byte;begin n:=0;readln(n);for c:=chr(0)to chr(n)do write(c);end.

Pascal 73

program _;var c,n:byte;begin readln(n);for c:=0to n do write(chr(c));end.

Builds and runs fine from http://www.onlinecompiler.net/pascal

Answer 26

x86 ASM (Linux) (many many bytes unless you compile it)

Written as a function, assumes parameter is passed in AX (I forget the number for the read syscall) Also doesn't preserve [SP] or BX.

test ax,ax
jz @Done
mov [sp],ax
@Loop:
mov ax,4
mov bx,1
mov cx,sp
mov dx,1
int 0x80
sub [sp],1  ; Can I do this?  Or do I need to load/sub/store separately?
jnz @Loop
@Done:
ret

Answer 27

Perl - 29

sub f{print map{chr}0..shift}

Answer 28

Julia: 20 characters (REPL)

This is close to the question's example: just generates the characters and let the REPL to do whatever it wants with them.

f(n)=map(char,[0:n])

Julia: 33 characters

Prints each character in a separate line.

print(map(char,[0:int(ARGS[1])]))

Answer 29

M (MUMPS) - 21

R n F i=1:1:n W $C(i)

In expanded form: READ n FOR i=1:1:n WRITE $CHAR(i)

Answer 30

BrainFuck - 140 112 Bytes

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

Try It Here!

Saved 28 bytes by changing [<<<->>>->+<]>[<<<->>>->+<]>[<<<->>>-] to [<<<->->->-].

What it does

,>,>,>                                                              Takes three inputs
                                                                    in three separate cells

-[>+<-----]>---[<+>-]<[<<<->->->-]<                                 Takes 48 off of each to
                                                                    convert them to decimal

[>+<-]<[>>++++++++++<<-]<[>>>>++++++++++[<++++++++++>-]<<<<-]>>>    Combines them into a
                                                                    three digit number by
                                                                    multiplying the first
                                                                    by 100, the second by
                                                                    10 and then adding all
                                                                    three

[>.+<-]                                                             Repeatedly prints the
                                                                    value of the adjacent
                                                                    cell and then adds one
                                                                    to it until it reaches
                                                                    the input value.

Answer 31

PHP, 35 34 bytes

<?=join(range(a^a,chr($argv[1])));

yup. PHP can create a range of characters.

Takes argument from command line. Save to file, execute.

Answer 32

><>, 14 bytes

0:o1+:r:@=?;$!

Try it here!

Explanation

0              push 0 to the stack                [n, 0]
 :             duplicate the top value            [n, 0, 0]
  o            output it                          [n, 0]
   1+          add one                            [n, 1]
     :         duplicate top value                [n, 1, 1]
      r        reverse the stack                  [1, 1, n]
       :       duplicate the top value again      [1, 1, n, n]
        @      move the top value back twice      [1, n, 1, n]
         =?;   pop top two values, if equal, end  [1, n]
            $  swap top two stack values          [n, 1]
             ! skip next instruction (0)

or

0:o1+$1-:?!;$!

Try it here!

Explanation

0              push 0 to the stack                [n, 0]
 :             duplicate the top value            [n, 0, 0]
  o            output it                          [n, 0]
   1+          add one                            [n, 1]
     $         swap top two values                [1, n]
      1-       subtract one                       [1, n-1]
        :      duplicate top value                [1, n-1, n-1]
         ?!;   if n is 0, end                     [1, n-1]
            $  swap top two stack values          [n-1, 1]
             ! skip next instruction (0)

For both simply place n on the stack and the result will be outputted.

Answer 33

SmileBASIC, 31 bytes

INPUT N
FOR I=.TO N?CHR$(I)NEXT

. is read as 0.0, and I could have just used 0 in this case, but . looks cooler.

Answer 34

J, 8 bytes

f=:{.&a.

Explanation:

f=:{.&a.
f=:      define a function f
      a. the ascii sequence
     &   attach it to the next operator
   {.    take the first n items of
         you'll notice I don't say how many,
         that's because in J you can leave blanks and the interpreter fills them in

Answer 35

√ å ı ¥ ® Ï Ø ¿ , 3 bytes

Note: Non-competing as language post-dates challenge

IrW

Explanation

I   › Take input from command line, evaluate and push to stack
 r  › Push the range from 0 to top value + 1
  W › Output the whole stack as Unicode characters

Alternate Solution

As pointed out by @FlipTack in his Java answer, it is not clear if the OP wants us to print up to and including the input or excluding the input.

If the second is true, the solution below is the correct answer.

IrPW

Explanation

I    › Take input from command line, evaluate and push to stack
 r   › Push the range from 0 to top value + 1
  P  › Pop the top value from the stack
   W › Output the whole stack as Unicode characters

Answer 36

evil, 10 bytes

I've been playing around with evil lately, and this is my first PPCG submission (albeit 2.5 years late). I find it a fun esolang to use partially because it seems nobody uses it!

ramlwalusb

Explanation

r   // Store input character to Accumulator as byte
a   // Since we are writing then adding, add 1 to Accumulator
m   // Drop a loop marker
l   // Swap Wheel and Accumulator
w   // Output Accumulator
a   // Increment Accumulator
l   // Swap Wheel and Accumulator
u   // Decrement Accumulator
sb  // Go back to m if A != 0

evil is also an easy language to write an interpreter for. I think there's a javascript one floating around somewhere, but I ended up just writing my own.

EDIT: Try it online!

Answer 37

Ruby - 35 33 bytes

Please note that I can't Ruby at all:

$*[0].to_i.times{|i|puts i.chr()}

Answer 38

PowerShell - 20

%{0..$_|%{[char]$_}}

Usage:
56 | %{0..$_|%{[char]$_}}

Answer 39

Java, 125 bytes

class M{public static void main(String[]a){p(256);}static void p(int l){int i=-1;for(;i++<l;){System.out.println((char)i);}}}

Simply puts in the number of characters to print from the ascii table @ p(n) where n is the number of characters.

Answer 40

Befunge-98, 26 20

0&;1-::0`j;;,$>:#,_@

It's longer than the other Befunge-98 answer, but it's not self-modifying and only uses one line. (Also, the pointer only moves to the right until it gets to the print loop.)

This is shorter now. Also, it's still not self-modifying. Hooray, jumping trickery!

Answer 41

Rebol - 35 34

for n 0 do input 1[prin to-char n]

Answer 42

If I'm allowed to have another answer in a different language, here goes...

Pascal: 91 bytes

PROGRAM A;VAR i,n:Integer;BEGIN
n:=0;readln(n);FOR i:=0 TO n DO
Write(chr(i));readln;END.

(just for kicks, really, I haven't messed in Pascal in ages)

Answer 43

Python 3 — 51 bytes

lambda n:sys.stdout.buffer.write(bytes(range(n+1)))

This is a variation of a line I keep in my shell history for when I need to refer to the ASCII table.

It first calls range(), passing n + 1 as the sole argument. When used like this, range() returns an iterable of integers between 0 (inclusive) and the argument (exclusive—hence the need for the +1). The iterable is then passed to bytes(), which returns a bytestring, interpreting each integer as one byte. The bytestring is then written directly to the buffer for stdout (passing it to sys.stdout.write() or print() would result in an exception; those accept strings, not bytestrings).

Note that n must not be greater than 255. If it is, bytes() will raise an exception, because values greater than 255 do not fit in a single byte.

Also note that this doesn't bind the function to a name. I'm assuming that's acceptable, given that it does still create the function.

Answer 44

PHP - 47 bytes

<?=join(array_map('chr',range(0,$argv[1])));

Usage:

php ascii.php n

Answer 45

LiveScript - 47

f=->alert String.fromCharCode.apply(,[0 to it])

Answer 46

PHP - 36

If PHP Notice are set to off then this:

<? for(;$i<$argv[1];)echo chr($i++);

PHP - 42

Otherwise:

<? for($i=0;$i<$argv[1];$i++)echo chr($i);

Answer 47

F# - 66 characters

[<EntryPoint>]
let m a=
 for x in char 0..a.[0].[0]do printfn"%c"x
 0

Answer 48

PowerShell, 20

[char[]](0.."$args")

Answer 49

C# - 65 63 52

c=>{for(var i='\0';i<=c;)System.Console.Write(i++);}

Inspired by Java solution

Usage:

public class Program
{
    public static void Main()
    {
        new System.Action<char>(c => {for(var i='\0';i<=c;)System.Console.Write(i++);})((char)255);
    }
}

Thanks to Martin for the help.

Answer 50

MATLAB: 13 bytes

@(n)char(0:n)

This is an anonymous function that prints the string.

MATLAB: 17 bytes

This one takes STDIN.

char(0:input(''))

I think these are pretty short for a non-golf language. :)

Answer 51

x86 DOS (11 bytes)

Takes parameter in CL

-u100
07AD:0100 mov ah,02
07AD:0102 cwd
07AD:0103 int 21
07AD:0105 inc dx
07AD:0106 cmp dl,cl
07AD:0108 jb 103
07AD:010A ret
07AD:010B 

Answer 52

Pip, 3 bytes (not competing)

The language is newer than the question, but happens to do very well with it:

C,a

a is the first command-line argument. The unary range operator , constructs a range of all numbers 0 <= n < a. Finally, C converts them to characters. The resulting list is autoprinted, by default without any delimiter. Works into Unicode range too!

Answer 53

Perl 6, 25 22 bytes

put (^@*ARGS[0])».chr

Answer 54

F#, 43 bytes

fun n->Seq.iter(printf"%c")['\x00'..char n]

That is...

fun n->                                     // A function that takes n
                           ['\x00'..char n] // Generates a list of chars from NUL to n
       Seq.iter(          )                 // For each one,
                printf"%c"                  // Print it!

I tried using \0 for NUL, but it doesn't work in F#. I couldn't get it under 4 characters, in any case. =P

Answer 55

ES6, 42 bytes

Sorry for the necro.

n=>String.fromCharCode(...Array(n).keys())

If you need it as a program, 54 bytes:

alert(String.fromCharCode(...Array(+prompt()).keys()))

However for some reason I can't get the above to work as a Stack Snippet.

Answer 56

Lua, 37 Bytes

a=...for i=1,a do print(a.char(i))end

Answer 57

Java 76 74 70

Thanks to Mego for saving 4 bytes.

public void f(int x){for(int u=0;u<x;u++)System.out.println((char)u);}

Previous versions:

class f{public void f(int x){for(int u=0;u<x;u++)System.out.println((char)u);}}
class f{public f(int x){for(int u=0;u<x;u++)System.out.println((char)u);}}

The second version needs to be called by new f(n);

Feel free to give me ideas for making it even smaller.

Answer 58

Pushy, 2 bytes

_{Non-competing as the language postdates the challenge.}

Input is given on the command line, $ pushy asciitable.pshy 90. Note that this will not work for numbers larger than 127.

X"

Explanation:

    \ Implicit: Input number on stack
X   \ Get range [0, n)
 "  \ Interpret as charcodes and print

Answer 59

QBIC, 14 bytes, NC

:[a|?chr$(b-1)

Takes a number form the command line and loops from 1 to that number, feeding each iteration into CHR$.

Non-competing, QBIC was thought of a year after this challenge was posted.

Answer 60

Perl 6, 9 bytes

(^*).chrs

The header and code alone are too short, so have this extra sentence.

Answer 61

Java 8, 45 bytes

A lambda expression which takes an integer and prints the table to STDOUT. Golfing suggestions welcome!

x->{for(char i=0;i<x;System.out.print(i++));}

It's not clear whether OP wants x to be the last character printed, or the first character not printed. If it's the second, just change i<x to i<=x :)

Answer 62

Tcl, 47 bytes

set i 0
time {puts [format %c $i];incr i} $argv

Try it online!

Answer 63

Python, 30 bytes

An unnamed lambda function which returns the result as a string.

lambda n:('%c'*n)%(*range(n),)

Try it online!

This uses the printf-style string formatting: when '%c' is formatted with an integer, it converts the integer to a character and displays that. So, we multiply the string by n, and format it with all values in range(n).

29 bytes

If we want to be cheeky and return a list of characters instead of a string, we can get 1 byte shorter:

lambda n:[*map(chr,range(n))]

Try it online!

Answer 64

QC 18 bytes

'00901)01016010003

'00 Read from stdin and store in memory at address 00
901 Print memory from address 01 until 0 is reached
)0101 Increment memory at 01 by 1
6010003 Jump to 03 if value at 01 and 00 are not equal

Edited because of invalid amount of bytes

Answer 65

REXX, 28 bytes

say xrange('0'x,d2c(arg(1)))

Answer 66

Sinclair ZX81 171 bytes for the listing (method 1):

 1 LET N$=""
 2 GOTO 2+(INKEY$<>"")
 3 LET A$=INKEY$
 4 IF A$=CHR$ 118 THEN GOTO 9
 5 IF CODE A$<28 OR CODE A$>37 THEN GOTO 2
 6 PRINT A$;
 7 LET N$=N$+A$
 8 GOTO 2
 9 LET N=VAL N$
10 IF N>255 THEN LET N=255
11 PRINT AT 0,0;
12 FOR I=0 TO N
13 PRINT CHR$ N;
14 NEXT I

This is using the INKEY$ command to build a string of numbers, which is checked by comparing each input to the character range from 0 to 9 inclusing in line 5. Each character is stored in the N$ variable and outputted to the screen. CHR$ 118 is the ZX81 equivalent of a new line "\r\n" in PHP for instance.

There is a check to see if you have entered a valid range once you have pressed NEW LINE (0 to 255 inclusive) - as you can only enter numbers, the range is not going to be below zero.

Then there is a simple FOR...NEXT loop from line 12 to output the non-ASCII compatible character set. So I lose points because the ZX81 does not handle ASCII without some conversion tables.

Also, the ZX81 character set is incomplete to upper-case and inversed upper-case only; the remaining characters are either graphical symbols or they are ZX81 BASIC keywords, such as PI, INKEY$, PRINT etc... There is a much simpler method that I will post later, but is more prone to human error.

Method 2, 34 bytes for the listing, no error checks and sanitizing inputs:

 1 INPUT N
 2 FOR I=0 TO N
 3 PRINT CHR$ I;
 4 NEXT I

Of course I'm sure that someone has already pointed out that true ASCII is 7 bit and the first 8 bit compatible ASCII set was PETSCII.

Answer 67

Commodore 64/128

This solution uses PETSCII which is an 8-bit wide ASCII-compatible character set.

Solution 1 - 42 BASIC bytes used (35 bytes for the listing)

0 printchr$(14);:fori=0to255:poke1024+i,i:next

Solution 2 - 10 bytes assembled, ~72 bytes source code

* = 49152
lda #$00
tax
.loop
    sta $0400,x
    dex
    txa
bne loop
rts

The assembly is doing what the BASIC listing is doing (without switching the character set to business mode first), but is obviously many times quicker. As the 6502 (6510/85xx) processor has an 8-bit accumulator and [8-bit] registers, we start at zero and count down, so 0 - 1 is 0xff. Each character is stored in the screen RAM located at 0x0400 (1024) and sta $0400,x says store the content of X to location $0400 + x. The bne loop will branch back based on the zero flag, once that is set (i.e., x=0x00) it will drop out of the loop and return to BASIC with rts.

Once assembled, run with sys 49152 - this solution should work on the C64 and 128. It will work on other Commodore machines as long as you move the routine to a free area of RAM and relocate the starting point of the screen RAM from 1024.

Answer 68

R, 24 bytes

cat(intToUtf8(1:scan()))

Try it online!

Answer 69

Excel VBA, 26 bytes

An anonymous VBE immediate window function that takes input from cell [A1]

For i=1To[A1]:?Chr(i):Next

Answer 70

Yabasic, 34 bytes

Input""n
For i=1To n
?Chr$(i)
Next

Try it online!

Answer 71

Kotlin, 42 bytes

{n:Int->for(c in 0..n-1)print(c.toChar())}

Try it online!

Answer 72

Check, 2 bytes

,o

Try it online!

Check has:

• Implicit input
• A range builtin
• A builtin to output a list of codepoints as characters

Answer 73

Momema, 25 bytes

0*-8j0j+1-=*0-9*00+-1*0j1

Outputs the characters in reverse order. Try it online!

Explanation

0   *-8     #            [0] = read num
j   0       #  label j0: goto j0
j   +1-=*0  #  label j1: goto j(1 - !![0])
-9  *0      #            print char [0]
0   +-1*0   #            [0] = 1 + [0]
j   1       #  label j2: goto j0

Answer 74

Haskell - 16 22 characters

(`take`['\0'..])

Edit

Now printing the result

print.(`take`['\0'..])

Answer 75

Lua

for i=0,255 do
    print(string.char(i))
end

Answer 76

C, 31 bytes

i;f(n){for(;i<n;)putchar(i++);}

Use:

i;f(n){for(;i<n;)putchar(i++);}

int main(void)
{
    f(34);   //Call the function
    return 0;
}

Answer 77

PL/SQL 59

select chr(rownum)from dual connect by rownum<=&i

Didn't see a requirement that said output had to be a concatenated string, so this should work?

Answer 78

JavaScript, 65 bytes

First code golf, but here's my simple JavaScript implementation:

function f(n){for(i=1;i<n;)console.log(String.fromCharCode(i++))}

Not great but decent. ;)

Usage:

f(x) // x could be any number, but generally numbers
     // greater than 0 are better. ;)

The output is rather long so I'm not going to copy it but if you run it I think you'll get the idea. :P

Uncompressed:

function f(n) {
    for (i = 1; i < n;)
        console.log(String.fromCharCode(i++)); // by using i++ we increase
                                               // i right as we get it
}

Answer 79

C#, 112 | 83 bytes

Full program, 112 bytes:

class P{static void Main(string[]a){for(int i=0;i<int.Parse(a[0]);i++){System.Console.Write("{0}\n",(char)i);}}}

A function, 83 bytes:

static void f(int n){for(int i=0;i<n;i++){System.Console.Write("{0}\n",(char)i);}}}

Answer 80

Microscript, 9 bytes

i1{d1s}ah

Or alternatively:

i1cs1]fah

Answer 81

Excel VBA - 143

For i = 1 To 127
Cells(i, 1) = i
Cells(i, 2) = Evaluate("DEC2HEX(" & i & ")")
Cells(i, 3) = Evaluate("DEC2OCT(" & i & ")")
Cells(i, 4) = Chr(i)
Next

Answer 82

K: 8 bytes

{10h$!x}

Q: 11 bytes

{10h$til x}

Answer 83

Gema, 43 characters

*=@set{i;0}@repeat{*;@int-char{$i}@incr{i}}

Sample run:

bash-4.3$ gema '*=@set{i;0}@repeat{*;@int-char{$i}@incr{i}}' <<< 96 | xxd 
0000000: 0001 0203 0405 0607 0809 0a0b 0c0d 0e0f  ................
0000010: 1011 1213 1415 1617 1819 1a1b 1c1d 1e1f  ................
0000020: 2021 2223 2425 2627 2829 2a2b 2c2d 2e2f   !"#$%&'()*+,-./
0000030: 3031 3233 3435 3637 3839 3a3b 3c3d 3e3f  0123456789:;<=>?
0000040: 4041 4243 4445 4647 4849 4a4b 4c4d 4e4f  @ABCDEFGHIJKLMNO
0000050: 5051 5253 5455 5657 5859 5a5b 5c5d 5e5f  PQRSTUVWXYZ[\]^_

Answer 84

Hassium, 45 Bytes

func a(n)for(x=0;x<n;print((x++).toChar())){}

Run and see expanded here

Answer 85

Pylons, 9

0{d1+,i}c

How it works:

0     # Push 0 to the top of the stack.
{     # Start a for loop.
 d    # Duplicate the top of the stack.
  1   # Push 1 to the stack.
   +  # Add the top two elements of the stack.
 ,    # Switch to for loop iterators.
  i   # Get input
   }  # End for loop
c     # Print stack as joined array of chars and exit.

Answer 86

Oracle SQL 11.2, 48 bytes

SELECT CHR(LEVEL)FROM DUAL CONNECT BY LEVEL<=:1;

Answer 87

Japt, 7 bytes (non-competing)

This answer is non-competing because Japt is newer than this challenge.

Uo md q

Test it online!

How it works

      // Implicit: U = input integer
Uo    // Create the range [0..U).
md    // Map each item X in this range to X.d().
      // If X is a number, this turns into the character with that char code.
q     // Join the array with the empty string.
      // Implicit: output last expression

Answer 88

DUP, 21 bytes

[1+a:0[$1+$a;<][^,]#]

Try it here!

Anonymous lambda. Usage:

256[1+a:0[$1+$a;<][^,]#]!

Explanation

[                     {start lambda}
 1+a:                 {inputnum is end of range (saved to a)}
     0                {0 is start of range}
      [       ][  ]#  {while loop}
       $1+$a;<        {dup, increment, check if top of stack < a}
                ^,    {if so, output char}
                    ] {end lambda}

Answer 89

Jelly, 2 bytes

ḶỌ

Try it online!

According to current reference implementation as of time of posting.

---

Jelly, 3 bytes

‘ḶỌ

Try it online!

Inclusive. Reference implementation is exclusive.