एक तबला पंथी छापो!

तबला रेक्टा (जिसे कभी-कभी 'विगेनियर टेबल' भी कहा जाता है), जोहानस ट्रिटेमियस द्वारा बनाई गई थी, और इसका उपयोग कई सिफर में किया गया है, जिसमें बेलासो के विगेनियर सिफर और ट्राइसेमियस सिफर के सभी वेरिएंट शामिल हैं। यह इस तरह दिख रहा है:

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

मुझे अक्सर इसकी आवश्यकता होती है, लेकिन इसे कॉपी और पेस्ट करने के लिए इंटरनेट पर कहीं भी नहीं पाया जा सकता है। क्योंकि वर्ग तालिका इतनी लंबी है, और टाइप करने के लिए भयावह उम्र लगती है , आपका कोड यथासंभव छोटा होना चाहिए।

नियमों / आवश्यकताओं

प्रत्येक जमा या तो एक पूर्ण कार्यक्रम या फ़ंक्शन होना चाहिए। यदि यह एक फ़ंक्शन है, तो प्रोग्राम के निचले भाग में फ़ंक्शन कॉल को जोड़ने की आवश्यकता के द्वारा इसे चलाया जा सकता है। कुछ भी (जैसे सी में हेडर), शामिल किया जाना चाहिए।
यदि यह संभव है, तो उस साइट का लिंक प्रदान करें जहां आपके कार्यक्रम का परीक्षण किया जा सकता है।
आपके प्रोग्राम को कुछ भी नहीं लिखना चाहिए STDERR।
मानक लोफॉल्स निषिद्ध हैं।
आपका कार्यक्रम किसी भी मामले में आउटपुट कर सकता है, लेकिन इसे मुद्रित किया जाना चाहिए (सरणी या समान नहीं)।

स्कोरिंग

कार्यक्रम डिफ़ॉल्ट रूप से या अपनी पसंद के किसी भिन्न वर्ण सेट द्वारा UTF-8 में बाइट्स के अनुसार बनाए जाते हैं।

आखिरकार, कम से कम बाइट के साथ जवाब जीत जाएगा।

प्रस्तुतियाँ

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

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

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

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

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

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

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

कोड स्निपेट दिखाएं

/* Configuration */

var QUESTION_ID = 86986; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 53406; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    if (/<a/.test(lang)) lang = jQuery(lang).text();
    
    languages[lang] = languages[lang] || {lang: a.language, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang > b.lang) return 1;
    if (a.lang < b.lang) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<div id="language-list">
  <h2>Winners by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

Expand snippet

— जॉर्ज गिब्सन
स्रोत

नियम 1 के बारे में: क्या हमें अपने द्वारा उपयोग किए जाने वाले प्रत्येक फ़ंक्शन के लिए प्रत्येक हेडर को शामिल करना होगा?

— उल्लू का बच्चा

मेरा मतलब था कि यदि हम उपयोग करते हैं printf, तो हमें शामिल करने की आवश्यकता है stdio.h, यदि isalphaउपयोग किया जाता है, ctype.hकी आवश्यकता है, आदि क्या यह सही है?

— उल्लू के जूलर

3

आपको संभवतः चुनौती के विनिर्देशन में "लोअरकेस की अनुमति है" डालनी चाहिए। बस अगर लोग इन टिप्पणियों को नहीं देखते हैं, तो इसे याद करने की संभावना कम है।

— शर्लक

2

क्या मुझे इसे प्रिंट करना है या मैं

— downrep_nation

1

मुझे पूरी रात जागते रहने के सवाल के लिए धन्यवाद। (+1)

— अनास्तासिया-रोमानोवा '

30

05AB1E , 6 5 बाइट्स

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 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

— अदनान
स्रोत

इसका नक़ल करने का उद्देश्य क्या है?

— 19:32 बजे फल

1

@ चैलेंजर 5 vकमांड एक मान का उपभोग करता है, इस पर पुनरावृत्ति करता है। इस मामले में, यह वर्णमाला का उपभोग करता है, इसलिए यह 26 बार पुनरावृत्त करता है। यह भी समय की सटीक राशि है कि हमें =Àफ़ंक्शन को पुनरावृत्त करने की आवश्यकता है । =पत्ते ढेर बरकरार है और Àकेवल बाईं ओर ढेर तत्व 1 के शीर्ष घूमता है। क्या इससे आपके सवाल का जवाब मिलता है? :)

— अदनान

101

विम, २५ २३ बाइट्स

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

संपादित करें : लोअरकेस ठीक है, इसलिए मैं दो कुंजी बचा सकता हूं।

— लिन
स्रोत

23

वह :h<_<cr>jjYप्रतिभाशाली है

— डाउनटाउन

3

वाह कमाल है! ओपी कहा लोअरकेस ठीक था तो आप निकाल सकते हैंV~

— DJMcMayhem

4

: @RobStarling देखने meta.codegolf.stackexchange.com/q/8995/40695

— Downgoat

4

मैं किसी को हिम्मत के साथ यह कोशिश कर रहा हूँ।

— एडिसन

2

@addison Emacs जवाब

— TuxCrafting

24

पायथन 2, 59 57 53 बाइट्स

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

-4 बाइट्स के लिए @xsot को धन्यवाद!

— डायने
स्रोत

4

मैं यह पसंद है। वैसे, आप अंतिम पंक्ति को छोटा कर सकते हैं print bytearray(a)।

— xsot

18

/// , 220 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह आश्चर्यजनक रूप से गैर-तुच्छ था और मुझे कोई सुराग नहीं है कि क्या यह इष्टतम है।

/// में इस तरह की समस्या को हल करने का एकमात्र तरीका आम सबस्ट्रिंग्स को निकालना है। (पता चला कि मैं गलत था। ) हालांकि, आउटपुट की प्रकृति के कारण यह बिल्कुल स्पष्ट नहीं है कि कौन सा सबस्ट्रिंग सबसे अच्छा निकाला जाना चाहिए क्योंकि आप वास्तव में लाइनब्रीक के कारण पूरे वर्णमाला को नहीं निकाल सकते हैं। तो आपको लिपटे वर्णमाला के कुछ सब्सट्रिंग निकालने की आवश्यकता होगी, लेकिन फिर आप कितने समय तक सब्सट्रिंग बनाते हैं और कौन से आप चुनते हैं, इसके संदर्भ में ट्रेड-ऑफ हैं।

तो यहाँ मैंने क्या किया। यह एक सीजेएम स्क्रिप्ट है जो दी गई स्ट्रिंग में 25 तक की सभी सबस्ट्रिंग को ढूंढती है और उनमें से प्रत्येक के लिए यह गणना करता है कि इसके निकालने से कितने बाइट्स बचेंगे। मूल रूप से अगर वहाँ Nएक लंबाई की प्रतियाँ हैं M, तो आप सब्सट्रेटिंग को बचाएंगे (N-1)*(M-1) - 5, इन सबस्ट्रिंग में स्लैश नहीं होते हैं। इसके अलावा, तकनीकी रूप से, जब आप पहले से ही 8 सबस्ट्रिंग निकालते हैं, तो अंत में निरंतर ऑफसेट कम हो जाता है-4 , लेकिन स्क्रिप्ट इस पर विचार नहीं करती है।

वैसे भी, यहाँ मैंने स्क्रिप्ट के साथ क्या किया:

वर्तमान कोड (जो शुरू में सिर्फ आउटपुट है) के खिलाफ स्क्रिप्ट चलाएँ।
उन सबस्ट्रिंग्स में से जो सबसे बड़ा सुधार देते हैं, सबसे कम एक को चुनें। यदि कई हैं, तो लेक्सिकोग्राफिक रूप से सबसे छोटा चुनें (जो मैं बता सकता हूं, दिए गए इनपुट के लिए यह सबस्ट्रेट्स के बीच ओवरलैप को कम करता है)।
एक अनुपयोगी निचले मामले पत्र के साथ कोड में चुने गए विकल्प की सभी घटनाओं को बदलें।
/x/ABC/उस कोड को प्रस्तुत करें जहां xचुना गया अक्षर है और विकल्प ABCहै।
तब तक दोहराएं जब तक कि कोई ऐसी परत न छूटे जो कुछ भी बचा ले।

अंत में, हम जिसके परिणामस्वरूप की जगह कुछ और बाइट्स बचाने के //साथ |और prepending /|/\/\//(यही कारण है कि सबस्ट्रिंग निकालने केवल 4 5 के बजाय बाइट्स 8-स्ट्रिंग या तो बाद की लागत)।

जैसा मैंने कहा, मुझे कोई सुराग नहीं है कि क्या यह इष्टतम है और मुझे इसके बजाय अनियमित दिखने वाला परिणाम काफी दिलचस्प लगता है। लाइन से नीचे कहीं गैर-इष्टतम (लेकिन अधिक) सबस्ट्रिंग को चुनकर एक छोटा समाधान प्राप्त करना संभव हो सकता है। मुझे आश्चर्य है कि इस समस्या की जटिलता वर्ग क्या है ...

— मार्टिन एंडर
स्रोत

वह ... शानदार है ...

— जॉर्ज गिब्सन

1

@GeorgeGibson धन्यवाद ... जब मैंने YXआउटपुट में कुछ देखा तो मुझे आधे से ज्यादा शुरुआत करनी पड़ी । ;)

— मार्टिन एंडर

मेरा जवाब है, यह इस (बड़ा और बाद में) का एक ठिकाना था। [कि अविश्वसनीय गोल्फ] के लिए +1!

— आउटगोल्फर

जटिलता वर्ग के संबंध में, समस्या तब तक अनिर्दिष्ट नहीं होनी चाहिए, जब तक /// ट्यूरिंग पूरी नहीं हो जाती? समस्या यह है "एक स्ट्रिंग दी गई है, सबसे छोटा /// प्रोग्राम ढूंढें जो इसे आउटपुट करता है"। छोटे तारों को छोड़कर, ऐसे /// प्रोग्राम मौजूद होंगे जो लूप को अनिश्चित काल तक (लेकिन अनिश्चित काल तक लूप साबित नहीं कर सकते हैं) जो कि उन्हें हमेशा के लिए चलाए बिना वांछित आउटपुट का उत्पादन नहीं कर सकते हैं। औपचारिक प्रमाण मैं स्वयं निश्चित नहीं हूं लेकिन सहज रूप से यह संभव नहीं है?

— भूत_न_थे_कोडे

16

सी, 47 बाइट्स

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

Ideone पर इसे आज़माएं

एक एकल लूप, प्रत्येक 26 वर्णों को मुद्रित करता है, लेकिन प्रत्येक 27 वें वर्ण के साथ एक नई पंक्ति द्वारा प्रतिस्थापित किया जाता है।

— एंडर्स कसीर्ग
स्रोत

1

अरे नहीं! मैंने सिर्फ वही फंक्शन लिखा है! :-) आप पहले अर्धविराम का उपयोग करके बचा सकते हैं, f(i)फिर f()बिना किसी तर्क के कॉल करें ।

— लेवल रिवर सेंट

@LevelRiverSt यह अपरिभाषित व्यवहार पर निर्भर होगा।

— एंडर्स कासोर्ग

2

यह अंततः आपके ऊपर है, लेकिन पीपीसीजी भाषाओं को उनके कार्यान्वयन द्वारा परिभाषित करने पर विचार करता है, इसलिए जब तक आप उल्लेख करते हैं कि यह किस कंपाइलर में काम करता है, यूबी पर निर्भर होना एक समस्या नहीं माना जाता है।

— डेनिस

जब आप पहली बार उल्लेख किया है तो मैं 1 बाइट दाढ़ी कर सकता हूं:i=702;f(){for(;i--;)//...

— tucuxi

3

@tucuxi नहीं, क्योंकि फ़ंक्शन उत्तर को पुन: प्रयोज्य किया जाना है ।

— एंडर्स केसेर्ग

15

जे, 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

— लीक नन
स्रोत

अच्छा! बहुत चालाक अंकगणित। सबसे सरल दृष्टिकोण जो |. (Shift)8 बाइट्स का उपयोग करता है वह लंबा है! (i.26)(|."0 _)u:65+i.26

— डैन ओक

1

@dahnoak आप 16 बाइट्स को छोटा कर सकते हैं u:65+1&|.^:]i.26क्योंकि पावर क्रियाविशेषण पिछले परिणामों को ट्रैक करता है यदि कोई सूची दी गई है।

— मील

1

@ मीलों अच्छा, मेरा दृष्टिकोण |.17 बाइट्स का उपयोग कर रहा है: u:65+|."0 1/~i.26(अभी भी उपयोग कर रहा है /~)

— लीक नून

1

@LeakyNun एक और 17 बाइट दृष्टिकोण है u:65+(|./~,.)i.26। मैंने एक हुक का उपयोग करके और ,.श्रेणी को स्तंभित करने के लिए रैंक से छुटकारा पा लिया लेकिन यह उसी लंबाई तक समाप्त हो गया।

— मील

क्या आप नहीं जानते कि क्या मैं कहीं पर tryj.tk का सोर्स कोड पा सकता हूं? मुझे इसके बारे में न तो कोई जानकारी मिल सकी और न ही लेखक (f211) के बारे में

— Dan Oak

15

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

इसे ऑनलाइन आज़माएं!

जकुबे के एल-वर्णमाला चुनौती के अद्भुत जवाब से प्रेरित होकर , मैंने सोचा कि मैं अपने हाथ को वास्तविक प्रोग्रामिंग में /// में आज़माऊंगा, क्योंकि यह सिर्फ संपीड़न के लिए उपयोग करने के विपरीत है। यह बहुत मुश्किल था और मुझे चार प्रयासों की आवश्यकता थी, लेकिन अंत में यह मेरे संपीड़न-आधारित समाधान की तुलना में बहुत कम निकला ।

व्याख्या

/// पर एक त्वरित प्राइमर: मूल रूप से दुभाषिया सिर्फ चरित्र द्वारा कोड चरित्र पढ़ता है और निम्न कार्य करता है:

अगर यह न तो है \और न ही /इसे प्रिंट करें।
यदि यह एक है \, तो अगले वर्ण को प्रिंट करें।
यदि यह एक है /, तो एक /x/y/निर्देश (उसी भागने के नियमों के साथ) को पार्स करें और xशेष कोड में सभी को बार-बार स्थान दें y।

जकुबे से कुछ और प्रेरणा लेते हुए, सादगी के लिए मैं सिर्फ इसके 4x4 संस्करण की व्याख्या करूंगा:

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

हम :दूसरे और तीसरे के बीच के सामान के साथ उन लोगों को बदलना शुरू करते हैं /। यह अंत में कोड को बाद की पंक्तियों को घुमाएगी। हमें यह मिलता है:

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

f, bऔर xसिर्फ आम तार, जिस पर हम विस्तार के लिए shorthands हैं। fस्लैश के लिए है, bबैकस्लैश के लिए है और xके लिए है \//जो काफी एक बहुत आने के लिए होता है। इसका कारण यह है कि मैं एकल चरित्र वाले पदार्थ के लिए उपनामों का उपयोग कर रहा हूं /और \यह है कि उन्हें पहले स्थानापन्न निर्देश में भाग जाना होगा, इसलिए मैं वास्तव में उन सभी बैकस्लैश की आवश्यकता नहीं करके काफी बाइट बचा रहा हूं। यहाँ हम क्या प्राप्त करते हैं x, fऔर bभरे हुए हैं:

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

बहुत पठनीय है।

तो पहली पंक्ति सिर्फ मुद्रित शब्दशः है। फिर हम फंकी भाग को प्राप्त करते हैं जो आगे की सभी पंक्तियों को घुमाता है। इसमें वास्तव में चार अलग-अलग निर्देश होते हैं। ध्यान देने वाली बात यह है कि मैं Aइन निर्देशों के भीतर होने वाली सभी घटनाओं से बच गया हूं । इसका कारण यह है कि यह मुझे शेष पंक्तियों में एस Aसे निर्देशों के भीतर अंतर करने की अनुमति देता है A, जिसे अलग तरीके से संसाधित करने की आवश्यकता होती है।

/\/\A/\//

यह मेल खाता है /Aऔर इसे /हटाकर बदल देता है A। ध्यान दें कि यह सबस्ट्रिंग केवल प्रत्येक के सामने दिखाई देता है ABCD, इसलिए यह बाद की सभी लाइनों के पहले वर्ण को छोड़ देता है:

/
\//\A_\//

यह एक स्लैश के बाद आने वाले लाइनफीड से मेल खाता है और इसे बदल देता है A_/। तो यह Aप्रत्येक पंक्ति के अंत में सम्मिलित करता है , रोटेशन को पूरा करता है और लाइनफीड को अंडरस्कोर में भी बदल देता है।

/_\//
\//

यह मेल खाता है _/और इसे स्लैश के बाद एक लाइनफीड के साथ बदलता है। अंडरस्कोर के माध्यम से मुझे इस चक्कर को बनाने की आवश्यकता है तथ्य यह है कि /// प्रत्येक निर्देश को बार-बार लागू करता है जब तक कि स्ट्रिंग अब मेल नहीं खाती। इसका मतलब है कि आप कभी भी उस प्रपत्र के निर्देश का उपयोग नहीं कर सकते हैं /x/axb/जहाँ x, aऔर bमनमाने तार हैं, क्योंकि प्रतिस्थापन के बाद xभी हमेशा मेल खाता रहेगा। विशेष रूप से, इसका मतलब है कि हम सिर्फ एक लाइनफीड के सामने कुछ नहीं डाल सकते हैं। हमें प्रक्रिया में लाइनफीड को बदलने और इस प्रतिस्थापन को पूर्ववत करने की आवश्यकता है।

/\\\A/\\B/

यह मेल खाता है \Aऔर इसके साथ प्रतिस्थापित करता है \B, ताकि शेष पंक्तियों के बाद निर्देश अगले वर्ण को संसाधित करें। सभी चार निर्देशों को संसाधित करने के बाद शेष स्ट्रिंग इस तरह दिखता है:

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

तो अब पहली घुमाई गई पंक्ति मुद्रित हो जाती है, और फिर निर्देशों का अगला सेट शेष पंक्तियों को किसी अन्य सेल और इसी तरह घुमाता है। अंतिम रोटेशन के बाद, हमारे पास कुछ और निर्देश हैं जिन्हें हम अनदेखा कर सकते हैं और फिर हम अधूरे निर्देश के साथ समाप्त होते हैं:

/\\\B/\\

अंत में अपूर्ण निर्देशों को केवल अनदेखा किया जाता है और कार्यक्रम समाप्त हो जाता है।

— मार्टिन एंडर
स्रोत

अच्छा है। कल मैंने एक अलग विचार के साथ थोड़ा प्रयोग किया। मैं प्रत्येक वर्ण को प्रत्येक पंक्ति में स्थानापन्न करना चाहता था। कुछ की तरह A->B, B->C... लेकिन यह काफी काम नहीं किया। पहले चार को हटाना और अंत में इसे जोड़ना निश्चित रूप से एक बेहतर दृष्टिकोण है।

— जक्यूब

@ जाकुब मैंने कोशिश की कि जैसे भी हो लेकिन कहीं भी नहीं हो रहा था। बाद में दिए गए निर्देशों के साथ खिलवाड़ करने से बचना बहुत कठिन है।

— मार्टिन एंडर

1

124 बाइट्स: goo.gl/efSLKQ यह सिर्फ आपका समाधान है, लेकिन मैंने कुछ अतिरिक्त प्रतिस्थापन जोड़ दिए हैं, जिससे आपको केवल एक बार वर्णमाला लिखने की आवश्यकता है। इसी तरह की समस्या पर भी उसी रणनीति का इस्तेमाल किया।

— जकुबे

1

122: goo.gl/zRsBbR

— Jakube

11

जेली , 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.

— डेनिस
स्रोत

11

एमएसीएस, 47 बाइट्स

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

जहां ^P"नियंत्रण पी" का अर्थ है, आदि यह 47 बाइट्स है, चूंकि एफ 3 और एफ 4 कुंजी को दो एएससीआईआई बाइट्स की आवश्यकता होती है।

शुरुआती इनपुट दर्ज करने के बाद, यह लाइन को डुप्लिकेट करने के लिए एक कीबोर्ड मैक्रो को परिभाषित करता है और पहले चरित्र को अंत तक ले जाता है। यह तब मैक्रो को आगे 24 बार चलाता है।

— MattBlissett
स्रोत

2

PPCG में आपका स्वागत है, अच्छा जवाब! Emacs का उत्तर देखना बहुत ही दुर्लभ है, मुझे यह भी नहीं पता कि Emacs का उत्तर पहले ही पोस्ट किया गया है या नहीं।

— TuxCrafting

10

जावास्क्रिप्ट (ईएस 6), 56 बाइट्स

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

हां, यह सही है, मेरा आधा कोड वर्णमाला स्ट्रिंग शाब्दिक है। सर्वश्रेष्ठ मैं शाब्दिक के बिना कर सकता है 81 बाइट्स:

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

यदि आप एक फ़ंक्शन के बजाय एक कार्यक्रम चाहते हैं, तो फ़ंक्शन को हटा दें _=>console.log() 10 बाइट्स की लागत के लिए और लपेटें ।

— नील
स्रोत

वाह, अच्छा किया। एक बहुत ही सुंदर समाधान। यह कैसे काम करता है?

— पॉलीडक्स

2

@Polyducks बहुत सारे और regexp जादू के बहुत सारे। स्वाभाविक रूप /./gसे आपूर्ति की गई वर्णमाला स्ट्रिंग के प्रत्येक अक्षर से मेल खाती है। प्रतिस्थापन स्ट्रिंग में, $&मैच से पहले स्ट्रिंग का हिस्सा $'और मैच $`से पहले स्ट्रिंग का हिस्सा का प्रतिनिधित्व करता है । $`$&$'इसलिए मूल स्ट्रिंग का प्रतिनिधित्व कर सकता है, लेकिन निश्चित रूप से यह मैच के बाद के हिस्से को शुरुआत में स्थानांतरित करने के लिए तुच्छ है, इस प्रकार रोटेशन प्रभाव प्रदान करता है।

— नील

सुपर स्मार्ट! अच्छा हुआ @ नील!

— पॉलीडक्स 14

9

मेथेमेटिका 68 61 बाइट्स

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

करने के लिए धन्यवाद...

@MartinEnder (7 बाइट्स)

— मार्टिन
स्रोत

इसके अलावा, Arrayहो सकता है कि मैपिंग एक से अधिक हो Range।

— मार्टिन एंडर

मैंने अभी जाँच की है और Array वास्तव में एक बाइट को बचाता है, लेकिन आप फिर से बचाकर दूसरे को बचा सकते हैं Column: Array[{"A"~CharacterRange~"Z"~RotateLeft~#,"\n"}&,26,0]<>""(आपको बस \nएक वास्तविक फीडबेक को बदलने की आवश्यकता होगी )।

— मार्टिन एंडर

7

कोई अंतर्निर्मित प्रतीक्षा करें? असंभव

— MC JulT

1

Print@@@NestList[RotateLeft,"A"~CharacterRange~"Z",25]

— एलेफाल्फा

Grid@Array[FromCharacterCode[Mod[+##-2,26]+65]&,{26,26}]

— mathe

9

पायथन 2, 75 65 61 58 बाइट्स

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

वर्णमाला के साथ हो जाता है map(chr,range(65,91)), फिर स्ट्रिंग शिफ्ट ऑपरेशन को मैन्युअल रूप से लागू करता है।

-4 बाइट्स के लिए @LeakyNun और @TheBikingViking के लिए धन्यवाद!

-3 बाइट्स के लिए @xnor को धन्यवाद!

— तांबा
स्रोत

2

जाहिरा तौर a="ABCDEFGHIJKLMNOPQRSTUVWXYZ"पर कम है।

— लीकेई नून

1

आप क्या कर सकते हैं a[1:]के बजाय a[1:26]।

— बाइकिंग बाइक

2

अपने पाश के रूप में किया जा सकता है for x in s:print s;s=s[1:]+x।

— xnor

3

आप वर्णमाला को हार्डकोड करने से एक बाइट को छोटा कर सकते हैं s='%c'*26%tuple(range(65,91)):।

— xnor

9

सी, 88 64 बाइट्स

f()बिना बहस के बुलाओ ।

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

इसे आइडोन पर आज़माएं ।

— owacoder
स्रोत

9

पीट , 247 बाइट्स / 190 कोडेल

इसे ऑनलाइन आज़माएं!

इसलिए, मुझे अनुमान लगाने में इससे अधिक समय लगा, और मेरे पास कुछ अन्य कुशल (अधिक स्टैक-फ्रेंडली) दृष्टिकोणों पर कुछ विचार हैं, लेकिन मुझे आखिरकार काम की चीज़ मिल गई (और एक दुभाषिया बग को ठीक किया और आईडीई सुविधाओं को जोड़ा । रास्ता), तो यहाँ यह है। शायद ही सबसे बाइट-कुशल भाषा है, लेकिन बहुत मज़ा आता है। यहाँ एक बड़ा दृश्य है, और एक ट्रेस लिया गया रास्ता दिखा रहा है। मेरे GitHub पर इतिहास ।

स्टैक-आधारित भाषा के रूप में, यह अब तक संक्षेप में समझाने के लिए बहुत जटिल है, लेकिन यहां विभिन्न वर्गों / छोरों का एक मूल अवलोकन है। सभी चर और फ़ंक्शन नाम केवल स्पष्टीकरण के लिए हैं, क्योंकि पीट में कोई चर या फ़ंक्शन नहीं हैं।

प्रारंभिक (ऊपरी-बाएं): line_counter27 से शुरू होता है , '@' को लोड करता हैcur_letter , सेट के करता हैletter_count होता है
मुख्य लूप (गहरे बैंगनी, केंद्र शीर्ष पर शुरू)
- decrements letter_counter
- शाखाओं को reset_line यदि शून्य (प्रकाश सियान 2-ब्लॉक)
- रोल्स cur_letterस्टैक के शीर्ष पर
- शाखाओं को check_done अगरcur_letter > 'X' (चैती / लाल ब्लॉक, दाईं ओर)
- वेतन वृद्धि cur_letter और आउटपुट (निचले-दाएं कोने)
- शाखाओं को reset_letter अगरcur_letter > 'Y' (हल्का हरा ब्लॉक, बाएं)
- रोल `letter_counter_ वापस स्टैक के शीर्ष पर, वापस लूप के शीर्ष पर
reset_line शाखा (बड़ा गुलाबी वर्ग):
- आउटपुट newline वर्ण
- पुनः निर्धारित करता है letter_count27 को है
- मुख्य लूप के शीर्ष पर वापस जाता है
check_done शाखा (ठीक आधा अंदर)
- रोल्स line_counter करने के लिए शीर्ष
- यदि शून्य हो तो शाखाएँ
- decrements line_counter और रोल वापस ढेर के नीचे करने के लिए
- फिर से शुरू होता है जहां इसे छोड़ दिया, मुद्रण पत्र
reset_line शाखा (बाईं ओर, हरा ब्लॉक):
- cur_letter'@' को रीसेट करता है
- फिर से शुरू, जहां यह छोड़ दिया, रोलिंग / पाश के शीर्ष पर लौटने

— cincodenada
स्रोत

8

MATL , 8 बाइट्स

@ डेनिस के धन्यवाद के साथ , जिन्होंने सुझाव दिया कि 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

— लुइस मेंडो
स्रोत

8

जावास्क्रिप्ट, 113 96 91 76 बाइट्स

कंसोल में चलने के लिए एक सुपर-लघु संस्करण:

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

स्निपेट का विस्तार करें

जावास्क्रिप्ट / एचटीएमएल, 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 का उपयोग करना चाहिए)

(EDIT 2: उनके इनपुट के लिए @Neil और @DanTheMan को धन्यवाद (टिप्पणियां देखें))

— Polyducks
स्रोत

क्या पहला C = 26 अप्रासंगिक नहीं है?

— डैनमैन मैन

ओह तस्वीर। ऐसा लगता है कि जब मैं इसे स्थानांतरित करने के लिए इसे हटाना भूल गया था। फिक्स्ड! धन्यवाद @DanTheMan :)

— Polyducks

1

l.slice(0,1)बस है l[0], जबकि ,27अनावश्यक है, जिस बिंदु पर आप स्लाइस को स्थानांतरित कर सकते हैं और समाप्त कर सकते हैं l.slice(1)+l[0]। इसके अलावा, मुझे लगता है कि आप console.logलूप बॉडी को स्थानांतरित कर सकते हैं और इस प्रकार अनुगामी से बच सकते हैं ;।

— नील

अब यह परीक्षण, धन्यवाद @ धन्यवाद! संपादित करें: मीठा पवित्र मोली। आप दोनों को धन्यवाद, मैं आपको टिप्पणी में श्रेय दूंगा।

— पॉलिडाक्स

1

ओह, अच्छा, यह सरल करने का एक और भी बेहतर तरीका है console.log ।

— नील

8

पॉवरशेल, 44 बाइट्स

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

— एक छोटा सा सिक्का
स्रोत

8

आर, 47 42 41 बाइट्स

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

इसे ऑनलाइन आज़माएं!

27 वर्णों को उत्पन्न करता है, 27 स्तंभों को हटाता है और 26 स्तंभों में प्रिंट करता है।

@Giuseppe के समाधान से प्रेरित सुधार ।

— रॉबर्ट हैकेन
स्रोत

1

46 बाइट्स

— Giuseppe

वाह, मैंने सोचा कि मैंने हर इंडेक्सिंग ट्रिक का उपयोग करने की कोशिश की थी repलेकिन यह विशेष रूप से प्रेरित था! बहुत अच्छा। अगर मैं कर सकता तो मैं फिर से उठता।

— ग्यूसेप

आप उपयोग कर सकते हैं 1के बजाय ""के लिए stdout।

— ग्यूसेप

6

सेसोस , 27 25 बाइट्स

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

इसे ऑनलाइन आज़माएं! उत्पन्न SBIN कोड देखने के लिए डीबग की जाँच करें । ^†

सीसोस विधानसभा

ऊपर की बाइनरी फ़ाइल निम्नलिखित एसएएसएम कोड को इकट्ठा करके बनाई गई है।

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 लिखते हैं वर्तमान सेल को , संबंधित वर्ण (लाइनफीड) को प्रिंट करते हैं और सेल को कॉल के साथ शून्य करते हैं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

अब हम डेटा हेड को 27 यूनिट बाईं ओर ले जाते हैं।

 v
65 0 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

बाद में प्रिंटिंग लूप प्रिंट करता है Aऔर टेप को इस प्रकार छोड़ता है।

   v
65 0 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

एक बार फिर, हम एक लाइनफ़ीड प्रिंट करते हैं, सेल की सामग्री को वर्तमान सेल के दाईं ओर ले जाते हैं, फिर डेटा हेड को इकाइयों में दाईं ओर ले जाते हैं।

         v
65 66 0 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

24 अधिक पुनरावृत्तियों के बाद , डेटा हेड को दाईं ओर ले जाने का अंतिम चरण टेप को निम्न अवस्था में छोड़ देता है।

                                                                                v
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0 0

डेटा हेड के तहत सेल अब 0 है और प्रोग्राम समाप्त हो जाता है।

^, TIO Sesos के नए संस्करण का उपयोग करता है, जो SASM के लिए पीछे की ओर संगत है, लेकिन कम SBIN कोड उत्पन्न करता है।

— डेनिस
स्रोत

6

हास्केल, 56 53 52 बाइट्स

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

समान लंबाई: (@AndersKaseorg द्वारा एक सुझाव का उपयोग करके)

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

मॉड्यूलर सामान करने के लिए आपको chr फंक्शन प्राप्त करने के लिए Data.Char को इम्पोर्ट करना होगा। 74 59 58 बाइट्स सबसे अच्छा था जो मुझे मिल सकता था: (tonnum फंक्शन सुझाने के लिए @nimi को धन्यवाद)

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

यह शायद बहुत कम हो सकता है, लेकिन मैं किसी हास्केल गोल्फिंग ट्रिक्स को नहीं जानता।

MapM_ के बजाय mapM का उपयोग किया (देखें @ लिन की टिप्पणी)

— KarlKastor
स्रोत

1

Used3 बाइट्स के लिए, में परिवर्तन ['A'..x]करें ['A'..'Z'], जो अब दो बार उपयोग किया जाता है, और इसे एक परिभाषा में उठाएं।

— एंडर्स कासोर्ग

@AndersKaseorg: धन्यवाद! हालांकि, मुझे एक और विचार मिला जिसने इसे एक ऑनलाइनर रखते हुए समान बाइट्स की संख्या को बचाया। मैंने आपके सुझाव को वैकल्पिक समाधान में जोड़ा, हालाँकि।

— कार्ल कस्तोर

यदि आपको केवल जरूरत chrहै Data.Char, तो आप toEnumइसके बजाय उपयोग कर सकते हैं और इसे छोड़ सकते हैं import।

— 22:59

1

मुझे बदलने का मन mapM_कर रहा हैmapM ठीक होना चाहिए। शायद यह एक मेटा पोस्ट के लायक है ...

— लिन

6

आर, 53 बाइट्स

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

यहाँ यह एक ऑनलाइन दुभाषिया पर है ।

— plannapus
स्रोत

5

रेटिना, 36 31 बाइट्स

मार्टिन एंडर को 5 बाइट्स धन्यवाद।

जेड
{2`
$ `
} T01`L`_L
\ `।
$ & $ '$ `¶

अग्रणी स्तनपान महत्वपूर्ण है।

इसे ऑनलाइन आज़माएं!

क्रेडिट ।

— लीक नन
स्रोत

5

ब्रेन-फ्लैक , 222 बाइट्स

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

इसे ऑनलाइन आज़माएं!

मैं ब्रेन-फ्लैक में नया हूं, इसलिए हो सकता है कि यह बहुत बड़ा हो सकता है, लेकिन कम से कम यह पहली कोशिश है। यह बाएं स्टैक पर 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

— डोरियन
स्रोत

5

वी , 36 , 10 बाइट्स

¬AZ25ñÙx$p

इसे ऑनलाइन आज़माएं!

यह "लैटिन 1" एन्कोडिंग का उपयोग करता है।

स्पष्टीकरण:

¬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

— DJMcMayhem
स्रोत

जाओ और फिर इसे

— जोड़ो

@ C @O'Bʀɪᴇɴ आपको अब तक पता होना चाहिए कि इस भाषा में कुछ भी करने का एकमात्र तरीका घोंघे की गति से है। संभवत: मैं अगले साल जनवरी में उठकर चलूंगा। : पी

— DJMcMayhem

ओह, अगले 6-8 सप्ताह में?

— कॉनर ओ'ब्रायन

4

सी #, 98 बाइट्स

मैंने यह देखने की कोशिश की है कि क्या मैं उन्हें एक स्ट्रिंग के रूप में शुरू करने की तुलना में छोटे अक्षरों को उत्पन्न कर सकता हूं, लेकिन यह वास्तव में संभव नहीं है। पत्र 26 बाइट्स हैं और यह स्निपेट अकेले है

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

25 बाइट्स है। मुझे लगता है कि उन्हें शुरू करना और फिर उन्हें + = a के साथ जोड़ना एक अच्छा उपाय है, लेकिन C # के साथ आप इस तरह के कार्यों के bytecount द्वारा सीमित हैं Substring()औरConsole.WriteLine() ।

98 बाइट्स में मेरा प्रयास:

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

— डैनियल
स्रोत

4

ऑक्टेव, 27 बाइट्स

हम एक पंक्ति और एक स्तंभ वेक्टर जोड़ रहे हैं, और ऑक्टेव अच्छी तरह से सिग्लन आयामों का विस्तार करता है, bsxfun(जैसा कि आपको मतलब में आवश्यकता होगी) की कोई आवश्यकता नहीं है ।

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

— flawr
स्रोत

4

क्यू, 20 बाइट्स

(til 26)rotate\:.Q.A

— skeevey
स्रोत

14 बाइट्स -1_'26 27#.Q.A

— स्ट्रीटस्टर

4

जावा, 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);}}

— Master_ex
स्रोत

आप आसानी से कुछ और बाइट्स शेव कर सकते हैं: System.out.printf("%c", ...)-> System.out.write(...), '\n'-> 10, 'A'-> 65। ध्यान दें कि न्यूलाइन / लाइन फीड चार सुझाव की अनुमति है, लेकिन विचारधारा आउटपुट की आवश्यकता है। :)

— एमएच।

@MH। महान युक्तियाँ! 9 बाइट्स बचाए :)

— Master_ex

मुझे पता है कि आपको यह उत्तर दिए हुए एक साल से अधिक हो गया है, लेकिन आप अभी भी कुछ चीजें गोल्फ कर सकते हैं: जिस स्थान को String[]aहटाया जा सकता है; और int s=0;while(s<26){p(s,26);p(0,s++);p(-1,0);}हो सकता है for(int s=0;s<26;p(0,s++),p(0,s++))p(s,26);।

— केविन क्रूज़सेन

4

बैश, 66 बाइट्स

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

मैं एक पूर्ण वर्णमाला बनाता हूं A, फिर शुरू होने वाले पात्रों को ले जाकर nऔर उन पूर्ववर्ती स्थिति को जोड़कर इसके 26 घुमाए गए संस्करणों को मुद्रित करता हूं n।

— टोबी स्पाईट
स्रोत

4

पर्ल, 42 बाइट्स

इसके लिए @Dom हेस्टिंग्स को पूरा श्रेय।

@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}'

यह संभव है कि हालांकि कम हो, लेकिन मुझे पता नहीं चला कि कैसे ... अभी तक

— बापू
स्रोत

42 बाइट समाधान के एक जोड़े के साथ आने का प्रबंधन: @l=A..Z;say@l[$_..25],@l[0..$_-1]for 0..25और $_=join"",A..Z;eval'say;/./;$_=$\'.$&;'x26दोनों की आवश्यकता होती है -E/ -M5.010।

— डोम हेस्टिंग्स 15

अच्छी तरह से किया। मेरी कोशिश से बहुत बेहतर लग रहा है! धन्यवाद

— दादा