एक मेम द्वारा प्रेरित मैंने आज पहले देखा था।

चुनौती का वर्णन

एक अनंत वर्णमाला ग्रिड पर विचार करें:

ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
...

एक शब्द लें ( CODEGOLFइस उदाहरण में) और इसे ग्रिड की एक अनुगामी बनाएं, एक अंतरिक्ष द्वारा अप्रयुक्त पत्रों को प्रतिस्थापित करें और अनंत ग्रिड के अंत में अक्षरों को हटा दें:

  C           O           
   DE G       O           
           L              
     F

उदाहरण

STACKEXCHANGE

                  ST      
A C       K               
    E                  X  
  C    H                  
A            N            
      G                   
    E

ZYXWVUTSRQPONMLKJIHGFEDCBA

F

ANTIDISESTABLISHMENTARIANISM

A            N     T      
        I                 
   D    I         S       
    E             ST      
AB         L              
        I         S       
       H    M             
    E        N     T      
A                R        
        I                 
A            N            
        I         S       
            M

ट्रेलिंग व्हाट्सएप की अनुमति है।
आपको रिक्त स्थान के साथ ~~अंतिम~~ किसी भी पंक्ति को पैड करने की आवश्यकता नहीं है । उदाहरण के लिए, यदि इनपुट है ABC, तो आप केवल ABC23 अनुगामी रिक्त स्थान के बिना आउटपुट कर सकते हैं ।
आप मान सकते हैं कि इनपुट [A-Z]+रेगेक्स से मेल खाएगा ।
वैकल्पिक रूप से, आप निम्न-केस वर्णमाला का उपयोग कर सकते हैं, जिस स्थिति में आउटपुट का मिलान होगा [a-z]+।
आप एक नई पंक्ति (का उपयोग करना चाहिए \n, \r\nलाइनों को अलग करने या समकक्ष), कि स्ट्रिंग की एक सूची है नहीं एक उचित उत्पादन प्रारूप है।
यह एक कोड-गोल्फ चुनौती है, इसलिए अपने कोड को यथासंभव छोटा बनाएं!

— shooqie
स्रोत

क्या प्रमुख नए समाचारों की अनुमति है?

— आउटगॉल्फ

@EriktheOutgolfer ज़रूर, जब तक यह ग्रिड संरचना को गड़बड़ नहीं करता है।

— शौकी

यदि गैर-घातक त्रुटि कार्यक्रम को रोकती है तो क्या यह ठीक होगा?

— ज़ाचरी

@ Zacharý हालांकि मैं देख सकता हूं कि कुछ बाइट्स कैसे बचा सकता है, मुझे लगता है कि यह बदसूरत है और अवांछित, शानदार उत्पादन करता है। तो नहीं। संपादित करें: जब तक कि आप अपने प्रोग्राम को एग्ज़िट कोड या किसी ऐसी चीज़ से बाहर न निकाल सकें, जो अपवाद स्टैक ट्रेस या कुछ इसी तरह के प्रिंटर्स के साथ न हो।

— शौकी

7

सुझाए गए परीक्षण मामले: BALLOON(दो आसन्न वर्ण जो समान हैं)।

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

10

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

TṪS`?' €…"AZ"ġ>

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

व्याख्या

TṪS`?' €…"AZ"ġ>  Implicit input, e.g. "HELLO"
             ġ>  Split into strictly increasing substrings: x = ["H","EL","LO"]
        …"AZ"    The uppercase alphabet (technically, the string "AZ" rangified).
 Ṫ               Outer product of the alphabet and x
  S`?' €         using this function:
                   Arguments: character, say c = 'L', and string, say s = "EL".
       €           1-based index of c in s, or 0 if not found: 2
  S`?'             If this is truthy, then c, else a space: 'L'
                 This gives, for each letter c of the alphabet,
                 a string of the same length as x,
                 containing c for those substrings that contain c,
                 and a space for others.
T                Transpose, implicitly print separated by newlines.

— Zgarb
स्रोत

7

जावा 10, 161 159 152 बाइट्स

s->{var x="";int p=0;for(var c:s)x+=p<(p=c)?c:";"+c;for(var y:x.split(";"))System.out.println("ABCDEFGHIJKLMNOPQRSTUVWXYZ".replaceAll("[^"+y+"]"," "));}

-2 बाइट्स @ नवीन को धन्यवाद ।
-7 बाइट प्रिंटिंग सीधे एक स्ट्रिंग वापस करने के बजाय, और जावा 10 में परिवर्तित।

स्पष्टीकरण: "

इसे यहाँ आज़माएँ।

s->{                      // Method with String parameter and no return-type
  var x="";               //  Temp-String
  int p=0;                //  Previous character (as integer), starting at 0
  for(var c:s)            //  Loop (1) over the characters of the input
    x+=p<(p=c)?           //   If the current character is later in the alphabet
                          //   (replace previous `p` with current `c` afterwards)
        c                 //    Append the current character to Temp-String `x`
       :                  //   Else:
        ";"+c;            //    Append a delimiter ";" + this character to Temp-String `x`
  for(var y:x.split(";")) //  Loop (2) over the String-parts
    System.out.println(   //   Print, with trailing new-line:
     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                          //    Take the alphabet,
        .replaceAll("[^"+y+"]"," "));}
                          //    and replace all letters not in the String-part with a space

विधि का पहला भाग एक सीमांकक के साथ इनपुट-शब्द को भागों में विभाजित करता है।
उदाहरण के लिए: CODEGOLF→ CO;DEGO;L;Fया BALLOON→ B;AL;LO;O;N।

दूसरा भाग इन भागों पर लूप करता है, और रेगेक्स का उपयोग उन सभी [^...]चीज़ों को बदलने के लिए करता है जो किसी स्थान से मेल नहीं खाती हैं।
उदाहरण के लिए , और , और एक जगह के साथ सब कुछ .replaceAll("[^CO]"," ")छोड़ देता है।CO

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

1

यह नहीं होगा B;AL;LO;O;N?

— NieDzejkob 12

1

-2 बाइट्स for(char c:s)x+=p<(p=c)?c:";"+c;:।

— नेवई

6

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

i;f(char*s){for(i=64;*s;putchar(*s^i?32:*s++))i+=i^90?1:puts("")-26;}

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

— scottinet
स्रोत

4

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

40 बाइट्स कोड + 4 के लिए -lF।

print map/$F[0]/?shift@F:$",A..Z while@F

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

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

आपके द्वारा पोस्ट किया गया लिंक 46 बाइट्स संस्करण के लिए है।

@ ThePirateBay धन्यवाद !! मुझे पता था कि मैंने कुछ अपडेट नहीं किया है!

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

4

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

f=lambda x,y=65:x and(y<=ord(x[0])and" "*(ord(x[0])-y)+x[0]+f(x[1:],-~ord(x[0]))or"\n"+f(x))

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

— हलवार्ड वुल्म
स्रोत

3

90 बाइट्स

— अंडा

4

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

संपादित करें एक अग्रणी नई रेखा स्वीकार किए जाने के बाद, मैं 2 बाइट्स बचा सकता हूं

s=>eval("for(o='',v=i=0;c=s.charCodeAt(i);v%=27)o+=v++?c-63-v?' ':s[i++]:`\n`")

1 बाइट के लिए, मैं लोअरकेस या अपरकेस इनपुट स्वीकार कर सकता हूं:

s=>eval("for(o='',v=i=0;c=s[i];v%=27)o+=v++?parseInt(c,36)-8-v?' ':s[i++]:`\n`")

कम गोल्फ वाला

s=>{
  var i,o,c,v
  for(o = '', v = 1, i = 0; c = s.charCodeAt(i); v %= 27)
    o += v++ ? c-63-v ? ' ' : s[i++] : '\n'
  return o
}

परीक्षा

f=s=>eval("for(o='',v=i=0;c=s.charCodeAt(i);v%=27)o+=v++?c-63-v?' ':s[i++]:`\n`")

function update() {
  var i=I.value
  i=i.replace(/[^A-Z]/gi,'').toUpperCase()
  O.textContent=f(i)
}

update()

<input id=I value='BALLOON' oninput='update()' >
<pre id=O></pre>

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

— edc65
स्रोत

आप \n-1 बाइट के लिए बैकटिक्स के अंदर शाब्दिक न्यूलाइन के साथ बदल सकते हैं ।

— जस्टिन मैरिनर

@JustinMariner नहीं, मैं eval में दोहरे उद्धरण के अंदर नहीं कर सकता

— edc65

ओह ठीक है, यह शर्म की बात है। मेरी गलती।

— जस्टिन मैरिनर

4

MATL , 24 23 बाइट्स

''jt8+t1)wdh26X\Ys(26e!

लोअरकेस अक्षरों का उपयोग करता है।

MATL ऑनलाइन पर यह कोशिश करो !

व्याख्या

''     % Push empty string
jt     % Push input string. Duplicate
8+     % Add 8 to each char (ASCII code). This transforms 'a' 105,
       % 'b' into 106, which modulo 26 correspond to 1, 2 etc
t1)    % Duplicate. Get first entry
wd     % Swap. COnsecutive differences.
h      % Concatenate horizontally
26X\   % 1-based modulo 26. This gives a result from 1 to 26
Ys     % Cumulative sum
(      % Write values (converted into chars) at specified positions
       % of the initially empty string
26e    % Reshape into a 26-row char matrix, padding with char 0
!      % Transpose. Implicitly display. Char 0 is shown as space

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

4

जाप , 18 16 बाइट्स

-2 बाइट्स @ शुग्गी को धन्यवाद

;ò¨ £B®kX ?S:Z
·

केवल अपरकेस इनपुट।

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

व्याख्या

वैकल्पिक चर पर स्विच करें, जहां Bअपरकेस वर्णमाला है।

ò¨

उन वर्णों के बीच इनपुट स्ट्रिंग को विभाजित करें जहां पहला ¨, दूसरे (या ) के बराबर या उससे अधिक है ।

£

फ़ंक्शन द्वारा प्रत्येक विभाजन को मैप करें, जहां Xवर्तमान विभाजन है।

B®

Zवर्तमान अक्षर होने के साथ अपरकेस वर्णमाला में प्रत्येक चरित्र को मैप करें ।

kX

वर्तमान विभाजन के सभी अक्षरों को वर्तमान अक्षर से हटा दें। यदि वर्तमान अक्षर वर्तमान विभाजन में समाहित है, तो यह एक रिक्त स्ट्रिंग में परिणत होता है।

?S:Z

यदि वह सत्य है (खाली स्ट्रिंग नहीं), तो एक स्थान लौटाएँ ( S), अन्यथा वर्तमान पत्र लौटाएँ।

·

पिछली पंक्ति के परिणाम को newlines के साथ शामिल करें और परिणाम प्रिंट करें।

— जस्टिन मेरिनर
स्रोत

के लिए 10 बाइट्स r"[^{Z}]"Sथोड़ा हास्यास्पद लगता है, लेकिन मैं किसी भी बेहतर तरीका है या तो ... नहीं मिल सकता है

— ETHproductions

17 बाइट्स

— झबरा

16 बाइट्स

— झबरा

@ सुग्गी के साथ अच्छी सोच kX!

— जस्टिन मैरिनर

वास्तव में मुझे लगता है कि आप दो बाइट्स बचाने के kX ?S:Zलिए बदल सकते हैंoX ªS

— ETHproductions

3

पायथ, 18 बाइट्स

#pbVGp?JqhzNNd=>zJ

इसे यहाँ आज़माएँ।

आउटपुट में नई लीडिंग, वर्णमाला को कम करती है।

— आउटगोल्फर को एरिक करें
स्रोत

3

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

<2\¬0;œṗfȯ⁶$¥€@€ØAY

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

— आउटगोल्फर को एरिक करें
स्रोत

OI<1®;-> >2\0;एक बाइट को बचाने के लिए (मैंने वास्तव में >2\0;œṗµØAf€ȯ€⁶µ€Y18 के लिए भी किया था , जो मुझे व्यक्तिगत रूप से पार्स करने में आसान लगता है)

— जोनाथन एलन

@JonathanAllan मुझे लगता है कि इसके लिए BALLOONया कुछ और विफल होगा ।

— १२:०२ पर आउटगॉल्फ

आप सही हैं, हां - तो इसके लिए किसी अन्य बाइट की आवश्यकता होगी जैसे <2\1;¬; ओह अच्छा।

— जोनाथन एलन

@JonathanAllan वैसे भी, मैं आपके विचार को अपने उत्तर में लागू करूंगा ... किया।

— आउटगॉल्फ

3

सी (जीसीसी), 91 63 बाइट्स

-28 ASCII- के लिए धन्यवाद

_;f(char*s){for(_=64;*s;)putchar(++_>90?_=64,10:*s^_?32:*s++);}

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

पिछला:

i,j;f(char*s){while(s[i]){for(j=65;j<91;j++)s[i]==j?putchar(s[i++]):printf(" ");puts("");}}

हां, इसका एक छोटा समाधान है, लेकिन मैंने इसे एक बार लिखने के बाद देखा ... इसे ऑनलाइन आज़माएं!

— एमडी एक्सएफ
स्रोत

82 बाइट्स , 80 अगर अग्रणी नईलाइन की अनुमति है

— ASCII-only

73

— केवल

63

— एएससीआईआई-केवल 23

3

गणितज्ञ, 101 बाइट्स

StringRiffle[
  Alphabet[]/.#->" "&/@
   (Except[#|##,_String]&@@@
     Split[Characters@#,#==1&@*Order]),"
",""]&

Splitआसन्न अक्षरों के साथ तुलना करते हुए, अक्षर अनुक्रमों में इनपुट को सख्ती से बढ़ाना Order। यदि Order[x,y] == 1, तो वर्णमाला में xपूर्ववर्ती yहै और इस प्रकार एक ही पंक्ति में दिखाई दे सकता है।

अक्षरों के प्रत्येक अनुक्रम के Exceptलिए, उन अक्षरों के लिए तार से मेल खाने के लिए एक पैटर्न बनाएं ; #|##के लिए एक आशुलिपि है Alternatives। Alphabetउस अक्षर के स्थान को पैटर्न से रिक्त स्थान से मिलाएं।

मध्यवर्ती चरणों का चित्रण:

"codegolf";
Split[Characters@#,#==1&@*Order]  &@%
Except[#|##,_String]&@@@         #&@%
Alphabet[]/.#->" "&/@               %

{{"c", "o"}, {"d", "e", "g", "o"}, {"l"}, {"f"}}

{Except["c" | "c" | "o", _String], 
 Except["d" | "d" | "e" | "g" | "o", _String], 
 Except["l" | "l", _String],
 Except["f" | "f", _String]}

{{" "," ","c"," "," "," "," "," "," "," "," "," "," "," ","o"," "," "," "," "," "," "," "," "," "," "," "},
 {" "," "," ","d","e"," ","g"," "," "," "," "," "," "," ","o"," "," "," "," "," "," "," "," "," "," "," "},
 {" "," "," "," "," "," "," "," "," "," "," ","l"," "," "," "," "," "," "," "," "," "," "," "," "," "," "},
 {" "," "," "," "," ","f"," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "}}

— hftf
स्रोत

2

गोल्फस्क्रिप्ट, 22 21 बाइट्स

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

nबिल्ट-इन के सावधानीपूर्वक अंतिम पुनर्निर्धारण के लिए -1 बाइट धन्यवाद ।

{.n>{}{'
'\}if:n}%:n;

स्पष्टीकरण (थोड़े अलग संस्करण के साथ):

{.n>{}{"\n"\}if:n}%:n; # Full program
{                }%    # Go through every character in the string
 .n>         if        # If ASCII code is greater than previous...
                       # (n means newline by default, so 1st char guaranteed to fit)
    {}                 # Do nothing
      {"\n"\}          # Else, put newline before character
               :n      # Redefine n as the last used character
                   :n; # The stack contents are printed at end of execution
                       # Literally followed by the variable n, usually newline
                       # So because n is by now an ASCII code...
                       # ...redefine n as the new string, and empty the stack

— जोशिया विंसलो
स्रोत

2

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

^
;¶
{`;.*
¶;ABCDEFGHIJKLMNOPQRSTUVWXYZ
¶¶
¶
)+`;(.*)(.)(.*¶)\2
$.1$* $2;$3
;.*

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

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

— FryAmTheEggman
स्रोत

2

05AB1E , 18 बाइट्स

ćIgµ¶?AvDyÊið?ë¼?ć

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

ćअंतिम तत्व निकाले जाने के बाद स्टैक पर खाली स्ट्रिंग / सूची छोड़ने पर 05AB1E (अर्क 1) से परेशानी हुई । यह समाधान 1-2 बाइट्स छोटा होगा यदि यह उसके लिए नहीं था।

ćIgµ¶?AvDyÊið?ë¼?ć  Implicit input 
ć                   Extract the 1st char from the string
 Igµ                While counter != length of the string
    ¶?              Print a newline
      Av            For each letter of the lowercased alphabet
        DyÊ         Is the examined character different from the current letter?
           ið?      If true, then print a space

              ë¼?ć  Else increment the counter, print the letter and push
                    the next character of the string on the stack

— scottinet
स्रोत

वास्तव में, का ð,अर्थ है "एक स्थान और एक नई रूपरेखा प्रिंट करें"।

— आउटगॉल्फ

आप सही हे। कोड को वास्तव में एक नई लाइन प्रिंट करने के लिए तय किया।

— 14

2

रेटिना , 130 126 बाइट्स

$
¶A
{-2=`
$'
}T`RL`_o`.$
+`(?<=(.)*)((.).*¶(?<-1>.)*(?(1)(?!)).+\3.*$)
 $2
(?<=(.)*)((.).*¶(?<-1>.)*(?<-1>\3.*$))
¶$2
}`¶.*$

इसे ऑनलाइन आज़माएं! संपादित करें: @ मार्टिनियर के वर्णमाला जनरेटर का उपयोग करके 4 बाइट्स सहेजे गए। स्पष्टीकरण:

$
¶A
{-2=`
$'
}T`RL`_o`.$

वर्णमाला में जोड़ें।

+`(?<=(.)*)((.).*¶(?<-1>.)*(?(1)(?!)).+\3.*$)
 $2

वर्णमाला में उनकी स्थिति के साथ यथासंभव अधिक से अधिक अक्षरों को संरेखित करें।

(?<=(.)*)((.).*¶(?<-1>.)*(?<-1>\3.*$))
¶$2

पहले अक्षर से पहले एक नई लाइन शुरू करें जिसे संरेखित नहीं किया जा सकता है।

}`¶.*$

वर्णमाला हटाएं, लेकिन तब तक सब कुछ फिर से करें जब तक कि कोई गलत अक्षर न हों।

— नील
स्रोत

यह केवल एक पंक्ति को प्रिंट करने के लिए लगता है, बाद की लाइनों पर अक्षरों को संरेखित नहीं करता है।

— जस्टिन मैरिनर

@JustinMariner मेरा बुरा, मैंने अपने आखिरी गोल्फ में एक टाइपो बनाया और इसे ठीक से जांचने में विफल रहा।

— नील

2

क्यू / केडीबी + , ४ 48 ४५ बाइट्स

उपाय:

-1{@[26#" ";.Q.A?x;:;x]}@/:(0,(&)(<=':)x)_x:;

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

नोट: लिंक इस समाधान के K (oK) पोर्ट के लिए है क्योंकि q / kdb + के लिए कोई TIO नहीं है।

उदाहरण:

q)-1{@[26#" ";.Q.A?x;:;x]}@/:(0,(&)(<=':)x)_x:"STACKEXCHANGE";
                  ST
A C       K
    E                  X
  C    H
A            N
      G
    E

q)-1{@[26#" ";.Q.A?x;:;x]}@/:(0,(&)(<=':)x)_x:"BALLOON";
 B
A          L
           L  O
              O
             N

स्पष्टीकरण:

Q को दाएं-बाएं व्याख्या की गई है। समाधान दो भागों में विभाजित है। पहले स्ट्रिंग को विभाजित करें जहां अगला वर्ण वर्तमान से कम या उसके बराबर है:

"STACKEXCHANGE" -> "ST","ACK","EX","CH","AN","G","E"

फिर 26 रिक्त स्थान की एक स्ट्रिंग लें, और इनपुट को उस सूचक पर लागू करें जहां इनपुट वर्णमाला में दिखाई देता है, और स्टडआउट पर प्रिंट करें।

"__________________________" -> __________________ST______

टूट - फूट:

-1{@[26#" ";.Q.A?x;:;x]}each(0,where (<=':)x) cut x:; / ungolfed solution
-1                                                  ; / print to stdout, swallow return value
                                                  x:  / store input as variable x
                                              cut     / cut slices x at these indices
                            (               )         / do this together
                                     (<=':)x          / is current char less-or-equal (<=) than each previous (':)?
                               where                  / indices where this is true
                             0,                       / prepended with 0
                        each                          / take each item and apply function to it
  {                    }                              / lambda function with x as implicit input
   @[      ;      ; ; ]                               / apply[variable;indices;function;arguments]
     26#" "                                           / 26 take " " is "      "...
            .Q.A?x                                    / lookup x in the uppercase alphabet, returns indice(s)
                   :                                  / assignment
                     x                                / the input to apply to these indices

टिप्पणियाँ:

K4 संस्करण के साथ प्रबल होकर -3 बाइट्स

— streetster
स्रोत

2

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

-7 बाइट्स धन्यवाद @Veskah

$args|%{if($_-le$p){$x;rv x}
$x=("$x"|% *ht($_-65))+($p=$_)}
$x

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

स्पष्टीकरण:

चपटा तर्क में प्रत्येक वर्ण के लिए:

आउटपुट स्ट्रिंग $xऔर स्पष्ट $xमान ( निकालें-परिवर्तनीय केrv लिए उर्फ है ), यदि पिछले चरित्र के कोड के लिए वर्तमान वर्ण कम या समकक्ष ( ) का एक कोड।-le
रिक्त स्थान और वर्तमान चरित्र को इसमें जोड़ें $x, इसे स्टोर करें $x। इसके अलावा यह पिछले वर्ण मान को ताज़ा करता है।

आउटपुट पिछले $x।

— Mazzy
स्रोत

1

63 बाइट्स का उपयोग करते हुए । |% *htकुछ बाइट्स को बचाने के लिए उपयोग करने की कोशिश की, लेकिन ऐसा लगता है कि यह भी टूट गया।

— विस्कह

1

जेली , २४ 21 बाइट्स

3 बाइट्स के लिए धन्यवाद एग्री द आउटगोलर।

O64;I%26’⁶ẋÐ€;"⁸Ẏs26Y

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

— लीक नन
स्रोत

8

मेरा मानना है कि यह इनपुट "बोलोन" के लिए विफल है - दोहराया वर्ण एक ही पंक्ति पर हैं।

— जस्टिन मेरिनर

1

SOGL V0.12 , 22 बाइट्स

±E⁄Z*{@;eJι=?Xē}}¹∑z⁄n

यह कोशिश करो!

— dzaima
स्रोत

1

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

f=([...s])=>s[0]?(g=i=>i>35?`
`+f(s):(i-parseInt(s[0],36)?" ":s.shift())+g(i+1))(10):""

अपरकेस या लोअरकेस इनपुट स्वीकार करता है। आउटपुट इनपुट के मामले से मेल खाता है।

टेस्ट

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

f=([...s])=>s[0]?(g=i=>i>35?`
`+f(s):(i-parseInt(s[0],36)?" ":s.shift())+g(i+1))(10):""

;O.innerText=["CODEGOLF","STACKEXCHANGE","F","ZYXWVUTSRQPONMLKJIHGFEDCBA","ANTIDISESTABLISHMENTARIANISM"]
.map(f).join("=".repeat(26)+"\n")

<pre id=O>

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

— जस्टिन मेरिनर
स्रोत

1

हास्केल, 81 74 73 बाइट्स

q@(w:y)!(x:z)|w==x=x:y!z|1<2=min ' 'x:q!z
x!_=x
a=['A'..'Z']++'\n':a
(!a)

लाईकोनी के लिए 1 बाइट धन्यवाद !

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

हास्केल हग अनुकूलन

हग्स दुभाषिया मुझे (!cycle$['A'..'Z']++"\n")इसके बजाय एक और बाइट को बचाने की अनुमति देता है: (!cycle(['A'..'Z']++"\n"))लेकिन जीएचसी पूर्व को पसंद नहीं करता है । (यह अब अप्रचलित है; ल्यकोनी ने पहले ही उस पंक्ति को एक तरह से फिर से लिखा था जिससे 1 बाइट बच गई थी।)
जाहिरा तौर पर, हग्स को सूची पैटर्न मिलानकर्ता के आसपास कोष्ठक की आवश्यकता नहीं है, इसलिए मैं दो और बाइट्स से जा सकता हूं: q@(w:y)!(x:z)से q@(w:y)!x:z।

— क्रिस्टियन लुपस्कू
स्रोत

आप के साथ एक बाइट बचा सकते हैं a=['A'..'Z']++'\n':a;(!a)। अब यह दिलचस्प है कि हग के लिए कुछ हद तक ढीले नियम हैं।

— लकोनी

@ लिकोनी मैं हास्केल को महीनों से देख रहा हूं और यह मुझे विस्मित करने के लिए बंद नहीं करता है। मुझे a=...:aचाल पसंद है। धन्यवाद!

— क्रिस्टियन लुपस्कू

मुझे नहीं पता कि क्या आप इसके बारे में जानते हैं, लेकिन मुझे लगता है कि यह ध्यान देने योग्य है। हग्स के यहाँ भिन्न होने का कारण यह है कि ghc की तुलना में उपयोगकर्ता परिभाषित ऑपरेटरों के लिए निम्न ऑपरेटर पूर्वता है।

— गेहूं जादूगर

@WheatWizard मैं जागरूक नहीं था। यह सही समझ में आता है, मुझे जीएचसी में मिली त्रुटि को देखते हुए।

— क्रिश्चियन लुपस्क्यू

1

पायथन 3 , 87 85 बाइट्स

def f(s,l=65):c,*t=s;o=ord(c)-l;return o<0and'\n'+f(s)or' '*o+c+(t and f(t,o-~l)or'')

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

— फेलिप नारदी बतिस्ता
स्रोत

1

जे , 39 बाइट्स

(_65+3 u:[)}&(26{.'')/.~0+/\@,2>:/\3&u:

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

— FrownyFrog
स्रोत

1

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

Ｆθ«Ｊ⌕αι⁺ⅉ‹⌕αιⅈι

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

 θ              Input string
Ｆ «             Loop over characters
     α     α    Uppercase letters predefined variable
      ι     ι   Current character
    ⌕     ⌕     Find index
             ⅈ  Current X co-ordinate
         ‹      Compare
        ⅉ       Current Y co-ordinate
       ⁺        Sum
   Ｊ            Jump to aboslute position
              ι Print current character

— नील
स्रोत

1

APL (Dyalog Classic) , 20 बाइट्स

⊃¨⎕a∘.∩⍨⊢⊂⍨1,2≥/⎕a⍳⊢

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

— NGN
स्रोत

1

के (ngn / k) , २ ९ २ n बाइट्स

{{x@x?`c$65+!26}'(&~>':x)_x}

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

{ } तर्क के साथ कार्य करें x

>':x प्रत्येक चार के लिए, क्या यह पिछले चार से अधिक है?

~ नकारना

& कहां (किन सूचकांकों पर) हमारे पास सही है

( )_xxउन सूचकांकों में कटौती , स्ट्रिंग्स की सूची लौटाएं

{ }' उनमें से प्रत्येक तार के लिए

`c$65+!26

अंग्रेजी वर्णमाला

x?यदि नहीं मिला है, तो प्रत्येक पत्र की पहली घटना के सूचकांक का xउपयोग करें, 0N(एक विशेष "अशक्त" मूल्य) का उपयोग करें

x@xउस के साथ सूचकांक ; 0Nरिटर्न के साथ इंडेक्सिंग " ", इसलिए हमें एक लंबाई -26 स्ट्रिंग मिलती है जिसमें से अक्षर xअपने वर्णमाला के पदों और बाकी सब जगहों पर होते हैं।

— NGN
स्रोत

1

आर , 129 117 बाइट्स

function(s){z={}
y=diff(x<-utf8ToInt(s)-64)
z[diffinv(y+26*(y<0))+x[1]]=LETTERS[x]
z[is.na(z)]=" "
write(z,1,26,,"")}

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

स्पष्टीकरण (अपुष्ट):

function(s){
 z <- c()                  # initialize an empty vector
 x <- utf8ToInt(s)-64      # map to char code, map to range 1:26
 y <- diff(x)              # successive differences of x
 idx <- cumsum(c(          # indices into z: cumulative sum of:
    x[1],                  # first element of x
    ifelse(y<=0,y+26,y)))  # vectorized if: maps non-positive values to themselves + 26, positives to themselves
 z[idx] <- LETTERS[x]      # put letters at indices
 z[is.na(z)] <- " "        # replace NA with space
 write(z,"",26,,"")        # write z as a matrix to STDOUT ("") with 26 columns and empty separator.

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

1

आर , 95 बाइट्स

यदि आप शब्द के काउंटर की स्थिति में पत्र का सामना करते हैं और पत्र को प्रिंट करते हैं, तो एक स्थान अन्यथा ऊपर उठाते हुए बस एक मामले को आगे बढ़ाते हुए ऊपरी मामले की वर्णमाला के माध्यम से बार-बार चलाएं।

function(s)while(F>""){for(l in LETTERS)cat("if"((F=substr(s,T,T))==l,{T=T+1;l}," "));cat("
")}

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

— J.Doe
स्रोत

1

गोल्फस्क्रिप्ट , 37 बाइट्स

64:a;{.a>{}{'
'\64:a;}if.a-(' '*\:a}%

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

मैंने एक अलग नाम के तहत एक गोल्फस्क्रिप्ट किया, लेकिन इसमें गलत आउटपुट था।

— JosiahRyanW
स्रोत

एक वर्णमाला ग्रिड में एक शब्द फिट

चुनौती का वर्णन

उदाहरण

टिप्पणियाँ

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

व्याख्या

जावा 10, 161 159 152 बाइट्स

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

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

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

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

MATL , 24 23 बाइट्स

व्याख्या

जाप , 18 16 बाइट्स

व्याख्या

पायथ, 18 बाइट्स

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

सी (जीसीसी), 91 63 बाइट्स

गणितज्ञ, 101 बाइट्स

गोल्फस्क्रिप्ट, 22 21 बाइट्स

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

05AB1E , 18 बाइट्स

रेटिना , 130 126 बाइट्स

क्यू / केडीबी + , ४ 48 ४५ बाइट्स

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

जेली , २४ 21 बाइट्स

SOGL V0.12 , 22 बाइट्स

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

टेस्ट

हास्केल, 81 74 73 बाइट्स

हास्केल हग अनुकूलन

पायथन 3 , 87 85 बाइट्स

जे , 39 बाइट्स

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

APL (Dyalog Classic) , 20 बाइट्स

के (ngn / k) , २ ९ २ n बाइट्स

आर , 129 117 बाइट्स

आर , 95 बाइट्स

गोल्फस्क्रिप्ट , 37 बाइट्स