28

작업은 ASCII 테이블 의 n 문자 를 표시하는 것입니다 .

매개 변수 n 을 취하는 함수 (또는 인수를 매개 변수로 사용하는 프로그램, STDIN도 허용되는 프로그램)를 작성할 수 있습니다.이 매개 변수는 인쇄 할 마지막 문자의 인덱스입니다.

이 작업은 매우 간단하므로 예를 들어 Python 2.7에서 가능한 구현이 있습니다.

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

내가 말했듯이 그것은 간단한 작업입니다. 그래서 이것은 코드 골프이며 가장 짧은 코드가 승리합니다!

편집하다

당신 중 일부는 지적했지만이 코드는 결과를 인쇄하지 않습니다. 영어로 문제를 설명하는 데 어려움을 겪을 수 있기 때문에 단지 예일뿐입니다. ;-).

편집 2

가장 짧은 코드가 아니더라도 프로그래밍 언어로 답변을 게시하십시오. 어쩌면 흥미로운 구현이있을 수 있습니다!

편집 3

결과를 인쇄하도록 예제를 수정했습니다.

code-golf

— oopbase
소스

1. 기능이어야합니까? 2. 참조 코드에 따르면 n 은 인쇄되지 않은 첫 번째 문자입니다.

— Dennis

2

실제로 참조 코드는 아무것도 인쇄하지 않습니다. 단지 문자 목록을 반환하고 REPL이 원하는 결과를 수행하도록합니다.

— manatwork

1

누군가 공감대를 설명해 주시겠습니까? 영어 실력이 좋지 않으면 죄송합니다. 질문에 분명하지 않은 것이 있으면 알려주십시오.

— oopbase

1

for x in range(input()):print chr(x)예제를 편집하려면 실제로 문자를 인쇄하십시오.

— FryAmTheEggman

2

nota [i for i in range(n)]는range(n)

— njzk2

19

CJam, 4 바이트

ric,

STDIN에서 읽는 전체 프로그램 ( 온라인 인터프리터의 입력 필드 ).

인수가 문자 인 경우 문자 배열을 리턴하는 range(chr(int(input())))사실을 이용하여 단순히 실행 ,합니다.

나는 딥을 부른다 c,입력이 이미 스택에 있다고 가정 할 때를 대비 (2 바이트) 합니다.

— 데니스
소스

입력을 지정해야합니까? 온라인 러너는 코드 자체를 출력합니다.

— manatwork

12

@manatwork : 잠깐만. 게시 할 때 서둘러야합니다 ...;)

— Dennis

나는 이것에 약간 혼란스러워한다. 0 (일명 0c)의 문자는 이후에 인쇄되는 것을 방지합니다. ric, (제대로 작동하는 것 같습니다. 코드가 작동하지 않음을 의미합니다.

— kaine

1

@kaine : Internet Explorer는 C ++로 작성되며 null로 끝나는 문자열을 사용하지 않습니다. 에 따르면 이 , null 문자는 HTML 5의 구문 분석 오류는; 브라우저는이를 로 바꾸거나 문서 처리를 중단해야합니다.

— Dennis

4

n처음 수십 개의 ASCII 문자는 인쇄 할 수없는 문자이므로 충분히 크게 입력해야합니다 . 재미있는 사실 :이 프로그램은 또한 유니 코드 테이블을 출력합니다. 예 : n = 9999

— Sanchises

25

brainfuck- 169 146 142 바이트

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

한계 :

EOF는 0이어야합니다
8 비트 랩핑 셀 필요
^ 때문에 mod는 256으로 입력

여기서 가장 짧은 대답은 아니지만 이봐! 이것은 자릿수를 보장하지 않고 사람이 읽을 수있는 입력이 필요하다는 사실을 제외하고는 정말, 정말 좋은 도전입니다. 3 자 길이로 만들기 위해 선행 0을 입력해야 할 수도 있지만 그게 얼마나 재미 있습니까? : D 이런 식으로 입력을 할 때의 주요 문제는 brainfuck의 유일한 분기 또는 루핑 구조가 현재 셀이 0인지 아닌지를 검사한다는 것입니다. 입력에 0이 포함될 수 있으면 코드가 가져 가지 않아야 할 분기를 취할 수 있습니다. 이 문제를 해결하기 위해 입력의 각 자리수에 1을 더한 값을 저장합니다 다음 마지막 초에 초과분을 뺍니다. 그렇게하면 항상 제로가 어디에 있는지 알 수 있습니다.

나는 이것이 입력을 파싱하지 않고 대단한 도전 일 것이라고 말했다. 왜 그런가요? 숫자 입력을하지 않는 척하자. 문제는 "입력 바이트를 제공하고 해당 바이트 아래의 모든 ASCII 문자를 출력하는 것"입니다. 내 대답은 다음과 같습니다.

brainfuck-8 바이트

,[->.+<]

상당히 차이가 있습니다! 실제 프로그램은 사람이 직접 입력하기 때문에 135 개의 명령을 사용하여 입력을 수집합니다 (프로그램의 95 % 이상!). 바이트와주고 같은 수를 저장 하는 나에게, 그것은 단지 하나의 걸립니다.

(재미있는 사실 : 만약 당신이 가상의 프로그램을 이해했다면 축하합니다! 당신은 전체적으로 brainfuck을 이해합니다. 전체 언어는 단지 8 개의 명령을 가지고 있으며, 그 프로그램은 각 명령을 정확히 한 번만 사용합니다.)

설명

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

— 지하의
소스

좋은! 노력을 위해 확실히 +1 :-)

— oopbase

1

출력 부분에 약간의 바이트를 저장할 수 있습니다. >[-]<[->.+<]현재 셀 옆의 셀을 0으로 설정 한 다음 옆에 셀을 늘리면서 동시에 값을 인쇄하면서 현재 셀을 카운트 다운하십시오.

— Shujal

@shu 그것은 훌륭한 포인트입니다! 나는 전혀 생각하지 않았다. 더 짧을뿐만 아니라 큰 입력에서 질식하는 데 발생한 문제를 해결하며 아마도 더 빠를 것입니다! 감사합니다 :)

— undergroundmonorail

예, 훨씬 빨라졌습니다. 나는 >[-]<이미 빈 셀 옆에 있었기 때문에 부품이 필요하지 않았습니다 . :)

— undergroundmonorail

1

또한 두 번째 답변이 유효합니다.

— Esolanging 과일

12

Pyth , 4 바이트

VQCN

기본적으로 Python 3 프로그램의 번역 :

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

— FryAmTheEggman
소스

11

비 펀지 (93) - 23 (21)

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

비 펀지 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>

Expand snippet

— 카르 쉘
소스

여기 에서 인라인 인터프리터를 사용했다고 생각하지 않기를 바랍니다. :)

— Ingo Bürk

이 질문은 우리가 어떤 순서로든 인쇄해야한다고 &> #- #1:# :#,_@

— 말하지

나는 다른 바이트를 총 15 개 줄였습니다. 줄 바꿈 때문에 게시물에서 편집 할 것입니다.

— Ingo Bürk

여분의 골프에서 잘 연주했습니다 :) 인라인 인터프리터는 하나가 있다는 것을 몰랐습니다. 감사합니다 :)

— karhell

통역사는 연결된 도전에서 새로운 것입니다. 나는 당신의 대답을 볼 때 실제로 그것을 사용할 것이라고 생각했습니다. :)

— Ingo Bürk

8

자바 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, @Ingo Bürk 및 @Loovjo에게 감사드립니다.

— 로돌포 디아스
소스

1

스캐너를 여는 동안 int를 선언 int i,n=new Scanner(...하고 루프를로 변경하여 일부 문자를 저장할 수 있습니다 for(;++i<n;). 또한을 호출 할 필요가 없습니다 Character.toString. System.out에 char 값을 제공하면 행복하게 출력됩니다.

— Shujal

1

과제는 귀하 a의 입력을 사용하도록 허용합니다 . 그리고 for증가 위치를 루프 본문으로 사용 하여 루프를 줄일 수 있다고 생각합니다 . for(;++i<n;System.out.print((char)i));(하지만 초기화 또는 종료 값을 + -1로 변경해야 할 수도 있습니다)

— flawr

1

함수를 작성할 수 있으므로 전체 클래스와 모든 것이 필요하지 않습니다.

— Ingo Bürk

1

@RodolfoDias 확실합니까? 분명히 ++i<n+1와 동일해야합니다 ++i<=n. =그러나 거기에 주목하십시오 ! 1 바이트 만 저장합니다. 그것은 나를 위해 작동합니다.

— Ingo Bürk

1

그래서 우리 void f(int n){int i=0;for(;++i<=n;System.out.print((char)i));}는 62 바이트입니다. 적어도 나는 골프를 더 이상 볼 수 없습니다. :)

— Ingo Bürk

6

APL, 5

⎕UCS⍳

사용법 예 :

⎕UCS⍳256

— 슈잘
소스

1

dfn을 만들 필요가 없습니다. ⎕UCS⍳ 만 잘 작동합니다. 그래서 5 개의 문자

— Moris Zucca

1

127 개가 넘는 코드 포인트를 지원할 필요는 없습니다. ⎕⎕AV 만 작동하면됩니다. 그래서 4 문자

— Adám

6

자바 스크립트, ES6 - 52 58 56 53 44 42 바이트

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

이것을 Firefox 콘솔에 붙여 넣습니다. 다음으로 실행f(NUM) .

~~첫 번째가 입력을 제대로 받아들이지 않았기 때문에 더 길게 만들어야했습니다.~~

다운 3, edc65 감사합니다! 스위블 덕분에 44까지 줄였습니다!

— 시몬 스터
소스

1

이것은 실제로 매개 변수 나 입력을 처리하지 않습니다.

— manatwork

70을 다른 숫자로 바꾸십시오. 그게 입력입니다.

— Scimonster

좋아, 나는 6 바이트의 비용으로 입력을 받도록 업데이트했다.

— Scimonster

3

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

— edc65

2

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

— 스위블

6

하스켈, 17 23 바이트

flip take['\0'..]

수입하지 않고 더 잘 할 수 있는지 확실하지 않습니다.

편집하다

내 첫 번째 솔루션은 실제로 결과를 인쇄 하지 않았 으므로 6 문자를 더 허용하십시오.

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

또한 짧지 않고 (인쇄 가능한 25 문자, 19 제외) 흥미로운 대체 접근법 ( 'Data.List'가 필요합니다) :

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

— 고고학
소스

실제로 결과를 인쇄하지는 않습니다.

— nyuszika7 시간

@ nyuszika7h 이제 그렇습니다

— John Dvorak

(`take`['\0'..])바이트를 저장합니다.

— Laikoni

4

Bash + BSD 공통 유틸리티, 9 바이트

jot -c $1

GNU dc, 20 바이트

?sc_1[1+dPdlc>m]dsmx

— 디지털 외상
소스

4

기음, 31 30 28 27

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

퍼치는 비표준이기 때문에 다음은 완전히 호환되는 버전입니다.

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

main에서 호출해야합니다.

main(){f(255);}

편집 : putchar 반환 값을 활용하여 개선 됨
편집 2 : 재귀를 통해 다른 문자로 줄임

— 타 크라
소스

1

퍼치는 비표준 기능입니다. 또한이 답변이 다운 투표 된 이유를 물을 수 있습니까?

— Stuntddude

@Stuntddude putchar를 사용하는 alternatve 버전을 추가하겠습니다. 왜 이것이 다운 보트인지 모릅니다. 결국, 그것은 더 짧은 것 중 하나입니다.

— takra

4

펄, 17 바이트

say chr for 0..$_

— 뎀 고니 니스
소스

1

괄호가 너무 많습니다. print chr for 0..$ARGV[0]

— manatwork

네가 옳아! 내가 perl을 사용

— 한지 오래

1

shift대신 $ARGV[0]2 바이트를 절약 할 수 있습니다 .

— nyuszika7 시간

다른 줄에 문자를 인쇄 할 수 있으면을 사용할 수 있습니다 say. 또한을 사용하여 원 라이너로 수행하면 문자 수가 짧아집니다 -n. 문자로 echo "90" | perl -nE'say chr for 0..$_'계산됩니다 18. 17대한 say chr for 0..$_플러스 1에 대한 n.

— hmatt1

네가 옳아. 그러나 say모든 버전의 perl에서는 작동하지 않습니다.

— Demnogonis 2018 년

3

CJam, 3

,:c

인수가 최상위 스택 요소라고 가정했습니다.

사용법 예 :

256,:c

ri,:c

— 슈잘
소스

3

루비, 30 자

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

— 손잡이
소스

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

...but then I'd have to count the chars of that alias definition too... :-(

3

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

— jpjacobs
소스

Notice that the alphabet is not exactly ASCII.

— FUZxxl

Up to {.&a. 127, it is no?

— jpjacobs

No because J has box drawing characters instead of some of the control characters.

— FUZxxl

Actually, writing this to a file and inspecting it with a hex viewer tells me that J outputs the correct values (0x00 0x01, ...) . it's only the J interpreter/ IDE interpretting those values as boxdrawing characters instead of control characters. It does exactly the same as all other languages using char or equivalents do.

— jpjacobs

That's weird because I tested it on my UNIX box and it did indeed output Unicode characters for some of the code-points.

— FUZxxl

3

gs2, 2 bytes

V.

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

— Lynn
소스

1

Successfully tested with this version, which predates the challenge by a month.

— Dennis

3

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:

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

— Mitch Schwartz
소스

Why haven't I thought of this??? This is ingenious!!!

— FinW

Can I borrow this to use on future answers?

— FinW

1

@FinW I'm guessing you don't know about this meta post.

— Mitch Schwartz

2

Golfscript - 5

Thanks to @Dennis

~,''+

— Beta Decay
소스

1

~,""+ is shorter and correctly processes input from STDIN.

— Dennis

@Dennis That doesn't produce any output for me...

— Beta Decay

1

Are you using the online interpeter? To correctly simulate input from STDIN, you have to use, e.g., ;"65", since the input from STDIN will always be a string.

— Dennis

1

@Dennis Oh thanks that works now!

— Beta Decay

2

Lua - 43 41 Bytes

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

— William Barbosa
소스

You can shorten this by a byte a=""for i=1,arg[1]do print(a.char(i))end

— Digital Veer

You can shorten this by 2 bytes for i=1,arg[1]do print(("").char(i))end

— manatwork

2

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                                               ;

— Justin
소스

2

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:

Get upper limit of range
Generate a range of the table.
Map the range to chr function ( takes int, returns ascii ).
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.

— Full Metal
소스

You could very much make this into a lambda, as the question states this, and in Python 2, map returns a list, so you could just do f=lambda i:map(chr,range(i))

— Justin

That's true, and my initial solution was similar but I didn't want to use a lambda so that I could immediately print output. I wish map kept the trend of returning a list instead of an iterator, even if it is more pythonic that way.

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

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

— Mark K Cowan
소스

1

FreePascal (and if I remember correctly, Turbo Pascal too) only needs 60 of those characters: var c,n:byte;begin read(n);for c:=0to n do write(chr(c))end. pastebin.com/aFLVTuvh

— manatwork

Quite possibly, I've only used Delphi. But someone edited that out of the title.

— Mark K Cowan

2

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

— Mark K Cowan
소스

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
소스

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
소스

2

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])]))

— manatwork
소스

2

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)

— temporicide
소스

2

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

— MickyT
소스

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

Second answer is invalid. You can rewrite it this way and golf 9 characters: DECLARE @ INT=64SELECT TOP(@+1)CHAR(ROW_NUMBER()OVER(ORDER BY 0/0)-1)FROM sys.messages

— t-clausen.dk

@t-clausen.dk not sure how I let that one through. Thanks for that.

— MickyT

2

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.

— FinW
소스

2

Keg, 4 bytes (SBCS)

¿ï(,

TIO

Push input, output ASCII table.

— A̲̲
소스

ASCII 테이블을 인쇄

CJam, 4 바이트

brainfuck- 169 146 142 바이트

brainfuck-8 바이트

Pyth , 4 바이트

비 펀지 (93) - 23 (21)

비 펀지 93 - (15) 13 (잉고 버크 의해)

자바 151 128 77 62 56 바이트

APL, 5

자바 스크립트, ES6 - 52 58 56 53 44 42 바이트

하스켈, 17 23 바이트

편집하다

Bash + BSD 공통 유틸리티, 9 바이트

GNU dc, 20 바이트

기음, 31 30 28 27

펄, 17 바이트

CJam, 3

루비, 30 자

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) (many many bytes unless you compile it)

Perl - 29

Ruby, 23

Explanation

Julia: 20 characters (REPL)

Julia: 33 characters

M (MUMPS) - 21

T-SQL: 68 63

T-SQL: 95 86

BrainFuck - 140 112 Bytes

Keg, 4 bytes (SBCS)