कोलमोगोरोव शिफ्टर

Question

पाठ की निम्न तीन पंक्तियों को आउटपुट या प्रदर्शित करते हैं, ठीक उसी तरह जैसे वे नीचे दिखाए गए हैं। एक अनुगामी न्यूलाइन स्वीकार किया जाता है।

 bC#eF&hI)kL,nO/qR2tU5wX8z
A!cD$fG'iJ*lM-oP0rS3uV6xY9
aB"dE%gH(jK+mN.pQ1sT4vW7yZ

पाठ का वह खंड नीचे वाले के समान है, लेकिन जहां n 'स्तंभ को नीचे की ओर घुमाया जाता है:

 !"#$%&'()*+,-./0123456789
ABCDEFGHIJKLMNOPQRSTUVWXYZ
abcdefghijklmnopqrstuvwxyz

ध्यान रखें कि यह कोल्मोगोरोव-जटिलता चुनौती है, इसलिए आउटपुट स्वरूप लचीला नहीं है।

Comments

क्या पाठ एक नई रेखा पर समाप्त होता है? विशेष रूप से '.... z \ n \ n' पर समाप्त होना ठीक है?

— टन हास्पेल

@ नहीं, यह अधिकतम एक अनुगामी न्यूलाइन होनी चाहिए

— स्टीवी ग्रिफ़िन

एक अग्रणी नईलाइन स्वीकार्य है?

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

@DomHastings नहीं, क्षमा करें।

— स्टीवी ग्रिफिन

(कई भाषाओं के लिए (HTML, ///, पाठ, बबलगम) हार्डकोडिंग उन 80 वर्णों (जो कि बबलगम को छोड़कर) सबसे छोटा होगा, जो उबाऊ है, कृपया ऐसा न करें)

— user202729

Answer 1

जावा 8, 169 162 150 146 116 113 106 95 94 93 92 91 90 बाइट्स

हाँ, हम अंत में यह किया है! हमने 88-बाइट शाब्दिक आउटपुट को हरा दिया है जो नीचे पाया जा सकता है। उन सभी को धन्यवाद जिन्होंने गोल्फ में भाग लिया!

v->{for(int i=0,t=0;++i<81;System.out.printf("%c",i%27<1?10:(4-t++%3)*32%97+i%27));}

-7 बाइट्स थैंक्स टू @StewieGriffin ।
-42 बाइट्स @Neil का धन्यवाद ।
-11 बाइट्स @PeterTaylor को धन्यवाद ।
-3 बाइट्स @ ओलिवियरग्रेगायर के लिए धन्यवाद ।
-6 बाइट्स @ OlivierGrégoire और @Neil (ओलिवियर ने नील के जावास्क्रिप्ट उत्तर का एक पोर्ट सुझाया ) के लिए धन्यवाद ।

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

स्पष्टीकरण:

v->{                          // Method with empty unused parameter and no return-type
  for(int i=0,t=0;++i<81;     //  Loop from 1 to 81 (exclusive)
     System.out.printf("%c",  //   Print the following character:
      i%27<1?                 //    If it's the last column
       10                     //     Print a new-line
      :                       //    Else:
       (4-t++%3)*32%97+i%27   //     Print the correct character based on the index

यहां देखें कि अंकगणित के प्रत्येक भाग में क्या होता है, और यह कैसे सही पात्रों पर समाप्त होता है।

---

जावा 8, 88 बाइट्स

v->" bC#eF&hI)kL,nO/qR2tU5wX8z\nA!cD$fG'iJ*lM-oP0rS3uV6xY9\naB\"dE%gH(jK+mN.pQ1sT4vW7yZ"

बोरिंग, लेकिन स्तंभों के इच्छित रोटेशन का उपयोग जावा में किसी भी तरह से कम नहीं होगा । एक पल में एक समाधान पोस्ट करेंगे या तो यह देखने के लिए कि यह कितना अलग है। स्पष्ट रूप से अंतर सिर्फ 4 बाइट्स है! : डी

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

---

Comments

मेरे सीजेएम दृष्टिकोण के आधार पर, मुझे पूरा यकीन है कि स्थिति में कोड बिंदु के लिए एक यथोचित सरल अंकगणितीय सूत्र होना चाहिए (x, y), जो आपके 169-बाइट दृष्टिकोण और शायद यहां तक ​​कि शाब्दिक स्ट्रिंग को हरा देगा।

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

116 बाइट्स:v->{String a="";for(int i=2,j,t;++i<6;){for(j=31;++j<58;a+=(char)(t<1?j+65:t>1?j:j+33))t=(j-i)%3;a+="\n";}return a;}

— नील

अहम, 95:v->{for(int i=0,r,c;++i<81;System.out.printf("%c",c<1?10:32*++r+c-1/r))r=(i/27+28-(c=i%27))%3;}

— पीटर टेलर

92 बाइट्स ( cपूरी तरह से हटा दिया गया)

— ओलिवियर ग्रेजायर

@ OlivierGrégoire जावा जावा आउटगोल्फिंग जावास्क्रिप्ट? मैंने गलत क्या किया?

— नील

Answer 2

भूसी , 13 बाइट्स

Tzṙṫ26¡m→"Aa 

ट्रेलिंग स्थान पर ध्यान दें। इसे ऑनलाइन आज़माएं!

व्याख्या

Tzṙṫ26¡m→"Aa   No input.
         "Aa   The string "Aa ".
      ¡        Iterate
       m→      map successor: ["Aa ","Bb!","Cc\"","Dd#",..
 z             Zip with
   ṫ26         the reversed range [26,25,24,..,1]
  ṙ            using rotation: [" Aa","b!B",..,"z9Z"]
               This also truncates the list to length 26.
T              Transpose, implicitly print separated by newlines.

Answer 3

एसपीएल (शेक्सपियर प्रोग्रामिंग लैंग्वेज), 1679 1618 1600 बाइट्स

.
Ajax,.
Ford,.
Puck,.
Act I:.
Scene I:.
[Enter Ajax and Ford]
Ajax:
You are the remainder of the quotient between the sum of the remainder of the quotient between the product of me and a fat joy and the sum of the cube of a big red day and the difference between a red fat pig and a big old fat cow and the quotient between me and the sum of a day and the square of the sum of a joy and a big red day and the sum of a cat and a fat son.
[Exit Ajax]
[Enter Puck]
Ford:
Am I as good as nothing? If so, you are a bad big old red fat day. Am I as good as a joy? If so, you are the sum of a joy and a the cube of an old bad day. Am I as good as a big day? If so, you are the sum of the square of the sum of a big red fat cat and an old cow and the sum of an old war and a lie.
[Exit Ford]
[Enter Ajax]
Ajax:
You are the sum of thyself and the remainder of the quotient between me and the sum of a man and the square of the sum of a son and a big fat cow. Speak thy mind!
[Exit Puck]
[Enter Ford]
Ford:
You are the sum of yourself and a son.
Ajax:
You are the remainder of the quotient between me and the sum of a cat and the square of the sum of a cow and an old red sky.
Ford:
Am I as good as nothing? If so, let us proceed to scene III.
Scene II:.
Ajax:
You are the product of the sum of a fat man and a cow and the sum of a man and the square of the sum of a cat and a big red son. Are you not better than me? If so, let us return to act I. Let us proceed to scene IV.
Scene III:.
Ajax:
You are the sum of a big old fat cat and a red cow. Speak thy mind! Let us return to scene II.
Scene IV:.
[Exeunt]

मेरे पास दुभाषिया ( https://github.com/drsam94/Spl ) के साथ कुछ मुद्दे थे , इसलिए यह उतना छोटा नहीं है जितना मुझे लगता है कि यह हो सकता था। लेकिन कम से कम यह काम करता है :)

---

यहाँ PHP में एक ही तर्क है, यह देखना थोड़ा आसान है कि क्या हो रहा है।

<?php

Act1Scene1:
$ford = ((2 * $ajax) % 52 + $ajax / 26) % 3;
if ($ford == 0) {
    $puck = 32;
}
if ($ford == 1) {
    $puck = 65;
}
if ($ford == 2) {
    $puck = 97;
}
$puck = $ajax % 26 + $puck;
echo chr($puck);

$ajax = $ajax + 1;

$ford = $ajax % 26;
if ($ford == 0) {
    goto Act1Scene3;
}

Act1Scene2:
if ($ajax < 78) {
    goto Act1Scene1;
}
goto Act1Scene4;

Act1Scene3:
$ford = 10;
echo chr($ford);
goto Act1Scene2;

Act1Scene4:

Comments

इस ध्वनि में भाषण एक डॉ। किताब की तरह लगता है। : ^ D

— DL25

Answer 4

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

f=(i=k=0)=>i<80?String.fromCharCode(++i%27?(4-k++%3)*32%97+i%27:10)+f(i):''

संपादित करें: @ ब्यान के लिए 11 बाइट्स सहेजे गए। अब शाब्दिक की तुलना में कम १० बाइट्स!

जावास्क्रिप्ट (Node.js) , 64 बाइट्स

f=(i=k=0)=>i<80?Buffer([++i%27?(4-k++%3)*32%97+i%27:10])+f(i):''

इसे ऑनलाइन आज़माएं! @Ryan को धन्यवाद।

Comments

आप पुनरावृत्ति के साथ 11 बाइट्स बचा सकते हैं: f=(i=k=0)=>i-80?String.fromCharCode(++i%27?(4-k++%3)*32%97+i%27:10)+f(i):''और 11 एक नोड वातावरण में एक तरफ के रूप में अधिक:f=(i=k=0)=>i-80?Buffer([++i%27?(4-k++%3)*32%97+i%27:10])+f(i):''

— Ry-

Answer 5

05AB1E , 17 15 बाइट्स

बच निकले 2 बाइट्स के लिए धन्यवाद एग्री द आउटग्राफर

žQAuA)øε¼¾GÁ]ø»

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

व्याख्या

žQ                 # push the list of printable ascii characters
  Au               # push upper-case alphabet
    A              # push lower-case alphabet
     )ø            # zip
       ε           # apply to each
        ¼          # increment counter
         ¾G        # for N in [1 ... counter] do:
           Á       # rotate string right
            ]      # end loops
             ø     # zip
              »    # print list joined by newlines

Comments

@Emigna मुझे लगता है कि εNएक बात होनी चाहिए। के दो विचारों को जोड़ती है vyNFÁ])ø»और तुम्हारा।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn: हाँ, मैं अक्सर Nउपयोग करते समय चाहता हूँ ε। यह तकनीकी रूप εसे फिट नहीं है क्योंकि यह एक लूप नहीं है, हालांकि जैसा कि हम कभी-कभी इसका उपयोग करते हैं, यह अच्छा होगा।

— Emigna

Answer 6

CJam (18 बाइट्स)

26{_" Aa"f+m>}%zN*

ऑनलाइन डेमो

विच्छेदन

स्पष्ट दृष्टिकोण मूल लाइनें उत्पन्न करना, ज़िप करना, साथ घूमना ee::m>और वापस ज़िप करना है। लेकिन ee::काफी लंबा है, और सीधे कॉलम बनाने के लिए यह छोटा है।

26{         e# For i = 0 to 25...
  _" Aa"f+  e#   Generate the unrotated column by offsets from the starting chars
  m>        e#   Rotate the appropriate distance
}%
zN*         e# Zip and join the rows with newlines

Answer 7

पायथन 2 , 72 बाइट्स

x=98
exec"r='';exec'r+=chr(x/3);x+=291*(x<180)-94;'*26;print r;x-=78;"*3

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

यह 31.333..पिछले वर्ण से हटाकर काम करता है , 97जब पिछले कोडपॉइंट 60 से कम है, और 26प्रत्येक पंक्ति के अंत में घटाकर ।

Answer 8

आर , 64 63 बाइट्स

cat(intToUtf8(c(32:57,10,65:90,10,97:122,10)[(0:80*55)%%81+1]))

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

Giuseppe के लिए -1 बाइट धन्यवाद

मैं काफी परीक्षण और त्रुटि के माध्यम से इस पर पहुंचा, इसलिए मैं संक्षिप्त स्पष्टीकरण के साथ संघर्ष कर रहा हूं। अनिवार्य रूप से, चरित्र कोड के बजाय, मैंने पाठ के मूल ब्लॉक (3 * 26 प्लस 3 न्यूलाइन्स) का प्रतिनिधित्व करने वाले 1:81 के एक अधिक सरल अनुक्रम के साथ शुरुआत की, और उन मानों की जांच की जहां ये मान घुमाए गए ब्लॉक में समाप्त होते हैं। यह एक नियमित अनुक्रम का अनुसरण करता है जो प्रत्येक बार 26 से कम हो जाता है, modulo 81 (या समतुल्य, 55 mod 81 से बढ़ता है)। यह उस अनुक्रम को फिर से बनाने (0:80*55)%%81+1]), वास्तविक यूनिकोड मूल्यों की मैपिंग c(32:57,10,65:90,10,97:122,10), पात्रों और मुद्रण में परिवर्तित करने की बात थी।

Comments

बहुत बढ़िया! मैं इसका भरपूर लाभ उठाऊंगा, हालाँकि मुझे वास्तव में 80+ बाइट रेंज में एक और समाधान की उम्मीद थी, इसलिए मुझे लगता है कि मैं 100 तक का इनाम लूंगा।

— ग्यूसेप

@Giuseppe कोई चिंता नहीं! यह ईमानदार होने की तुलना में चुनौती के बारे में अधिक है।

— user2390246

आह, आप एक बाइट का उपयोग कर बचा सकता है 55के बजाय -26के बाद से -26 == 55(आधुनिक 81)।

— ग्यूसेप

@Giuseppe सुझाव के लिए धन्यवाद, और इनाम के लिए!

— user2390246

Answer 9

जाप , 17 15 बाइट्स

"@`"
;By@=cÄ é

इसे ऑनलाइन टेस्ट करें!

व्याख्या

"@`"         The string "@`\x1F". The following newline sets U to this string.
;            Reset variables A-L to various values. B is set to
 B           the uppercase alphabet, which we only use to get a length of 26.
  y@         Map each column Z (initially just the letter itself) through this function:
     cÄ        Increment each char-code in U.
        é      Rotate by 1 character.
    =          Set U to the result to keep the chain going.
             This generates the 26 columns exactly how we needed them.
             Implicit: output result of last expression

7 अन्य संभावित 15-बायर्स:

;By@" Aa"c+Y éY
;ByÈpv)iSc+Y)éY
;ByÈ+v)iSc+Y)éY
;ByÈpv)iYd32)éY
;ByÈ+v)iYd32)éY
;ByÈpv)i32dY)éY
;ByÈ+v)i32dY)éY

Answer 10

सीजाम , 23 21 बाइट्स

3{26{_I-" aA"=+}/N}fI

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

व्याख्या

3{         e# For I from 0 to 2...
  26{      e#   For i 0 to 25...
    _I-    e#     Duplicate i and subtract I. This shifts the starting
           e#     character of each line left in the following string.
    " aA"= e#     Pick the character at the start of the unrotated line
           e#     of the current character. We basically just cycle
           e#     through non-letters, lower-case, upper-case, which is
           e#     the cycle throughout the result. Due to the I-, when
           e#     We get to the second line we start from A, and on the
           e#     third line we start from a.
    +      e#     Add i to the starting character to get the correct
           e#     column.
  }/
  N        e#   Push a linefeed.
}fI

Comments

बहुत अच्छी व्याख्या। मुझे विशेष रूप से पसंद है: "इस यादृच्छिक दिखने वाले स्ट्रिंग को पुश करें।" : पी

— स्टीवी ग्रिफिन

@StewieGriffin क्षमा करें, उस स्ट्रिंग को जाना था।

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

Answer 11

MATL , 16 बाइट्स

1Y2tk9V:v26:l&YS

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

व्याख्या

1Y2     % Push 'AB...Z' (predefined literal)
t       % Duplicate
k       % Maker lowercase
9V      % Push 9, convert to string representation: gives char '9'
:       % Range. For chars, gives string from space to that
v       % Concatenate vertically. Gives a 3×26 char matrix
26      % Push 26
:       % Range. For numbers, gives numeric vector from 1 to that
l&YS    % Circularly shift each column of the first input (char matrix)
        % by the amount specified by the second input (numeric vector).
        % Implicitly display

Comments

नाइस :) मैं अभी भी संघर्ष करता हूं जब मुझे डिफ़ॉल्ट I / O फ़ंक्शन के कार्यों को बदलना होगा ... :(

— Stewie Griffin

1:26शिफ्ट के रूप में उपयोग करने के लिए तार के आदेश के साथ बहुत अच्छा है । मुझे अपने आर जवाब में कोशिश करनी चाहिए ...

— Giuseppe

@ स्टुअरीग्रिफिन मेटा-फंक्शन &एक शानदार अतिरिक्त था, स्वेवर के विचार से :-)

— लुइस मेंडो

@Giuseppe हाँ, कि एक बाइट बचाई :-)

— लुइस मेंडो

Answer 12

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

26“ aA‘ẋs+ḶỌY

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

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

26“ aA‘ẋs+ḶỌY  Main link. No arguments.

26             Set the argument and the return value to 26.
  “ aA‘ẋ       Repeat [32, 97, 65] (code points of ' ', 'a', and 'A') 26 times.
        s      Split the result into chunks of length 26.
          Ḷ    Unlength; yield [0, ..., 25].
         +     Add [0, ..., 25] to each of the chunks.
           Ọ   Unordinal; cast all integers to characters.
            Y  Jojn, separating by linefeeds.

Answer 13

पर्ल 5 , 46 बाइट्स

print map{chr$n+++ord,$/x!($n%=26)}($",A,a)x26

सहेजे गए 13 बाइट्स @TonHospel की आर्कन विजार्ड्री की बदौलत !

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

Comments

आपका $i++बस है $_और आप sayइसके बजाय उपयोग कर सकते हैं printयह वास्तव में है50

— टन इंस्पिरेशन

हम्म, और यह {}मानचित्र के लिए भी छुटकारा पाने में आसान है 49:say map$/x/26|52/.chr$_%26+(32,65,97)[$_%3],0..77

— टन हास्पेल

@ टोनहोस हां, बिल्कुल! धन्यवाद!

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

पाश Redesigning देता है 47: print map{chr$n+++$_,$/x!($n%=26)}(32,97,65)x26। दुर्भाग्य sayसे एक नया भी कई देता है।

— टन हास्पेल

और एक मजेदार 48:say map$/x/.A/.chr$n++%26+(65,32,97)[$n%3],A..BZ

— टन होज़ल

Answer 14

आर , 88 86 बाइट्स

cat(intToUtf8(rbind(diffinv(matrix(c(66,-32,-31),25,5,T)[,1:3],,,t(c(32,65,97))),10)))

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

आर स्ट्रिंग हेरफेर में भयानक है और हालांकि इसमें कुछ नीरस मैट्रिक्स बिल्डिन हैं, घुमाव एक और चीज है जो यह बहुत आसानी से नहीं करता है। मैं खुशी-खुशी किसी को भी इनाम दूंगा जो मुझे आर-गोल्फ में बाहर कर सकते हैं।

मेरे छोटे जवाब मिलने के बावजूद, मैं अभी भी 88 बाइट्स से छोटे दूसरे आर उत्तर के लिए 50 प्रतिनिधि इनाम दूंगा।

मुझे लगता है कि मैं अपने आप को इनाम अगर मैं कर सकता था, लेकिन यह "उबाऊ" जवाब की तुलना में कम पूरे दो बाइट्स है! मैं पुनर्चक्रण के लिए आर के पेन्चेंट का उपयोग करके रोटेशन से बचता हूं।

EDIT: user2390246 के जवाब ने मुझे पूरी तरह से परेशान कर दिया और मैं 100 अंक का इनाम दूंगा क्योंकि यह समाधान बहुत बेहतर है।

यहां आने के लिए, मैंने अपने ASCII कोड पॉइंट्स utf8ToInt( diffवांछितों को हटाते हुए) के साथ वांछित आउटपुट को डिकंस्ट्रक्ट किया , एक मैट्रिक्स बनाया, और उन पर कॉलम वाइज अंतर प्राप्त करते हुए भाग गया । वहाँ आवधिकता को ध्यान में रखते हुए, मैंने एक गोल्फ शैली में मैट्रिक्स का निर्माण करने के लिए सेट किया, diffinvजो मूल को फिर से बनाने के लिए उपयोग करने की उम्मीद कर रहा था ।

आवधिकता के लिए धन्यवाद, हम diffR मैट्रिक्स को R को एक गैर-एकाधिक लंबाई के साथ रीसायकल करने के लिए मजबूर कर सकते हैं , और उन स्तंभों को निकाल सकते हैं जिन्हें हम वास्तव में चाहते थे:

matrix(c(66,-32,-31),25,5,T)[,1:3]

फिर हम इस प्रक्रिया diffinvको उल्टा करते हैं, कोड बिंदुओं को फिर से बनाने के लिए, 10(newlines) की एक पंक्ति को नीचे की ओर जोड़ते हैं , ASCII के साथ फिर से जोड़ते हैं intToUtf8, और catपरिणाम।

Comments

आप अपने आप को एक इनाम देने की तरह कर सकते हैं। इनाम में आपको x प्रतिनिधि की लागत आएगी, और आप इससे x प्रतिनिधि प्राप्त करेंगे ... तो, इस पर विचार करें!

— स्टीवी ग्रिफिन

चुनौती स्वीकार की गई!

— user2390246

Answer 15

स्टैक्स , 14 12 बाइट्स

ü≤▐éh╢%╠£┐3]

इसे चलाएं और डीबग करें

अनपैक्ड, अनगुल्फेड और टिप्पणी की गई, यह इस तरह दिखता है।

3R26        push [1,2,3] and 26
K           cross-map using the rest of the program, printing lines implicitly
            this instruction maps over a cartesian join
  -         subtract
  " Aa"@    index into " Aa" using the subtraction result
  i+        add the iteration index

इसको चलाओ

यह कार्यक्रम केवल उन विशेषताओं का उपयोग करता है जो कि स्टेक्स की प्रारंभिक रिलीज के बाद से उपलब्ध हैं, लेकिन जाहिर है Kकि जब मैं मूल रूप से यह उत्तर लिखता हूं तो मैं क्रॉस-मैप के बारे में भूल गया था ।

इस उत्तर के बारे में ध्यान देने वाली एक दिलचस्प बात यह है कि Rयह एक अनावश्यक निर्देश है क्योंकि Kसंक्षेप में पूर्णांकों को श्रेणियों में बदल दिया जाता है। हालाँकि इसके अलावा कोई रास्ता नहीं है 3और 26बीच में कुछ अतिरिक्त बाइट के बिना।

Answer 16

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

0..2|%{-join(32..57|%{[char]($_+(0,65,33)[$j++%3])})}

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

मैं देखता हूं कि यह डोम के पर्ल उत्तर के समान है, लेकिन मैं स्वतंत्र रूप से इस पर पहुंचा।

यह इस तथ्य का फायदा उठाता है कि पैटर्न Symbol - Lowercase - Capitalतब भी चला जाता है , जब न्यूलाइन्स ( 8 - z - Aउदाहरण के लिए) को लपेटते हुए , और इस तरह केवल एक स्ट्रिंग में एक साथ शामिल होने से पहले उपयुक्त ऑफसेट ( $j++%3वर्तमान के माध्यम से चुने गए ) को जोड़ता है । यह तीन लाइनों ( पुनरावृत्तियों के बीच संरक्षण ) के साथ आने के लिए तीन बार किया जाता है । उन तीन लाइनों को पाइप लाइन पर छोड़ दिया जाता है, और निहितार्थ हमें मुफ्त में नए अंक देता है।$_-join$jWrite-Output

Answer 17

जूलिया 0.6 , 79 बाइट्स

println.([prod([' ':'9' 'A':'Z' 'a':'z'][n,mod1(i-n,3)] for n=1:26) for i=2:4])

[' ':'9' 'A':'Z' 'a':'z'][n,mod1(i-n,3)]उपयुक्त रोटेशन के साथ उस सरणी में वर्णों के अनुक्रमित 2d सरणी है । prodस्ट्रिंग के लिए वर्णों का एक वेक्टर लेता है (चूंकि स्ट्रिंग में शामिल होने के लिए गुणा का उपयोग किया जाता है)। वेक्टर में 3 स्ट्रिंग वाले परिणामस्वरूप दो नेस्टेड वेक्टर कॉम्प्रिहेंशन होते हैं, फिर println.वेक्टर में प्रत्येक स्ट्रिंग को एक न्यूलाइन द्वारा प्रिंट करते हैं।

TIO में prodस्ट्रिंग प्राप्त करने के लिए दो अक्षरों को गुणा (करने ) के लिए उपयुक्त विधि का अभाव है । मुझे पता है कि इस पद्धति को कुछ समय पहले जोड़ा गया था, लेकिन टीआईओ संस्करण मेरे पीसी पर संस्करण के समान ही प्रतीत होता है जहां यह कोड काम करता है, इसलिए मैं पूरी तरह से समझा नहीं सकता कि यह टीआईओ पर काम क्यों नहीं करता है।

कॉपी पेस्ट उदाहरण ( ;यह आवश्यक नहीं है, यह सिर्फ REPL में अतिरिक्त आउटपुट को दबाता है):

julia> println.([prod([' ':'9' 'A':'Z' 'a':'z'][n,mod1(i-n,3)] for n=1:26) for i=2:4]);
 bC#eF&hI)kL,nO/qR2tU5wX8z
A!cD$fG'iJ*lM-oP0rS3uV6xY9
aB"dE%gH(jK+mN.pQ1sT4vW7yZ

Answer 18

चारकोल , 26 21 15 बाइट्स

Ｅ³⭆⧧⟦γαβ⟧⁻κμμ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

 ³              Literal 3
Ｅ               Map over implicit range
   β            Lowercase letters
  ⭆             Map over characters and concatenate
            κ   Outer index
             μ  Inner index
           ⁻    Subtract
       γ        Printable characters
        α       Uppercase letters
         β      Lowercase letters
     §⟦   ⟧     Circularly index into list (selects one of the three strings)
              μ Inner index
    §           (Circularly) index into string
                Implicitly print each inner map result on a separate line

Answer 19

जे , 29, 27 25 बाइट्स

-2 बाइट्स धन्यवाद फ्रॉन्फ्रोग -2 मील के लिए बाइट्स धन्यवाद

 |:u:(<26)2&(|.>:)32 65 97

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

प्रारंभिक दृष्टिकोण: जे , 29 बाइट्स

u:(-|."_1&.|:32 65 97+/])i.26

स्पष्टीकरण: i.26- सीमा 0-26

   i.26
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

32 65 97+/] - पात्रों के लिए एक 3-पंक्ति तालिका बनाएं

   32 65 97+/i.26
32 33 34  35  36  37  38  39  40  41  42  43  44  45  46  47  48  49  50  51  52  53  54  55  56  57
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
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122

&.|:transpose तो अगली verb ( |.) करें और फिर से transpose करें

-|."_1 प्रत्येक पंक्ति को n बार घुमाएं

     (-i.26)|."_1|:32 65 97+/i.26
 32  65  97
 98  33  66
 67  99  34
 35  68 100
101  36  69
 70 102  37
 38  71 103
104  39  72
 73 105  40
 41  74 106
107  42  75
 76 108  43
 44  77 109
110  45  78
 79 111  46
 47  80 112
113  48  81
 82 114  49
 50  83 115
116  51  84
 85 117  52
 53  86 118
119  54  87
 88 120  55
 56  89 121
122  57  90

u: यूनिकोड में परिवर्तित करें

    u:(-i.26)|."_1&.|:32 65 97+/i.26
 bC#eF&hI)kL,nO/qR2tU5wX8z
A!cD$fG'iJ*lM-oP0rS3uV6xY9
aB"dE%gH(jK+mN.pQ1sT4vW7yZ

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

Comments

@FrownyFrog धन्यवाद! जाहिरा तौर पर मैंने मैट्रिक्स कॉलम-वार बनाने की संभावना की जांच नहीं की।

— गैलेन इवानोव

|:u:(<26)2&(|.>:)32 65 972 बाइट्स बचाता है।

— मील

@ मीलों महान कोड के लिए धन्यवाद!

— गैलेन इवानोव

Answer 20

सी, 70 69 67 60 64 बाइट्स

i;f(t){for(i=t=0;++i<81;putchar(i%27?(4-t++%3)*32%97+i%27:10));}

फ़ंक्शन को पुन: प्रयोज्य बनाने के लिए +4 बाइट्स ।

अमान्य 60-बाइट्स का उत्तर जो पुन: प्रयोज्य नहीं है:

i,t;f(){for(;++i<81;putchar(i%27?(4-t++%3)*32%97+i%27:10));}

मेरे जावा 8 पोर्ट का पोर्ट @Neil का जावास्क्रिप्ट उत्तर है ।

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

Comments

चूंकि कार्यों को पुन: प्रयोज्य करना पड़ता है और यह फ़ंक्शन सफाई से बाहर नहीं निकलता है, इसलिए यह वैश्विक चर को पीछे छोड़ देता है। आप एक की जरूरत है i=t=0।

— जोनाथन फ्रीच

@JonathanFrech फिक्स्ड

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

Answer 21

एपीएल + विन, 26 बाइट्स

सूचकांक मूल ०

⎕av[(-⍳26)⊖32 65 97∘.+⍳26]

APL परमाणु वेक्टर में वर्णों के पूर्णांक सूचकांक मानों का एक मैट्रिक्स उत्पन्न करें।

प्रत्येक कॉलम को उसकी संख्या मान से नीचे की ओर घुमाएं।

परमाणु वेक्टर से पात्रों को प्रदर्शित करने के लिए परिणामी सूचकांकों का उपयोग करें।

Answer 22

विम, 81 79 बाइट्स

a !"#$%&'()*+,-./0123456789␛:h<_␍jjYZZpPgU$klqq"aDjlma"bD"ap`ajD"bpkkp`akl@qq@q

स्पष्टीकरण (सरलीकृत)

a !"#$%&'()*+,-./0123456789␛    Insert the first line
:h<_␍jjYZZpPgU$                  Insert the alphabet twice by copying it from the help page
klqq                             Define the loop `q`:
"aDjl                             Cut the rest of the line to `a`
ma"bD"ap                          Replace the rest of the second line (cut `b`, paste `a`)
`ajD"bp                           Replace the rest of the third line (cut `c`, paste `b`)
kkp                               Paste `c`
`akl@qq@q                        Run the loop, each time one more step to the right

Answer 23

सी, 72 बाइट्स

f(k,x,n){for(n=81;n;putchar(x?k*32+59-x-!k:10))x=--n%27,k=(3+x-n/27)%3;}

Answer 24

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

for x in 2,99,196:s='';exec"s+=chr(32+x%291/3);x-=94;"*26;print s

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

Answer 25

ब्रेनफक , 121 115 बाइट्स

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

6 बाइट बचाने के लिए @JoKing को धन्यवाद!

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

Comments

115 बाइट्स संख्या पीढ़ी के साथ के बारे में बात करके

— जो राजा

+++[[<+>>++<-]>]वास्तव में सब कुछ, हुह की शुरुआत है? धन्यवाद!

— डेनिस

Answer 26

जाप , 17 बाइट्स

26Æ" Aa"c+X éX÷y

झसे आज़माओ

---

व्याख्या

26Æ           Ã       :Create the range [0,26) and pass each X through a function
   " Aa"              :  String literal
        c+X           :  Add X to the codepoint of each character
            éX        :  Rotate right X times
               ·      :Join with newlines
                y     :Transpose

Comments

ऊह, मेरे पास एक अलग समाधान था जो एक अलग जवाब देने के लिए पर्याप्त हो सकता है या नहीं भी हो सकता है:;Bå_cÄ é}"@`" ·y

— ETHproductions

खैर अब जब कि हम वही लंबाई के बारे में बेहतर महसूस कर रहे हैं ;-)

— ETHproductions

@ETHproductions: मेरे लिए बहुत अलग दिखता है :) यह देखने जा रहा था कि क्या मैं Cदोपहर के भोजन के बाद मैपिंग करके एक छोटे समाधान के साथ आ सकता हूं । पता नहीं कैसे yऔर ·गलत तरीके से समाप्त हो गया; मुझे आईएनजी Ctrl+Zसे पहले भी कई बार एड करना होगा Ctrl+A!

— झबरा

Answer 27

पायथन 2 , 79 बाइट्स

p=0
exec"o=0;r='';exec'r+=chr(o+[32,65,97][(p-o)%3]);o+=1;'*26;p+=1;print r;"*3

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

Answer 28

APL (Dyalog Unicode) , 23 बाइट्स ( Adám's SBCS )

(⎕UCS-⊖∘↑32 65 97+⊂)⍳26

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

-1 Adám को धन्यवाद ।

संवादात्मक वातावरण में चलता है।

मान लेता है ⎕IO←0।

Comments

23: (⎕UCS-⊖∘↑32 65 97+⊂)⍳26या(⎕UCS-⊖32 65 97∘.+⊢)⍳26

— Adám

@ एडम उह, धन्यवाद।

— आउटगॉल्फ

Answer 29

K4 , 38 बाइट्स

समाधान:

-1"c"$+(-t).q.rotate'32 65 97+/:t:!26;

उदाहरण:

q)k)-1"c"$+(-t).q.rotate'32 65 97+/:t:!26;
 bC#eF&hI)kL,nO/qR2tU5wX8z
A!cD$fG'iJ*lM-oP0rS3uV6xY9
aB"dE%gH(jK+mN.pQ1sT4vW7yZ

स्पष्टीकरण:

रोटेशन करने के लिए 9 वर्ण ...

-1"c"$+(-t).q.rotate'32 65 97+/:t:!26;
-1                                   ; / print to stdout, swallow return
                                  !26  / til 26, 0..25
                                t:     / save as variable t
                             +/:       / add each right item to...
                     32 65 97          / the list 32, 65, 97 (ASCII offsets)
           .q.rotate'                  / rotate each-both
       (-t)                            / negate, 0..-25
      +                                / flip rows and columns
  "c"$                                 / cast to characters

Answer 30

पर्ल, 49 46 बाइट्स

perl -E 'say map chr($_*55%81)=~y// -:A-Z             
a-z       
/cr,0..79'

या

perl -E 'say grep{$_=chr$_*55%81;y// -:A-Z             
a-z       
/c}0..79'

Comments

+1! मैं आपको किसी भी बाइट्स को वापस बचाने में मदद नहीं कर सकता, लेकिन मैंने उपयोग करने के बारे में सोचा $^x8, लेकिन पर्याप्त लंबाई के साथ एक और संस्करण के बारे में नहीं सोच सकता है, लेकिन शायद "@INC"यह बहुत लंबा है, और "@-"इसके बजाय का उपयोग कर रहा है $n++, लेकिन फिर भी, एक ही लंबाई। जब तक कि यह आपको इसे और कम करने में मदद नहीं करता है? जब तक आप -pध्वज नहीं जोड़ते हैं और अंतर्निहित आउटपुट नहीं है?

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

@DomHastings आह, इतनी तैयारी की बिना लूप का रास्ता मिल गया

— टन हास्पेल