พิมพ์ Tabula Recta!

Tabula Recta (บางครั้งเรียกว่า 'Vigenere Table') สร้างโดย Johannes Trithemius และถูกนำมาใช้ในยันต์หลายแห่งรวมถึงตัวแปรทั้งหมดของตัวเลข Vigenere ของ Bellaso และ Trithemius cipher ดูเหมือนว่านี้:

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 ตามค่าเริ่มต้นหรือชุดอักขระอื่นที่คุณเลือก

ในที่สุดคำตอบที่มีจำนวนไบต์น้อยที่สุดจะเป็นผู้ชนะ

การส่ง

เพื่อให้แน่ใจว่าคำตอบของคุณปรากฏขึ้นโปรดเริ่มคำตอบด้วยหัวข้อโดยใช้เทมเพลต Markdown ต่อไปนี้:

# 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

ลีดเดอร์บอร์ด

นี่คือ Stack Snippet เพื่อสร้างทั้งกระดานผู้นำปกติและภาพรวมของผู้ชนะตามภาษา

/* 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 ไบต์

ขอบคุณDowngoatสำหรับการบันทึก 1 ไบต์ รหัส:

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 ลองออนไลน์! .

เป็นกลุ่ม25 23 ไบต์

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

↵คีย์ส่งคืนอยู่ที่ไหน

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

แก้ไข : ตัวพิมพ์เล็กไม่เป็นไรดังนั้นฉันสามารถบันทึกสองปุ่มได้

Python 2, 59 57 53 ไบต์

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

ขอบคุณ @xsot สำหรับ -4 ไบต์!

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

ลองออนไลน์!

นี่เป็นเรื่องไม่น่าแปลกใจและฉันก็ไม่รู้ว่ามันดีที่สุดแล้ว

วิธีเดียวในการเล่นกอล์ฟที่มีปัญหาเช่นนี้ใน /// คือการแยกสารตั้งต้นทั่วไป ( ปรากฎว่าฉันผิด ) เนื่องจากลักษณะของการส่งออกจึงไม่ชัดเจนว่าควรแยกสารตั้งต้นใดดีที่สุดเนื่องจากคุณไม่สามารถแยกตัวอักษรทั้งหมดได้เนื่องจากการแพร่กระจาย ดังนั้นคุณจะต้องแยกสตริงย่อยของตัวอักษรที่ห่อไว้ แต่ก็มีการแลกเปลี่ยนในแง่ของระยะเวลาที่คุณสร้างสตริงย่อยและตัวเลือกที่คุณเลือก

ดังนั้นนี่คือสิ่งที่ฉันทำ นี่คือสคริปต์ CJamซึ่งค้นหาสตริงย่อยทั้งหมดที่มีความยาว 25 ในสตริงที่กำหนดและสำหรับแต่ละไฟล์คำนวณว่ามีกี่ไบต์ที่แตกไฟล์ที่จะบันทึก โดยทั่วไปหากมีNสำเนาของMสตริงย่อยยาวคุณต้องบันทึก(N-1)*(M-1) - 5สตริงย่อยสตริงย่อยเหล่านี้ไม่มีสแลช นอกจากนี้ในทางเทคนิคเมื่อคุณได้แยก 8 สตริงย่อยแล้วดังนั้นค่าออฟเซ็ตคงที่ในตอนท้ายจะลดลง-4แต่สคริปต์ไม่ได้พิจารณาสิ่งนั้น

อย่างไรก็ตามนี่คือสิ่งที่ฉันทำกับสคริปต์:

• เรียกใช้สคริปต์กับรหัสปัจจุบัน (ซึ่งเริ่มเป็นเพียงแค่การส่งออก)
• เลือกวัสดุที่สั้นที่สุดจากวัสดุพิมพ์ที่มีการปรับปรุงมากที่สุด หากมีหลายให้เลือกเล็กที่สุด lexicographically (จากสิ่งที่ฉันสามารถบอกได้สำหรับการป้อนข้อมูลที่กำหนดนี้จะช่วยลดการทับซ้อนระหว่างสตริงย่อย)
• แทนที่เกิดขึ้นทั้งหมดของสายอักขระย่อยที่เลือกในรหัสด้วยอักษรตัวพิมพ์เล็กที่ไม่ได้ใช้
• ย่อหน้า/x/ABC/รหัสที่xเป็นตัวอักษรตัวเลือกและABCเป็นอักขระย่อย
• ทำซ้ำจนกว่าจะไม่มีวัสดุเหลืออยู่ที่จะบันทึกสิ่งใด ๆ

ในตอนท้ายเราบันทึกอีกสองสามไบต์โดยการแทนที่ผลลัพธ์//ด้วย|และการเตรียมการ/|/\/\//(นี่คือเหตุผลที่การแยกสตริงย่อยมีค่าใช้จ่ายเพียง 4 แทน 5 ไบต์หลังจากสตริงย่อยที่ 8 หรือมากกว่านั้น)

อย่างที่ฉันพูดฉันไม่มีเงื่อนงำว่าสิ่งนี้ดีที่สุดและฉันพบว่าผลลัพธ์ที่ดูค่อนข้างผิดปกติน่าสนใจทีเดียว อาจเป็นไปได้ที่จะได้รับโซลูชั่นที่สั้นลงโดยการเลือกวัสดุพิมพ์ที่ไม่เหมาะสม ฉันสงสัยว่าระดับความซับซ้อนของปัญหานี้คืออะไร ...

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 ฉันคิดว่าฉันลองใช้มือกับการเขียนโปรแกรมจริงใน /// เมื่อเทียบกับการใช้เพียงแค่การบีบอัด นี่เป็นเรื่องยุ่งยากสวยและผมจำเป็นต้องมีสี่ครั้ง แต่ในที่สุดก็ออกมามากน้อยกว่าฉันวิธีการแก้ปัญหาการบีบอัดตาม

การอธิบาย

ไพรเมอร์แบบย่อใน ///: โดยพื้นฐานแล้วล่ามจะอ่านตัวอักษรของรหัสตามตัวอักษรและทำสิ่งต่อไปนี้:

• ถ้ามันไม่ใช่\หรือมิได้/พิมพ์
• ถ้าเป็น\ให้พิมพ์ตัวอักษรถัดไป
• ถ้าเป็น/ให้แยกวิเคราะห์/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ภายในคำแนะนำจากAs ในแถวที่เหลือซึ่งต้องดำเนินการแตกต่างกัน

/\/\A/\//

นี้ตรง/Aและแทนที่มันด้วยเอา/ Aโปรดทราบว่าสตริงย่อยนี้จะปรากฏที่ด้านหน้าของแต่ละรายการABCDดังนั้นสิ่งนี้จะลดอักขระตัวแรกของบรรทัดที่ตามมาทั้งหมด:

/
\//\A_\//

A_/นี้ตรงกับเลื่อนบรรทัดตามด้วยการเฉือนและแทนที่มันด้วย ดังนั้นสิ่งนี้จะแทรกเข้าไปAที่ส่วนท้ายของแต่ละบรรทัดทำการหมุนจนเสร็จและเปลี่ยนไลน์ฟีดให้เป็นขีดล่าง

/_\//
\//

การจับคู่นี้_/และแทนที่ด้วย linefeed ตามด้วยเครื่องหมายทับ เหตุผลที่ฉันต้องทำให้การอ้อมนี้ผ่านทางขีดล่างคือข้อเท็จจริงที่ว่า /// ใช้แต่ละคำสั่งซ้ำ ๆ จนกระทั่งสตริงไม่ตรงอีกต่อไป นั่นหมายความว่าคุณจะไม่สามารถใช้การเรียนการสอนที่มีรูปแบบ/x/axb/ที่x, aและbสตริงโดยพลการเพราะหลังจากเปลี่ยนตัวxมักจะยังคงตรงกับ โดยเฉพาะอย่างยิ่งนี่หมายความว่าเราไม่สามารถแทรกสิ่งที่อยู่ข้างหน้า linefeed เราจำเป็นต้องเปลี่ยน linefeed ในกระบวนการและยกเลิกการเปลี่ยนนี้

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

Emacs, 47 ไบต์

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

โดยที่ความ^Pหมาย "Control P" ฯลฯ มีขนาด 47 ไบต์เนื่องจากปุ่ม F3 และ F4 ต้องการ ASCII สองไบต์

หลังจากป้อนอินพุตเริ่มต้นมันจะนิยามแมโครคีย์บอร์ดเพื่อทำสำเนาบรรทัดและย้ายอักขระตัวแรกไปยังจุดสิ้นสุด จากนั้นเรียกใช้แมโครอีก 24 ครั้ง

JavaScript (ES6), 56 ไบต์

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

ใช่ถูกต้องครึ่งรหัสของฉันคือสตริงตัวอักษร ดีที่สุดที่ฉันสามารถทำได้โดยไม่มีตัวอักษรคือ 81 ไบต์:

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

หากคุณต้องการโปรแกรมมากกว่าฟังก์ชั่นให้ลบ_=>และตัดคำในconsole.log()ราคา 10 ไบต์

Mathematica 68 61 ไบต์

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

ขอบคุณที่ ...

@MartinEnder (7 ไบต์)

Python 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))จากนั้นใช้การดำเนินการกะสตริงด้วยตนเอง

ขอบคุณ @LeakyNun และ @TheBikingViking สำหรับ -4 ไบต์!

ขอบคุณ @xnor สำหรับ -3 ไบต์!

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 codels

ลองออนไลน์!

ดังนั้นนี้เอานานกว่าผมคาดและผมก็มีความคิดไม่กี่ในบางส่วนมีประสิทธิภาพมากขึ้น (เพิ่มเติมกองมิตร) วิธีอื่น ๆ แต่ในที่สุดผมก็มีสิ่งแดงทำงาน (และการแก้ไขข้อผิดพลาดล่ามและเพิ่มคุณสมบัติ IDEพร้อม วิธี) ดังนั้นนี่คือ แทบจะไม่ได้ใช้ภาษาที่มีประสิทธิภาพสูงสุด แต่สนุกมาก นี่คือมุมมองที่กว้างขึ้นและร่องรอยแสดงเส้นทางที่ถ่าย ประวัติความเป็นมาของฉันขึ้นไปบนGitHub

ในฐานะที่เป็นภาษาแบบสแต็กมันมีความซับซ้อนเกินกว่าที่จะอธิบายสั้น ๆ แต่นี่เป็นภาพรวมพื้นฐานของสิ่งที่ส่วน / ลูปต่างๆทำ ชื่อตัวแปรและฟังก์ชันทั้งหมดเป็นเพียงคำอธิบายเนื่องจากไม่มีตัวแปรหรือฟังก์ชันใน Piet

• การเริ่มต้น (ซ้ายบน): เริ่มต้นline_counterที่ 27 โหลด '@' เป็นcur_letterตั้งletter_countเป็น 27
• หลักห่วง (เริ่มต้นที่สีม่วงเข้มตรงกลางด้านบน)
  • decrements letter_counter
  • สาขาไปreset_lineถ้าศูนย์ (ไฟสีฟ้า 2 บล็อก)
  • ม้วนcur_letterไปด้านบนของสแต็ค
  • สาขาถึงcheck_doneถ้าcur_letter > 'X'(บล็อกน้าน / สีแดงด้านขวา)
  • เพิ่มcur_letterและเอาท์พุทมัน (มุมล่างขวา)
  • สาขาไปreset_letterถ้าcur_letter > 'Y'(บล็อกสีเขียวอ่อน, ซ้าย)
  • เลื่อน `letter_counter_ กลับไปด้านบนสุดของสแต็กกลับไปด้านบนของลูป
• reset_line สาขา (จัตุรัสสีชมพูใหญ่):
  • เอาต์พุตอักขระบรรทัดใหม่
  • รีเซ็ตletter_countเป็น 27
  • กลับสู่ด้านบนของลูปหลักต่อไป
• check_done สาขา (ครึ่งขวาภายใน)
  • เลื่อนline_counterไปด้านบน
  • สาขาจะสิ้นสุดถ้าศูนย์
  • ลดลง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

Javascript, 113 96 91 76 ไบต์

รุ่นสั้นพิเศษสำหรับใช้ในคอนโซล:

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

Javascript / HTML, 140 123 118 105 ไบต์

เวอร์ชันที่สวยกว่าพร้อมเอาต์พุต HTML ที่ทำให้ OP สามารถคัดลอกและวางได้ง่ายขึ้น:

<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 alphabetes ลบ 27 ตัวอักษรและพิมพ์ใน 26 คอลัมน์

ปรับปรุงแรงบันดาลใจจาก @Giuseppe 's วิธีการแก้ปัญหา

Sesos , 27 25 ไบต์

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

ลองออนไลน์! ตรวจสอบDebugเพื่อดูรหัส SBIN ที่สร้างขึ้น ^†

ประกอบน้ำมัน

ไฟล์ไบนารีข้างต้นถูกสร้างขึ้นโดยการประกอบรหัส 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

ตราบใดที่เซลล์ภายใต้ส่วนหัวของข้อมูลไม่เป็นศูนย์เราจะทำสิ่งต่อไปนี้

คัดลอกหมายเลขไปยังเซลล์ทั้งสองทางด้านซ้ายและเพิ่ม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

กระบวนการหยุดหลังจาก26ซ้ำตั้งแต่สำเนาขวาสุดเป็น0แล้ว เราย้ายเซลล์ไปทางขวาดังนั้นสถานะสุดท้ายของเทปหลังจากการเริ่มต้นมีดังนี้

     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พบ หลังจากการพิมพ์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ถึงเซลล์ปัจจุบันพิมพ์ตัวอักษรที่เกี่ยวข้อง (linefeed) และศูนย์เซลล์ด้วยการเรียกไปยังgetอินพุตว่างเปล่าโดยไม่ต้องเปลี่ยนเทป

หลังจากนั้นเราย้ายเนื้อหาของเซลล์ไปทางขวาไปยังเซลล์ปัจจุบันจากนั้นย้ายส่วนหัวข้อมูลไปยังหน่วยทางด้านขวา

      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

ตอนนี้เราย้าย data head 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

อีกครั้งเราพิมพ์ linefeed ย้ายเนื้อหาของเซลล์ไปทางขวาไปยังเซลล์ปัจจุบันจากนั้นย้ายส่วนหัวของข้อมูลไปยังหน่วยทางด้านขวา

         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

เซลล์ภายใต้ data head เป็น0และโปรแกรมสิ้นสุดลง

^† TIO ใช้ Sesos เวอร์ชันใหม่กว่าซึ่งเข้ากันได้กับ SASM แต่สร้างรหัส SBIN ที่สั้นกว่า

Haskell, 56 53 52 Bytes

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

ความยาวเท่ากัน: (ใช้ข้อเสนอแนะโดย @AndersKaseorg)

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

เพื่อทำสิ่งโมดูลาร์ที่คุณต้องนำเข้า Data.Char เพื่อรับฟังก์ชั่น chr, 74 59 58 Bytes เป็นสิ่งที่ดีที่สุดที่ฉันจะได้รับด้วย: (ขอบคุณ @nimi สำหรับการแนะนำฟังก์ชั่น toEnum)

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 36ไบต์

5 ไบต์ขอบคุณ Martin Ender

Z
{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 ไบต์ ผมคิดว่าการเริ่มต้นพวกเขาแล้วต่อท้ายด้วย + = เป็นทางออกที่ดี แต่ด้วย C # คุณจะถูก จำกัด โดย bytecount ของฟังก์ชั่นเหมือนและSubstring()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(ตามที่คุณต้องการใน Matlab)

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

q, 20 ไบต์

(til 26)rotate\:.Q.A

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

Bash, 66 ไบต์

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

ฉันจะสร้างตัวอักษรเต็มรูปแบบในAแล้วพิมพ์ 26 รุ่นที่หมุนของมันได้โดยการใช้ตัวอักษรเริ่มต้นที่และท้ายตำแหน่งก่อนหน้านี้ผู้nn

Perl, 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}'  

อาจเป็นไปได้ที่จะสั้นลง แต่ฉันยังไม่ทราบว่า ... ยัง