28

任务是显示ASCII表的n个字符。

您可以编写一个带有参数n的函数（或将参数作为参数的程序，也允许使用STDIN），该参数将是要打印的最后一个字符的索引。

任务非常简单，因此举个例子，这里是Python 2.7的可能实现：

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

正如我所说的，这是一个简单的任务。所以这是代码高尔夫球，最短的代码获胜！

编辑

正如您中某些人指出的那样，该代码不会打印结果。这只是一个例子，因为我可能很难用英语解释问题;-)。

编辑2

可以用任何编程语言随意发布答案，即使它不是最短的代码。也许那里有一些有趣的实现！

编辑3

修复了示例，以便打印结果。

code-golf

— oopbase
source

1.它必须是一个函数吗？2.根据您的参考代码，n将是第一个未打印的字符。

— 丹尼斯

2

实际上，参考代码不打印任何内容。它只是返回一个字符列表，并让REPL对结果做任何想做的事情。

— manatwork，2014年

1

有人可以解释一下反对意见吗？如果我的英语不好，我很抱歉。如果问题中有不清楚的地方，请告诉我。

— oopbase 2014年

1

for x in range(input()):print chr(x)如果要编辑示例，则将实际打印字符。

— FryAmTheEggman 2014年

2

nota [i for i in range(n)]非常类似于range(n)

— njzk2 2014年

19

CJam，4个字节

ric,

从STDIN读取的完整程序（在线解释器中的输入字段）。

这简单地执行range(chr(int(input())))，利用了以下事实：,如果参数为字符，则返回一个字符数组。

我将dibs称为c,（2字节），以防万一假设输入已经在堆栈中。

— 丹尼斯
source

您是否需要指定一些输入？在线运行程序仅输出代码本身。

— manatwork，2014年

12

@manatwork：请稍等。当您发布这些内容时，您必须快点...;）

— 丹尼斯

我对此有些困惑。0（也称为0c）处的字符可防止在其后打印其他任何内容。RIC，（似乎做工精细这意味着代码不起作用。

— 凯恩

1

@kaine：Internet Explorer用C ++编写，它不使用以null终止的字符串。根据此，空字符是HTML 5解析错误; 浏览器必须将其替换为-或中止处理文档。

— 丹尼斯

4

请记住，您必须输入足够大n的字符，因为前几十个ASCII字符是不可打印的字符。有趣的事实：该程序还输出Unicode表，例如n = 9999

— Sanchises 2014年

25

脑干- 169 146 142字节

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

局限性：

EOF必须为0
需要8位包装单元
由于^，mod输入为256

这里不是最短的答案，但是，脑干！这将是一个非常非常好的脑力挑战，除了它要求人类可读的输入而不保证数字位数的事实。我可能需要输入使其前导零成为3个字符，但这有什么意思呢？：D用这种方式输入的一个主要问题是Brainfuck唯一的分支或循环结构会检查当前单元格是否为零。当输入可以包含零时，它可能导致您的代码采用不应采用的分支。为了解决这个问题，我将输入的每个数字加1，然后在可能的最后一秒减去多余的数字。这样，我总是知道我的零点在哪里。

我确实说过，这在无需解析输入的情况下将是一个巨大的挑战。这是为什么？好吧，让我们假装我们不接受数字输入。我们将说挑战是“给定一个输入字节，输出该字节以下的所有ASCII字符”。这就是我的答案：

Brainfuck-8个字节

,[->.+<]

有很大的不同！真正的程序使用135条指令来收集输入（超过程序的95％！），只是因为它是人为输入。存储号码为一个字节，并给这对我，并且只需要一个。

（有趣的事实：如果您了解假设的程序，那么恭喜您！您完全理解了Brainfuck。整个语言只有八个命令，并且该程序恰好只使用每个命令一次。）

说明

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

— 地下单轨铁路
source

真好！肯定为+1 ：-)

— oopbase 2014年

1

您可以在输出部分保存一些字节：>[-]<[->.+<]将当前单元格旁边的单元格设置为0，然后倒数当前单元格，同时增加其旁边的单元格并同时打印该值。

— Shujal 2014年

@shu这是一个很好的观点！我一点都没有想到。除了更短之外，它还解决了我因大输入而窒息的问题，而且速度可能更快！谢谢:)

— Undergroundmonorail

是的，现在速度要快得多。我也不需要>[-]<零件，因为我已经在一个空单元旁边。：）

— Undergroundmonorail

1

同样，您的第二个答案是有效的。

— Esolanging Fruit

12

Pyth，4个字节

VQCN

基本上是Python 3程序的翻译：

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

— 弗莱姆·埃格曼
source

11

Befunge 93 - 23 21

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

Befunge 93 - 15 13（由英戈伯克）

这是反向打印列表，但是OP仅表示我们需要打印第一个n字符，而不必按顺序打印。

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

如果不继续使用Befunge98，可能无法进一步打高尔夫球（有关“;”运算符，请参见@Kasran的答案）

在这里尝试：

显示代码段

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>

展开摘要

— 卡尔黑尔
source

我希望您不要介意我从这里使用了嵌入式翻译器：)

— IngoBürk2014年

问题并没有说明我们必须以任何顺序打印它，所以这要短五个字节：（&> #- #1:# :#,_@它只是以相反的方式打印）

— IngoBürk2014年

我总共减少了15个字节。由于换行，我将其编辑到您的帖子中。

— IngoBürk，2014年

在额外的高尔夫球比赛中打得很好：)至于在线翻译，我不知道有没有。太好了，谢谢:)

— karhell 2014年

口译员是来自链接挑战的新手。我只是以为我看到您的回答后会真正使用它。:)

— IngoBürk2014年

8

Java，151 128 77 62 56字节

首先尝试代码搜索。

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

用法：

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

感谢@ Shujal，@ flawr，@ IngoBürk和@Loovjo大大减少了字节。

— 鲁道夫·迪亚斯
source

1

您可以通过在打开扫描仪时声明int int i,n=new Scanner(...并将循环更改为来保存一些字符for(;++i<n;)。另外，您无需调用Character.toString。您可以只将System.out的一个char值输入，它将很高兴地输出它。

— Shujal 2014年

1

挑战允许您将您a用作输入。而且我认为您可以for通过滥用增量位置作为循环主体来缩短循环：（for(;++i<n;System.out.print((char)i));但是您可能必须将初始化或最终值更改为+ -1）

— 更加模糊的2014年

1

您可以编写函数，因此不需要整个类和所有内容。

— IngoBürk，2014年

1

@RodolfoDias您确定吗？显然，++i<n+1应该等效于++i<=n。请注意其中的内容=！它只保存一个字节。这个对我有用。

— IngoBürk'14

1

因此，我们得出的void f(int n){int i=0;for(;++i<=n;System.out.print((char)i));}结果是62个字节。至少我现在不喜欢高尔夫。:)

— IngoBürk2014年

6

杀伤人员地雷5

⎕UCS⍳

用法示例：

⎕UCS⍳256

— 舒加尔
source

1

您不必制作dfn。只是“ UCS”就可以了。所以5个字符

— Moris Zucca 2014年

1

您不必支持超过127个的代码点。只需↑⎕AV即可正常工作。因此，4个字符

— 亚当

6

的JavaScript，ES6 - 52个 58 56 53 44 42字节

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

将此粘贴到Firefox控制台中。运行为f(NUM)。

~~必须延长时间，因为第一个未正确接受输入。~~

下来3，感谢edc65！减少到44个，感谢Swivel！

— 西蒙斯特
source

1

这实际上不能同时处理参数和输入。

— manatwork 2014年

只需将70更改为其他数字即可；这就是输入。

— Scimonster 2014年

好的，我将其更新为接受输入，但花费了6个字节。

— Scimonster 2014年

3

-2：f = n => [... Array（n）]。map（（v，i）=> String.fromCharCode（i））

— edc65

2

44个字符！f=n=>String.fromCharCode(...Array(n).keys())

— 旋转

6

Haskell，17 23字节

flip take['\0'..]

不知道没有进口是否有可能做得更好。

编辑

我的第一个解决方案实际上并未打印结果，因此可以再添加6个字符：

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

另外，不是更短（打印时为25个字符，没有打印时为19个字符），而是一种有趣的替代方法（不过，它需要“ Data.List”）：

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

— 始祖鸟
source

这实际上不会打印结果。

— nyuszika7h 2014年

@ nyuszika7h现在可以了

— John Dvorak

(`take`['\0'..])保存一个字节。

— Laikoni '17

4

Bash + BSD通用实用程序，9个字节

jot -c $1

GNU dc，20个字节

?sc_1[1+dPdlc>m]dsmx

— 数字创伤
source

4

C， 31 30 28 27

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

由于putch是非标准的，因此这是完全兼容的版本：

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

必须从main调用：

main(){f(255);}

编辑：利用putchar返回值进行了改进
编辑2：通过递归减少了另一个字符

— 塔克拉
source

1

推杆是非标准功能。另外，请问为什么这个答案被否决了？

— Stuntddude

@Stuntddude我将添加一个使用putchar的替代版本，并且不知道为什么它被否决了。毕竟，它是较短的之一。

— 塔克拉2015年

4

Perl，17个字节

say chr for 0..$_

— 角膜肌
source

1

括号过多。print chr for 0..$ARGV[0]

— manatwork 2014年

你是对的！它已经有一段时间，因为我用perl的

— Demnogonis

1

您可以使用shift而不是$ARGV[0]保存2个字节。

— nyuszika7h 2014年

如果允许在不同的行上打印字符，则可以使用say。另外，如果您使用来作为单行代码，字符计数会更短-n。echo "90" | perl -nE'say chr for 0..$_'将算作18字符。17为... say chr for 0..$_加1分n。

— hmatt1 2014年

你是对的。但是say不适用于所有版本的perl。

— Demnogonis 2014年

3

果酱，3

,:c

我假设参数是顶部堆栈元素。

用法示例：

256,:c

ri,:c

— 舒加尔
source

3

Ruby，30个字符

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

— 门把手
source

3

AWK-27

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

要在stdin上给出参数，请按以下方式运行：

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

只是为了好玩：以肯定的开头的“积极思考版本” yes：

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

NR-1需要打印(char)0的NR==1。:-(

为什么我们没有no命令？那有点意思！

1

alias no='yes no'

— nyuszika7h 2014年

...但是后来我也必须计算该别名定义的字符... :-(

3

J-5个字节

{.&a.

{.是Head，a.是Alphabet（所有字符的列表）并将&其绑定，从而生成一个单子动词，例如：

{.&a. 100 NB. first 100 characters

注意：似乎这不能交互工作：Jconsole和jQt似乎设置了转换，输出框字符而不是某些控制字符。在脚本或命令行中，它确实可以工作：

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

— jpjacobs
source

请注意，字母并非完全是ASCII。

— FUZxxl 2015年

到了{.&a. 127，不是吗？

— jpjacobs

否，因为J具有方框图字符而不是某些控制字符。

— FUZxxl

实际上，将其写入文件并使用十六进制查看器进行检查会告诉我J输出正确的值（0x00 0x01，...）。只是J解释器/ IDE将这些值解释为箱形绘图字符，而不是控制字符。它与使用char或等效语言的所有其他语言完全相同。

— jpjacobs

这很奇怪，因为我在UNIX机器上对其进行了测试，并且确实为某些代码点输出了Unicode字符。

— FUZxxl

3

gs2，2个字节

V.

我认为这应该是竞争！即使在gs2的早期，它也可以工作。在这里尝试。

— 林恩
source

1

已成功测试了此版本，该版本比挑战要早一个月。

— 丹尼斯

3

Brainfuck，44个字节

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

需要一个没有尾随换行符的十进制字符串。

在线尝试。

[0, max_cell_size]在Brainfuck 范围内读取整数并不困难。我鼓励您自己发明一种干净的方法。我认为这是初学者水平的练习。（打印单元格数值的相反操作更为复杂，可以认为是中级任务。）

这是一个可以处理2568位实现的58字节版本：

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

— 米奇·施瓦兹（Mitch Schwartz）
source

为什么我没有想到这个？？？这很巧妙！！！

— FinW

我可以借用它以用于将来的答案吗？

— FinW

1

@FinW我猜你对这个meta post不了解。

— 米奇·施瓦兹

2

Golfscript-5

感谢@Dennis

~,''+

— Beta衰变
source

1

~,""+较短，可以正确处理来自STDIN的输入。

— 丹尼斯

@Dennis对我没有任何输出...

— Beta Decay

1

您是否正在使用在线干预？为了正确模拟来自STDIN的输入，您必须使用例如;"65"，因为来自STDIN的输入将始终是字符串。

— 丹尼斯

1

@丹尼斯哦，谢谢，现在可以工作了！

— Beta Decay

2

Lua- 43 41字节

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

— 威廉·巴博萨
source

您可以将其缩短一个字节a=""for i=1,arg[1]do print(a.char(i))end

— Digital Veer 2015年

您可以将其缩短2个字节for i=1,arg[1]do print(("").char(i))end

— manatwork '16

2

Befunge 98、22

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

这么久很伤心。

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

— 贾斯汀
source

2

Python 3.4-36字节/ 43字节

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

255输入（）

它是如何工作的：

获取范围上限
生成表格范围。
将范围映射到chr函数（采用int，返回ascii）。
通过splat参数扩展（数字->字符->打印！）来使用地图

第二个只是删除分隔每个字符的空间，以换取7个字节。

— 全铁
source

正如问题所指出的，您非常有可能将其变成lambda，然后在Python 2中map返回一个列表，因此您可以这样做f=lambda i:map(chr,range(i))

— Justin

是的，我最初的解决方案很相似，但我不想使用lambda以便立即打印输出。我希望map保留返回列表而不是迭代器的趋势，即使那样更像pythonic。

— Full Metal

2

帕斯卡87

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

帕斯卡73

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

可从http://www.onlinecompiler.net/pascal构建并正常运行

— 马克·科文
source

1

FreePascal（如果我没记错的话，Turbo Pascal也是如此）只需要其中的60个字符：var c,n:byte;begin read(n);for c:=0to n do write(chr(c))end. pastebin.com/aFLVTuvh

— manatwork 2014年

很可能，我只使用了Delphi。但是有人从标题中删除了该内容。

— Mark K Cowan

2

x86 ASM（Linux）（很多字节，除非您对其进行编译）

作为函数编写，假定参数以AX传递（我忘记了读取的syscall的编号），并且也不保留[SP]或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

— 马克·科文
source

2

（我应该在该漏洞中放一个F00F漏洞利用程序，无论如何都不会运行它）

— Mark K Cowan 2014年

7

我本来要运行这个。我现在不打算运行它。

— Aearnus

2

Perl-29

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

— nyuszika7h
source

2

红宝石，23岁

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

说明

输入作为lambda的参数。它期望一个整数。
“解构运算符”（*）#to_ary在Range上调用以在其自己的行上打印每个字符。

— 英国茶
source

2

朱莉娅：20个字符（REPL）

这接近于问题的示例：仅生成字符并让REPL对它们执行任何操作。

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

朱莉娅：33个字符

在单独的行中打印每个字符。

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

— 工作的人
source

2

M（MUMPS）-21

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

展开形式： READ n FOR i=1:1:n WRITE $CHAR(i)

— 临时杀人
source

2

T-SQL：68 63

作为打印循环

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

T-SQL：95 86

作为查询

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

编辑：进行了 更改和Muqo指出的修复。谢谢。@ t-clausen.dk建议的维修和打高尔夫球

— 米奇
source

对于循环，您可以保存5个左右的字符，将WHILE转换为GOTOwith标签。对于查询，可以指定msdb.sys.objects以保证有足够的对象。同样，它不输出CHAR（0）。但是，可以安慰一下ORDER BY @。

— Muqo 2014年

第二个答案无效。您可以用这种方式重写它并打9个字符：DECLARE @ INT = 64SELECT TOP（@ + 1）CHAR（ROW_NUMBER（）OVER（ORDER BY 0/0）-1）FROM sys.messages

— t-clausen.dk

@ t-clausen.dk不知道我如何让那一个通过。感谢那。

— MickyT '16

2

BrainFuck - 140个 112字节

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

在这里尝试！

更改[<<<->>>->+<]>[<<<->>>->+<]>[<<<->>>-]为，节省了28个字节[<<<->->->-]。

它能做什么

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

2

桶，4字节（SBCS）

¿ï(,

蒂奥

推送输入，输出ASCII表。

— 一种
source

打印ASCII表

CJam，4个字节

脑干- 169 146 142字节

Brainfuck-8个字节

Pyth，4个字节

Befunge 93 - 23 21

Befunge 93 - 15 13（由英戈伯克）

Java，151 128 77 62 56字节

杀伤人员地雷5

的JavaScript，ES6 - 52个 58 56 53 44 42字节

Haskell，17 23字节

编辑

Bash + BSD通用实用程序，9个字节

GNU dc，20个字节

C， 31 30 28 27

Perl，17个字节

果酱，3

Ruby，30个字符

AWK-27

J-5个字节

gs2，2个字节

Brainfuck，44个字节

Golfscript-5

Lua- 43 41字节

Befunge 98、22

Python 3.4-36字节/ 43字节

帕斯卡87

帕斯卡73

x86 ASM（Linux）（很多字节，除非您对其进行编译）

Perl-29

红宝石，23岁

说明

朱莉娅：20个字符（REPL）

朱莉娅：33个字符

M（MUMPS）-21

T-SQL：68 63

T-SQL：95 86

BrainFuck - 140个 112字节

桶，4字节（SBCS）