28

A tarefa é exibir n caracteres da tabela ASCII .

Você pode escrever uma função (ou um programa que use o argumento como parâmetro, STDIN também é permitido) que use o parâmetro n , que será o índice do último caractere a ser impresso.

A tarefa é bastante simples, portanto, como exemplo, aqui está uma possível implementação no Python 2.7:

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

Como eu disse, é uma tarefa simples. Portanto, este é o código-golfe e os códigos mais curtos vencem!

EDITAR

Como alguns de vocês apontaram, este código não imprime o resultado. É apenas um exemplo, pois eu posso ter dificuldade em explicar o problema em inglês ;-).

EDIT2

Sinta-se à vontade para postar a resposta em qualquer linguagem de programação, mesmo que não seja o código mais curto. Talvez haja algumas implementações interessantes por aí!

EDIT3

Corrigido o exemplo para que ele imprima o resultado.

code-golf oopbase
fonte

1. Tem que ser uma função? 2. De acordo com o seu código de referência, n seria o primeiro caractere que não é impresso.

Dennis

2

Na verdade, o código de referência não imprime nada. Ele apenas retorna uma lista dos caracteres e permite que o REPL faça o que quiser com o resultado.

manatwork

1

Alguém pode explicar o voto negativo? Sinto muito se meu inglês não é tão bom. Se houver algo claro na pergunta, por favor me diga.

Oopbase 28/10/2014

1

for x in range(input()):print chr(x)Na verdade, imprimiria os caracteres, se você quiser editar seu exemplo.

FryAmTheEggman 28/10

2

nota [i for i in range(n)]é bastante semelhante arange(n)

njzk2 28/10

19

CJam, 4 bytes

ric,

Programa completo que lê STDIN (campo de entrada no intérprete online) ).

Isso simplesmente é executado range(chr(int(input()))), aproveitando o fato de ,retornar um array de caracteres se o argumento for um caractere.

Eu chamo dibs em c,(2 bytes), apenas no caso de supor que a entrada já esteja na pilha que seja permitida.

Dennis
fonte

Você precisa especificar alguma entrada? O corredor on-line apenas gera o próprio código.

manatwork

12

@ manatwork: Apenas um segundo. Você tem que se apressar quando você postar estes ...;)

Dennis

Estou um pouco confuso com isso. O caractere em 0 (aka 0c) impede que qualquer outra coisa seja impressa depois dele. ric, (parece funcionar bem Isso significa que o código não funciona..

kaine

1

@kaine: O Internet Explorer é escrito em C ++, que não usa seqüências terminadas em nulo. De acordo com isso , caracteres nulos são erros de análise no HTML 5; o navegador deve substituí-lo por um ou interromper o processamento do documento.

Dennis

4

Lembre-se de que você deve inserir um número suficientemente grande n, porque as primeiras dezenas de caracteres ASCII são caracteres não imprimíveis. Curiosidade: este programa também gera a tabela Unicode, por exemplo n = 9999 #

2929 Sanchises

25

brainfuck - 169 146 142 bytes

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

Limitações:

O EOF deve ser 0
Requer células de quebra de 8 bits
Por causa de ^, os mods são introduzidos por 256

Não é a resposta mais curta aqui, mas ei, foda-se! Esse seria um desafio realmente bom, exceto pelo fato de exigir informações legíveis por humanos sem garantir o número de dígitos. Eu poderia ter exigido entrada para ter zeros à esquerda para fazer 3 caracteres, mas que graça é essa? : D Um grande problema com a entrada de dados dessa maneira é que a única estrutura ramificada ou em loop do cérebro verifica se a célula atual é zero ou não. Quando a entrada pode conter zeros, isso pode fazer com que seu código pegue ramificações que não deveria estar recebendo. Para resolver esse problema, armazeno cada dígito da entrada mais 1 e subtraio o excesso no último segundo possível. Dessa forma, eu sempre sei onde estão meus zeros.

Eu disse que esse teria sido um grande desafio, sem ter que analisar dados. Por que é que? Bem, vamos fingir que não recebemos uma entrada numérica. Diremos que o desafio é "Com um byte de entrada, produza todos os caracteres ASCII abaixo desse byte". Aqui está a minha resposta:

brainfuck - 8 bytes

,[->.+<]

É muita diferença! O programa real usa 135 instruções para coletar a entrada (mais de 95% do programa!), Apenas porque é um humano digitando-o. Armazene o número como um byte e me dê isso , e leva apenas um.

(Fato interessante: se você entendeu o programa hipotético, parabéns! Você entende o cérebro completamente. O idioma inteiro possui apenas oito comandos, e esse programa usa cada um exatamente uma vez.)

Explicação

-[+>+[+<]>+]>+               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

undergroundmonorail
fonte

Agradável! Definitivamente +1 para o esforço :-)

oopbase 28/10

1

Você pode salvar alguns bytes na parte de saída: >[-]<[->.+<]defina a célula ao lado da célula atual como 0 e, em seguida, conte a célula atual enquanto aumenta a célula ao lado e imprime o valor simultaneamente.

Shujal 28/10

@shu Esse é um ponto excelente! Eu não pensei nisso. Além de ser mais curto, ele corrige o problema que tive ao engasgar com entradas grandes e provavelmente é mais rápido! Obrigado :)

undergroundmonorail

Sim, é muito, muito mais rápido agora. Eu também não precisava da >[-]<peça porque já estava ao lado de uma célula vazia. :)

undergroundmonorail

1

Além disso, sua segunda resposta é válida.

Esolanging Fruit

12

Pitão , 4 bytes

VQCN

Basicamente, uma tradução do programa Python 3:

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

FryAmTheEggman
fonte

11

Befunge 93 - 23 21

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

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

Este imprime a lista ao contrário, mas o OP disse apenas que precisamos imprimir os primeiros ncaracteres, não que ele esteja em ordem.

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

Pode não ser mais possível jogar golfe sem passar para o Befunge98 (para o operador ";", consulte a resposta de @ Kasran )

Experimente aqui:

Mostrar snippet de código

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>

Expand snippet

karhell
fonte

Eu espero que você não se importa que eu usei um intérprete em linha a partir de aqui :)

Ingo Bürk

A questão não diz que devemos imprimi-lo em qualquer ordem, de modo que este é de cinco byte mais curto: &> #- #1:# :#,_@(ele só imprime em sentido inverso)

Ingo Bürk

Raspei outros bytes para um total de 15. Por causa das novas linhas, eu o editarei na sua postagem.

Ingo Bürk

Bem jogado no golfe extra :) Quanto ao intérprete em linha, eu não sabia que havia um. É ótimo, obrigado :)

karhell

O intérprete é novo no desafio vinculado. Eu apenas pensei em usá-lo quando vi sua resposta. :)

Ingo Bürk

8

Java, 151 128 77 62 56 bytes

Primeira tentativa no código de golfe.

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

Uso:

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));
    }
}

Agradecemos a @Shujal, @flawr, @Ingo Bürk e @Loovjo pela grave redução de bytes.

Rodolfo Dias
fonte

1

Você pode salvar alguns caracteres declarando o int enquanto abre o scanner: int i,n=new Scanner(...e alterando o loop para for(;++i<n;). Além disso, você não precisa invocar Character.toString. Você pode apenas alimentar System.out com um valor de char e ele terá a saída feliz.

Shujal 28/10

1

O desafio permite o uso do seu acomo entrada. E eu acho que você pode encurtar o forciclo por abusar o lugar incremento como corpo do loop: for(;++i<n;System.out.print((char)i));(mas você pode ter que alterar o valor de inicialização ou no final de + - 1)

flawr

1

Você tem permissão para escrever uma função, portanto não há necessidade de uma classe inteira e tudo.

Ingo Bürk

1

@RodolfoDias Você tem certeza? Obviamente, ++i<n+1deve ser equivalente a ++i<=n. Observe o =lá, no entanto! Apenas salva um byte. Funciona para mim.

Ingo Bürk

1

Então, chegamos a void f(int n){int i=0;for(;++i<=n;System.out.print((char)i));}62 bytes. Pelo menos não vejo mais golfe agora. :)

Ingo Bürk

6

APL, 5

⎕UCS⍳

Exemplo de uso:

⎕UCS⍳256

Shujal
fonte

1

Você não precisa criar um dfn. Apenas o ⎕UCS funcionaria bem. Então 5 caracteres

Moris Zucca

1

Você não precisa suportar pontos de código acima de 127. Apenas ↑ ⎕AV funcionaria bem. So 4 chars

Adám

6

JavaScript, ES6 - 52 58 56 53 44 42 bytes

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

Cole isso no console do Firefox. Executar como f(NUM).

~~Teve que prolongar, porque o primeiro não aceitou adequadamente a entrada.~~

Abaixo 3, graças edc65! Até 44, graças à Swivel!

Scimonster
fonte

1

Isso realmente não lida com parâmetro nem com entrada.

manatwork

Apenas mude os 70 para um número diferente; essa é a entrada.

Scimonster

Ok, eu atualizei para receber entrada, ao custo de 6 bytes.

Scimonster

3

-2: f = n => [... Matriz (n)]. Mapa ((v, i) => String.fromCharCode (i))

edc65 28-14

2

44 caracteres! f=n=>String.fromCharCode(...Array(n).keys())

Swivel

6

Haskell, 17 23 bytes

flip take['\0'..]

Não tenho certeza se é possível fazer melhor sem as importações.

Editar

Minha primeira solução não imprimiu o resultado, portanto, permita mais 6 caracteres para isso:

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

Além disso, não é mais curto (25 caracteres com impressão, 19 sem), mas uma abordagem alternativa interessante (requer 'Data.List'):

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

archaephyrryx
fonte

Na verdade, isso não imprime o resultado.

nyuszika7h

@ nyuszika7h agora ele faz

John Dvorak

(`take`['\0'..])salva um byte.

Laikoni

4

Utilitários comuns do Bash + BSD, 9 bytes

jot -c $1

GNU dc, 20 bytes

?sc_1[1+dPdlc>m]dsmx

Trauma Digital
fonte

4

C, 31 30 28. 27

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

Como o putch não é padrão, aqui está a versão totalmente compatível:

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

Deve ser chamado de main:

main(){f(255);}

EDIT: Melhorado aproveitando o valor de retorno putchar
EDIT 2: Reduzido por outro caractere através da recursão

takra
fonte

1

o putch é uma função não padrão. Além disso, posso perguntar por que esta resposta foi rebaixada?

Stuntddude

@Stuntddude Vou adicionar uma versão alternativa que usa putchar, e não faço ideia do motivo pelo qual isso foi prejudicado. Afinal, é um dos mais curtos.

takra

4

Perl, 17 bytes

say chr for 0..$_

Demnogonis
fonte

1

Parênteses demais. print chr for 0..$ARGV[0]

manatwork

Você está certo! Tem sido um tempo desde que eu usei perl

Demnogonis

1

Você pode usar em shiftvez de $ARGV[0]salvar 2 bytes.

nyuszika7h

Se você tiver permissão para imprimir os caracteres em linhas diferentes, poderá usá-lo say. Além disso, a contagem de caracteres é menor se você fizer isso como uma linha única -n. echo "90" | perl -nE'say chr for 0..$_'contaria como 18caracteres. 17para say chr for 0..$_mais 1para o n.

hmatt1

Você está certo. Mas saynão funcionará com todas as versões do perl.

Demnogonis

3

CJam, 3

,:c

Presumi que o argumento fosse o elemento da pilha superior.

Exemplo de uso:

256,:c

ri,:c

Shujal
fonte

3

Ruby, 30 caracteres

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

Maçaneta da porta
fonte

3

awk - 27

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

Para dar o parâmetro em stdin, execute-o como:

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

Apenas por diversão: a "versão positiva do pensamento" começa com um definitivo yes:

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

NR-1é necessária para imprimir (char)0para NR==1. :-(

E por que não temos um nocomando? Isso é meio cruel!

fonte

1

alias no='yes no'

nyuszika7h

... mas então eu teria que contar os caracteres dessa definição de alias também ... :-(

3

J - 5 bytes

{.&a.

{.é Head, a.é Alphabet (uma lista de todos os caracteres) e os &une, gerando um verbo monádico chamado:

{.&a. 100 NB. first 100 characters

Nota : Parece que isso não funciona de maneira interativa: Jconsole e jQt parecem configurar uma tradução, gerando caracteres de caixa em vez de alguns caracteres de controle. Em um script ou na linha de comando, ele funciona:

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

jpjacobs
fonte

Observe que o alfabeto não é exatamente ASCII.

FUZxxl

Até {.&a. 127, não é?

Jpjacobs 01/07

Não, porque J possui caracteres de desenho de caixa em vez de alguns dos caracteres de controle.

FUZxxl 01/07/2015

Na verdade, gravar isso em um arquivo e inspecioná-lo com um visualizador hexadecimal diz que J gera os valores corretos (0x00 0x01, ...). é apenas o J intérprete / IDE interpretando esses valores como caracteres de desenho de caixa em vez de caracteres de controle. Faz exatamente o mesmo que todos os outros idiomas que usam charou equivalentes.

jpjacobs

Isso é estranho, porque eu testei na minha caixa UNIX e, de fato, produziu caracteres Unicode para alguns dos pontos de código.

FUZxxl 01/07/2015

3

gs2, 2 bytes

V.

Isso deveria estar competindo, eu acho! Teria funcionado mesmo nos primeiros dias do gs2. Experimente aqui.

Lynn
fonte

1

Testado com sucesso com esta versão , que antecede o desafio em um mês.

Dennis

3

Brainfuck, 44 bytes

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

Espera uma sequência decimal sem uma nova linha à direita.

Experimente online.

Ler números inteiros na faixa [0, max_cell_size]de brainfuck não é difícil. Convido você a inventar um método limpo por conta própria. Considero isso um exercício de nível iniciante. (A operação reversa de impressão do valor numérico de uma célula está mais envolvida e pode ser considerada uma tarefa de nível intermediário.)

Aqui está uma versão de 58 bytes que pode lidar 256com implementações de 8 bits:

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

Mitch Schwartz
fonte

Por que eu não pensei nisso ??? Isso é engenhoso !!!

FinW

Posso emprestar isso para usar em respostas futuras?

FinW

1

@ Finin Eu acho que você não sabe sobre este meta post .

22617 Mitch

2

Golfscript - 5

Graças a @Dennis

~,''+

Beta Decay
fonte

1

~,""+é mais curto e processa corretamente a entrada do STDIN.

Dennis

@ Dennis Isso não produz qualquer saída para mim ...

Beta Decay

1

Você está usando o interpeter online? Para simular corretamente a entrada do STDIN, você deve usar, por exemplo ;"65", uma vez que a entrada do STDIN sempre será uma string.

Dennis

1

@ Dennis Oh, obrigado que funciona agora!

Decay Beta

2

Lua - 43 41 bytes

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

William Barbosa
fonte

Você pode encurtar isso por um bytea=""for i=1,arg[1]do print(a.char(i))end

Digital Veer

Você pode encurtar este por 2 bytesfor i=1,arg[1]do print(("").char(i))end

manatwork

2

Befunge 98, 22

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

Meio triste que isso seja tão longo.

&: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                                               ;

Justin
fonte

2

Python 3.4 - 36 bytes / 43 bytes

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

255 entrada ()

Como isso funciona é:

Obter o limite superior do intervalo
Gere um intervalo da tabela.
Mapeie o intervalo para a função chr (leva int, retorna ascii).
Consumir o mapa via expansão de argumento de splat (número -> caractere -> impressão!)

O segundo apenas remove o espaço que separa cada caractere em troca de 7 bytes.

Full Metal
fonte

Você poderia muito bem fazer isso em um lambda, como a questão diz isso, e em Python 2, mapretorna uma lista, então você poderia apenas fazerf=lambda i:map(chr,range(i))

Justin

Isso é verdade, e minha solução inicial foi semelhante, mas eu não queria usar um lambda para poder imprimir imediatamente a saída. Eu gostaria que o mapa mantivesse a tendência de retornar uma lista em vez de um iterador, mesmo que seja mais pitônico dessa maneira.

Full Metal

2

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.

Cria e roda bem em http://www.onlinecompiler.net/pascal

Mark K Cowan
fonte

1

FreePascal (e se bem me lembro, Turbo Pascal também) precisa apenas 60 desses personagens: var c,n:byte;begin read(n);for c:=0to n do write(chr(c))end. pastebin.com/aFLVTuvh

manatwork

Muito possivelmente, eu só usei Delphi. Mas alguém editou isso fora do título.

Mark K Cowan

2

x86 ASM (Linux) (muitos bytes, a menos que você o compile)

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

Mark K Cowan
fonte

2

(I should have put a F00F exploit in there, it's not like anyone will run it anyway)

Mark K Cowan

7

I was going to run this. I'm not going to run this now.

Aearnus

2

Perl - 29

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

nyuszika7h
fonte

2

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.

britishtea
fonte

2

Julia: 20 caracteres (REPL)

Isso é próximo ao exemplo da pergunta: apenas gera os caracteres e deixa o REPL fazer o que quiser com eles.

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

Julia: 33 caracteres

Imprime cada caractere em uma linha separada.

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

homem a trabalhar
fonte

2

M (MUMPS) - 21

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

Em forma expandida: READ n FOR i=1:1:n WRITE $CHAR(i)

temporicida
fonte

2

T-SQL: 68 63

Como um loop de impressão

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

T-SQL: 95 86

Como uma consulta

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

Edit: Feito alterações e correções apontadas por Muqo. Obrigado. Correções e golfe sugeridos por @ t-clausen.dk

MickyT
fonte

For the loop, you can save 5 or so characters converting the WHILE to a GOTO with label. For the query, maybe specify msdb.sys.objects to guarantee enough objects. Also, it doesn't output CHAR(0). However, as consolation you can ORDER BY @.

Muqo

A segunda resposta é inválida. Você pode reescrevê-lo dessa maneira e jogar 9 caracteres: DECLARE @ INT = 64SELECT TOP (@ + 1) CHAR (ROW_NUMBER () OVER (ORDER BY 0/0) -1) FROM sys.messages

t-clausen.dk

@ t-clausen.dk não tenho certeza de como eu deixei isso passar. Obrigado por isso.

MickyT

2

BrainFuck - 140 112 Bytes

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

Experimente aqui!

Salva 28 bytes mudando [<<<->>>->+<]>[<<<->>>->+<]>[<<<->>>-]para [<<<->->->-].

O que faz

,>,>,>                                                              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.

FinW
fonte

2

Barril , 4 bytes (SBCS)

¿ï(,

TIO

Push push, tabela de saída ASCII.

A̲̲
fonte

Imprimir a tabela ASCII

Respostas:

CJam, 4 bytes

brainfuck - 169 146 142 bytes

brainfuck - 8 bytes

Pitão , 4 bytes

Befunge 93 - 23 21

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

Java, 151 128 77 62 56 bytes

APL, 5

JavaScript, ES6 - 52 58 56 53 44 42 bytes

Haskell, 17 23 bytes

Editar

Utilitários comuns do Bash + BSD, 9 bytes

GNU dc, 20 bytes

C, 31 30 28. 27

Perl, 17 bytes

CJam, 3

Ruby, 30 caracteres

awk - 27

J - 5 bytes

gs2, 2 bytes

Brainfuck, 44 bytes

Golfscript - 5

Lua - 43 41 bytes

Befunge 98, 22

Python 3.4 - 36 bytes / 43 bytes

Pascal 87

Pascal 73

x86 ASM (Linux) (muitos bytes, a menos que você o compile)

Perl - 29

Ruby, 23

Explanation

Julia: 20 caracteres (REPL)

Julia: 33 caracteres

M (MUMPS) - 21

T-SQL: 68 63

T-SQL: 95 86

BrainFuck - 140 112 Bytes

Barril , 4 bytes (SBCS)