George Gibson의 Print a Tabula Recta에서 영감을 얻었 습니다 .

이 정확한 텍스트를 인쇄 / 출력해야합니다.

ABCDEFGHIJKLMNOPQRSTUVWXYZ
BBCDEFGHIJKLMNOPQRSTUVWXYZ
CCCDEFGHIJKLMNOPQRSTUVWXYZ
DDDDEFGHIJKLMNOPQRSTUVWXYZ
EEEEEFGHIJKLMNOPQRSTUVWXYZ
FFFFFFGHIJKLMNOPQRSTUVWXYZ
GGGGGGGHIJKLMNOPQRSTUVWXYZ
HHHHHHHHIJKLMNOPQRSTUVWXYZ
IIIIIIIIIJKLMNOPQRSTUVWXYZ
JJJJJJJJJJKLMNOPQRSTUVWXYZ
KKKKKKKKKKKLMNOPQRSTUVWXYZ
LLLLLLLLLLLLMNOPQRSTUVWXYZ
MMMMMMMMMMMMMNOPQRSTUVWXYZ
NNNNNNNNNNNNNNOPQRSTUVWXYZ
OOOOOOOOOOOOOOOPQRSTUVWXYZ
PPPPPPPPPPPPPPPPQRSTUVWXYZ
QQQQQQQQQQQQQQQQQRSTUVWXYZ
RRRRRRRRRRRRRRRRRRSTUVWXYZ
SSSSSSSSSSSSSSSSSSSTUVWXYZ
TTTTTTTTTTTTTTTTTTTTUVWXYZ
UUUUUUUUUUUUUUUUUUUUUVWXYZ
VVVVVVVVVVVVVVVVVVVVVVWXYZ
WWWWWWWWWWWWWWWWWWWWWWWXYZ
XXXXXXXXXXXXXXXXXXXXXXXXYZ
YYYYYYYYYYYYYYYYYYYYYYYYYZ
ZZZZZZZZZZZZZZZZZZZZZZZZZZ

(예, 직접 입력했습니다)

모든 대문자 대신 모든 소문자를 사용할 수 있습니다.

그러나 사례 선택은 전체 텍스트에서 일관성이 있어야합니다.

규칙 / 요구 사항

• 각 제출물은 전체 프로그램 또는 기능이어야합니다. 함수 인 경우 프로그램 맨 아래에 함수 호출을 추가하기 만하면 실행 가능해야합니다. 다른 것 (예 : C의 헤더)이 포함되어야합니다.
• 가능하면 프로그램을 테스트 할 수있는 사이트에 대한 링크를 제공하십시오.
• 프로그램은에 아무 것도 쓰지 않아야합니다 STDERR.
• 표준 허점 은 금지되어 있습니다.
• 프로그램은 어떤 경우에도 출력 할 수 있지만 인쇄해야합니다 (어레이 또는 이와 유사한 것이 아님).

채점

프로그램은 기본적으로 UTF-8 또는 선택한 다른 문자 세트로 바이트 단위로 점수가 매겨집니다.

결국 가장 적은 바이트를 가진 답이 이길 것입니다.

제출물

답변이 표시되도록하려면 다음 마크 다운 템플릿을 사용하여 헤드 라인으로 답변을 시작하십시오.

# Language Name, N bytes

N제출물의 크기는 어디에 있습니까 ? 당신이 당신의 점수를 향상시킬 경우에, 당신은 할 수 있습니다 를 통해 눈에 띄는에 의해, 헤드 라인에 오래된 점수를 유지한다. 예를 들어 :

# Ruby, <s>104</s> <s>101</s> 96 bytes

헤더에 여러 숫자를 포함하려는 경우 (예 : 점수가 두 파일의 합계이거나 인터프리터 플래그 페널티를 별도로 나열하려는 경우) 실제 점수가 헤더 의 마지막 숫자 인지 확인하십시오 .

# Perl, 43 + 2 (-p flag) = 45 bytes

언어 이름을 링크로 만들어 리더 보드 스 니펫에 표시 될 수도 있습니다.

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

리더 보드

다음은 일반 리더 보드와 언어 별 수상자 개요를 생성하는 스택 스 니펫입니다.

/* Configuration */

var QUESTION_ID = 87064; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 48934; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    if (/<a/.test(lang)) lang = jQuery(lang).text();
    
    languages[lang] = languages[lang] || {lang: a.language, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang > b.lang) return 1;
    if (a.lang < b.lang) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<div id="language-list">
  <h2>Winners by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

Excel, 19,604 바이트

=CHAR(64+MAX(COLUMN(),ROW()))

에이 수식을 붙여 A1넣은 다음 위로 끕니다 A1:Z26.

바이트 수 :

1. 수식은 27 바이트입니다.
2. 26 ^ 2 번 복사해야합니다. 27 * 26 * 26 = 19604.
3. 나와 다른 사람들은 공식을 반복해서 입력 할 필요가 없기 때문에 점수가 낮아야한다고 생각했습니다. 나는 그것이 관련이 없다고 생각합니다-우리는 프로그램의 크기를 세어 보았습니다.
4. 비교를 위해- 이 28,187 문자 JS 답변을보십시오 -분명히, 누군가이 모든 것을 입력하는 대신 생성했지만 크기는 변경되지 않습니다.

Vim, 43 바이트

:h<_↵jjYZZPqqlmaYp`ajyl:norm v0r♥"↵`ajq25@q

여기서는 ↵Return ( 0x0a)을 ♥나타내고 Ctrl-R ( 0x12)을 나타냅니다 .

내 Tabula Recta 답변만큼 짧지는 않지만…

젤리, 6 바이트

ØA»'j⁷

여기에서 시도하십시오. 어제 게으르지 않았고 (1 줄 j⁷바꿈)에 대한 1 바이트 대안을 구현 한 경우 ...

ØA      The uppercase alphabet.
  »'    Table of max(x, y).
    j⁷  Join by newlines.

brainfuck, 103 96 95 91 87 바이트

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

이것은 Esolangs의 brainfuck constant를 64로 사용 합니다. 온라인으로 사용해보십시오!

/// , 141 94 92 82 바이트

/:/\\\\A//#/:b:c:d:e:f:g:h:i:j:k:l:m:n:o:p:q:r:s:t:u:v:w:x:y:z://:/\/a#
\/a\///A/#

온라인으로 사용해보십시오 : 데모

꽤 재미있는 언어입니다.

설명:

4x4 정사각형 만 인쇄하는 단축 코드 :

/:/\\\\A//#/:b:c:d://:/\/a#
\/a\///A/#

첫 번째 교체 /:/\\\\A/는 :로 대체 됩니다 \\A. 이것은 다음을 제공합니다.

/#/\\Ab\\Ac\\Ad\\A//\\A/\/a#
\/a\///A/#

그럼 /#/\\Ab\\Ac\\Ad\\A//\\A/대체 #와 함께 \Ab\Ac\Ad\A:

/\\A/\/a\Ab\Ac\Ad\A
\/a\///A/\Ab\Ac\Ad\A

이제 후속 코드에서 /\\A/\/a\Ab\Ac\Ad\A<newline>\/a\//각각을 \A로 대체 /aAbAcAdA<newline>/a/하므로 결과는 다음과 같습니다.

/A//aAbAcAdA
/a/b/aAbAcAdA
/a/c/aAbAcAdA
/a/d/aAbAcAdA
/a/

이제 첫 번째 부분 /A//은 모든 As를 제거합니다 .

abcd
/a/b/abcd
/a/c/abcd
/a/d/abcd
/a/

처음 다섯 문자 abcd<newline>가 인쇄됩니다. 다음 명령 /a/b/은 a로 대체 되어 다음 b과 같은 결과가 나타납니다.

bbcd
/b/c/bbcd
/b/d/bbcd
/b/

다시 처음 다섯 문자 bbcd<newline>가 인쇄됩니다. 다음 명령 /b/c/은 다음으로 대체 b됩니다 c.

cccd
/c/d/cccd
/c/

다시 처음 다섯 문자 cccd<newline>가 인쇄됩니다. 다음 명령 /c/d/은 다음으로 대체 c됩니다 d.

dddd
/d/

처음 다섯 문자 dddd<newline>가 인쇄됩니다. 그리고 다음 명령 /d/은 불완전하므로 아무 것도하지 않습니다.

Dyalog APL , 11 바이트

⎕A[∘.⌈⍨⍳26]

A[... 처음 26 개의 정수 의 최대 표 ]에 따라 대문자 알파벳에서 요소를 선택하십시오.
    ∘.⌈⍨
    ⍳26

TryAPL 온라인!

Mathematica, 69 65 57 바이트

^{@MartinEnder 로 인해 8 바이트가 저장 되었습니다 .}

FromCharacterCode[64+Max~Array~{26,26}]~StringRiffle~"
"&

익명의 기능. 입력을받지 않고 문자열을 출력으로 반환합니다. 기본적으로 char('A' + max(x, y))모든 x , y 는 1에서 26까지입니다.

/// , 348 바이트

/|/\/\///v/NNN|u/MMM|t/LLL|s/WXYZ|r/OOO|q/KLMa|p/RRRR|o/QQQQ|n/PPPP|m/SSS|l/EFGc|k/RSTb|j/UUUU|i/TTTT|h/WWW|g/VVV|f/XXXX|e/ZZZZZ|d/YYYYY|c/HIJq|b/UVs
|a/NOPQk/ABCDlBBCDlCCCDlDDDDlEEEElFFFFFFGcGGGGGGGcHHHHHHHcIIIIIIIIIJqJJJJJJJJJJqKKKKKKKKKKqttttMauuuuMavvvvNarrrrrPQknnnnQkooooQkppppRkmmmmmmSTbiiiiibjjjjjbgggggggVs
hhhhhhhWs
ffffffYZ
dddddZ
eeeeeZ

온라인으로 사용해보십시오!

나는 이것을 기반으로 한 도전에 대한 /// 답변과 동일한 기술을 사용 했습니다 . 그러나 CJam 스크립트 는 자신과 겹칠 수있는 하위 문자열을 올바르게 처리하지 못했기 때문에 수정 해야 했습니다.

레티 나 , 41 바이트

바이트 수는 ISO 8859-1 인코딩을 가정합니다. 선행 줄 바꿈이 중요합니다.

26$*Z
{`^[^A].+
$&¶$&
}T0-2`L`_L`^(.)\1+

설명

26$*Z

문자열을의 26 개 사본으로 설정하십시오 Z. 그런 다음 {...}Retina에게 문자열 변경이 중지 될 때까지 나머지 두 명령을 루프에서 수행하도록 지시합니다.

{`^[^A].+
$&¶$&

로 시작하지 않으면 첫 번째 줄을 복제하십시오 A.

}T0-2`L`_L`^(.)\1+

이것은 음역 단계입니다. 문자열이 동일한 문자의 사본 두 개 이상으로 시작하는 경우에만 적용됩니다. 그렇다면 마지막 문자를 제외한 모든 문자가 감소합니다. 감소는 L(대문자 알파벳)을 _L(공백 다음에 대문자 알파벳) 에 매핑하여 발생합니다 . "마지막을 제외한 모든 것"은 -2Retina에게 모든 문자를 매치에서 마지막으로 두 번째로만 음역하도록 지시 하는 한계로 표시됩니다 .

온라인으로 사용해보십시오!

하스켈, 35 바이트

a=['A'..'Z']
unlines$(<$>a).max<$>a

파이썬 2, 59 바이트

n=0;exec'print bytearray([n+65]*n+range(n+65,91));n+=1;'*26

Ideone에서 테스트하십시오 .

R, 58 바이트

l=LETTERS;for(i in 1:26){l[2:i-1]=l[i];cat(l,"\n",sep="")}

연산자 우선 순위 덕분에 2:i-1와 같습니다 1:(i-1). LETTERS알파벳이 대문자로 포함 된 내장 상수 를 사용합니다 . 다른 모든 것은 설명이 필요 없습니다.
용법:

> l=LETTERS;for(i in 1:26){l[2:i-1]=l[i];cat(l,"\n",sep="")}
ABCDEFGHIJKLMNOPQRSTUVWXYZ
BBCDEFGHIJKLMNOPQRSTUVWXYZ
CCCDEFGHIJKLMNOPQRSTUVWXYZ
DDDDEFGHIJKLMNOPQRSTUVWXYZ
EEEEEFGHIJKLMNOPQRSTUVWXYZ
FFFFFFGHIJKLMNOPQRSTUVWXYZ
GGGGGGGHIJKLMNOPQRSTUVWXYZ
HHHHHHHHIJKLMNOPQRSTUVWXYZ
IIIIIIIIIJKLMNOPQRSTUVWXYZ
JJJJJJJJJJKLMNOPQRSTUVWXYZ
KKKKKKKKKKKLMNOPQRSTUVWXYZ
LLLLLLLLLLLLMNOPQRSTUVWXYZ
MMMMMMMMMMMMMNOPQRSTUVWXYZ
NNNNNNNNNNNNNNOPQRSTUVWXYZ
OOOOOOOOOOOOOOOPQRSTUVWXYZ
PPPPPPPPPPPPPPPPQRSTUVWXYZ
QQQQQQQQQQQQQQQQQRSTUVWXYZ
RRRRRRRRRRRRRRRRRRSTUVWXYZ
SSSSSSSSSSSSSSSSSSSTUVWXYZ
TTTTTTTTTTTTTTTTTTTTUVWXYZ
UUUUUUUUUUUUUUUUUUUUUVWXYZ
VVVVVVVVVVVVVVVVVVVVVVWXYZ
WWWWWWWWWWWWWWWWWWWWWWWXYZ
XXXXXXXXXXXXXXXXXXXXXXXXYZ
YYYYYYYYYYYYYYYYYYYYYYYYYZ
ZZZZZZZZZZZZZZZZZZZZZZZZZZ

Sesos , 25 바이트

0000000: 2829c0 756fc6 aecae2 aecd9c 39e09e 099c63 7d8e3d  ().uo.......9....c}.=
0000015: 65a7c0 39                                         e..9

온라인으로 사용해보십시오! 확인 디버그를 생성 sbin에 코드를 볼 수 있습니다.

Sesos 어셈블리

위의 바이너리 파일은 다음 SASM 코드를 조합하여 생성되었습니다.

add 26
jmp
    jmp
        rwd 1, add 1, rwd 1, add 1, fwd 2, sub 1
    jnz
    rwd 2, add 64
    jmp
        fwd 2, add 1, rwd 2, sub 1
    jnz
    fwd 1, sub 1
jnz
fwd 1
jmp
    jmp
        rwd 1, add 1, fwd 1, sub 1
    jnz
    nop
        rwd 1
    jnz
    fwd 1
    jmp
        put, add 1, fwd 1
    jnz
    fwd 1
    jmp
        put, fwd 1
    jnz
    add 10, put, get
    nop
        rwd 1
    jnz
    fwd 1
; jnz (implicit)

작동 원리

테이프를로 초기화하여 시작합니다 ABCDEFGHIJKLMNOPQRSTUVWXYZ. 이것은 다음과 같습니다.

테이프를 다음 상태로 유지하면서 셀에 26 을 씁니다 .

                                                       v
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 26 0

데이터 헤드 아래의 셀이 0이 아닌 한 다음을 수행합니다.

왼쪽의 두 셀에 숫자를 복사하고 가장 왼쪽 사본에 64 를 추가 하십시오.

                                                   v
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 90 26 0 0

가장 왼쪽 복사본을 원래 위치로 이동 한 다음 가장 오른쪽 복사본에서 1 을 뺍니다 .

                                                     v
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 25 90 0

가장 오른쪽 사본이 그때까지 0 이므로 프로세스는 26 번의 반복 후에 중지됩니다 . 셀을 오른쪽으로 이동하므로 초기화 후 테이프의 최종 상태는 다음과 같습니다.

     v
0 0 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

이제 데이터 헤드 아래의 셀이 0이 될 때까지 다음 프로세스를 반복하여 출력을 생성 할 준비가되었습니다.

먼저 데이터 헤드 아래의 셀 내용을 한 단위 왼쪽으로 이동 한 다음 0이 아닌 내용이있는 마지막 셀까지 왼쪽으로 이동합니다.

   v
0 65 0 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

이제 데이터 헤드 아래의 셀부터 시작하여 0 셀 을 찾을 때까지 오른쪽으로 이동하여 모든 셀을 인쇄 한 다음 인쇄 한 각 셀을 인쇄합니다. 인쇄 후 A테이프는 다음과 같이 보입니다.

     v
0 66 0 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

이제 우리는 오른쪽으로 이동하여 0 셀이 나타날 때까지 모든 셀을 다시 인쇄합니다 . 인쇄 후 BCDEFGHIJKLMNOPQRSTUVWXYZ테이프는 다음과 같이 보입니다.

                                                                                  v
0 66 0 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

이제 우리 는 현재 셀에 10 을 쓰고 해당 문자 (줄 바꿈)를 인쇄하고 get빈 입력에 대한 호출로 셀을 0으로 만들고 테이프는 변경하지 않습니다.

마지막으로, 0이 아닌 마지막으로 왼쪽으로 이동하여 다음 반복을 위해 테이프를 준비합니다.

        v
0 66 0 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

다음 반복은 비슷합니다. 우리는 먼저 이동 (66) 모두 인쇄, 왼쪽으로 한 셀 (66 개) (세포 BB)와로 증가 67 후 (오른쪽에 남아있는 비 - 제로 세포를 인쇄 CDEFGHIJKLMNOPQRSTUVWXYZ의 데이터 헤드), 그리고 마지막으로 배치 67 다음과 같이 테이프를 떠나, .

           v
0 66 66 0 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

후 24 더 반복하고 인쇄 후 ZZZZZZZZZZZZZZZZZZZZZZZZZZ및 라인 피드, 테이프는 다음과 같은 상태로 남아있다.

                                                                                  v
0 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 0 0

데이터 헤드를 왼쪽이 아닌 0이 아닌 다음 셀로 이동하면 현재 위치에 그대로 남아 있으므로 그 아래의 셀은 0 이고 루프가 종료됩니다.

J, 13 바이트

u:65+>./~i.26

온라인 통역사 .

설명

u:65+>./~i.26
         i.26  generate [0 1 ... 25]
       /~      build a table...
     >.        ...of maximum
  65+          add 65 to each element
u:             convert to unicode

MATLAB / 옥타브, 43 39 바이트

@beaker[...,''] 가 char로 변환하는 데 사용한다는 아이디어 덕분에 1 바이트가 제거되었습니다 .

@()[91-rot90(gallery('minij',26),2),'']

이것은 2D char 배열을 반환하는 익명 함수입니다.

Ideone에서 사용해보십시오 .

설명

gallery('minij',...) 각 항목이 행 및 열 인덱스의 최소값과 같은 행렬을 제공합니다.

 1     1     1     1  ...
 1     2     2     2
 1     2     3     3
 1     2     3     4
 ...

이것은 다음과 rot90(...,2)같이 180도 회전합니다 .

26    25    24    23  ...
25    25    24    23
24    24    24    23
23    23    23    23
...  

이 91-...작업은 대문자의 ASCII 코드를 제공합니다.

65    66    67    68
66    66    67    68
67    67    67    68
68    68    69    68 ...
...

마지막으로 [...,'']빈 문자열로 가로로 연결합니다. 이것은 char로 변환하는 효과가 있습니다.

PowerShell v2 +, 76 52 40 바이트

65..90|%{-join[char[]](,$_*$i+++$_..90)}

에서 65로 반복 합니다 89. 각 반복마다 쉼표 연산자를 사용하여 배열을 현재 쉼표 연산자를 사용하여 $_증가 후 사후 헬퍼 변수로 곱하고 현재 숫자 $i++의 배열과 연결 $_합니다 90. 그것은 char-array 캐스트로 캡슐화되어 -join문자열로 합쳐집니다. 예를 들어, 첫 번째 반복의 경우이 배열은 65..90또는 전체 알파벳과 같습니다. 두 번째 반복은 66+66..90또는 전체 알파벳이 B반복되고 없음 A입니다.

그것들은 모두 프로그램 끝에서 (배열로) 파이프 라인에 남아 있으며 콘솔에 인쇄하는 것은 암시 적입니다 ( .ToString()배열 의 기본값 은 줄 바꿈을 통해 분리되므로 무료로 얻습니다).

PS C:\Tools\Scripts\golfing> .\print-the-l-phabet.ps1
ABCDEFGHIJKLMNOPQRSTUVWXYZ
BBCDEFGHIJKLMNOPQRSTUVWXYZ
CCCDEFGHIJKLMNOPQRSTUVWXYZ
DDDDEFGHIJKLMNOPQRSTUVWXYZ
EEEEEFGHIJKLMNOPQRSTUVWXYZ
FFFFFFGHIJKLMNOPQRSTUVWXYZ
GGGGGGGHIJKLMNOPQRSTUVWXYZ
HHHHHHHHIJKLMNOPQRSTUVWXYZ
IIIIIIIIIJKLMNOPQRSTUVWXYZ
JJJJJJJJJJKLMNOPQRSTUVWXYZ
KKKKKKKKKKKLMNOPQRSTUVWXYZ
LLLLLLLLLLLLMNOPQRSTUVWXYZ
MMMMMMMMMMMMMNOPQRSTUVWXYZ
NNNNNNNNNNNNNNOPQRSTUVWXYZ
OOOOOOOOOOOOOOOPQRSTUVWXYZ
PPPPPPPPPPPPPPPPQRSTUVWXYZ
QQQQQQQQQQQQQQQQQRSTUVWXYZ
RRRRRRRRRRRRRRRRRRSTUVWXYZ
SSSSSSSSSSSSSSSSSSSTUVWXYZ
TTTTTTTTTTTTTTTTTTTTUVWXYZ
UUUUUUUUUUUUUUUUUUUUUVWXYZ
VVVVVVVVVVVVVVVVVVVVVVWXYZ
WWWWWWWWWWWWWWWWWWWWWWWXYZ
XXXXXXXXXXXXXXXXXXXXXXXXYZ
YYYYYYYYYYYYYYYYYYYYYYYYYZ
ZZZZZZZZZZZZZZZZZZZZZZZZZZ

C #, 147 바이트

void e(){for(int i=0,j=97;i<26;i++,j++)Console.WriteLine(new string((char)j,i)+new string(Enumerable.Range(j,26-i).Select(n=>(char)n).ToArray()));}

때때로 나는 왜 시도조차 메신저 궁금

편집 : 고정

온라인으로 사용해보십시오

MATL, 10 바이트

lY2t!2$X>c

온라인 데모 (이 통역에 문제가있는 경우에 저를 핑 (ping) MATL 채팅 . 또한, 여기 경우에 TIO 링크는 당신이 문제가)

설명

lY2     % Push an array of characters to the stack: 'AB...Z'
t!      % Duplicate and transpose
2$X>    % Take the element-wise maximum between these two (with expansion)
c       % Explicitly convert back to characters
        % Implicitly display the result.

파이썬 2, 76 70 68 바이트

a=range(65,91)
i=0
for c in a:a[:i]=[c]*i;i+=1;print'%c'*26%tuple(a)

연결된 질문에 대한 나의 대답 과 매우 유사합니다 .

@xnor 덕분에 2 바이트를 절약했습니다!

옥타브, 26 바이트

disp([max(L=65:90,L'),''])

ideone에서 샘플 실행 .

05AB1E , 9 바이트

암호:

AAv¬N×?=¦

설명:

AA         # Push the alphabet twice.
  v        # For each in the alphabet.
   ¬       # Get the first character and
    N×     # multiply by the iteration variable.
      ?    # Pop and print.
       =   # Print the initial alphabet without popping.
        ¦  # Remove the first character of the initial alphabet and repeat.

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오! .

자바 스크립트 ES6, 81 바이트

x=>[...a='ABCDEFGHIJKLMNOPQRSTUVWXYZ'].map((x,y)=>x.repeat(y)+a.slice(y)).join`
`

자명하다.

R, 56 바이트

댓글을 달 수있는 담당자는 없지만 @plannapus 답변 은 다음과 같이 약간 다운 될 수 있습니다.

for(i in 1:26)cat({L=LETTERS;L[1:i]=L[i];L},"\n",sep="")

같은 결과가 나옵니다 :

ABCDEFGHIJKLMNOPQRSTUVWXYZ
BBCDEFGHIJKLMNOPQRSTUVWXYZ
CCCDEFGHIJKLMNOPQRSTUVWXYZ
DDDDEFGHIJKLMNOPQRSTUVWXYZ
EEEEEFGHIJKLMNOPQRSTUVWXYZ
FFFFFFGHIJKLMNOPQRSTUVWXYZ
GGGGGGGHIJKLMNOPQRSTUVWXYZ
HHHHHHHHIJKLMNOPQRSTUVWXYZ
IIIIIIIIIJKLMNOPQRSTUVWXYZ
JJJJJJJJJJKLMNOPQRSTUVWXYZ
KKKKKKKKKKKLMNOPQRSTUVWXYZ
LLLLLLLLLLLLMNOPQRSTUVWXYZ
MMMMMMMMMMMMMNOPQRSTUVWXYZ
NNNNNNNNNNNNNNOPQRSTUVWXYZ
OOOOOOOOOOOOOOOPQRSTUVWXYZ
PPPPPPPPPPPPPPPPQRSTUVWXYZ
QQQQQQQQQQQQQQQQQRSTUVWXYZ
RRRRRRRRRRRRRRRRRRSTUVWXYZ
SSSSSSSSSSSSSSSSSSSTUVWXYZ
TTTTTTTTTTTTTTTTTTTTUVWXYZ
UUUUUUUUUUUUUUUUUUUUUVWXYZ
VVVVVVVVVVVVVVVVVVVVVVWXYZ
WWWWWWWWWWWWWWWWWWWWWWWXYZ
XXXXXXXXXXXXXXXXXXXXXXXXYZ
YYYYYYYYYYYYYYYYYYYYYYYYYZ
ZZZZZZZZZZZZZZZZZZZZZZZZZZ

비록 행렬로서의 응답이 허용된다면 ( 즉 , 여기처럼 ), 우리는 49 바이트를 할 수 있습니다 :

sapply(1:26,function(l){L=LETTERS;L[1:l]=L[l];L})

R , 42 41 바이트

write(outer(L<-LETTERS,L,pmax),'',26,,'')

온라인으로 사용해보십시오!

다음 짧은 R의 대답은 너무 오래 그것을 선으로 라인을 출력하기 때문에 여전히 비트입니다. 나는이 일을 위해 가능한 한 오늘 아침 또 다른 질문에 대해 생각하고 훨씬 짧은 접근 방식을 실현 : 나는 한 번에 모두 사용하여 매트릭스를 생성 outer하고 pmax(병렬 최대를) 다음과 함께 한 번에 (*)를 인쇄 write.

(*) 기술적으로, 그 전치 행렬이지만, 대각선에 걸쳐 운 좋게 대칭입니다.

하스켈, 53 46 바이트

unlines[(i<$['B'..i])++[i..'Z']|i<-['A'..'Z']]

L- 파벳이 포함 된 단일 문자열을 반환합니다.

문자를 통해 이동 i에서 A에 Z와 목록 만들기 (length ['B'..i])의 사본 i다음을 [i..'Z']. 사이에 개행을 가진 요소를 결합하십시오.

파이썬 3, 71 65 바이트

-6 바이트에 대한 @LeakyNun 덕분에

r=range(26)
for i in r:print(''.join(chr(max(i,x)+65)for x in r))

STDOUT으로 인쇄하는 전체 프로그램.

작동 원리

문자 코드를 알파벳 문자에 0for에서 Ato 25로 할당합니다 Z. 프로그램은 반복 될 현재 문자와 반복 섹션의 길이 및 문자 색인을 결정 [0, 25]하는 라인 카운터 를 사용하여 간격 을 i반복합니다 x. 를 호출 max(i,x)하면 반복되는 문자 아래의 모든 문자가 동일한 문자 코드에 고정됩니다. 추가 65하고 호출 chr하면 결과 문자 코드가 해당 ASCII 문자로 변환됩니다. ''.join문자를 연결하고 각 줄은 STDOUT에 인쇄됩니다.

Ideone에서 사용해보십시오

𝔼𝕊𝕄𝕚𝕟, 12 자 / 15 바이트

ᶐⓢ⒨Ċ_+ᶐč_)ü⬬

Try it here (Chrome Canary only).

기본적으로 내 ES6 답변의 포트입니다.

R, 54 바이트

v=L=LETTERS;for(i in 2:26){L[1:i]=L[i];v=cbind(v,L)};v

이 솔루션은 R 내장 상수를 사용 LETTERS하여 대문자를 나열합니다. letters소문자에 대한 상수도 있습니다.

C, 78 70 67 바이트

f(i,j){for(;++i<27;puts(""))for(j=0;++j<27;putchar((i>j?i:j)+64));}

이 코드는 C에 대해 다음과 같은 골프 기술을 사용합니다.

• 생략은 기본 (등 포함 stdio.h)
• 함수 및 변수 유형을 생략 (반환)하여 기본값으로 설정 int
• if-else 블록 대신 삼항 연산자를 사용하십시오.
• 문자 표현 대신 문자의 ASCII 코드를 사용하십시오 (예 : 65대신 'A')
• putchar단일 문자를 출력하는 데 사용
• 학대의 주 논쟁 목록
• puts("")줄 바꿈을 출력하는 데 사용

또한 규칙 If it is a function, it must be runnable by only needing to add the function call to the bottom of the program.은 매개 변수를 사용하여 함수를 호출하는 것을 금지하지 않습니다 (ABcDexter 덕분에).

Ideone에서 사용해보십시오

ungolfed 버전 (gcc에 대한 경고 없음)은 다음과 같습니다.

#include <stdio.h>

#define MAX(x, y) (x>y ? x : y)

int main()
{
    for(int i=0; i<26; i++)
    {
        for(int j=0; j<26; j++)
            printf("%c", MAX(i, j) + 'A');
        printf("\n");
    }
    return 0;
}

체다, 90 바이트

(|>26).map(i->String.letters.chars.map((j,k,l)->k<i?l[i]:j).fuse).vfuse.slice(1)

즉 String.letters너무 깁니다 : /

.slice(1)선행 줄 바꿈이 허용되지 않기 때문에 추가해야했습니다.

설명

(|>26)       // Range from [0, 26)
.map(i->     // Loop through that range
 String.letters.chars // Alphabet array
  .map(               // Loop through alphabet
  (j,k,l) ->          // j = letter, j = index, l = alphabet
    k<i?l[i]:j        // Basically `l[max(k,i)]` 
  ).fuse     // Collapse the array
).vfuse      // Join on newlines

체다, 65 바이트 (비경쟁)

(|>26).map(i->String.letters.map((j,k,l)->k<i?l[i]:j).fuse).vfuse

야간 지점 과 함께 작동합니다 . 비경쟁 ... 슬픈 부분은 이미 변경 사항이 있다는 것입니다.