65

जॉर्ज गिब्सन प्रिंट द्वारा एक तबुला आयत से प्रेरित ।

आप इस सटीक टेक्स्ट को प्रिंट / आउटपुट कर सकते हैं:

ABCDEFGHIJKLMNOPQRSTUVWXYZ
BBCDEFGHIJKLMNOPQRSTUVWXYZ
CCCDEFGHIJKLMNOPQRSTUVWXYZ
DDDDEFGHIJKLMNOPQRSTUVWXYZ
EEEEEFGHIJKLMNOPQRSTUVWXYZ
FFFFFFGHIJKLMNOPQRSTUVWXYZ
GGGGGGGHIJKLMNOPQRSTUVWXYZ
HHHHHHHHIJKLMNOPQRSTUVWXYZ
IIIIIIIIIJKLMNOPQRSTUVWXYZ
JJJJJJJJJJKLMNOPQRSTUVWXYZ
KKKKKKKKKKKLMNOPQRSTUVWXYZ
LLLLLLLLLLLLMNOPQRSTUVWXYZ
MMMMMMMMMMMMMNOPQRSTUVWXYZ
NNNNNNNNNNNNNNOPQRSTUVWXYZ
OOOOOOOOOOOOOOOPQRSTUVWXYZ
PPPPPPPPPPPPPPPPQRSTUVWXYZ
QQQQQQQQQQQQQQQQQRSTUVWXYZ
RRRRRRRRRRRRRRRRRRSTUVWXYZ
SSSSSSSSSSSSSSSSSSSTUVWXYZ
TTTTTTTTTTTTTTTTTTTTUVWXYZ
UUUUUUUUUUUUUUUUUUUUUVWXYZ
VVVVVVVVVVVVVVVVVVVVVVWXYZ
WWWWWWWWWWWWWWWWWWWWWWWXYZ
XXXXXXXXXXXXXXXXXXXXXXXXYZ
YYYYYYYYYYYYYYYYYYYYYYYYYZ
ZZZZZZZZZZZZZZZZZZZZZZZZZZ

(हां, मैंने हाथ से टाइप किया)

आपको सभी अपरकेस के बजाय सभी लोअरकेस का उपयोग करने की अनुमति है।

हालाँकि, आपकी पसंद का मामला पूरे पाठ के अनुरूप होना चाहिए।

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

प्रत्येक सबमिशन या तो एक पूर्ण कार्यक्रम या फ़ंक्शन होना चाहिए। यदि यह एक फ़ंक्शन है, तो प्रोग्राम के निचले भाग में फ़ंक्शन कॉल को जोड़ने की आवश्यकता के द्वारा इसे चलाया जा सकता है। कुछ भी (जैसे सी में हेडर) शामिल किया जाना चाहिए।
यदि यह संभव है, तो उस साइट का लिंक प्रदान करें जहां आपके कार्यक्रम का परीक्षण किया जा सकता है।
आपके प्रोग्राम को कुछ भी नहीं लिखना चाहिए 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 = 87064; // 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 = 48934; // 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>

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

code-golf kolmogorov-complexity alphabet

— लीक नयन
स्रोत

1

एक्सेल, 19,604 बाइट्स

=CHAR(64+MAX(COLUMN(),ROW()))

इस सूत्र को चिपकाएँ A1, फिर सभी को खींचें A1:Z26।

बाइट गिनती:

सूत्र 27 बाइट्स है।
आपको इसे 26 ^ 2 बार कॉपी करना होगा। 27 * 26 * 26 = 19604।
मुझे और अन्य लोगों को लगा कि स्कोर कम होना चाहिए क्योंकि आपको बार-बार फॉर्मूला टाइप करने की जरूरत नहीं है। अब मुझे लगता है कि यह अप्रासंगिक है - हम कार्यक्रम के आकार की गणना करते हैं, न कि काम करने वाले इसे लिखने में खर्च करते हैं।
तुलना के लिए - यह 28,187 वर्ण जेएस उत्तर देखें - जाहिर है, किसी ने यह सब टाइप करने के बजाय इसे उत्पन्न किया, लेकिन यह इसका आकार नहीं बदलता है।

— ugoren
स्रोत

22

इसने मुझे हंसाया, आपको मेटा स्किंग पर पोस्ट करना चाहिए कि इसे कैसे गिना जाए

— रोहन झुनझुनवाला

19

इसके लिए एक उचित गणना 45: (1) A1:Z26नाम बॉक्स में टाइप की जाएगी (फॉर्मूला बार के बाईं ओर) [ 7 बाइट्स]; (2) टाइप =CHAR(64+MAX(COLUMN(),ROW()))+ फॉर्मूला बार [ 30 बाइट्स] में दर्ज करें; (3) Alt E I D Alt E I Rचयनित सीमा [ 8 बाइट्स] को भरने के लिए टाइप करें । कुल 7 + 30 + 8 = 45 ।

— जोफैन

8

मुझे नहीं लगता कि मतली की कम मात्रा के रूप में स्वत: पूर्ण गिनती। तब मैं निस्संदेह अपने जाल को कम करके अपने जावा को छोटा कर सकता था। मुझे लगता है कि कीस्ट्रोक्स 46 किस्ट्रोक्स द्वारा किया गया उपाय अधिक उचित है

— रोहन झुनझुनवाला

3

@rohan I, एक के लिए, आपके साथ Java + स्वतः पूर्ण भाषा कहने से पूरी तरह ठीक होगा।

— जॉन ड्वोरक

5

@ जोफन [A1:Z26]="=CHAR(64+MAX(COLUMN(),ROW()))"40 बाइट्स है और अभी भी सुरुचिपूर्ण है

— अनास्तासिया-

39

विम, 43 बाइट्स

:h<_↵jjYZZPqqlmaYp`ajyl:norm v0r♥"↵`ajq25@q

यहाँ ↵रिटर्न ( 0x0a) का ♥प्रतिनिधित्व करता है और Ctrl-R ( 0x12) का प्रतिनिधित्व करता है ।

नहीं के रूप में बहुत कम के रूप में मेरे तबला व्याख्यान का जवाब है, लेकिन ...

— लिन
स्रोत

3

क्या। । नरक। है। इस। सुनसान। जादू।

— haneefmubarak

1

आप किस हेल्प पेज को खोल रहे हैं? जब मैं कर h<_↵यह मेरे लिए लाता है:help at_t

— DJMcMayhem

मैं v_b_<_exampleCygwin के लिए Vim 7.4 में खुल रहा हूं ।

— लिन

@haneefmubarak हाँ, यह विम का जादू है।

— क्रोमियम

28

जेली, 6 बाइट्स

ØA»'j⁷

इसे यहाँ आज़माएँ। अगर कल ही मैं आलसी नहीं होता और उस एक-बाइट को वैकल्पिक रूप से लागू करता j⁷(नए सिरे से जुड़ता) ...

ØA      The uppercase alphabet.
  »'    Table of max(x, y).
    j⁷  Join by newlines.

— लिन
स्रोत

7

आर्ग, निंजा कुछ मिनटों के लिए चाहेंगे ... चेन कांटा होने के बाद से उस विकल्प ने मदद नहीं की होगी।

— डेनिस

बेवकूफ सवाल है, लेकिन अगर यह 6 बाइट्स है, तो यह किस वर्ण में सेट है?

— श्री लिस्टर

@MrLister: मैंने उत्तर के शीर्षक में जेली कोड पृष्ठ पर एक लिंक जोड़ा।

— लिन

लाइनफीड से जुड़ें है Y।

— पुरकाकूदरी

@ Pietu1998 मुझे लगता है कि Yपोस्ट की तारीख हालांकि चुनौती है

— caird coinheringaahing

17

ब्रेनफक, 103 96 95 91 87 बाइट्स

+++++[>+++++>++<<-]>+[[<<<+>>>-]----[<+>----]<+<<[>+>+>+<<<-]>-]>>[[<.>-]>[.>>]<<[<]>>]

यह 64 के लिए Esolangs के ब्रेनफक स्थिरांक का उपयोग करता है । इसे ऑनलाइन आज़माएं!

— डेनिस
स्रोत

16

/// , 141 94 92 82 बाइट्स

/:/\\\\A//#/: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://:/\/a#
\/a\///A/#

इसे ऑनलाइन आज़माएँ: प्रदर्शन

काफी मजेदार भाषा।

व्याख्या:

केवल 4x4 वर्ग प्रिंट करने के लिए संक्षिप्त कोड:

/:/\\\\A//#/:b:c:d://:/\/a#
\/a\///A/#

पहले प्रतिस्थापन के साथ /:/\\\\A/बदल :जाता है \\A। यह देता है:

/#/\\Ab\\Ac\\Ad\\A//\\A/\/a#
\/a\///A/#

फिर के साथ /#/\\Ab\\Ac\\Ad\\A//\\A/बदलता #है \Ab\Ac\Ad\A:

/\\A/\/a\Ab\Ac\Ad\A
\/a\///A/\Ab\Ac\Ad\A

अब इसके बाद के कोड में /\\A/\/a\Ab\Ac\Ad\A<newline>\/a\//प्रत्येक \Aको प्रतिस्थापित करता है /aAbAcAdA<newline>/a/, इसलिए यह इस प्रकार है:

/A//aAbAcAdA
/a/b/aAbAcAdA
/a/c/aAbAcAdA
/a/d/aAbAcAdA
/a/

अब पहला भाग /A//सभी As को हटा देता है ।

abcd
/a/b/abcd
/a/c/abcd
/a/d/abcd
/a/

पहले पाँच वर्ण abcd<newline>छपते हैं। अगले आदेश द्वारा /a/b/प्रतिस्थापित aकिया जाता है b, जिसके परिणामस्वरूप:

bbcd
/b/c/bbcd
/b/d/bbcd
/b/

फिर से पहले पाँच वर्ण bbcd<newline>छपते हैं। अगले आदेश द्वारा /b/c/प्रतिस्थापित :bc

cccd
/c/d/cccd
/c/

फिर से पहले पाँच वर्ण cccd<newline>छपते हैं। अगले आदेश द्वारा /c/d/प्रतिस्थापित :cd

dddd
/d/

पहले पाँच वर्ण dddd<newline>छपते हैं। और अगला कमांड /d/अधूरा है और इसलिए कुछ भी नहीं करता है।

— Jakube
स्रोत

अरे, यह चालाक है। अच्छा काम। :) इन पंक्तियों के साथ समाधान के लिए कोई विचार तबला रेका चुनौती?

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

@MartinEnder नहीं, अभी तक नहीं। मैं इसे शाम को देखूंगा। इस चुनौती के कारण दोपहर के भोजन के ब्रेक को पहले से ही एक पूरे घंटे (दो बार सामान्य रूप से) तक बढ़ा दिया।

— जकूबे

मुझे कुछ पता चला (अपने विचारों से बहुत मदद के साथ, विशेष रूप से जिस तरह से आप एक के बाद एक चरित्र को संसाधित करने के लिए बाद के निर्देशों को संशोधित करते हैं)।

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

15

दिल्लोग एपीएल , 11 बाइट्स

⎕A[∘.⌈⍨⍳26]

A[... पहले 26 पूर्णांक की अधिकतम तालिका के ]अनुसार अपरकेस वर्णमाला से तत्व चुनें
∘.⌈⍨
⍳26

TryAPL ऑनलाइन!

— एडम
स्रोत

10

गणितज्ञ, 69 65 57 बाइट्स

^{@MartinEnder के कारण 8 बाइट्स की बचत हुई ।}

FromCharacterCode[64+Max~Array~{26,26}]~StringRiffle~"
"&

अनाम फ़ंक्शन। कोई इनपुट नहीं लेता है और आउटपुट के रूप में एक स्ट्रिंग लौटाता है। मूल रूप से बस char('A' + max(x, y))सभी x , y से 1 से 26 तक लगते हैं।

— LegionMammal978
स्रोत

5

10k पर बधाई!

— लोवोजो

9

/// , 348 बाइट्स

/|/\/\///v/NNN|u/MMM|t/LLL|s/WXYZ|r/OOO|q/KLMa|p/RRRR|o/QQQQ|n/PPPP|m/SSS|l/EFGc|k/RSTb|j/UUUU|i/TTTT|h/WWW|g/VVV|f/XXXX|e/ZZZZZ|d/YYYYY|c/HIJq|b/UVs
|a/NOPQk/ABCDlBBCDlCCCDlDDDDlEEEElFFFFFFGcGGGGGGGcHHHHHHHcIIIIIIIIIJqJJJJJJJJJJqKKKKKKKKKKqttttMauuuuMavvvvNarrrrrPQknnnnQkooooQkppppRkmmmmmmSTbiiiiibjjjjjbgggggggVs
hhhhhhhWs
ffffffYZ
dddddZ
eeeeeZ

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

मैंने इसे बनाने के लिए उसी तकनीक का उपयोग किया है जो मेरे /// उत्तर के लिए चुनौती पर आधारित थी । हालाँकि, मुझे CJam स्क्रिप्ट को ठीक करना पड़ा क्योंकि यह सही ढंग से उन सबस्ट्रिंग को हैंडल नहीं करता था जो खुद को ओवरलैप कर सकते हैं।

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

मुझे वास्तव में इस भाषा को सीखने की जरूरत है ...

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

9

रेटिना , 41 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है। अग्रणी लाइनफीड महत्वपूर्ण है।


26$*Z
{`^[^A].+
$&¶$&
}T0-2`L`_L`^(.)\1+

व्याख्या


26$*Z

स्ट्रिंग को 26 प्रतियों में सेट करें Z। तब {...}रेटिना को शेष दो निर्देशों को लूप में निष्पादित करने के लिए निर्देश दें जब तक कि स्ट्रिंग बदलना बंद न हो जाए।

{`^[^A].+
$&¶$&

पहली पंक्ति को डुप्लिकेट करें यदि यह a से शुरू नहीं होता है A।

}T0-2`L`_L`^(.)\1+

यह एक लिप्यंतरण चरण है। यह केवल तभी लागू होता है जब स्ट्रिंग एक ही चरित्र की कम से कम दो प्रतियों के साथ शुरू होती है। यदि हां, तो उन पात्रों में से सभी अंतिम हैं। डिक्रिप्टिंग L(ऊपरी मामले वर्णमाला) मैपिंग (ऊपरी मामले वर्णमाला के _Lबाद रिक्त ) द्वारा होती है। "सभी लेकिन अंतिम" उस सीमा से संकेतित होता है -2जो रेटिना को केवल मैच के दूसरे-से-अंतिम तक के सभी पात्रों को बदलने के लिए कहता है।

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

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

2

100k के लिए बधाई! :)

— Yytsi

8

हास्केल, 35 बाइट्स

a=['A'..'Z']
unlines$(<$>a).max<$>a

— लिन
स्रोत

8

अजगर 2, 59 बाइट्स

n=0;exec'print bytearray([n+65]*n+range(n+65,91));n+=1;'*26

Ideone पर इसका परीक्षण करें ।

— डेनिस
स्रोत

7

आर, 58 बाइट्स

l=LETTERS;for(i in 1:26){l[2:i-1]=l[i];cat(l,"\n",sep="")}

ऑपरेटर पूर्वता के लिए धन्यवाद, 2:i-1के बराबर है 1:(i-1)। अंतर्निहित निरंतर का उपयोग करता LETTERSहै जिसमें ऊपरी मामले में वर्णमाला होती है। बाकी सब कुछ आत्म-व्याख्यात्मक है।
उपयोग:

> l=LETTERS;for(i in 1:26){l[2:i-1]=l[i];cat(l,"\n",sep="")}
ABCDEFGHIJKLMNOPQRSTUVWXYZ
BBCDEFGHIJKLMNOPQRSTUVWXYZ
CCCDEFGHIJKLMNOPQRSTUVWXYZ
DDDDEFGHIJKLMNOPQRSTUVWXYZ
EEEEEFGHIJKLMNOPQRSTUVWXYZ
FFFFFFGHIJKLMNOPQRSTUVWXYZ
GGGGGGGHIJKLMNOPQRSTUVWXYZ
HHHHHHHHIJKLMNOPQRSTUVWXYZ
IIIIIIIIIJKLMNOPQRSTUVWXYZ
JJJJJJJJJJKLMNOPQRSTUVWXYZ
KKKKKKKKKKKLMNOPQRSTUVWXYZ
LLLLLLLLLLLLMNOPQRSTUVWXYZ
MMMMMMMMMMMMMNOPQRSTUVWXYZ
NNNNNNNNNNNNNNOPQRSTUVWXYZ
OOOOOOOOOOOOOOOPQRSTUVWXYZ
PPPPPPPPPPPPPPPPQRSTUVWXYZ
QQQQQQQQQQQQQQQQQRSTUVWXYZ
RRRRRRRRRRRRRRRRRRSTUVWXYZ
SSSSSSSSSSSSSSSSSSSTUVWXYZ
TTTTTTTTTTTTTTTTTTTTUVWXYZ
UUUUUUUUUUUUUUUUUUUUUVWXYZ
VVVVVVVVVVVVVVVVVVVVVVWXYZ
WWWWWWWWWWWWWWWWWWWWWWWXYZ
XXXXXXXXXXXXXXXXXXXXXXXXYZ
YYYYYYYYYYYYYYYYYYYYYYYYYZ
ZZZZZZZZZZZZZZZZZZZZZZZZZZ

— plannapus
स्रोत

एक नए उपयोगकर्ता को यहां

— Kritii Lithos

7

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

0000000: 2829c0 756fc6 aecae2 aecd9c 39e09e 099c63 7d8e3d  ().uo.......9....c}.=
0000015: 65a7c0 39                                         e..9

इसे ऑनलाइन आज़माएं! उत्पन्न 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
        rwd 1, add 1, fwd 1, sub 1
    jnz
    nop
        rwd 1
    jnz
    fwd 1
    jmp
        put, add 1, fwd 1
    jnz
    fwd 1
    jmp
        put, fwd 1
    jnz
    add 10, put, get
    nop
        rwd 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

अब हम आउटपुट उत्पन्न करने के लिए तैयार हैं, निम्नलिखित प्रक्रिया को दोहराते हुए जब तक कि डेटा हेड के तहत सेल शून्य न हो जाए।

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

   v
0 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

अब, हम सभी कोशिकाओं को प्रिंट करते हैं, डेटा हेड के नीचे एक के साथ शुरू करते हैं और दाएं चलते हैं जब तक कि हम 0 सेल नहीं पाते हैं , प्रत्येक मुद्रित सेल को प्रिंट करने के बाद बढ़ाते हैं। मुद्रण के बाद A, टेप निम्नानुसार दिखता है।

     v
0 66 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

अब हम दाएं चलते हैं, फिर से सभी सेल को तब तक प्रिंट करते हैं जब तक कि एक 0 सेल सामने न आ जाए। मुद्रण के बाद BCDEFGHIJKLMNOPQRSTUVWXYZ, टेप निम्नानुसार दिखता है।

                                                                                  v
0 66 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

अब, हम वर्तमान सेल में 10 लिखते हैं , संबंधित वर्ण (लाइनफीड) को प्रिंट करते हैं और getखाली इनपुट पर कॉल के साथ सेल को शून्य करते हैं , जिससे टेप अपरिवर्तित रहता है।

अंत में, हम अंतिम गैर-शून्य पर बाईं ओर जाते हैं, अगले पुनरावृत्ति के लिए टेप तैयार करते हैं।

        v
0 66 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

अगला पुनरावृति समान है। हम पहले 66 एक सेल को बाईं ओर ले जाते हैं, दोनों 66 सेल ( BB) को प्रिंट करते हैं और उन्हें 67 तक बढ़ाते हैं , फिर शेष गैर-शून्य कोशिकाओं को दाईं ओर प्रिंट करते हैं ( CDEFGHIJKLMNOPQRSTUVWXYZ), और अंत में डेटा हेड को 67 पर रखते हैं , टेप को निम्नानुसार छोड़ते हैं ।

           v
0 66 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 अधिक पुनरावृत्तियों और मुद्रण के बाद ZZZZZZZZZZZZZZZZZZZZZZZZZZऔर एक linefeed, टेप निम्नलिखित राज्य में छोड़ दिया है।

                                                                                  v
0 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 0 0

डेटा सिर को बाईं ओर अगले गैर-शून्य सेल में ले जाने से यह अपनी वर्तमान स्थिति में निकल जाएगा, इसलिए इसके तहत सेल 0 है और लूप समाप्त हो जाता है।

— डेनिस
स्रोत

7

जे, 13 बाइट्स

u:65+>./~i.26

ऑनलाइन दुभाषिया ।

व्याख्या

u:65+>./~i.26
         i.26  generate [0 1 ... 25]
       /~      build a table...
     >.        ...of maximum
  65+          add 65 to each element
u:             convert to unicode

— लीक नयन
स्रोत

6

मतलाब / ऑक्टेव, 43 39 बाइट्स

1 बाइट ने चेर में[...,''] बदलने के लिए उपयोग करने के @ बीकर के विचार के लिए धन्यवाद हटा दिया ।

@()[91-rot90(gallery('minij',26),2),'']

यह एक अनाम फ़ंक्शन है जो 2D वर्ण सरणी लौटाता है।

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

व्याख्या

gallery('minij',...) एक मैट्रिक्स देता है जिसमें प्रत्येक प्रविष्टि अपनी पंक्ति और स्तंभ सूचक के न्यूनतम के बराबर होती है:

 1     1     1     1  ...
 1     2     2     2
 1     2     3     3
 1     2     3     4
 ...

यह 180 डिग्री के साथ घुमाया जाता है rot90(...,2):

26    25    24    23  ...
25    25    24    23
24    24    24    23
23    23    23    23
...

91-...आपरेशन बड़े अक्षरों का ASCII कोड देता है:

65    66    67    68
66    66    67    68
67    67    67    68
68    68    69    68 ...
...

अंत में [...,'']एक खाली स्ट्रिंग के साथ क्षैतिज रूप से समतल करता है। इससे चर में परिवर्तित होने का प्रभाव पड़ता है।

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

1

बहुत चतुर उपयोगgallery

— स्वेवर

2

बहुत बुरा है `नहीं gallery('maxij',...), हुह? ;)

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

@MartinEnder पूरी तरह से! :-) BTW, मैं Mathematica buildin की प्रतीक्षा कर रहा हूँ ...

— लुइस मेंडू

आप एक लंबे इंतजार के लिए हैं, यह एक स्ट्रिंग-आधारित चुनौती है। : पी

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

6

PowerShell v2 +, 76 52 40 बाइट्स

65..90|%{-join[char[]](,$_*$i+++$_..90)}

से लूप्स 65के लिए 89। प्रत्येक पुनरावृत्ति, हम अल्पविराम-संचालक का उपयोग करके एक सरणी का निर्माण कर रहे हैं, जिसमें वर्तमान संख्या के $_बाद के सहायक चर द्वारा गुणा किया गया है $i++, जिसे वर्तमान संख्या के एक सरणी के साथ समाहित किया $_गया है 90। कि एक चार-सरणी डाली में समझाया गया है, और -joinएक स्ट्रिंग में एक साथ एड। उदाहरण के लिए, पहली पुनरावृत्ति के लिए, यह सारणी 65..90या संपूर्ण वर्णमाला के बराबर होगी । दूसरी पुनरावृत्ति होगी 66+66..90, या पूरे वर्णमाला के साथ Bदोहराया और नहीं A।

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

PS C:\Tools\Scripts\golfing> .\print-the-l-phabet.ps1
ABCDEFGHIJKLMNOPQRSTUVWXYZ
BBCDEFGHIJKLMNOPQRSTUVWXYZ
CCCDEFGHIJKLMNOPQRSTUVWXYZ
DDDDEFGHIJKLMNOPQRSTUVWXYZ
EEEEEFGHIJKLMNOPQRSTUVWXYZ
FFFFFFGHIJKLMNOPQRSTUVWXYZ
GGGGGGGHIJKLMNOPQRSTUVWXYZ
HHHHHHHHIJKLMNOPQRSTUVWXYZ
IIIIIIIIIJKLMNOPQRSTUVWXYZ
JJJJJJJJJJKLMNOPQRSTUVWXYZ
KKKKKKKKKKKLMNOPQRSTUVWXYZ
LLLLLLLLLLLLMNOPQRSTUVWXYZ
MMMMMMMMMMMMMNOPQRSTUVWXYZ
NNNNNNNNNNNNNNOPQRSTUVWXYZ
OOOOOOOOOOOOOOOPQRSTUVWXYZ
PPPPPPPPPPPPPPPPQRSTUVWXYZ
QQQQQQQQQQQQQQQQQRSTUVWXYZ
RRRRRRRRRRRRRRRRRRSTUVWXYZ
SSSSSSSSSSSSSSSSSSSTUVWXYZ
TTTTTTTTTTTTTTTTTTTTUVWXYZ
UUUUUUUUUUUUUUUUUUUUUVWXYZ
VVVVVVVVVVVVVVVVVVVVVVWXYZ
WWWWWWWWWWWWWWWWWWWWWWWXYZ
XXXXXXXXXXXXXXXXXXXXXXXXYZ
YYYYYYYYYYYYYYYYYYYYYYYYYZ
ZZZZZZZZZZZZZZZZZZZZZZZZZZ

— AdmBorkBork
स्रोत

6

सी #, 147 बाइट्स

void e(){for(int i=0,j=97;i<26;i++,j++)Console.WriteLine(new string((char)j,i)+new string(Enumerable.Range(j,26-i).Select(n=>(char)n).ToArray()));}

कभी-कभी मुझे आश्चर्य होता है कि im भी कोशिश क्यों कर रहा है

संपादित करें: इसे ठीक किया गया

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

— downrep_nation
स्रोत

मैं वास्तव में नहीं क्योंकि im भी कंसोल का उपयोग कर रहा हूँ जो मुझे System.Console टाइप करने की आवश्यकता होगी जो कोई नहीं करता है।

— डाउनरेप_न्यूज

विचार करना j = 97 और i beilieve (char) j + i + "" काम कर सकता है और छोटा हो सकता है, लेकिन मैं केवल जावा जानता हूं इसलिए मुझे यकीन नहीं है

— रोहन झुनझुनवाला

पहले अक्षर के लिए ऑफसेट के रूप में j का उपयोग किया जाता है। अगर मुझे j = 97 करना है तो मुझे j ++

— aswell

2

क्या दुख की बात है कि इसके ~ 50% ब्रेनफुक समाधान से अधिक लंबे समय तक

— fyrepenguin

1

जब मैं इसे चलाता हूं तो यह सही उत्तर नहीं देता है, क्या आप इसे आज़माने के लिए लिंक जोड़ सकते हैं?

— TheLethalCoder

5

MATL, 10 बाइट्स

lY2t!2$X>c

ऑनलाइन डेमो (यदि आपके पास इस दुभाषिया के साथ समस्याएं हैं, तो मुझे MATL चैट में पिंग करें। इसके अलावा,आपके द्वारा जारी किए गए मामले में यहां TIO लिंक है)

व्याख्या

lY2     % Push an array of characters to the stack: 'AB...Z'
t!      % Duplicate and transpose
2$X>    % Take the element-wise maximum between these two (with expansion)
c       % Explicitly convert back to characters
        % Implicitly display the result.

— Suever
स्रोत

5

पायथन 2, 76 70 68 बाइट्स

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

जुड़े हुए प्रश्न के मेरे उत्तर के समान ।

@Xnor (फिर से) के लिए धन्यवाद 2 बाइट्स सहेजे गए!

— तांबा
स्रोत

1

बस के रूप में पहले, इसे चालू करने में कम है execमें forवर्तमान चरित्र से अधिक दोहराया जा रहा है उपयोग करने के लिए: for c in a:a[:i]=[c]*i;i+=1;print'%c'*26%tuple(a)।

— xnor

वाह, यह बहुत अच्छा है: D

— ABcDexter

4

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

disp([max(L=65:90,L'),''])

नमूना विचारधारा पर चलता है ।

— बीकर
स्रोत

बहुत अच्छा! मैं [...,'']ट्रिक को

— भूलता रहता

1

@LuisMendo यह वास्तव में केवल 1 बाइट बचाता है, लेकिन यह आकर्षक है! : D

— बीकर

4

05AB1E , 9 बाइट्स

कोड:

AAv¬N×?=¦

व्याख्या:

AA         # Push the alphabet twice.
  v        # For each in the alphabet.
   ¬       # Get the first character and
    N×     # multiply by the iteration variable.
      ?    # Pop and print.
       =   # Print the initial alphabet without popping.
        ¦  # Remove the first character of the initial alphabet and repeat.

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

— अदनान
स्रोत

4

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

x=>[...a='ABCDEFGHIJKLMNOPQRSTUVWXYZ'].map((x,y)=>x.repeat(y)+a.slice(y)).join`
`

आत्म व्याख्यात्मक।

— मामा फन रोल
स्रोत

क्या कुछ ऐसा होगा [... "पत्र"]? नक्शा छोटा होगा?

— मेयरमोनी

यह मेरा मूल दृष्टिकोण था, लेकिन यह 2 बाइट्स लंबा है।

— मामा फन रोल

यही दृष्टिकोण था जब मैंने सोचा कि जब मैंने इस चुनौती को देखा

— मेयरमोनी

आम तौर पर, स्ट्रिंग्स चार-चार से अधिक पुनरावृति होने पर इसका उपयोग replaceकरना बेहतर होता है map।

— मामा फन रोल

1

में a.slice(y)जहां चर है aसे आते हैं?

— gcampbell

4

आर, 56 बाइट्स

टिप्पणी करने के लिए रिपीट न करें, लेकिन @plannapus का उत्तर थोड़ा नीचे दिया जा सकता है:

for(i in 1:26)cat({L=LETTERS;L[1:i]=L[i];L},"\n",sep="")

एक ही आउटपुट में परिणाम:

ABCDEFGHIJKLMNOPQRSTUVWXYZ
BBCDEFGHIJKLMNOPQRSTUVWXYZ
CCCDEFGHIJKLMNOPQRSTUVWXYZ
DDDDEFGHIJKLMNOPQRSTUVWXYZ
EEEEEFGHIJKLMNOPQRSTUVWXYZ
FFFFFFGHIJKLMNOPQRSTUVWXYZ
GGGGGGGHIJKLMNOPQRSTUVWXYZ
HHHHHHHHIJKLMNOPQRSTUVWXYZ
IIIIIIIIIJKLMNOPQRSTUVWXYZ
JJJJJJJJJJKLMNOPQRSTUVWXYZ
KKKKKKKKKKKLMNOPQRSTUVWXYZ
LLLLLLLLLLLLMNOPQRSTUVWXYZ
MMMMMMMMMMMMMNOPQRSTUVWXYZ
NNNNNNNNNNNNNNOPQRSTUVWXYZ
OOOOOOOOOOOOOOOPQRSTUVWXYZ
PPPPPPPPPPPPPPPPQRSTUVWXYZ
QQQQQQQQQQQQQQQQQRSTUVWXYZ
RRRRRRRRRRRRRRRRRRSTUVWXYZ
SSSSSSSSSSSSSSSSSSSTUVWXYZ
TTTTTTTTTTTTTTTTTTTTUVWXYZ
UUUUUUUUUUUUUUUUUUUUUVWXYZ
VVVVVVVVVVVVVVVVVVVVVVWXYZ
WWWWWWWWWWWWWWWWWWWWWWWXYZ
XXXXXXXXXXXXXXXXXXXXXXXXYZ
YYYYYYYYYYYYYYYYYYYYYYYYYZ
ZZZZZZZZZZZZZZZZZZZZZZZZZZ

हालाँकि, यदि मैट्रिक्स के रूप में उत्तर की अनुमति है ( जैसे कि यहाँ ), हम 49 बाइट्स कर सकते हैं:

sapply(1:26,function(l){L=LETTERS;L[1:l]=L[l];L})

— Nutle
स्रोत

मैंने @plannapus के उत्तर पर एक टिप्पणी छोड़ी है जो आपके उत्तर के लिए उसे पुनर्निर्देशित कर रही है

— क्रिस्ति लिथोस

यह अच्छा है, लेकिन अभी भी एक छोटा दृष्टिकोण है

— Giuseppe

4

आर , 42 41 बाइट्स

write(outer(L<-LETTERS,L,pmax),'',26,,'')

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

अगले कम से कम आर जवाब अभी भी कुछ लंबा के बाद से यह लाइन द्वारा लाइन बाहर प्रिंट है। मैं आज पहले एक और प्रश्न के बारे में सोच रहा था और महसूस किया कि इस के लिए बहुत कम दृष्टिकोण संभव था: मैं मैट्रिक्स को एक बार उपयोग करने outerऔर pmax(समानांतर अधिकतम) उत्पन्न करता हूं और फिर एक चरण में इसे (*) प्रिंट करता हूं write।

(*) तकनीकी रूप से, इसका संक्रमण, लेकिन यह सौभाग्य से अपने विकर्ण भर में सममित है।

— ग्यूसेप
स्रोत

3

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

unlines[(i<$['B'..i])++[i..'Z']|i<-['A'..'Z']]

L- वर्णमाला के साथ एक स्ट्रिंग लौटाता है।

वर्ण के माध्यम से जाने iसे Aकरने के लिए Zऔर की एक सूची बनाने (length ['B'..i])की प्रतियां iद्वारा पीछा किया [i..'Z']। नए के बीच में तत्वों के साथ जुड़ें।

— nimi
स्रोत

3

पायथन 3, 71 65 बाइट्स

-6 बाइट्स के लिए @LeakyNun को धन्यवाद

r=range(26)
for i in r:print(''.join(chr(max(i,x)+65)for x in r))

एक पूरा कार्यक्रम जो STDOUT को प्रिंट करता है।

यह काम किस प्रकार करता है

हम, वर्णमाला के अक्षरों को चरित्र कोड असाइन से 0के लिए Aकरने के लिए 25के लिए Z। कार्यक्रम [0, 25]एक पंक्ति काउंटर के साथ अंतराल पर लूप iकरता है, जो वर्तमान चरित्र को दोहराया जाना और दोहराया अनुभाग की लंबाई, और एक चरित्र सूचकांक निर्धारित करता है x। कॉल करने से max(i,x), दोहराए गए वर्ण के नीचे के सभी वर्ण उसी के वर्ण कोड से जुड़ जाते हैं। जोड़ने 65और कॉल chrकरने से परिणामी वर्ण कोड उनके ASCII समकक्षों में परिवर्तित हो जाते हैं; ''.joinवर्णों को संक्षिप्त करता है, और प्रत्येक पंक्ति STDOUT में मुद्रित होती है।

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

— TheBikingViking
स्रोत

3

S, 12 चार्ट / 15 बाइट्स

ᶐⓢ⒨Ċ_+ᶐč_)ü⬬

Try it here (Chrome Canary only).

मूल रूप से मेरे ES6 उत्तर का एक बंदरगाह।

— मामा फन रोल
स्रोत

मैं ZZZZZZZZZZZZZZZ...नीचे की रेखा के लिए नहीं मिल रहा हूँ । केवल एक हो रही है Z।

— cwallenpoole

आप कौन सा ब्राउज़र उपयोग कर रहे हैं?

— ममा फन रोल

1

वास्तव में, क्रोम कैनरी में चल रहे कोड का स्क्रीनशॉट

— मामा फन रोल

+1 कि नकारात्मक अंक से छुटकारा पाने के लिए। Google Chrome में काम नहीं करता है, लेकिन यह फ़ायरफ़ॉक्स में काम करता है।

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

एफएफ की भी कोशिश की, लेकिन यह काम नहीं किया। ओह अच्छा। हटा दिया गया -1।

— cwallenpoole

3

आर, 54 बाइट्स

v=L=LETTERS;for(i in 2:26){L[1:i]=L[i];v=cbind(v,L)};v

यह समाधान R अंतर्निहित स्थिर का उपयोग करता है LETTERS, जो कि ... अच्छी तरह से ... अपरकेस अक्षरों को सूचीबद्ध करता है। lettersलोअरकेस अक्षरों के लिए भी स्थिर है ।

— फ़्रेडरिक
स्रोत

मुझे थोड़ा सा नाइटपिक हो रहा है, लेकिन यह आउटपुट एक मैट्रिक्स है, न कि सटीक टेक्स्ट वांछित (यानी वांछित आउटपुट में सभी कोट्स, स्पेस, रॉनेम्स, कॉलनेम आदि नहीं होने चाहिए)।

— प्लेनैपस

3

सी, 78 70 67 बाइट्स

f(i,j){for(;++i<27;puts(""))for(j=0;++j<27;putchar((i>j?i:j)+64));}

सी के लिए कोड निम्नलिखित गोल्फ तकनीक का उपयोग करता है:

omit बुनियादी शामिल (जैसे stdio.h)
कार्य और चर को छोड़ना (लौटना), उन्हें डिफ़ॉल्ट बनाता है int
इफ-ब्लॉक के बजाय टर्नरी ऑपरेटर का उपयोग करें
एक पत्र के ASCII कोड का उपयोग इसके चार प्रतिनिधित्व (यानी के 65बजाय 'A') करें
putcharएक चरित्र का उत्पादन करने के लिए उपयोग करें
दुरुपयोग मुख्य तर्क सूची
puts("")एक नई लाइन का उत्पादन करने के लिए उपयोग करें

इसके अलावा, नियम If it is a function, it must be runnable by only needing to add the function call to the bottom of the program.फ़ंक्शन को मापदंडों के साथ बुलाया जाने के लिए मना नहीं करता है (एबीसीडेक्सटर के लिए धन्यवाद!)।

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

एक ungolfed संस्करण (बिना किसी चेतावनी के gcc के साथ) इस तरह दिखेगा:

#include <stdio.h>

#define MAX(x, y) (x>y ? x : y)

int main()
{
    for(int i=0; i<26; i++)
    {
        for(int j=0; j<26; j++)
            printf("%c", MAX(i, j) + 'A');
        printf("\n");
    }
    return 0;
}

— sigalor
स्रोत

8 बाइट्स सहेजें f(i,j){for(i=0;++i<27;puts(""))for(j=0;++j<27;putchar((i>j?i:j)+64));}:। आपको एक पूर्ण कार्यक्रम की आवश्यकता नहीं है, बस एक फ़ंक्शन है जो हर बार एक ही संचालन करता है जिसे यह कहा जाता है (जो यह करता है)।

— उल्लू 2

@owacoder धन्यवाद, इसे ठीक किया।

— सिगेलॉर

क्या आप इसे हटा सकते हैं i=0;और फ़ंक्शन को कॉल कर सकते हैं f(0,0)?

— एब्सडैक्टर

1

@ABDDexter हां, यह काम करना चाहिए (नियम If it is a function, it must be runnable by only needing to add the function call to the bottom of the program.यह करने के लिए मना नहीं करता है, क्योंकि यह नहीं कहता है कि फ़ंक्शन कॉल की अनुमति नहीं है)। मैं वैसे भी mainकॉल करने देता हूं f(0), क्योंकि लूप के लिए दूसरे के लिए इनिशियलाइजेशन ( jकाउंटर के रूप में एक ) फिर भी आवश्यक है।

— सिगलोर

@ सिगलर हां ठीक है। मैं अपने आप को C में

— आज़मा

3

चेडर, 90 बाइट्स

(|>26).map(i->String.letters.chars.map((j,k,l)->k<i?l[i]:j).fuse).vfuse.slice(1)

यह String.lettersबहुत लंबा है: /

.slice(1)क्योंकि जोड़ने के लिए अग्रणी newline अस्वीकृत है

व्याख्या

(|>26)       // Range from [0, 26)
.map(i->     // Loop through that range
 String.letters.chars // Alphabet array
  .map(               // Loop through alphabet
  (j,k,l) ->          // j = letter, j = index, l = alphabet
    k<i?l[i]:j        // Basically `l[max(k,i)]` 
  ).fuse     // Collapse the array
).vfuse      // Join on newlines

चेडर, 65 बाइट्स (गैर-प्रतिस्पर्धात्मक)

(|>26).map(i->String.letters.map((j,k,l)->k<i?l[i]:j).fuse).vfuse

रात की शाखा के साथ काम करता है । गैर-प्रतिस्पर्धात्मक ... दुखद बात यह है कि मेरे पास पहले से ही बदलाव थे ... बस कभी भी कमिट नहीं किया; _

— Downgoat
स्रोत

मैंने सोचा था कि 65@"90स्ट्रिंग.लेटर्स के लिए कुछ काम करता है

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

L- वर्णमाला प्रिंट / आउटपुट

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

स्कोरिंग

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

लीडरबोर्ड

एक्सेल, 19,604 बाइट्स

विम, 43 बाइट्स

जेली, 6 बाइट्स

ब्रेनफक, 103 96 95 91 87 बाइट्स

/// , 141 94 92 82 बाइट्स

व्याख्या:

दिल्लोग एपीएल , 11 बाइट्स

गणितज्ञ, 69 65 57 बाइट्स

/// , 348 बाइट्स

रेटिना , 41 बाइट्स

व्याख्या

हास्केल, 35 बाइट्स

अजगर 2, 59 बाइट्स

आर, 58 बाइट्स

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

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

यह काम किस प्रकार करता है

जे, 13 बाइट्स

व्याख्या

मतलाब / ऑक्टेव, 43 39 बाइट्स

व्याख्या

PowerShell v2 +, 76 52 40 बाइट्स

सी #, 147 बाइट्स

MATL, 10 बाइट्स

पायथन 2, 76 70 68 बाइट्स

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

05AB1E , 9 बाइट्स

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

आर, 56 बाइट्स

आर , 42 41 बाइट्स

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

पायथन 3, 71 65 बाइट्स

S, 12 चार्ट / 15 बाइट्स

आर, 54 बाइट्स

सी, 78 70 67 बाइट्स

चेडर, 90 बाइट्स

व्याख्या

चेडर, 65 बाइट्स (गैर-प्रतिस्पर्धात्मक)