Cetak Tabula Recta!

Tabula Recta (kadang-kadang disebut 'Vigenere Table'), diciptakan oleh Johannes Trithemius, dan telah digunakan di beberapa cipher, termasuk semua varian cipher Vigenere Bellaso dan cipher Trithemius. Ini terlihat seperti ini:

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

Saya sering membutuhkan ini, tetapi tidak dapat menemukannya di mana pun di internet untuk menyalin dan menempel. Karena tabel persegi sangat panjang, dan perlu waktu lama untuk mengetik, kode Anda harus sesingkat mungkin.

Aturan / Persyaratan

• Setiap pengajuan harus berupa program atau fungsi lengkap. Jika itu adalah suatu fungsi, itu harus dapat dijalankan dengan hanya perlu menambahkan panggilan fungsi ke bagian bawah program. Hal lain (mis. Tajuk dalam C), harus dimasukkan.
• Jika memungkinkan, berikan tautan ke situs tempat program Anda dapat diuji.
• Program Anda tidak boleh menulis apa pun STDERR.
• Celah Standar dilarang.
• Program Anda dapat menampilkan dalam hal apa pun, tetapi harus dicetak (bukan array atau serupa).

Mencetak gol

Program-program dinilai berdasarkan byte, dalam UTF-8 secara default atau serangkaian karakter pilihan Anda.

Akhirnya, jawaban dengan byte terkecil akan menang.

Pengajuan

Untuk memastikan bahwa jawaban Anda muncul, silakan mulai jawaban Anda dengan tajuk utama, menggunakan templat Penurunan harga berikut:

# Language Name, N bytes

di mana Nukuran kiriman Anda. Jika Anda meningkatkan skor Anda, Anda bisa menyimpan skor lama di headline, dengan mencoretnya. Misalnya:

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

Jika Anda ingin memasukkan beberapa angka dalam tajuk Anda (mis. Karena skor Anda adalah jumlah dari dua file atau Anda ingin membuat daftar penalti penterjemah secara terpisah), pastikan bahwa skor aktual adalah angka terakhir di tajuk:

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

Anda juga dapat membuat tautan nama bahasa yang kemudian akan muncul di cuplikan papan peringkat:

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

Papan peringkat

Berikut ini adalah Stack Snippet untuk menghasilkan leaderboard biasa dan gambaran umum pemenang berdasarkan bahasa.

/* 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 byte

Terima kasih kepada Downgoat untuk menghemat 1 byte. Kode:

ADv=À

Penjelasan:

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.

Menggunakan pengkodean CP-1252 . Cobalah online! .

Vim, 25 23 byte

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

Di mana ↵tombol 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.

EDIT : huruf kecil tidak apa-apa, jadi saya bisa menyimpan dua tombol.

Python 2, 59 57 53 byte

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

Berkat @ xsot untuk -4 byte!

/// , 220 byte

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

Cobalah online!

Ini mengejutkan non-sepele dan saya tidak tahu apakah itu optimal.

Satu-satunya cara untuk mengatasi masalah seperti ini di /// adalah dengan mengekstraksi substring umum. ( Ternyata saya salah. ) Namun, karena sifat dari output itu sama sekali tidak jelas substring mana yang sebaiknya diekstraksi karena Anda tidak dapat benar-benar mengekstrak seluruh alfabet karena linebreak. Jadi, Anda perlu mengekstrak beberapa substring dari alfabet yang dibungkus, tetapi kemudian ada trade-off dalam hal berapa lama Anda membuat substring dan mana yang Anda pilih.

Jadi, inilah yang saya lakukan. Ini adalah skrip CJam yang menemukan semua substring hingga panjang 25 dalam string yang diberikan dan untuk masing-masing menghitung berapa byte byte yang akan disimpan. Pada dasarnya jika ada Nsalinan dari Msubstring panjang, Anda akan menyimpan (N-1)*(M-1) - 5substring, substring ini tidak mengandung garis miring. Juga, secara teknis, ketika Anda sudah mengekstraksi 8 substring atau lebih, offset konstan di akhir dikurangi menjadi -4, tetapi skrip tidak menganggap itu.

Bagaimanapun, inilah yang saya lakukan dengan skrip:

• Jalankan skrip terhadap kode saat ini (yang awalnya hanya keluaran).
• Keluar dari substring yang menghasilkan peningkatan terbesar, pilih yang terpendek. Jika ada beberapa, pilih leksikografis terkecil (dari apa yang saya tahu, untuk input yang diberikan ini mengurangi tumpang tindih antara substring).
• Ganti semua kemunculan substring yang dipilih dalam kode dengan huruf kecil yang tidak terpakai.
• Tambahkan /x/ABC/ke kode di mana xhuruf yang dipilih dan ABCadalah substring.
• Ulangi sampai tidak ada lagi substring yang akan menyimpan apa pun.

Pada akhirnya, kami menyimpan beberapa byte lagi dengan mengganti hasilnya //dengan |dan prepending /|/\/\//(inilah sebabnya mengekstraksi substring hanya memakan biaya 4 alih-alih 5 byte setelah substring ke-8 atau lebih).

Seperti yang saya katakan, saya tidak tahu apakah ini optimal dan saya menemukan hasil yang agak tidak teratur cukup menarik. Dimungkinkan untuk mendapatkan solusi yang lebih pendek dengan memilih substring yang tidak optimal (tetapi lebih) di suatu tempat di telepon. Saya ingin tahu apa kelas kompleksitas masalah ini ...

C, 47 byte

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

Cobalah di Ideone

Satu putaran, mencetak alfabet setiap 26 karakter tetapi dengan setiap 27 karakter digantikan oleh baris baru.

J, 15 byte

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

Penerjemah 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 byte

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

Cobalah online!

Terinspirasi oleh jawaban Jakube yang luar biasa untuk tantangan L-phabet, saya pikir saya akan mencoba tangan saya juga pada pemrograman aktual di /// dan bukan hanya menggunakannya untuk kompresi. Ini cukup sulit dan saya membutuhkan empat upaya, tetapi pada akhirnya itu jauh lebih pendek daripada solusi berbasis kompresi saya .

Penjelasan

Sebuah primer cepat pada ///: pada dasarnya penerjemah hanya membaca karakter kode dengan karakter dan melakukan hal berikut:

• Jika bukan a \atau a /, cetaklah.
• Jika a \, cetak karakter berikutnya.
• Jika itu adalah /, parsing /x/y/instruksi (dengan aturan pelolosan yang sama) dan berulang-ulang gantikan semua xkode yang tersisa y.

Mengambil lebih banyak inspirasi dari Jakube, untuk kesederhanaan saya hanya akan menjelaskan versi 4x4 ini:

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

Kami mulai dengan mengganti :barang-barang dengan yang kedua dan ketiga /. Ini akan menjadi kode yang memutar baris berikutnya. Kami mendapatkan ini:

/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

Itu f, bdan xhanya singkatan untuk string umum, yang akan kita kembangkan sekarang. The fyaitu untuk garis miring, yang badalah untuk backslashes dan xbagi \//yang kebetulan datang cukup banyak. Alasan saya menggunakan alias untuk substring karakter tunggal /dan \adalah bahwa mereka harus melarikan diri dalam instruksi substitusi pertama, jadi saya sebenarnya menyimpan cukup banyak byte dengan tidak memerlukan semua backslash tersebut. Inilah yang kami dapatkan x, fdan btelah diisi:

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

Sangat mudah dibaca.

Jadi baris pertama baru saja dicetak kata demi kata. Kemudian kita sampai pada bagian funky yang memutar semua baris lebih lanjut. Ini sebenarnya terdiri dari empat instruksi berbeda. Satu hal yang perlu diperhatikan adalah bahwa saya telah lolos dari semua kejadian Adalam instruksi ini. Alasannya adalah ini memungkinkan saya untuk membedakan As di dalam instruksi dari As di baris yang tersisa, yang perlu diproses secara berbeda.

/\/\A/\//

Ini cocok /Adan menggantinya dengan /, menghapus A. Perhatikan bahwa substring ini hanya muncul di bagian depan masing-masing ABCD, jadi ini menjatuhkan karakter pertama dari semua baris berikut:

/
\//\A_\//

Ini cocok dengan umpan baris yang diikuti oleh garis miring dan ganti dengan A_/. Jadi ini menyisipkan Apada akhir setiap baris, menyelesaikan rotasi dan juga mengubah umpan baris menjadi garis bawah.

/_\//
\//

Ini cocok _/dan menggantinya dengan linefeed diikuti dengan garis miring. Alasan saya perlu membuat jalan memutar ini melalui garis bawah adalah kenyataan bahwa /// menerapkan setiap instruksi berulang kali hingga string tidak lagi cocok. Itu berarti Anda tidak akan pernah bisa menggunakan instruksi formulir di /x/axb/mana x, adan bmerupakan string arbitrer, karena setelah substitusi xakan selalu tetap cocok. Secara khusus, ini berarti kita tidak bisa hanya memasukkan sesuatu di depan umpan baris. Kita perlu mengganti linefeed dalam proses dan membatalkan penggantian ini.

/\\\A/\\B/

Ini cocok \Adan menggantinya dengan \B, sehingga instruksi setelah baris yang tersisa memproses karakter berikutnya. Setelah keempat instruksi diproses, string yang tersisa terlihat seperti ini:

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

Jadi sekarang baris pertama yang diputar akan dicetak, dan kemudian rangkaian instruksi berikutnya memutar baris yang tersisa oleh sel lain dan seterusnya. Setelah rotasi terakhir, kami memiliki beberapa instruksi lagi yang dapat kami abaikan dan kemudian kami akhiri dengan instruksi tidak lengkap:

/\\\B/\\

Instruksi yang tidak lengkap pada akhirnya hanya diabaikan dan program berakhir.

Jelly , 7 byte

ØAṙJṢj⁷

Cobalah online!

Bagaimana itu bekerja

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

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

Di mana ^Pberarti "Kontrol P", dll. Itu 47 byte, karena tombol F3 dan F4 memerlukan dua byte ASCII.

Setelah memasukkan input awal, itu mendefinisikan makro keyboard untuk menduplikasi baris dan memindahkan karakter pertama ke akhir. Ini kemudian menjalankan makro lebih jauh 24 kali.

JavaScript (ES6), 56 byte

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

Ya, benar, setengah kode saya adalah string alfabet literal. Yang terbaik yang bisa saya lakukan tanpa literal adalah 81 byte:

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

Jika Anda menginginkan program daripada fungsi, maka hapus _=>dan bungkus console.log()dengan biaya 10 byte.

Mathematica 68 61 byte

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

Terimakasih untuk...

@MartinEnder (7 byte)

Python 2, 75 65 61 58 byte

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

Dapatkan alfabet dengan map(chr,range(65,91)), kemudian secara manual menerapkan operasi string shift.

Terima kasih kepada @LeakyNun dan @TheBikingViking untuk -4 byte!

Berkat @xnor untuk -3 byte!

C, 88 64 byte

Panggilan f()tanpa argumen.

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

Cobalah di ideone .

Piet , 247 byte / 190 kode

Cobalah secara Online!

Jadi, ini memakan waktu lebih lama dari yang saya perkirakan, dan saya punya beberapa ide tentang beberapa pendekatan lain yang lebih efisien (lebih ramah tumpukan), tapi saya akhirnya berhasil bekerja (dan memperbaiki bug interpreter dan menambahkan fitur IDE di sepanjang cara), jadi ini dia. Bukan bahasa byte yang paling efisien, tapi sangat menyenangkan. Berikut tampilan yang lebih besar, dan jejak yang menunjukkan jalur yang diambil. Riwayat di GitHub saya .

Sebagai bahasa berbasis stack, terlalu berbelit-belit untuk dijelaskan secara singkat, tapi inilah gambaran umum dasar tentang apa yang dilakukan berbagai bagian / loop. Semua nama variabel dan fungsi hanya untuk penjelasan, karena tidak ada variabel atau fungsi di Piet.

• Inisialisasi (kiri atas): dimulai line_counterpada 27, memuat '@' as cur_letter, ditetapkan letter_countke 27
• Loop utama (mulai dari ungu tua, tengah atas)
  • Pengurangan letter_counter
  • Cabang ke reset_linejika nol (light cyan 2-block)
  • Gulung cur_letterke bagian atas tumpukan
  • Cabang ke check_donejika cur_letter > 'X'(blok merah / merah, sisi kanan)
  • Menambahkan cur_letterdan mengeluarkannya (sudut kanan bawah)
  • Cabang ke reset_letterif cur_letter > 'Y'(blok hijau muda, kiri)
  • Gulung `letter_counter_ kembali ke atas tumpukan, kembali ke atas loop
• reset_line cabang (kotak merah muda besar):
  • Menghasilkan karakter baris baru
  • Ulang letter_countke 27
  • Terus kembali ke atas loop utama
• check_done cabang (setengah kanan di dalam)
  • Gulung line_counterke atas
  • Cabang berakhir jika nol
  • Penurunan line_counterdan gulungan kembali ke bawah tumpukan
  • Melanjutkan ke tempat yang ditinggalkannya, mencetak surat
• reset_line cabang (sisi kiri, blok hijau):
  • Mereset cur_letterke '@'
  • Melanjutkan di mana ia tinggalkan, berguling / kembali ke atas lingkaran

MATL , 8 byte

Dengan terima kasih kepada @Dennis , yang menyarankan bahwa MATL harus memasukkan pengindeksan modular, dan kepada @Suever , yang memiliki ide operasi berpasangan otomatis.

1Y2t&+Q)

Cobalah 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 byte

Versi super singkat untuk berjalan di konsol:

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

Javascript / HTML, 140 123 118 105 byte

Versi yang lebih cantik, dengan output HTML yang memudahkan OP untuk menyalin dan menempel:

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

(EDIT: Saya seharusnya hanya menggunakan string AZ daripada menghasilkannya)

(EDIT 2: Terima kasih kepada @Neil dan @DanTheMan atas masukan mereka (lihat komentar))

PowerShell, 44 byte

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

R, 47 42 41 byte

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

Cobalah online!

Menghasilkan 27 alphabet, menghilangkan 27-huruf dan mencetak dalam 26 kolom.

Peningkatan terinspirasi oleh @Giuseppe 's solusi .

Sesos , 27 25 byte

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

Cobalah online! Periksa Debug untuk melihat kode SBIN yang dihasilkan. ^†

Perakitan Sesos

File biner di atas telah dihasilkan dengan merakit kode SASM berikut.

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)

Bagaimana itu bekerja

Kami mulai dengan menginisialisasi rekaman ke ABCDEFGHIJKLMNOPQRSTUVWXYZ. Ini sebagai berikut.

Menulis 26 ke sel, meninggalkan kaset dalam keadaan berikut.

                                                     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

Selama sel di bawah kepala data bukan nol, kami melakukan hal berikut.

Salin nomor ke dua sel ke kiri dan tambahkan 64 ke salinan paling kiri.

                                                   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

Pindahkan salinan paling kiri ke lokasi asli, lalu kurangi 1 dari salinan paling kanan.

                                                     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

Proses berhenti setelah 26 iterasi, karena salinan paling kanan adalah 0 saat itu. Kami memindahkan sel ke kanan, sehingga keadaan akhir rekaman setelah inisialisasi adalah sebagai berikut.

     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

Sekarang kita siap untuk menghasilkan output, dengan mengulangi proses berikut sampai sel di bawah kepala data nol.

Pertama, kita mencetak karakter di bawah kepala data dan bergerak ke kanan, mengulangi langkah ini sampai sel dengan nilai 0 ditemukan. Setelah mencetak ABCDEFGHIJKLMNOPQRSTUVWXYZ, rekaman itu terlihat sebagai berikut.

                                                                                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

Sekarang kita memindahkan data head 27 unit ke kiri (kembali ke 0 terkemuka ) dan ulangi kombinasi print-move sampai sel dengan nilai 0 ditemukan. Ini tidak mencetak apa pun dan meninggalkan kaset sebagai berikut.

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

Sekarang, kita menulis 10 ke sel saat ini, mencetak karakter yang sesuai (linefeed) dan nol sel dengan panggilan masuk getpada input kosong, meninggalkan rekaman tidak berubah.

Setelah itu, kami memindahkan konten sel ke kanan ke sel saat ini, lalu memindahkan kepala data ke unit di sebelah kanan.

      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

Iterasi berikutnya sedikit berbeda. Langkah pencetakan pertama mencetak BCDEFGHIJKLMNOPQRSTUVWXYZ, meninggalkan kaset sebagai berikut.

                                                                                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

Sekarang kita memindahkan data head 27 unit ke kiri.

 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

Lingkaran pencetakan berikutnya mencetak Adan meninggalkan kaset sebagai berikut.

   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

Sekali lagi, kami mencetak umpan baris, memindahkan konten sel ke kanan ke sel saat ini, lalu memindahkan kepala data ke unit ke kanan.

         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

Setelah 24 iterasi lagi, langkah terakhir memindahkan kepala data ke kanan meninggalkan rekaman dalam kondisi berikut.

                                                                                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

Sel di bawah kepala data sekarang 0 dan program berakhir.

^† TIO menggunakan versi Sesos yang lebih baru, yang kompatibel dengan SASM, tetapi menghasilkan kode SBIN yang lebih pendek.

Haskell, 56 53 52 Bytes

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

panjang yang sama: (menggunakan saran oleh @AndersKaseorg)

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

untuk melakukan hal-hal modular Anda harus mengimpor Data.Char untuk mendapatkan fungsi chr, 74 59 58 Bytes adalah yang terbaik yang bisa saya dapatkan dengan itu: (terima kasih kepada @nimi untuk menyarankan fungsi toEnum)

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

Ini mungkin bisa jauh lebih pendek, tapi saya tidak tahu ada trik golf Haskell.

mapM bekas, bukan mapM_ (lihat komentar @ Lynn)

R, 53 byte

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

Ini dia penerjemah online .

Retina, 36 31 byte

5 byte berkat Martin Ender.

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

Linefeed terkemuka adalah signifikan.

Cobalah online!

Kredit .

Brain-Flak , 222 byte

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

Cobalah online!

Saya baru mengenal Brain-Flak, jadi mungkin ini bisa banyak bermain golf, tapi setidaknya ini percobaan pertama. Ini menyimpan 27 huruf penuh pada tumpukan kiri, kemudian memindahkan huruf ke kanan dan mengganti setiap 27 huruf dengan baris baru.

Kode sumber saya agak membingungkan, tetapi saya akan menambahkannya.

(((()()()()){})
    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 byte

¬AZ25ñÙx$p

Cobalah online!

Ini menggunakan pengkodean "Latin1".

Penjelasan:

¬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 byte

Saya telah mencoba untuk melihat apakah saya dapat menghasilkan huruf lebih pendek dari sekadar menginisialisasi mereka sebagai string, tetapi itu tidak benar-benar mungkin. Huruf-hurufnya adalah 26 byte dan potongan ini saja

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

adalah 25 byte. Saya pikir menginisialisasi mereka dan kemudian menambahkannya dengan + = a adalah solusi yang baik, tetapi dengan C # Anda dibatasi oleh bytecount fungsi seperti Substring()dan Console.WriteLine().

Usaha saya di 98 byte:

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

Oktaf, 27 byte

Kami menambahkan baris dan vektor kolom, dan Oktaf dengan baik memperluas dimensi sigleton, tidak perlu bsxfun(seperti yang Anda perlukan di Matlab).

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

q, 20 byte

(til 26)rotate\:.Q.A

Jawa, 190 176 172 163 byte

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 byte

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

Saya membuat alfabet penuh A, kemudian mencetak 26 versi yang diputar dengan mengambil karakter mulai ndan menambahkan posisi sebelumnya n.

Perl, 42 byte

Kredit penuh ke @Dom Hastings untuk ini.

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

Atau (jumlah byte yang sama):

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

Perlu -M5.010atau -Euntuk dijalankan, misalnya:

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

Jawaban lama saya (55 byte):

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

Perlu -M5.010dijalankan. Jadi jalankan dengan:

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

Mungkin mungkin untuk melakukan yang lebih pendek, tetapi saya belum mengetahui caranya ... belum