Bir Tabula Recta yazdırın!

Tabula Recta (bazen 'Vigenere Masası' olarak da adlandırılır), Johannes Trithemius tarafından yaratıldı ve Bellaso'nun Vigenere şifresi ve Trithemius şifresinin tüm varyasyonları dahil olmak üzere birkaç şifrede kullanıldı. Bu gibi görünüyor:

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

Buna sık sık ihtiyacım var ama kopyalayıp yapıştırmak için internette hiçbir yerde bulamıyorum. Kare masa kadar uzun olduğunu ve kahrolası sürdüğünden yaşları yazmak için, kodunuz mümkün olduğunca kısa olmalıdır.

Kurallar / Gereksinimler

• Her gönderim tam bir program veya işlev olmalıdır. Eğer bu bir fonksiyon ise, fonksiyon çağrısını sadece programın altına eklemek zorunda kalarak çalıştırılabilir olmalıdır. Başka herhangi bir şey (örn. C'deki başlıklar) dahil edilmelidir.
• Mümkünse, programınızın test edilebileceği bir siteye bağlantı sağlayın.
• Programınız hiçbir şey yazmamalı STDERR.
• Standart Loopholes yasaktır.
• Programınız her durumda çıktı verebilir, ancak yazdırılması gerekir (bir dizi veya benzeri değil).

puanlama

Programlar baytlara göre, UTF-8'de varsayılan olarak veya seçtiğiniz farklı bir karakter kümesinde puanlanır.

Sonunda, en az bayt olan cevap kazanacaktır.

gönderimler

Cevabınızın göründüğünden emin olmak için, lütfen aşağıdaki Markdown şablonunu kullanarak cevabınızı bir başlık ile başlatın:

# Language Name, N bytes

Gönderinizin Nbüyüklüğü nerede ? Puanınızı artırmak varsa, olabilir onları içinden vurarak, başlığa eski hesapları tutmak. Örneğin:

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

Başlığınıza birden fazla sayı eklemek istiyorsanız (örneğin, puanınız iki dosyanın toplamı olduğundan veya tercüman bayrağı cezalarını ayrı ayrı listelemek istediğiniz için), gerçek puanın başlıktaki son sayı olduğundan emin olun :

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

Dil adını, daha sonra büyük afiş snippet'inde görünecek bir bağlantı da yapabilirsiniz:

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

Liderler Sıralaması

Burada hem düzenli bir lider tablosu hem de kazananların dile göre genel bir bakış oluşturması için bir Stack Snippet'i var.

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

1 bayt tasarruf için Downgoat'a teşekkürler . Kod:

ADv=À

Açıklama:

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 kodlamasını kullanır . Çevrimiçi deneyin! .

Vim, 25 23 bayt

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

↵Dönüş anahtarı nerede .

: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 : küçük harf tamam, bu yüzden iki anahtar kaydedebilirsiniz.

Python 2, 59 57 53 bayt

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

-4 byte için @xsot'a teşekkürler!

/// , 220 bayt

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

Çevrimiçi deneyin!

Bu şaşırtıcı derecede önemsizdi ve optimal olup olmadığı hakkında hiçbir fikrim yok.

// / 'de böyle bir problemi çözmenin tek yolu, ortak alt dizgelerin çıkarılmasıdır. ( Hatalı olduğum ortaya çıkıyor. ) Ancak, çıktının doğası gereği, satır çizgileri nedeniyle alfabenin tamamını çıkaramadığınız için hangi alt dizgelerin en iyi şekilde çıkarılması gerektiği açık değildir. Öyleyse, sarılmış alfabenin bazı alt dizgilerini çıkarmanız gerekir, ancak daha sonra alt dizeleri ne kadar süreyle yaptığınız ve hangisini seçtiğiniz ile ilgili takaslar vardır.

İşte yaptığım şey buydu. Bu, verilen dizgide uzunluğu 25'e kadar olan tüm alt dizileri bulan ve her biri için, çıktısının kaç bayt tasarruf edeceğini hesaplayan bir CJam betiğidir . Temel Nolarak bir uzunluk- Malt dizinin kopyaları varsa, alt dizileri kaydedersiniz (N-1)*(M-1) - 5, bu alt diziler eğik çizgi içermez. Ayrıca, teknik olarak, 8 alt dizgiyi zaten çıkardığınızda, sonunda sabit ofset azalır -4, ancak script bunu dikkate almaz.

Her neyse, işte senaryo ile yaptım:

• Komut dosyasını geçerli koda karşı çalıştırın (başlangıçta yalnızca çıktıdır).
• En büyük iyileşmeyi sağlayan alt dizgilerden en küçüğünü seçin. Birkaç tane varsa, sözlüksel olarak en küçük olanı seçin (söyleyebileceğimden, verilen girdi için bu, alt diziler arasındaki örtüşmeleri azaltır).
• Seçili alt dize kodundaki tüm oluşumları kullanılmamış bir küçük harf ile değiştirin.
• Seçili harfin olduğu ve alt dize /x/ABC/olduğu koda bağlı .xABC
• Hiçbir şey kurtarabilecek hiçbir alt dizge kalmayana kadar tekrarlayın.

Sonunda, biz sonuçlanan değiştirerek birkaç bayt kaydetmek //ile |ve prepending /|/\/\//(alt dizeleri ayıklanması sadece 4 yerine 5 byte 8 alt dize kadar sonra maliyeti bu yüzden).

Dediğim gibi, bunun optimal olup olmadığına dair hiçbir fikrim yok ve oldukça düzensiz görünen sonucu oldukça ilginç buluyorum. Çizginin bir yerinde optimal olmayan (ancak daha fazla) alt dizileri seçerek daha kısa bir çözüme ulaşmak mümkün olabilir. Bu sorunun karmaşıklık sınıfının ne olduğunu merak ediyorum ...

C, 47 bayt

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

Ideone'da dene

Her 26 karakterde bir ancak her 27 karakterde bir alfabenin yerini alan tek bir ilmek, yeni bir satırla değiştirilir.

J, 15 bayt

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

Çevrimiçi tercüman .

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 bayt

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

Çevrimiçi deneyin!

Jakube’ün L-phabet yarışmasına verdiği müthiş cevaptan esinlenerek , sadece sıkıştırma için kullanmanın aksine, /// 'de gerçek programlamayı da deneyebileceğimi düşündüm . Bu oldukça zordu ve dört denemeye ihtiyacım vardı, fakat sonunda sıkıştırma tabanlı çözümümden çok daha kısa çıktı .

açıklama

///: 'daki hızlı bir astar, temel olarak yorumlayıcı sadece kod karakterini karakter olarak okur ve şunları yapar:

• Ne bir \ne de bir a ise /, yazdırın.
• Eğer bir ise \, bir sonraki karakteri yazdır.
• Eğer bir ise /, bir /x/y/talimatı (aynı kaçış kurallarına göre) ayrıştırın xve kalan kodun hepsini tekrar tekrar yerine koyun y.

Jakube'den biraz ilham alarak, basitlik için bunun 4x4 versiyonunu açıklayacağım:

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

Bunları :ikinci ve üçüncü arasındaki şeylerle değiştirerek başlıyoruz /. Bu, sonraki satırları döndüren kod olarak sona erecektir. Bunu anlıyoruz:

/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, bVe xşimdi genişletmek edeceğiz ortak dizeleri, sadece kestirme vardır. fEğik çizgiler için deyişle, bters eğik içindir ve xiçindir \//oldukça fazla gelip olur ki. Sebebi tek karakterlik alt dizeleri takma adlarını kullanıyorum /ve \ilk ikame talimatında öncelenmelidir zorunda olduklarını, bu yüzden aslında tüm bu ters eğik çizgi gerek etmeyerek bayt oldukça fazla biriktiriyorum. Burada sonra ne olsun x, fve bdoldurulmuş olduğu:

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

Çok okunabilir.

Böylece ilk satır sadece yazılı yazdırılır. Sonra tüm sıraları döndüren korkak kısma geçiyoruz. Aslında dört farklı talimattan oluşuyor. Dikkat edilmesi gereken bir şey, Abu talimatların içindeki tüm oluşumlardan kaçtığım. Bunun sebebi A, talimatlar dahilinde Akalanları farklı satırlarda işlenmeleri gereken kalan satırlardakilerden ayırt etmeme izin vermesidir .

/\/\A/\//

Bu maçları /Ave değiştirir /kaldırarak A. Bu alt dizinin yalnızca her birinin önünde göründüğünü unutmayın, bu ABCDnedenle sonraki tüm satırların ilk karakterini bırakır:

/
\//\A_\//

Bu, bir satır çizgisinin ardından gelen bir eğik çizgiyle eşleşir ve onun yerine geçer A_/. Böylece bu A, her çizginin sonuna bir ekler , dönüşü tamamlar ve ayrıca satır beslemeyi bir alt çizgi haline getirir.

/_\//
\//

Bu eşleşir _/ve onu bir satır çizgisiyle takip eden bir satır çizgisiyle değiştirir. Bu sapmayı alt çizgi üzerinden yapmamın nedeni, /// her dizeyi dizge artık uyuşmayana kadar tekrar tekrar uygulamaktır. Yani formun bir talimat kullanmak asla anlamına gelir , ve ikame sonra çünkü keyfi dizeleri hep yine aynı olacaktır. Özellikle, bu demek oluyor ki, sadece bir satır yemeğinin önüne bir şey ekleyemeyiz. İşlemdeki satır beslemesini değiştirmeliyiz ve bu değişimini geri almalıyız./x/axb/xabx

/\\\A/\\B/

Bu eşleşir \Ave onunla değiştirilir \B, böylece kalan satırlardan sonraki talimatlar bir sonraki karakteri işler. Dört komutun tümü işlendikten sonra, kalan dize şuna benzer:

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

Böylece şimdi ilk döndürülmüş satır yazdırılır ve ardından bir sonraki komut dizisi kalan satırları başka bir hücre vb. Tarafından döndürür. Son rotasyondan sonra, görmezden gelebileceğimiz birkaç talimat daha var ve daha sonra eksik olan talimatla sona ereceğiz:

/\\\B/\\

Sonundaki eksik talimatlar basitçe yoksayılır ve program sonlandırılır.

Jöle , 7 bayt

ØAṙJṢj⁷

Çevrimiçi deneyin!

Nasıl çalışır

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

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

Nerede ^PF3 ve F4 tuşları iki ASCII bayt gerektirdiği için, 47 bayt var vs. "Denetim P" anlamına gelir.

Başlangıç ​​girişine girdikten sonra, satırı çoğaltmak ve ilk karakteri sonuna kadar taşımak için bir klavye makrosu tanımlar. Daha sonra makroyu 24 kez daha çalıştırır.

JavaScript (ES6), 56 bayt

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

Evet, doğru, kodumun yarısı alfabe dizgisidir. Hazır bilgi olmadan yapabildiğim en iyi şey 81 bayttır:

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

İşlev yerine bir program istiyorsanız, o zaman kaldırın _=>ve console.log()10 baytlık bir ücret karşılığında paketleyin.

Mathematica 68 61 bayt

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

Sayesinde...

@MartinEnder (7 bayt)

Python 2, 75 65 61 58 bayt

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

Alfabeyi ile alır map(chr,range(65,91)), ardından string shift işlemini el ile uygular.

-4 baytlık @LeakyNun ve @TheBikingViking'e teşekkürler!

-3 bayt için @xnor'a teşekkürler!

C, 88 64 bayt

f()Argümanlar olmadan arayın .

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

İdeone üzerinde deneyin .

Piet , 247 bayt / 190 kodek

Çevrimiçi Deneyin!

Yani, bu ben beklenen çok daha uzun sürdü ve ben daha verimli (daha yığın dostu) diğer yaklaşımlar bazı birkaç fikirleri var, ama sonunda çalışma dang şey var (ve tercüman hata düzeltildi ve IDE özellikleri eklendi boyunca yol), yani burada. En bayt verimli bir dil değil, ama çok eğlenceli. İşte daha geniş bir görünüm ve izlenen yolu gösteren bir iz. Benim Geçmiş yukarı GitHub'dan .

Yığın tabanlı bir dil olarak, kısaca açıklamak için fazla kıvrımlıdır, ancak işte çeşitli bölümlerin / döngülerin ne yaptığıyla ilgili temel bir genel bakış. Tüm değişken ve fonksiyon isimleri sadece açıklama amaçlıdır, Piet'de değişken veya fonksiyon yoktur.

• Başlatma (sol üst): başlatır line_counter27 yükler de '@' olarak cur_letter, ayarlar letter_count27'ye
• Ana döngü (koyu mordan başlayarak, orta üstte)
  • Azaltır letter_counter
  • Şubeler reset_linesıfırsa (açık mavi 2 blok)
  • cur_letterYığının tepesine rulo
  • Şubeye check_doneeğer cur_letter > 'X'(deniz mavisi / kırmızı blok, sağ taraf)
  • Artırır cur_letterve çıkarır (sağ alt köşe)
  • Şubeye reset_lettereğer cur_letter > 'Y'(açık yeşil blok, sol)
  • Rolls `letter_counter_ yığının en üstüne, döngünün en üstüne
• reset_line şube (büyük pembe kare):
  • Yeni satır karakterini çıktılar
  • letter_count27'ye sıfırlar
  • Ana döngünün tepesine devam ediyor
• check_done dal (sağ yarısı içinde)
  • En line_counterüste rulolar
  • Dallar sıfırsa bitecek
  • Düşürür line_counterve istifin altına geri döner
  • Mektubu kaldığı yerden devam ettirir, mektubu yazdırır
• reset_line dal (sol taraf, yeşil blok):
  • cur_letter'@' Konumuna sıfırlar
  • Kaldığı yerden devam eder, döngünün üst kısmına döner / geri döner

MATL , 8 bayt

İçin teşekkür grubu @Dennis , önerilen Matl modüler indeksleme içermelidir ve bu @Suever vardı fikir otomatik ikili operasyonların.

1Y2t&+Q)

Çevrimiçi deneyin!

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 bayt

Konsolda çalıştırmak için süper kısa bir sürüm:

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

Javascript / HTML, 140 123 118 105 bayt

OP'nin kopyalanıp yapıştırılmasını kolaylaştıran bir HTML çıktısına sahip daha güzel bir sürüm:

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

(EDIT: Oluşturmak yerine AZ karakterini kullanmalıydım)

(EDIT 2: @Neil ve @DanTheMan'a girişleri için teşekkürler (yorumlara bakın))

PowerShell, 44 bayt

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

R, 47 42 41 bayt

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

Çevrimiçi deneyin!

27 alfabe oluşturur, 27. harfleri kaldırır ve 26 sütuna yazdırır.

Esinlenerek İyileştirme @Giuseppe 'in çözeltisi .

Sesos , 27 25 bayt

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

Çevrimiçi deneyin! Kontrol Debug oluşturulan SBIN kodunu görmek için. ^†

Sesos derleme

Yukarıdaki ikili dosya aşağıdaki SASM kodunu birleştirerek oluşturulmuştur.

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)

Nasıl çalışır

Kaseti başlatarak başlıyoruz ABCDEFGHIJKLMNOPQRSTUVWXYZ. Bu aşağıdaki gibidir.

Kaseti aşağıdaki durumda bırakarak bir hücreye 26 yazın .

                                                     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

Veri başlığının altındaki hücre sıfır olmadıkça, aşağıdakileri yaparız.

Sayıyı iki hücreye sola kopyalayın ve 64'ü en soldaki kopyaya ekleyin .

                                                   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

En soldaki kopyayı orijinal konumuna taşıyın, sonra en sağdaki kopyadan 1'i çıkarın.

                                                     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

İşlem 26 yinelemeden sonra durur , çünkü en sağdaki kopya 0'a göredir . Bir hücreyi sağa doğru hareket ettiririz; bu nedenle, başlatmanın ardından bandın son hali aşağıdaki gibidir.

     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

Şimdi veri başlığının altındaki hücre sıfır olana kadar aşağıdaki işlemi tekrarlayarak çıktıyı üretmeye hazırız.

İlk önce, veri başlığının altındaki karakteri basarız ve sağa hareket ederiz, bu adımı 0 değerine sahip bir hücre bulunana kadar tekrarlayın . Yazdırdıktan sonra ABCDEFGHIJKLMNOPQRSTUVWXYZ, bant aşağıdaki gibi görünür.

                                                                                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

Şimdi veri kafasını 27 birimi sola doğru hareket ettiriyoruz (baştaki 0'a geri dönüyoruz ) ve 0 değerine sahip bir hücre bulunana kadar baskı-hareket kombinasyonunu tekrar ediyoruz . Bu hiçbir şeyi yazdırmaz ve bandı aşağıdaki gibi bırakır.

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

Şimdi, mevcut hücreye 10 yazıyoruz , karşılık gelen karakteri yazdırıyoruz (satır getbeslemesi ) ve boş girişe bir çağrı yaparak hücreyi sıfırlayarak bandı değiştirmeden bırakıyoruz.

Daha sonra, hücrenin içeriğini mevcut hücreye doğru sağa, ardından veri kafasını birime sağa taşırız.

      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

Bir sonraki yineleme biraz farklıdır. İlk yazdırma adımı BCDEFGHIJKLMNOPQRSTUVWXYZ, bandı aşağıdaki şekilde bırakarak yazdırılır .

                                                                                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

Şimdi veri kafasını 27 birim sola hareket ettiriyoruz .

 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

Bir sonraki yazdırma döngüsü A, bandı yazdırır ve aşağıdaki gibi bırakır.

   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

Bir kez daha, bir satır beslemesi yazdırırız, hücrenin içeriğini geçerli hücreye sağa doğru hareket ettiririz, daha sonra veri kafasını birime doğru sağa taşırız.

         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 yinelemeden sonra , veri kafasını sağa hareket ettirmenin son adımı bandı aşağıdaki durumda bırakır.

                                                                                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

Veri başlığının altındaki hücre şimdi 0'dır ve program sonlandırılır.

^† TIO, SASM için geriye dönük uyumlu olan ancak daha kısa SBIN kodu üreten Sesos'un daha yeni bir sürümünü kullanıyor.

Haskell, 56 53 52 Bayt

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

Aynı uzunluk: (@AndersKaseorg tarafından yapılan bir öneriyi kullanarak)

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

modüler şeyler yapmak için Data.Char komutunu kullanmanız gerekir, chr fonksiyonunu elde etmek için, 74 59 58 Bytes bu konuda elde edebileceğim en iyisiydi: (toEnum fonksiyonunu önerdiğiniz için @nimi sayesinde)

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

Bu muhtemelen çok daha kısa olabilir, ancak Haskell golf püf noktalarını bilmiyorum.

mapM_ yerine mapM kullandı (@ Lynn'in yorumuna bakın)

R, 53 bayt

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

İşte bir çevrimiçi tercüman üzerinde .

Retina, 36 31 bayt

Martin Ender sayesinde 5 bayt.

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

Lider hat beslemesi önemlidir.

Çevrimiçi deneyin!

Kredi .

Brain-Flak , 222 bayt

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

Çevrimiçi deneyin!

Brain-Flak'ta yeniyim, bu yüzden belki de çok fazla golf oynayabilir, ama en azından ilk denemede. Sol yığında 27 tam alfabe saklar, sonra alfabeyi sağa taşır ve her 27 harfin yerine yeni bir satır yazar.

Kaynak kodum biraz kafa karıştırıcı, ancak yine de ekleyeceğim.

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

¬AZ25ñÙx$p

Çevrimiçi deneyin!

Bu "Latin1" kodlamasını kullanır.

Açıklama:

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

Harfleri yalnızca bir dize olarak başlatmaktan daha kısa harfler üretip üretemediğimi görmeye çalıştım, ancak bu gerçekten mümkün değil. Harfler 26 bayttır ve bu snippet yalnız

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

25 bayttır. Onları başlatmak ve sonra bir + = a ile eklemek iyi bir çözüm olduğunu düşünüyorum, ancak C # ile Substring()ve gibi fonksiyonların bytecount ile sınırlıdır Console.WriteLine().

98 bayt'taki denemem:

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

Octave, 27 bayt

Bir satır ve sütun vektörü ekliyoruz ve Octave sigleton boyutlarını güzel bir şekilde genişletiyor, buna gerek yok bsxfun(Matlab'da istediğiniz gibi).

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

q, 20 bayt

(til 26)rotate\:.Q.A

Java, 190 176 172 163 bayt

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 bayt

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

Aİçinde tam bir alfabe oluşturur , sonra 26 döndürülmüş versiyonunu, başlangıçtaki karakterleri alarak nve bunları ekleyerek yazdırırım n.

Perl, 42 bayt

Bunun için @Dom Hastings'e tam kredi.

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

Veya (aynı bayt sayısı):

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

İhtiyaç duyma -M5.010veya -Eçalıştırma, örneğin:

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

Eski cevabım (55 bayt):

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

İhtiyaç -M5.010 gerek. Öyleyse kaç:

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

Yine de daha kısa yapmak mümkün olabilir, ama nasıl olduğunu henüz anlamadım.