एक बहुत लंबा टेरा रीमा

38

विवरण

एक बहुत लंबे टेरा रीमा के लिए कविता योजना का आउटपुट।

इनपुट

कोई नहीं।

उत्पादन

ABA
BCB
CDC
DED
EFE
FGF
GHG
HIH
IJI
JKJ
KLK
LML
MNM
NON
OPO
PQP
QRQ
RSR
STS
TUT
UVU
VWV
WXW
XYX
YZY

नियम

आप व्हाट्सएप या न्यूलाइन्स के साथ अलग छंदों के बीच चयन कर सकते हैं, इसलिए:

ABA BCB...

या

ABA
BCB
...

प्रति पंक्ति एक एकल अनुगामी व्हाट्सएप ने अनुमति दी और एक अनुगामी न्यूलाइन ने अनुमति दी।

आउटपुट या तो अपरकेस या लोअरकेस हो सकता है।

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा के लिए बाइट्स में सबसे छोटा कोड जीत जाता है।

code-golf  string  kolmogorov-complexity  alphabet 
— LiefdeWen
स्रोत
4
क्या लाइनों की सूची ठीक है?
— अशुभ
6
En.wikipedia.org/wiki/Terza_rima के अनुसार आपका अंत गलत है। यह जेड या जेडजेड के साथ समाप्त होना चाहिए।
— क्रिस
क्या तुकबंदी योजना से परे अतिरिक्त उत्पादन हो सकता है? यह मुझे कुछ बाइट्स बचा सकता है।
— NK1406
@ NK1406 नहीं क्षमा करें।
— LiefdeWen
1
@totallyhuman स्ट्रिंग सरणी ठीक है।
— LiefdeWen

जवाबों:

24

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

@ L4m2 के लिए 1 बाइट का धन्यवाद सहेजा गया

f=(n=45358)=>n%63?f(n-1333)+n.toString(36)+' ':''

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

कैसे?

हम n = 45358 ( बेस -36 में yzy ) से शुरू करते हैं। हम प्रत्येक पुनरावृत्ति पर n से 1333 घटाते हैं ( बेस -36 में 111 )। हम जैसे ही n MOD 63 = 0 बंद करते हैं , क्योंकि 12033 ( बेस -36 में 9a ) पहला मान है जिसके लिए यह शर्त पूरी होती है, और 63 ऐसी संपत्ति के साथ सबसे छोटा मॉडुलो है।

Decimal | Base-36 | MOD 63
--------+---------+-------
  45358 |   yzy   |   61
  44025 |   xyx   |   51
  42692 |   wxw   |   41
  41359 |   vwv   |   31
  40026 |   uvu   |   21
  38693 |   tut   |   11
  37360 |   sts   |    1
  36027 |   rsr   |   54
  34694 |   qrq   |   44
  33361 |   pqp   |   34
  32028 |   opo   |   24
  30695 |   non   |   14
  29362 |   mnm   |    4
  28029 |   lml   |   57
  26696 |   klk   |   47
  25363 |   jkj   |   37
  24030 |   iji   |   27
  22697 |   hih   |   17
  21364 |   ghg   |    7
  20031 |   fgf   |   60
  18698 |   efe   |   50
  17365 |   ded   |   40
  16032 |   cdc   |   30
  14699 |   bcb   |   20
  13366 |   aba   |   10
  12033 |   9a9   |    0
— Arnauld
स्रोत
आपने बेस 36 कैसे तय किया? और क्या आपको यकीन है कि इसका इष्टतम है?
— लाईफ़डेवेन
2
@LiefdeWen यह सभी अक्षरों को शामिल करने के लिए सबसे कम आधार है, इसलिए यह इष्टतम है।
— आउटगॉल्फ को एरिक करें
@ user202729 आपका क्या मतलब है? वह ओपी नहीं है, इसलिए वह उन लोगों में से एक है जिन्हें आप संदर्भित करते हैं?
— 1843
17
एक (संयुक्त राष्ट्र) दिलचस्प पक्ष-नोड के रूप में, 1333 = 666 * 2 + 1 और पीपीसीजी पर यह मेरा 666 वां उत्तर है।
— अरनौलड
3
@ अरनल्ड कृपया सुनिश्चित करें कि आप अपने अगले उत्तर में कहीं 1335 मूल्य का उपयोग करें।
— IanF1
15

सी (जीसीसी) , 41 बाइट्स

f(i){for(i='ABA';i%29;i+=65793)puts(&i);}

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

फिक्स्ड और -9 उपयोगकर्ता 202029 के लिए धन्यवाद । डेनिस को -1 और अरनौल को भी धन्यवाद ।

— मिस्टर एक्सकोडर
स्रोत
— user202729
1
(i='ABA';i<'ZZZ';i+=65793)एक बाइट बचाता है।
— डेनिस
एक और बाइट बचाने के 59e5बजाय का उपयोग करें 'ZZZ'।
— user202729
आप 41 बाइट्स केi%29 लिए उपयोग कर सकते हैं
— अरनुलड
9

ब्रेनफक , 51 48 बाइट्स

@ ब्वॉयज के लिए 3 बाइट्स को सहेजा गया।

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

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

व्याख्या

INITIALIZE TAPE:

0000:           (none)
0001: C_NEWLINE (10)
0002: V_COUNT   (25)
0003: V_ALPHA   (64)
++++++++[>+>+++>++++++++<<<-]>++>+

V_COUNT TIMES:              [-
    INCREMENT V_ALPHA         >+
    PRINT V_ALPHA             .
    PRINT V_ALPHA PLUS ONE    +.
    PRINT V_ALPHA             -.
    PRINT C_NEWLINE           <<.
END LOOP                    >]
— कोनोर ओ ब्रायन
स्रोत
@ ConorO'Brien - मैंने अभी देखा कि मेरा उत्तर आपके लिए काफी समान है। कृपया बेझिझक टिप्पणी करें यदि आपको लगता है कि यह बहुत करीब है और मैं इसे हटा दूंगा।
— एलपीड्रो
1
@ElPedro नहीं, आप ठीक हैं, इस चुनौती में नवाचार के लिए ज्यादा गुंजाइश नहीं है :)
— कॉनर ओ'ब्रायन
9

05AB1E , 5 बाइट्स

Aü«€û

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

-1 बाइट थैंक्स टू एमिग्ना
-1 बाइट थैंक्स टू रूल चेंज; कि बाहर इशारा करने के लिए kalsowerus के लिए धन्यवाद

हेहे, वर्तमान में पायथ को हरा देता है। \ O /

व्याख्या

Aü«€û»  Full Program
A       Lowercase Alphabet
 ü«     Pairwise with merge-list
   €û   For each, palindromize
— HyperNeutrino
स्रोत
आप कर सकते हैंAü«€û»
— Emigna
@Eigna हे शांत, धन्यवाद! : डी
— हाइपरएन्यूट्रीनो
अच्छा, यही मुझे बिना देखे भी मिल गया।
— मैजिक ऑक्टोपस Urn
टिप्पणियों के अनुसार, स्ट्रिंग्स की एक सूची आउटपुट के रूप में ठीक है, आप सम्मिलित को हटा सकते हैं।
— कलसोवरस
9

ब्रेनफक , 51 49 बाइट्स

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

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

एक स्पष्टीकरण पर एक प्रयास ...

+++++                     #Put 5 in cell 0 because that is the highest common denominator of 10, 65 and 25
[                         #Start loop
>+++++                    #Counter in cell 1 is 25 (How many lines we must print)
>+++++++++++++            #Counter in cell 2 is 65 (ASCII A)  
>++                       #Counter in cell 3 is 10 (Newline)
<<<-]                     #Decrement the outer counter until the cells have the right values (muliples of 5).
>                         #Move to the counter that says how many lines we must print.
[>.                       #Print the character in cell 2
+.                        #Add one to the character in cell 2 and print it
-.                        #Subtract one from the character in cell 2 and print it
+                         #Add one to the character in cell 2 for the next loop
>.                        #Print a new line
<<-]                      #Decrement cell 1 and run again until cell 1 is 0

-2 @ धन्यवाद के साथ

ब्रेनफॉक पर मेरा पहला प्रयास तो किसी भी संकेत कृतज्ञता प्राप्त की। अगर मैं इसके साथ अधिक अनुभवी था, तो मुझे यकीन है कि मैं कुछ और बाइट्स हटा सकता हूं, लेकिन मैं कल ही इसमें मिला हूं।

— ElPedro
स्रोत
— जो किंग
6

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

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

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

एक कारण यह अन्य मस्तिष्क-फ्लैक उत्तर की तुलना में कम है, क्योंकि यह लोअरकेस वर्णों के बजाय अपरकेस का उपयोग करता है, जिनके छोटे ASCII मान हैं, और इसलिए धक्का देना आसान है।

स्पष्टीकरण:

#Push 25
((((()()()){}){}){}())

#While true
{

    #Keep track of the number on top of the stack...
    # We'll call it 'a'
    (({})

        #Push A +...
        <((({}

        # 64 (push)
        ((((()()()()){}){}){}){})
        # + 1 (push)
        ())
        # - 1 (push)
        [()])

        # Push 10
        ((()()()()()){})>

    # Now that's all pushed, we push a - 1 to decrement the loop counter
    [()])

# Endwhile
}
— DJMcMayhem
स्रोत
मैं पहला संस्करण लिखता हूं और कोई भी अपवित्र नहीं मिलता है जो आप एक गोल्फ संस्करण लिखते हैं और +5 प्राप्त करते हैं। ???
— क्रिस्टोफर
5

आर, 51 47 बाइट्स

L=LETTERS;cat(sprintf("%s%s%1$s",L[-26],L[-1]))

आउटपुट:

> L=LETTERS;cat(sprintf("%s%s%1$s",L[-26],L[-1]))
ABA BCB CDC DED EFE FGF GHG HIH IJI JKJ KLK LML MNM NON OPO PQP QRQ RSR STS TUT UVU VWV WXW XYX YZY
— plannapus
स्रोत
फैंसी बिना अनुभवहीन तरीका sprintfहै 49 बाइट्स
— ग्यूसेप
@Giuseppe क्योंकि मैं sprintfसही ढंग से उपयोग नहीं किया होगा :)
— plannapus
ठीक है, लेकिन मुझे एक 40 बटर मिला :)
— Giuseppe
@ गिउसेप इउच :)
— प्लेनैपस
1
एक और [40 बायटर ] [ tio.run/##K/r/… ASCII कोड को परिवर्तित करने के आधार पर, मामले में
— NofP
5

जावा 8 , 132 85 62 60 बाइट्स

  • नील को 47 बाइट्स धन्यवाद
  • ओलिवर के लिए 26 बाइट्स धन्यवाद
  • केविन के लिए 3 बाइट्स और बहुत बेहतर फॉर्मेटिंग धन्यवाद
  • ओलिवर द्वारा तय की गई त्रुटि

golfed

a->{for(char i=64;++i<90;)System.out.println(""+i+++i--+i);}

Ungolfed

public class TerzaRima {
    interface A{
        void a(String a);
    }
    static A a = a -> {
        for (char i = 64; ++i < 90; ) System.out.println("" + i++ + i-- + i);
    };
    public static void main(String[] args){
        a.a(null);
    }
}
— DevelopingDeveloper
स्रोत
1
एक चार सरणी मुद्रण शायद एक बहुत छोटा होगा।
— नील
1
आप कर सकते हैं iएक charबहुत?
— नील
2
a->{for(char c=64;++c<90;)System.out.println(""+c++ +c--+c);}(62 बाइट्स)
— ओलिवियर ग्रेजायर
2
वर्तमान में यह एक फ़ंक्शन या प्रोग्राम के बजाय एक स्निपेट है, इसलिए आपको v->{...}@ OlivierGrunire द्वारा ऊपर बताए अनुसार जोड़ना होगा। ( यदि आप नहीं जानते कि जावा 8 लैम्ब्डा कैसे काम करता है, तो मैंने पहले एक बार स्पष्टीकरण दिया था। ) इसके अलावा, आप ओलिवियर की तरह लूप के ब्रैकेट को हटा सकते हैं, और अतिरिक्त गोल्फ के रूप में आप प्रिंट को बदल सकते हैं System.out.print(" "+i+++i--+i);(इसके बजाय एक स्थान एक नई लाइन की, और आपको उस स्थान की आवश्यकता नहीं है c+++c--+c)। इसे यहाँ आज़माएँ।
— केविन क्रूज़सेन
1
धन्यवाद @KevinCruijssen सुझावों के लिए और साथ ही जावा लैम्ब्डा दस्तावेज़। कुछ सरल लंबों को लागू करने के लिए गाइड का पालन करना बहुत आसान था। मैंने उसी के अनुसार अपडेट किया है!
— विकसित करना
4

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

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

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

— OVS
स्रोत
+1 मैं इसका सबसे अधिक पालन करता हूं, लेकिन यह इसके साथ शुरू होता है - क्या इसका मतलब है कि आप लूप शुरू करने से पहले सेल 0 से -1 सेट कर रहे हैं? यदि आपके पास समय है तो एक दिमागी नौसिखिया के लिए स्पष्टीकरण का कोई भी मौका? Btw, मेरे प्रयास पर -2 के लिए धन्यवाद।
— एलपीड्रो
@ElPedro यह ब्रेनफॉक दुभाषिया पर निर्भर करता है, tio.run स्टोर्स पर इंटरप्रेटर प्रत्येक सेल में 8-बिट संख्या को अनसाइन करता है, इसलिए लूप से पहले पहली सेल 255 हो जाती है।
— ओव्स
@ElPedro इनिशियलाइज़ेशन सेगमेंट वास्तव में BF-Crunch द्वारा उत्पन्न किया गया है ।
— 18
4

ब्रेनफक , 45 37 बाइट्स

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

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

एक बड़े स्थान के साथ रिक्त स्थान द्वारा अलग किए गए अपरकेस में प्रिंट।

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

+[[<+>>++<-]>] Intialises the tape with the format n^2
               1 2 4 8 16 32 64 128 0 0'
<<---          Navigates to the desired section and tweaks the counter
               1 2 4 8 16 32 64 125<
[-----<+.+.-.<.>>] Prints the Terza Rima, using:
                 125 as the loop counter (decremented by 5 each loop)
                 64 as the current alphabetic character (incremented and printed each loop)
                 32 as the space character
— मजाक कर रहा है
स्रोत
1
यह वास्तव में बहुत अच्छा है! बहुत बढ़िया!
— डस्ट
3

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

[[x,succ x,x]|x<-['A'..'Y']]

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

succ इस तरह के एक दुर्भाग्यपूर्ण नामकरण पसंद है ...

व्याख्या

[[x,succ x,x]|x<-['A'..'Y']]

[            |x<-          ]  -- for x in...
                 ['A'..'Y']   -- the alphabet sans Z
 [x,succ x,x]                 -- construct a string of x, the successor of x and x
— totallyhuman
स्रोत
4
मुझे ऐसा महसूस नहीं होता है कि उन्हें आवश्यकतानुसार अंतरिक्ष या न्यूलाइन के साथ अलग करने के बजाय स्ट्रिंग्स की एक सूची वापस करना पूरी तरह से उचित है।
— user28667
@ user28667 इसे आमतौर पर चुनौतियों में अनुमति दी जाती है (यह शायद डिफ़ॉल्ट IO पोस्ट पर होना चाहिए, अगर यह पहले से ही नहीं है)। ओपी को विशेष रूप से इस चुनौती का जवाब देना बाकी है। हालांकि, यह कोई कारण नहीं है।
— 22
@totallyhuman फिलहाल चुनौती स्पष्ट रूप से निर्दिष्ट करती है कि आउटपुट को अलग करने के लिए या तो रिक्त स्थान या newlines का उपयोग किया जाना चाहिए, इस प्रकार यह उत्तर वर्तमान में अमान्य है। तो सख्ती से साइट के अनुसार नियमों इसे नष्ट कर दिया जाना चाहिए, या सिर्फ एक prepending द्वारा तय unlinesया unwords।
— लिकोनी
@ लैकोनी मुझे लगता है कि आप निंजा चाहेंगे। चुनौती स्पष्ट रूप से आउटपुट के रूप में लाइनों की एक सूची से इनकार नहीं करती है। (साथ ही, जो उत्तरों की एक उचित मात्रा को अमान्य कर देगा।) किसी भी तरह से, उत्तर अब अमान्य नहीं है ।
— अशुभ
3

आर , 40 बाइट्स

cat(intToUtf8(rbind(x<-65:89,x+1,x,10)))

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

आर टू प्लेनैपस और ग्यूसेप के उत्तरों में एक और विकल्प । उनके अनुरोध के बाद पोस्ट किया। यह समाधान ASCII कोड का उपयोग UTF8 कोडिंग के लिए करता है।

PS यदि TAB की अनुमति दी गई थी, तो कोई नई सारणी (ASCII कोड 10) को सारणीकरण (ASCII कोड 9) से बदल सकता है, और समाधान 39 बाइट्स तक सिकुड़ सकता है:

cat(intToUtf8(rbind(x<-65:89,x+1,x,9)))

— NofP
स्रोत
मुझे लगता है कि इसका उपयोग 9पूरी तरह से ठीक है, क्योंकि यह व्हाट्सएप है, जिसे ओपी द्वारा अनुमति है।
— Giuseppe
3

आर , 40 36 बाइट्स

cat(paste0(L<-LETTERS,L[-1],L)[-26])

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

प्लाननापस के उत्तर का एक विकल्प ; यह थोड़ा गोल्फ खिलाड़ी निकला; मैंने इसे उनके अनुरोध के अनुसार पोस्ट किया है।

NofP द्वारा यह 40 बाइट उत्तर भी देखें जो काफी अच्छा है।

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

पावरशेल , 39 37 बाइट्स

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

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

से लूप्स 65के लिए 89। प्रत्येक पुनरावृत्ति, हम पूर्व-वेतन वृद्धि और पूर्व-डिक्रीमेंट का उपयोग करते हुए, वर्तमान अंक के (वर्तमान, एक और अधिक) के पूर्णांक सरणी का निर्माण कर रहे हैं। इसके बाद एक char-रे के रूप में फिर से कास्ट किया जाता है , और -joinएक साथ एक स्ट्रिंग में एड किया जाता है। प्रत्येक स्ट्रिंग को पाइप लाइन पर छोड़ दिया जाता है और Write-Outputप्रोग्राम पूरा होने पर एक निहितार्थ हमें मुफ्त में प्रत्येक तत्व के बीच एक नई रेखा देता है।

वैकल्पिक रूप से, एक ही बाइट गिनती

65..89|%{-join[char[]]($_,($_+1),$_)}

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

— AdmBorkBork
स्रोत
1
($_,($_+1),$_)एक ही समान लंबाई वाला
— टुपल है
2

पेपे, 59 56 बाइट्स

-3 बाइट्स u_ndefined के लिए धन्यवाद

REeEeEEeEerEeEeeeeeERrEEEEErEEEeeREEreeerEEEEEeeEreeERee

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

स्पष्टीकरण:

# Prepare stacks

  # prepare stack R [Z]
  REeEeEEeEe  # push Z

  # prepare stack r [A,B,A]
  rEeEeeeeeE  # push A
  RrEEEEE     # copy and increment A (getting B)
  rEEEee      # duplicate A to end

# Start loop
REE           # create label Z

  reee        # output stack r contents
  rEEEEEeeE   # increment all

  reeE        # end line

Ree           # loop while r[p] != Z
— लाल तिपतिया घास
स्रोत
1
जगह rEeEeeeeEeके साथ RrEEEEE3 बाइट्स बंद की बचत होती है
— u_ndefined
@u_ndefined धन्यवाद! पेपे में झंडे जोड़े जाने से पहले मैंने यह कोड बनाया था। उत्तर अपडेट किया गया।
— RedClover
1

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


ABA
;{:G`
T`_p`p`[^Y]..

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

— मार्टिन एंडर
स्रोत
21 बाइट्स, लेकिन नई सुर्खियों में आने से ...
— नील
@ नहीं, हाँ, आपको इसकी आवश्यकता भी नहीं है `...। हालांकि उन नई नई कहानियों से छुटकारा पाना वास्तव में कष्टप्रद है। मैं रेटिना 1.0 में छोरों को थोड़ा और अधिक लचीला और सुविधाजनक बनाने की उम्मीद कर रहा हूं।
— मार्टिन एंडर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.