Wydrukuj Tabula Recta!

Tabula Recta (czasami nazywana „tabelą Vigenere”) została stworzona przez Johannesa Trithemiusa i została użyta w kilku szyfrach, w tym we wszystkich wariantach szyfru Vigenere Bellaso i szyfru Trithemius. To wygląda tak:

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

Często tego potrzebuję, ale nie mogę go znaleźć w Internecie, aby skopiować i wkleić. Ponieważ kwadratowy stół jest tak długi i zajmuje dużo lat, aby napisać , Twój kod musi być jak najkrótszy.

Zasady / wymagania

• Każde zgłoszenie powinno być pełnym programem lub funkcją. Jeśli jest to funkcja, musi być uruchomiona, wystarczy dodać wywołanie funkcji na dole programu. Wszystko inne (np. Nagłówki w C) musi zostać uwzględnione.
• Jeśli to możliwe, podaj link do strony, na której można przetestować Twój program.
• Twój program nie może nic pisać STDERR.
• Standardowe luki są zabronione.
• Twój program może wysyłać dane w każdym przypadku, ale musi zostać wydrukowany (nie tablica lub podobny).

Punktacja

Programy są oceniane według bajtów, domyślnie w UTF-8 lub według innego zestawu znaków.

W końcu wygra odpowiedź z najmniejszą liczbą bajtów.

Zgłoszenia

Aby upewnić się, że twoja odpowiedź się pojawi, zacznij od nagłówka, korzystając z następującego szablonu Markdown:

# Language Name, N bytes

gdzie Njest rozmiar twojego zgłoszenia. Jeśli poprawić swój wynik, to może zachować stare porachunki w nagłówku, uderzając je przez. Na przykład:

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

Jeśli chcesz umieścić w nagłówku wiele liczb (np. Ponieważ twój wynik jest sumą dwóch plików lub chcesz osobno wymienić kary za flagi tłumacza), upewnij się, że rzeczywisty wynik jest ostatnią liczbą w nagłówku:

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

Możesz także ustawić nazwę języka jako link, który pojawi się we fragmencie tabeli wyników:

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

Tabela liderów

Oto fragment kodu, który pozwala wygenerować zarówno zwykłą tabelę wyników, jak i przegląd zwycięzców według języka.

/* 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 bajtów

Dzięki Downgoat za oszczędność 1 bajtu. Kod:

ADv=À

Wyjaśnienie:

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.

Wykorzystuje kodowanie CP-1252 . Wypróbuj online! .

Vim, 25 23 bajtów

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

Gdzie ↵jest klawisz 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.

EDYCJA : małe litery są w porządku, więc mogę zapisać dwa klucze.

Python 2, 59 57 53 bajtów

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

Dzięki @xsot za -4 bajty!

/// , 220 bajtów

/|/\/\///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

Wypróbuj online!

Było to zaskakująco nietrywialne i nie mam pojęcia, czy jest optymalne.

Jedynym sposobem na rozwiązanie tego problemu w /// jest wyodrębnienie typowych podciągów. ( Okazuje się, że się myliłem. ) Jednak ze względu na charakter wyniku nie jest wcale jasne, które podciągi powinny być najlepiej wyodrębnione, ponieważ nie można wyodrębnić całego alfabetu z powodu przełamania linii. Musisz więc wyodrębnić niektóre podciągi z zawiniętego alfabetu, ale są też kompromisy pod względem tego, jak długo tworzysz podciągi i które wybierasz.

Oto co zrobiłem. Jest to skrypt CJam, który wyszukuje wszystkie podciągi o długości do 25 w danym ciągu i dla każdego z nich oblicza, ile bajtów zaoszczędziłoby jego wyodrębnianie. Zasadniczo, jeśli istnieją Nkopie Mpodłańcucha o długości , można zapisać (N-1)*(M-1) - 5podciągi, te podciągi nie zawierają ukośników. Ponadto, technicznie rzecz biorąc, kiedy już wyodrębniłeś około 8 podciągów, stałe przesunięcie na końcu zmniejsza się do -4, ale skrypt tego nie bierze pod uwagę.

W każdym razie oto, co zrobiłem ze skryptem:

• Uruchom skrypt dla bieżącego kodu (który początkowo jest tylko wyjściem).
• Spośród podłoży, które zapewniają największą poprawę, wybierz najkrótszą. Jeśli jest ich kilka, wybierz najmniejszy leksykograficznie (z tego, co mogę powiedzieć, dla danego wejścia zmniejsza to nakładanie się podłańcuchów).
• Zamień wszystkie wystąpienia wybranego podciągu w kodzie na nieużywaną małą literę.
• Wstaw /x/ABC/do kodu, w którym xjest wybrana litera i ABCpodłańcuch.
• Powtarzaj, aż nie pozostaną żadne podciągi, które by cokolwiek zapisały.

Na koniec, możemy zaoszczędzić kilka bajtów więcej zastępując wynikające //z |i poprzedzenie /|/\/\//(dlatego wydobywania podciągi kosztuje tylko 4 zamiast 5 bajty po 8 podciągu lub tak).

Tak jak powiedziałem, nie mam pojęcia, czy jest to optymalne i dość nieregularnie wyglądający wynik wydaje mi się bardzo interesujący. Może być możliwe uzyskanie krótszego rozwiązania poprzez wybranie nieoptymalnych (ale więcej) podciągów gdzieś poniżej linii. Zastanawiam się, jaka jest klasa złożoności tego problemu ...

C, 47 bajtów

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

Wypróbuj na Ideone

Pojedyncza pętla drukująca alfabet co 26 znaków, ale co 27 ​​znak zastępowany jest nową linią.

J, 15 bajtów

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

Tłumacz online .

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 bajtów

/:/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:

Wypróbuj online!

Zainspirowany niesamowitą odpowiedzią Jakube'a na wyzwanie związane z literami L, pomyślałem, że spróbuję również swoich sił w programowaniu w ///, zamiast używać go do kompresji. Było to dość trudne i potrzebowałem czterech prób, ale ostatecznie okazało się, że jest znacznie krótsze niż moje rozwiązanie oparte na kompresji .

Wyjaśnienie

Szybki start na ///: w zasadzie interpreter po prostu odczytuje kod znak po znaku i wykonuje następujące czynności:

• Jeśli nie jest to \ani a /, wydrukuj go.
• Jeśli tak \, wydrukuj następny znak.
• Jeśli jest to /, przeanalizuj /x/y/instrukcję (z tymi samymi regułami zmiany znaczenia) i kilkakrotnie zamień wszystko xw pozostałym kodzie na y.

Biorąc trochę inspiracji z Jakube, dla uproszczenia wyjaśnię po prostu wersję 4x4 tego:

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

Zaczynamy od zastąpienia tych :rzeczy między drugim a trzecim /. Skończy się to kodem, który obraca kolejne rzędy. Otrzymujemy to:

/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, bI xto tylko skróty dla typowych ciągów, które będziemy rozszerzać teraz. To fjest dla ukośników, bjest dla ukośników odwrotnych i xdla \//których zdarza się dość często. Powodem, dla którego używam aliasów dla podłańcuchów jednoznakowych /i \jest to, że musiałyby one być poprzedzone znakami ucieczki w pierwszej instrukcji podstawiania, więc w rzeczywistości oszczędzam sporo bajtów, nie potrzebując tych wszystkich odwrotnych ukośników. Oto co otrzymujemy po x, fi bzostały wypełnione:

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

Bardzo czytelny.

Więc pierwszy wiersz jest drukowany dosłownie. Następnie dochodzimy do funky, która obraca wszystkie kolejne rzędy. W rzeczywistości składa się z czterech różnych instrukcji. Należy zauważyć, że uniknąłem wszystkich wystąpień Aw tych instrukcjach. Powodem tego jest to, że pozwala mi odróżnić As wewnątrz instrukcji od As w pozostałych wierszach, które muszą być przetwarzane inaczej.

/\/\A/\//

To dopasowuje /Ai zastępuje go /, usuwając A. Zauważ, że ten podciąg pojawia się tylko z przodu każdego ABCD, więc upuszcza pierwszy znak wszystkich kolejnych wierszy:

/
\//\A_\//

Odpowiada to wysuwowi wiersza, po którym następuje ukośnik i zastępuje go A_/. To wstawia znak Ana końcu każdej linii, kończąc obrót, a także zamienia linię na podkreślenie.

/_\//
\//

To dopasowuje _/i zastępuje go wierszem, a następnie ukośnikiem. Powodem, dla którego muszę zrobić ten objazd przez podkreślenie, jest fakt, że /// stosuje każdą instrukcję wielokrotnie, dopóki łańcuch nie będzie już pasował. Oznacza to, że nigdy nie można używać instrukcji w formie /x/axb/gdzie x, ai bsą dowolne ciągi znaków, bo po podstawienie xzawsze będzie wciąż takie same. W szczególności oznacza to, że nie możemy po prostu wstawić czegoś przed linią. Musimy w tym procesie wymienić wysuw linii i cofnąć tę zamianę.

/\\\A/\\B/

To dopasowuje \Ai zastępuje go \B, dzięki czemu instrukcje po pozostałych wierszach przetwarzają następny znak. Po przetworzeniu wszystkich czterech instrukcji pozostały ciąg wygląda następująco:

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

Tak więc teraz drukowany jest pierwszy obrócony rząd, a następnie następny zestaw instrukcji obraca pozostałe rzędy o inną komórkę i tak dalej. Po ostatnim obrocie mamy jeszcze kilka instrukcji, które możemy zignorować, a następnie kończymy niepełną instrukcją:

/\\\B/\\

Niekompletne instrukcje na końcu są po prostu ignorowane i program się kończy.

Galaretka , 7 bajtów

ØAṙJṢj⁷

Wypróbuj online!

Jak to działa

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

Emacs, 47 bajtów

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

Gdzie ^Poznacza „Control P” itp. To 47 bajtów, ponieważ klawisze F3 i F4 wymagają dwóch bajtów ASCII.

Po wprowadzeniu danych wejściowych definiuje makro klawiatury, które powiela linię i przenosi pierwszy znak na koniec. Następnie uruchamia makro kolejne 24 razy.

JavaScript (ES6), 56 bajtów

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

Tak, zgadza się, połowa mojego kodu to literał ciąg alfabetu. Najlepsze, co mogę zrobić bez literału, to 81 bajtów:

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

Jeśli chcesz program, a nie funkcję, usuń _=>i owiń console.log()za 10 bajtów.

Mathematica 68 61 bajtów

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

Dzięki...

@MartinEnder (7 bajtów)

Python 2, 75 65 61 58 bajtów

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

Pobiera alfabet map(chr,range(65,91)), a następnie ręcznie stosuje operację przesunięcia łańcucha.

Dzięki @LeakyNun i @TheBikingViking za -4 bajty!

Dzięki @xnor za -3 bajty!

C, 88 64 bajtów

Zadzwoń f()bez argumentów.

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

Wypróbuj na ideone .

Piet , 247 bajtów / 190 kodów

Wypróbuj online!

Trwało to znacznie dłużej, niż się spodziewałem, i mam kilka pomysłów na inne, bardziej wydajne (bardziej przyjazne dla stosów) podejścia, ale w końcu udało mi się zadziałać (poprawiłem błąd interpretera i dodałem funkcje IDE wzdłuż sposób), więc oto jest. Nie jest to najbardziej wydajny bajtowo język, ale jest naprawdę świetna zabawa. Oto większy widok i ślad pokazujący wybraną ścieżkę. Historia na moim GitHubie .

Jako język oparty na stosie jest zbyt skomplikowany, by go krótko wyjaśniać, ale oto podstawowy przegląd tego, co robią różne sekcje / pętle. Wszystkie nazwy zmiennych i funkcji służą wyłącznie wyjaśnieniu, ponieważ w Piet nie ma żadnych zmiennych ani funkcji.

• Inicjalizacja (lewy górny róg): zaczyna się line_counterod 27, ładuje „@” as cur_letter, ustawia letter_countna 27
• Pętla główna (od ciemnego fioletu, środkowa góra)
  • Ubytki letter_counter
  • Rozgałęzia się do reset_linezera (jasnobłękitny 2-blokowy)
  • Rzutuje cur_letterna szczyt stosu
  • Gałęzie do check_doneif cur_letter > 'X'(turkusowy / czerwony blok, prawa strona)
  • Przyrosty cur_letteri wyjścia (prawy dolny róg)
  • Gałęzie do reset_letterif cur_letter > 'Y'(jasnozielony blok, po lewej)
  • Zrzuca `letter_counter_ z powrotem na górę stosu, z powrotem na górę pętli
• reset_line gałąź (duży różowy kwadrat):
  • Wyświetla znak nowej linii
  • Resetuje letter_countdo 27
  • Kontynuuje powrót do początku głównej pętli
• check_done gałąź (prawa połowa wewnątrz)
  • Rolls line_counterto top
  • Oddziały kończą się, jeśli zero
  • Zmniejsza line_counteri przewraca z powrotem na dół stosu
  • Wznawia od miejsca, w którym zostało przerwane, drukuje list
• reset_line gałąź (lewa strona, zielony blok):
  • Resetuje się cur_letterdo „@”
  • Wznawia od miejsca, w którym zostało przerwane, przewijanie / powrót do początku pętli

MATL , 8 bajtów

Z podziękowaniami @Dennis , który zasugerował, że MATL powinien obejmować modułowe indeksowanie, oraz @Suever , który wpadł na pomysł automatycznych operacji parowania.

1Y2t&+Q)

Wypróbuj online!

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

JavaScript, 113 96 91 76 bajtów

Super-krótka wersja do uruchamiania w konsoli:

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

JavaScript / HTML, 140 123 118 105 bajtów

Ładniejsza wersja z wyjściem HTML, który ułatwia OP kopiowanie i wklejanie:

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

(EDYCJA: Powinienem był po prostu użyć ciągu AZ zamiast go generować)

(EDYCJA 2: Podziękowania dla @Neil i @DanTheMan za ich wkład (patrz komentarze))

PowerShell, 44 bajty

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

R, 47 42 41 bajtów

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

Wypróbuj online!

Generuje 27 alfabetów, usuwa 27 liter i drukuje w 26 kolumnach.

Poprawa zainspirowany @Giuseppe „s rozwiązania .

Sesos , 27 25 bajtów

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

Wypróbuj online! Zaznacz opcję Debuguj, aby zobaczyć wygenerowany kod SBIN. ^†

Montaż Sesos

Powyższy plik binarny został wygenerowany przez skompletowanie następującego kodu 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)

Jak to działa

Zaczynamy od inicjalizacji taśmy ABCDEFGHIJKLMNOPQRSTUVWXYZ. Jest to następujące.

Napisz 26 do komórki, pozostawiając taśmę w następującym stanie.

                                                     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

Dopóki komórka pod głowicą danych jest niezerowa, wykonujemy następujące czynności.

Skopiuj liczbę do dwóch komórek po lewej stronie i dodaj 64 do kopii najbardziej po lewej stronie.

                                                   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

Przenieś kopię po lewej stronie do oryginalnej lokalizacji, a następnie odejmij 1 od kopii po prawej stronie.

                                                     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

Proces zatrzymuje się po 26 iteracjach, ponieważ prawostronna kopia wynosi do tego czasu 0 . Przesuwamy komórkę w prawo, więc końcowy stan taśmy po inicjalizacji jest następujący.

     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

Teraz jesteśmy gotowi wygenerować wynik, powtarzając następujący proces, aż komórka pod głowicą danych wyniesie zero.

Najpierw drukujemy znak pod głowicą danych i przechodzimy w prawo, powtarzając ten krok, aż do znalezienia komórki o wartości 0 . Po wydrukowaniu ABCDEFGHIJKLMNOPQRSTUVWXYZtaśma wygląda następująco.

                                                                                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

Teraz przesuwamy głowicę danych o 27 jednostek w lewo (z powrotem do początkowego 0 ) i powtarzamy kombinację print-move, aż do znalezienia komórki o wartości 0 . Nie drukuje nic i pozostawia taśmę w następujący sposób.

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

Teraz piszemy 10 do bieżącej komórki, wypisujemy odpowiedni znak (wysuw linii) i zerujemy komórkę, wywołując getpuste wejście, pozostawiając niezmienioną taśmę.

Następnie przenosimy zawartość komórki w prawo do bieżącej komórki, a następnie przesuwamy głowicę danych do jednostek w prawo.

      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

Kolejna iteracja jest nieco inna. Pierwszy krok drukowania zostanie wydrukowany BCDEFGHIJKLMNOPQRSTUVWXYZ, pozostawiając taśmę w następujący sposób.

                                                                                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

Teraz przesuwamy głowicę danych o 27 jednostek w lewo.

 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

Kolejna pętla drukująca drukuje Ai pozostawia taśmę w następujący sposób.

   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

Ponownie drukujemy wysuw linii, przesuwamy zawartość komórki w prawo do bieżącej komórki, a następnie przesuwamy głowicę danych do jednostek w prawo.

         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

Po 24 kolejnych iteracjach ostatni krok przesunięcia głowicy danych w prawo pozostawia taśmę w następującym stanie.

                                                                                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

Komórka pod głowicą danych ma teraz wartość 0 i program się kończy.

^† TIO używa nowszej wersji Sesos, która jest wstecznie kompatybilna z SASM, ale generuje krótszy kod SBIN.

Haskell, 56 53 52 bajtów

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

ta sama długość: (przy użyciu sugestii @AndersKaseorg)

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

aby robić rzeczy modułowe, musisz zaimportować dane.Char, aby uzyskać funkcję chr, 74 59 58 Bajtów było najlepsze, co mogłem z tym uzyskać: (dzięki @nimi za sugestię funkcji toEnum)

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

To może być prawdopodobnie krótsze, ale nie znam żadnych sztuczek golfowych Haskell.

użyłem mapM zamiast mapM_ (patrz komentarz @ Lynn)

R, 53 bajty

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

Tutaj jest na tłumacza online .

Siatkówka, 36 31 bajtów

5 bajtów dzięki Martinowi Enderowi.

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

Wiodące podawanie linii jest znaczące.

Wypróbuj online!

Kredyty .

Brain-Flak , 222 bajty

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

Wypróbuj online!

Jestem nowy w Brain-Flak, więc może to można dużo zagrać w golfa, ale przynajmniej to pierwsza próba. Przechowuje 27 pełnych alfabetów na lewym stosie, a następnie przesuwa alfabety w prawo i zamienia każdą 27 literę na nową linię.

Mój kod źródłowy jest nieco mylący, ale mimo to go dodam.

(((()()()()){})
    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 bajtów

¬AZ25ñÙx$p

Wypróbuj online!

Wykorzystuje to kodowanie „Latin1”.

Wyjaśnienie:

¬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 bajtów

Próbowałem sprawdzić, czy mogę wygenerować litery krótsze niż tylko inicjowanie ich jako łańcucha, ale tak naprawdę nie jest to możliwe. Litery mają 26 bajtów i sam ten fragment kodu

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

ma 25 bajtów. Myślę, że zainicjowanie ich, a następnie dodanie ich za pomocą + = a jest dobrym rozwiązaniem, ale w C # jesteś ograniczony liczbą bajtów funkcji takich jak Substring()i Console.WriteLine().

Moja próba na 98 bajtów:

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

Oktawa, 27 bajtów

Dodajemy wektor wiersza i kolumny, a Octave ładnie rozszerza wymiary sigleton, bez potrzeby bsxfun(tak jak w Matlabie).

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

q, 20 bajtów

(til 26)rotate\:.Q.A

Java, 190 176 172 163 bajtów

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

Bash, 66 bajtów

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

Tworzę pełny alfabet A, a następnie drukuję 26 jego obróconych wersji, biorąc znaki zaczynające się od ni dołączając poprzednie n.

Perl, 42 bajty

Pełny kredyt za @Dom Hastings za to.

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

Lub (ta sama liczba bajtów):

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

Potrzebuje -M5.010lub -Euruchomić, na przykład:

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

Moja stara odpowiedź (55 bajtów):

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

Musisz -M5.010biec. Więc uruchom z:

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

Prawdopodobnie można to zrobić krócej, ale nie dowiedziałem się, jak ... jeszcze