Tabula Recta를 인쇄하십시오!

Tabula Recta (때때로 'Vigenere Table'이라고도 함)는 Johannes Trithemius에 의해 만들어졌으며 Bellaso의 Vigenere 암호와 Trithemius 암호의 모든 변형을 포함하여 여러 암호에 사용되었습니다. 다음과 같이 보입니다 :

ABCDEFGHIJKLMNOPQRSTUVWXYZ
BCDEFGHIJKLMNOPQRSTUVWXYZA
CDEFGHIJKLMNOPQRSTUVWXYZAB
DEFGHIJKLMNOPQRSTUVWXYZABC
EFGHIJKLMNOPQRSTUVWXYZABCD
FGHIJKLMNOPQRSTUVWXYZABCDE
GHIJKLMNOPQRSTUVWXYZABCDEF
HIJKLMNOPQRSTUVWXYZABCDEFG
IJKLMNOPQRSTUVWXYZABCDEFGH
JKLMNOPQRSTUVWXYZABCDEFGHI
KLMNOPQRSTUVWXYZABCDEFGHIJ
LMNOPQRSTUVWXYZABCDEFGHIJK
MNOPQRSTUVWXYZABCDEFGHIJKL
NOPQRSTUVWXYZABCDEFGHIJKLM
OPQRSTUVWXYZABCDEFGHIJKLMN
PQRSTUVWXYZABCDEFGHIJKLMNO
QRSTUVWXYZABCDEFGHIJKLMNOP
RSTUVWXYZABCDEFGHIJKLMNOPQ
STUVWXYZABCDEFGHIJKLMNOPQR
TUVWXYZABCDEFGHIJKLMNOPQRS
UVWXYZABCDEFGHIJKLMNOPQRST
VWXYZABCDEFGHIJKLMNOPQRSTU
WXYZABCDEFGHIJKLMNOPQRSTUV
XYZABCDEFGHIJKLMNOPQRSTUVW
YZABCDEFGHIJKLMNOPQRSTUVWX
ZABCDEFGHIJKLMNOPQRSTUVWXY

나는 이것을 자주 필요로하지만 인터넷에서 복사하여 붙여 넣을 곳을 찾을 수 없습니다. 사각 테이블이 너무 오래, 그리고 빌어 먹을 걸리기 때문에 나이를 입력, 코드는 가능한 짧게해야합니다.

규칙 / 요구 사항

• 각 제출물은 전체 프로그램 또는 기능이어야합니다. 함수 인 경우 프로그램 맨 아래에 함수 호출을 추가하기 만하면 실행 가능해야합니다. 다른 것 (예 : 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 = 86986; // 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 = 53406; // 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>

05AB1E , 6 5 바이트

1 바이트를 절약 한 Downgoat 에게 감사드립니다 . 암호:

ADv=À

설명:

A      # Push the lowercase alphabet.
 D     # Duplicate it.
  v    # For each in the alphabet...
   =   #   Print without popping and with a newline.
    À  #   Rotate 1 to the left.

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

Vim, 25 23 바이트

:h<_↵jjYZZP25@='Ypx$p'↵

↵Return 키는 어디에 있습니까 ?

:h<_↵                       Open the help section v_b_<_example.
     jjY                    Copy the "abcdefghijklmnopqrstuvwxyz" line.
        ZZP                 Close this buffer and paste in ours.
           25@='     '↵     Run these commands 25 times:
                Yp          Duplicate line and move to column 1 of new line.
                  x         Cut the first character.
                   $p       Move to the end and paste.

편집 : 소문자는 괜찮으므로 두 개의 키를 저장할 수 있습니다.

파이썬 2, 59 57 53 바이트

a=range(65,91)*27
a[::-27]=[10]*26
print bytearray(a)

-4 바이트를위한 @xsot에 감사합니다!

/// , 220 바이트

/|/\/\///n/WXY|m/JKL|l/PQRS|k/CDEF|j/ZaNfV|i/MbAeI|h/TUcO|g/GHdB|f/OlTU|e/BkGH|d/ImMbA|c/VnZaN|b/NfVnZ|a/AeImM/ab
ed
kg
DEFgC
EFgCD
FgCDE
gk
HdBkG
de
mi
KLiJ
LiJK
im
ba
fc
lh
QRShP
RShPQ
ShPQR
hl
UcOlT
cf
nj
XYjW
YjWX
jn

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

이것은 놀랍게도 사소한 것이 아니며 그것이 최적인지에 대한 단서가 없습니다.

///에서 이와 같은 문제를 해결하는 유일한 방법은 공통 부분 문자열을 추출하는 것입니다. ( 내가 잘못 밝혀졌습니다. ) 그러나, 실제로 인해 바꿈에 전체 알파벳을 추출 할 수 없기 때문에 문자열 가장 추출해야 전혀 분명하지 않다 출력의 특성. 따라서 래핑 된 알파벳의 일부 하위 문자열을 추출해야하지만 하위 문자열을 만드는 시간과 선택한 문자열에 따라 상충 관계가 있습니다.

여기 내가 한 일이 있습니다. 이것은 주어진 문자열에서 길이가 최대 25까지 인 모든 하위 문자열을 찾고 각각에 대해 추출 할 바이트 수를 계산하는 CJam 스크립트 입니다. 기본적으로 N길이 M하위 문자열의 사본이있는 경우 하위 문자열을 저장 (N-1)*(M-1) - 5하면이 하위 문자열에는 슬래시가 포함되지 않습니다. 또한 기술적으로 이미 8 개의 하위 문자열을 추출하면 끝의 상수 오프셋이로 줄어 -4들지만 스크립트는이를 고려하지 않습니다.

어쨌든, 여기 내가 스크립트로 한 일이 있습니다.

• 현재 코드 (처음에는 출력)에 대해 스크립트를 실행하십시오.
• 가장 큰 개선을 가져 오는 부분 문자열 중에서 가장 짧은 부분을 선택하십시오. 여러 개가있는 경우 사전 식에서 가장 작은 것을 선택하십시오 (내가 알 수있는 것 중에서 주어진 입력에 대해 하위 문자열 간의 겹침을 줄입니다).
• 코드에서 선택한 부분 문자열을 모두 사용하지 않는 소문자로 바꿉니다.
• 선택한 문자 가 있고 부분 문자열 인 /x/ABC/코드 앞에 추가 하십시오 .xABC
• 저장할 문자열이 없을 때까지 반복하십시오.

마지막으로 결과 //를 대체 |하고 앞에 붙임 으로써 몇 바이트를 더 절약 할 수 있습니다 /|/\/\//( 서브 문자열을 추출하는 데 8 번째 서브 스트링 이후 5 바이트 대신 4 바이트 만 소요됨).

내가 말했듯이, 이것이 최적인지 여부는 알 수 없으며 다소 불규칙한 모양의 결과가 매우 흥미 롭습니다. 최적화되지 않은 (하지만 더 많은) 부분 문자열을 선택하면 더 짧은 솔루션을 얻을 수 있습니다. 이 문제의 복잡성 클래스가 무엇인지 궁금합니다.

C, 47 바이트

i;f(){for(i=702;i--;)putchar(i%27?90-i%26:10);}

Ideone에서 사용해보십시오

26 자마다 알파벳을 인쇄하지만 27 번째 문자마다 줄 바꿈으로 교체되는 단일 루프.

J, 15 바이트

u:65+26|+/~i.26

온라인 통역사 .

u:65+26|+/~i.26
           i.26  creates vector [0 1 2 ... 25]
        +/~      builds an addition table with itself
     26|         modulo 26 to every element
  65+            add 65 to every element
u:               convert every element from codepoint to character

/// , 128 바이트

/:/fABCDEFGHIJKLMNOPQRSTUVWXYZ
fbfbAfxf
xbA_xf_x
xfbbbAfbb//x/bff//f/\///b/\\: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:

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

L- phabet 문제에 대한 Jakube의 놀라운 답변 에서 영감을 얻은 결과 압축에 사용하는 것과는 대조적으로 ///의 실제 프로그래밍 에 손 을 대려고 노력 했습니다. 이것은 꽤 까다 로웠으며 네 번의 시도가 필요했지만 결국 압축 기반 솔루션 보다 훨씬 짧았습니다 .

설명

/// :의 빠른 입문서는 기본적으로 인터프리터는 문자별로 코드 문자를 읽고 다음을 수행합니다.

• \또는도 아닌 경우 /인쇄하십시오.
• 인 경우 \다음 문자를 인쇄하십시오.
• 이 경우 명령어 (동일한 이스케이프 규칙 포함)를 /구문 분석 하고 나머지 코드에서 /x/y/모두를 x로 대체하십시오 y.

Jakube에서 더 많은 영감을 얻어 단순성을 위해 4x4 버전을 설명하겠습니다.

/:/fABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbb//x/bff//f/\///b/\\:B:C:D:

우리 :는 두 번째와 세 번째 사이의 것들 로 대체하는 것으로 시작합니다 /. 이것은 후속 행을 회전시키는 코드가됩니다. 우리는 이것을 얻습니다 :

/x/bff//f/\///b/\\fABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbbBfABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbbCfABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbbDfABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbb

f, b그리고 x우리가 지금 확장합니다 일반적인 문자열, 단지 shorthands 있습니다. f슬래시를위한 것임은은 b백 슬래시위한 것으로는 x입니다 \//꽤 많이 올 일이있다. 그 이유는 내가 단일 문자 문자열에 대한 별칭을 사용하고 /그리고 \그들이 첫번째 대체 명령에서 탈출해야하는 거라고, 그래서 실제로 모든 백 슬래시를 필요로하지 않음으로써 바이트 꽤 많이 절약하고 있습니다. 여기에 우리가 후 무엇을 얻을 x, f과 b에서 작성되었습니다

ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\B/ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\C/ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\D/ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\

매우 읽기 쉽다.

따라서 첫 번째 줄은 그대로 인쇄됩니다. 그런 다음 모든 행을 회전시키는 펑키 부분에 도달합니다. 실제로 네 가지 명령으로 구성됩니다. 한가지주의 할 점은 A이 지시 사항 내에서 모든 발생을 피했다는 것입니다 . 그 이유 A는 명령 A내의을 나머지 행의 s 와 구별 할 수 있기 때문에 다르게 처리해야하기 때문입니다.

/\/\A/\//

이 일치 /A하고를로 바꾸고 /를 제거합니다 A. 이 하위 문자열은 각의 앞에만 나타나 ABCD므로 모든 후속 행의 첫 번째 문자가 삭제됩니다.

/
\//\A_\//

이것은 줄 바꿈과 슬래시가 일치하고이를로 바꿉니다 A_/. 따라서 A각 줄의 끝에를 삽입 하여 회전을 완료하고 줄 바꿈을 밑줄로 바꿉니다.

/_\//
\//

일치 _/하고 줄 바꿈과 슬래시로 바꿉니다. 밑줄을 통해이 우회를 해야하는 이유는 문자열이 더 이상 일치하지 않을 때까지 /// 각 명령을 반복적으로 적용하기 때문입니다. 즉, 형식의 명령을 사용하지 않을 수 있음을 의미 , 그리고 대체이 후하기 때문에, 임의의 문자열을 항상 여전히 일치합니다. 특히 이것은 라인 피드 앞에 무언가를 삽입 할 수 없다는 것을 의미합니다. 프로세스에서 줄 바꿈을 교체하고이 교체를 실행 취소해야합니다./x/axb/xabx

/\\\A/\\B/

나머지 행 뒤의 명령이 다음 문자를 처리하도록 일치 \A하고이를로 바꿉니다 \B. 네 개의 명령어가 모두 처리 된 후 나머지 문자열은 다음과 같습니다.

BCDA
/\/\B/\///
\//\B_\///_\//
\///\\\B/\\C/BCDA
/\/\B/\///
\//\B_\///_\//
\///\\\B/\\D/BCDA
/\/\B/\///
\//\B_\///_\//
\///\\\B/\\

이제 첫 번째 회전 된 행이 인쇄되고 다음 명령 세트가 나머지 셀을 다른 셀 등으로 회전시킵니다. 마지막 회전 후에 무시할 수있는 몇 가지 명령이 더 있고 불완전한 명령으로 끝납니다.

/\\\B/\\

끝의 불완전한 명령은 단순히 무시되고 프로그램이 종료됩니다.

젤리 , 7 바이트

ØAṙJṢj⁷

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

작동 원리

ØAṙJṢj⁷  Main link. No arguments.

ØA       Set argument and return value to "ABCDEFGHIJKLMNOPQRSTUVWXYZ".
   J     Yield the indices of the argument, i.e., [1, ..., 26].
  ṙ      Rotate the alphabet 1, ..., 26 units to the left.
         This generates all rotations, but not in the correct order.
    Ṣ    Sort the rotated alphabets.
     j⁷  Join, separating by linefeeds.

이맥스, 47 바이트

abcdefghijklmnopqrstuvwxyz^M
^P
<F3>
^K ^K ^Y ^Y
^P
^<space> ^F ^W ^E ^Y ^A
<F4>
^U 2 4 F4

어디 ^P "Control P"등을 의미합니다. F3 및 F4 키에는 두 개의 ASCII 바이트가 필요하므로 47 바이트입니다.

시작 입력을 입력 한 후에는 행을 복제하고 첫 번째 문자를 끝으로 이동하는 키보드 매크로를 정의합니다. 그런 다음 매크로를 24 번 더 실행합니다.

자바 스크립트 (ES6), 56 바이트

_=>"ABCDEFGHIJKLMNOPQRSTUVWXYZ".replace(/./g,"$&$'$`\n")

예, 맞습니다. 내 코드의 절반은 알파벳 문자열 리터럴입니다. 리터럴없이 할 수있는 최선은 81 바이트입니다.

_=>[...Array(26)].map((_,i,a)=>a.map(_=>(i++%26+10).toString(36)).join``).join`
`

함수가 아닌 프로그램을 원하면 10 바이트의 비용으로 _=>와 랩 을 제거하십시오 console.log().

Mathematica 68 61 바이트

Column[""<>RotateLeft["A"~CharacterRange~"Z",#]&/@0~Range~25]

덕분에 ...

@MartinEnder (7 바이트)

파이썬 2, 75 65 61 58 바이트

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

을 사용하여 알파벳을 map(chr,range(65,91))가져온 다음 문자열 이동 연산을 수동으로 적용합니다.

-4 바이트에 대한 @LeakyNun 및 @TheBikingViking 덕분에!

-3 바이트의 @xnor에게 감사합니다!

C, 88 64 바이트

f()논증없이 부르십시오 .

f(i,j){for(i=j=0;i<26;putchar(j==26?j=0,i++,10:65+(i+j++)%26));}

ideone에서 사용해보십시오 .

Piet , 247 바이트 / 190 코덱

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

그래서,이 내가 예상했던 것보다 훨씬 더 오래 가고, 나는 더 효율적 (더 스택 친화적 인) 다른 접근 일부에 대한 몇 가지 아이디어를 가지고,하지만 난 마지막 작업 댕 일을 가지고 (그리고 통역의 버그를 수정 및 IDE 기능을 추가 함께 방법), 그래서 여기 있습니다. 가장 바이트 효율적인 언어는 아니지만 많은 재미가 있습니다. 여기 더 큰 시야와 촬영 경로가 표시됩니다. 내 GitHub의 역사 .

스택 기반 언어로서 설명하기에는 너무 복잡하지만 다양한 섹션 / 루프의 기본 개요는 다음과 같습니다. Piet에는 변수 나 함수가 없으므로 모든 변수와 함수 이름은 설명을위한 것입니다.

• 초기화 (왼쪽)는 : 시작 line_counter(27), 부하에서 '@'로 cur_letter설정,letter_count 27
• 메인 루프 (진한 자주색에서 시작, 중앙 상단)
  • 감소 letter_counter
  • 지점 reset_lineif zero로 (라이트 시안 2 블록)
  • 롤 cur_letter스택 맨 위로
  • 지점 check_doneif로cur_letter > 'X' (틸 / 레드 블록, 오른쪽)
  • 증분 cur_letter 및 출력 (오른쪽 아래 모서리)
  • 지점 reset_letterif로cur_letter > 'Y' (연한 녹색 블록, 왼쪽)
  • `letter_counter_를 롤의 맨 위로, 루프의 맨 위로 롤백
• reset_line 지점 (큰 분홍색 사각형) :
  • 개행 문자를 출력합니다
  • letter_count27으로 재설정
  • 메인 루프의 맨 위로 계속
• check_done 지점 (오른쪽 절반)
  • line_counter맨 위로 롤
  • 0 인 경우 종료되는 분기
  • line_counter스택의 맨 아래로 감소 및 롤백
  • 중단 된 위치로 재개, 편지 인쇄
• reset_line 분기 (왼쪽, 녹색 블록) :
  • cur_letter'@'으로 재설정
  • 중단 된 지점에서 다시 시작, 롤링 / 루프 맨 위로 복귀

MATL , 8 바이트

덕분에와 @Dennis , 제안 MATL이 모듈 색인을 포함해야하고, 할 수 있다는 @Suever 했다, 아이디어 자동 페어 작업을.

1Y2t&+Q)

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

1Y2    % Predefined literal: string 'AB...Z'
t      % Push another copy of it
&+     % 2D array with all pairwise additions of ASCII code points from that string.
       % Gives the 26×26 array [130 131... 155; 131 132... 146; ...; 155 156... 180] 
Q      % Add 1 to each element. First entry is now 131, etc
)      % Index into string 'AB...Z'. Since it has length 26 and MATL uses modular
       % indexing, 131 is the first entry (character 'A'), etc. Implicitly display

자바 스크립트, 113 96 91 76 바이트

콘솔에서 실행하기위한 초단기 버전 :

l="ZABCDEFGHIJKLMNOPQRSTUVWXY";for(C=26;C--;console.log(l=l.slice(1)+l[0]));

자바 / HTML, 140 123 118 105 바이트

OP를보다 쉽게 ​​복사하고 붙여 넣을 수있는 HTML 출력이있는 더 예쁜 버전 :

<script>l="ABCDEFGHIJKLMNOPQRSTUVWXYZ";for(C=26;C--;document.write(l+"<br>"),l=l.slice(1)+l[0]);</script>

(편집 : 문자열 AZ를 생성하는 대신 방금 사용해야했습니다)

(편집 2 : 입력에 @Neil 및 @DanTheMan 덕분에 (댓글 참조))

PowerShell, 44 바이트

-1..24|%{-join[char[]](65..90)[($_-25)..$_]}

R, 47 42 41 바이트

write(rep(LETTERS,27)[-27*1:26],1,26,,'') 

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

알파벳 27 개를 생성하고 27 번째 글자를 제거하고 26 열로 인쇄합니다.

@Giuseppe 의 솔루션에서 영감을 얻은 개선 .

Sesos , 27 25 바이트

0000000: 685902 ae7b33 764992 c45d9b 397360 8fef1f 7bca72  hY..{3vI..].9s`...{.r
0000015: 3adc33 07

온라인으로 사용해보십시오! 확인 디버그를 생성 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
        put, fwd 1
    jnz
    rwd 27
    jmp
        put, fwd 1
    jnz
    add 10, put, get, fwd 1
    jmp
        rwd 1, add 1, fwd 1, sub 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 인 셀을 찾을 때까지이 단계를 반복합니다 . 인쇄 후 ABCDEFGHIJKLMNOPQRSTUVWXYZ테이프는 다음과 같이 보입니다.

                                                                                v
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

이제 데이터 헤드 27 단위를 왼쪽 ( 앞으로 0으로 )으로 이동하고 값이 0 인 셀을 찾을 때까지 인쇄 이동 조합을 반복합니다 . 이것은 아무것도 인쇄하지 않고 다음과 같이 테이프를 떠납니다.

v
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

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

그런 다음 셀의 내용을 오른쪽으로 현재 셀로 이동 한 다음 데이터 헤드를 단위로 오른쪽으로 이동합니다.

      v
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

다음 반복은 약간 다릅니다. 첫 번째 인쇄 단계는 BCDEFGHIJKLMNOPQRSTUVWXYZ다음과 같이 테이프를 남기고 인쇄 합니다.

                                                                                v
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

이제 데이터 헤드를 27 단위 왼쪽으로 움직 입니다.

 v
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

후속 인쇄 루프는 A다음과 같이 테이프를 인쇄 하고 떠납니다.

   v
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

다시 한 번, 줄 바꿈을 인쇄하고 셀의 내용을 오른쪽으로 현재 셀로 이동 한 다음 데이터 헤드를 단위로 오른쪽으로 이동합니다.

         v
65 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 번 더 반복 한 후 데이터 헤드를 오른쪽으로 이동하는 마지막 단계는 테이프를 다음 상태로 둡니다.

                                                                                v
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 이며 프로그램이 종료됩니다.

^† TIO는 최신 버전의 Sesos를 사용합니다.이 버전은 SASM과 이전 버전과 호환되지만 더 짧은 SBIN 코드를 생성합니다.

하스켈, 56 53 52 바이트

mapM(\x->putStrLn$init$[x..'Z']++['A'..x])['A'..'Z']

동일한 길이 : (@AndersKaseorg의 제안 사용)

a=['A'..'Z']
mapM putStrLn[take 26$[x..'Z']++a|x<-a]

chr 함수를 얻기 위해 Data.Char를 가져와야하는 모듈 식 작업을 수행하려면 74 59 58 바이트가 가장 좋았습니다. (toEnum 함수를 제안한 @nimi 덕분에)

a=[0..25]
mapM(\x->putStrLn[toEnum$65+(x+y)`mod`26|y<-a])a

이것은 아마도 훨씬 짧을 수 있지만, Haskell 골프 트릭을 모른다.

mapM_ 대신 mapM을 사용했습니다 (@Lynn의 의견 참조)

R, 53 바이트

for(i in 1:26)cat(LETTERS[c(i:26,1:i-1)],"\n",sep="")

여기는 온라인 통역사에 있습니다.

레티 나, 36 31 바이트

Martin Ender 덕분에 5 바이트.

지
{2`
$`
} T01`L`_L
\`.
$ & $ '$`¶

선행 줄 바꿈이 중요합니다.

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

크레딧 .

Brain-Flak , 222 바이트

(((()()()()){})<(((({}){}){}){})>)((((([[]]{}){}()){}))<>()){<>({}<>)<>{({}<(({}()))>[()])}{}<>([({})]<>{})<>(({}<>))<>({}[()])}{}<>(({}<>))<>{}{}{}<>{({}<(({}())[()]<{({}<<>({}<>)>[()])}{}{}((()()()()()){})>)>[()])}{}{}{}

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

나는 Brain-Flak을 처음 사용하므로 골프를 많이 할 수는 있지만 적어도 첫 번째 시도입니다. 왼쪽 스택에 27 개의 전체 알파벳을 저장 한 다음 알파벳을 오른쪽으로 이동하고 모든 27 번째 문자를 줄 바꿈으로 바꿉니다.

내 소스 코드는 약간 혼란 스럽지만 그럼에도 추가 할 것입니다.

(((()()()()){})
    park 8 in third
    <(((({}){}){}){})> push 64
)
((((([[]]{}){}()){}))<>()) push 26 twice on left and 27 on right
left stack: 64 letter, 26 letter count, 26 constant
right stack: 27 alphabet count
{ while alphabet count
    <>
    ({}<>)<> push 26 back to right
    { while counter
        (
            {} park counter in third
                <(({}()))> add next letter to stack
            [()] decrement counter
        )
    }
    {} pop 0 counter
    <>([({})]<>{}) set Z back to A-1
    <>(({}<>)) move 26 twice from right to left
    <> go to right stack
    ({}[()]) decrement counter
}
{} pop 0
<>(({}<>)) push 26 twice on right stack
<>{}{}{} pop counter, @ and Z from left stack
<> go to right stack
{ while alphabet count
    (
        {} save alphabet count on third stack
        <(
            ({}())[()] save constant on third stack and push lettercount 26 + 1 for lf
            <
                {   while lettercount
                    (
                        {} save lettercount on third stack
                        <
                            <>({}<>) pull letter from left to right
                        > 
                        [()] decrement lettercount
                    )
                }
                {} pop 0
                {} pop last letter
                ((()()()()()){}) push lf
            >
        )>
        [()] decrement alphabet count
    )
}
{}{}{} pop alphabet count, constant and lf

V , 36 , 10 바이트

¬AZ25ñÙx$p

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

이것은 "Latin1"인코딩을 사용합니다.

설명:

¬AZ         " Insert the alphabet
   25ñ      " 25 times...
      Ù     "   Duplicate this line
       x    "   Cut the first character
        $p  "   Move to the end of the line and past the character we just cut

C #, 98 바이트

문자열로 초기화하는 것보다 짧은 문자를 생성 할 수 있는지 확인하려고했지만 실제로는 불가능합니다. 문자는 26 바이트이며이 스 니펫 만

for(char a='A';a<'[';a++)

25 바이트입니다. 나는 그것들을 초기화하고 a + = a로 추가하는 것이 좋은 해결책이라고 생각하지만 C #에서는 Substring()and와 같은 함수의 바이트 수에 의해 제한됩니다 Console.WriteLine().

98 바이트에서의 나의 시도 :

var a="ABCDEFGHIJKLMNOPQRSTUVWXYZ";a+=a;for(int i=0;i<26;i++)Console.WriteLine(a.Substring(i,26));

옥타브, 27 바이트

우리는 행과 열 벡터를 추가하고 Octave는 필요없이 (글 라브 랩에서 필요한 것처럼) sigleton 치수를 멋지게 확장합니다 bsxfun.

[mod((v=0:25)+v',26)+65,'']

q, 20 바이트

(til 26)rotate\:.Q.A

자바 190 176 172 163 바이트

class C{public static void main(String[] a){int s=0;while(s<26){p(s,26);p(0,s++);p(-1,0);}}static void p(int s,int e){for(;s<e;s++)System.out.write(s<0?10:65+s);}}

배쉬, 66 바이트

A=`printf %c {A..Z}`
for i in {0..25};do echo ${A:$i}${A::$i};done

에서 전체 알파벳을 A만든 다음 문자를 시작하고 n그 이전 위치를 추가하여 26 개의 회전 된 버전을 인쇄 n합니다.

펄, 42 바이트

이것에 대한 @Dom Hastings의 완전한 신용.

@l=A..Z;say@l[$_..25],@l[0..$_-1]for 0..25  

또는 (같은 바이트 수) :

$_=join"",A..Z;eval'say;/./;$_=$\'.$&;'x26

예를 들어 필요 -M5.010또는 -E실행

perl -E '@l=A..Z;say@l[$_..25],@l[0..$_-1]for 0..25'

내 옛 대답 (55 바이트) :

@t=A..Z;for$i(0..25){print$t[($_+$i)%26]for 0..25;say}

-M5.010실행 해야 합니다. 따라서 다음을 실행하십시오.

perl -M5.010 -e '@t=A..Z;for$i(0..25){print$t[($_+$i)%26]for 0..25;say}'  

그래도 더 짧을 수는 있지만 방법을 찾지 못했습니다 ... 아직