कुछ वर्णमाला वर्षा करें

Question

वर्णमाला वर्षा

काम:

मूल आधार इनपुट स्ट्रिंग को प्रिंट करना है और फिर प्रत्येक वर्ण को लंबवत रूप से दोहराना है, इसके आधार पर (केस-असंवेदनशील) वर्णमाला में यह (0-अनुक्रमित) स्थिति है A-Z। Aस्थान पर है 0 इसलिए दोहराया नहीं गया eहै, स्थिति 4 पर है, इसलिए 4 बार दोहराया गया Pहै, स्थिति 15 पर है, इसलिए 15 बार दोहराया गया है, !ऐसा नहीं है, A-Zइसलिए इसे 0 बार दोहराया गया है, आदि।

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

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

इनपुट:

• इनपुट मानक मुद्रण योग्य ASCII वर्ण सेट में होगा, 32 से 126 तक ~।
• इनपुट स्ट्रिंग 1 वर्ण लंबी या लंबी होगी।
• इसमें कोई अग्रणी या अनुगामी व्हाट्सएप नहीं होगा।
• आप एक स्ट्रिंग के रूप में इनपुट ले सकते हैं ( "hello") या पात्रों की सूची ( ["h", "e", "l", "l", "o"])

उदाहरण:

इनपुट का विवरण aaaa:

aaaa

इनपुट का विवरण abcda:

abcda
 bcd
  cd
   d

इनपुट Programming Puzzles & Code Golf!, देता है:

Programming Puzzles & Code Golf!
Progr mming Puzzles   Code Golf
Progr mming Puzzles   Code Golf
Progr mming Puzzles    ode Golf
Progr mming Puzzles    o e Golf
Progr mming Puzzl s    o   Golf
Progr mming Puzzl s    o   Gol
Pro r mmin  Puzzl s    o    ol
Pro r mmin  Puzzl s    o    ol
Pro r mm n  Puzzl s    o    ol
Pro r mm n  Puzzl s    o    ol
Pro r mm n  Puzzl s    o    ol
Pro r mm n  Puzz  s    o    o
Pro r    n  Puzz  s    o    o
Pro r       Puzz  s    o    o
Pr  r       Puzz  s
 r  r        uzz  s
 r  r        uzz  s
             uzz  s
             uzz
             uzz
              zz
              zz
              zz
              zz
              zz

इनपुट ~|[abc<0>cba]|~, देता है:

~|[abc<0>cba]|~
    bc   cb
     c   c

टिप्पणियाँ:

• मानक खामियों लागू होते हैं
• आउटपुट स्ट्रिंग्स की एक सूची हो सकती है, लेकिन:
• विलुप्त हो रहे अनुगामी न्यूलाइन्स की अनुमति नहीं है ( \nअंतिम पंक्ति पर एकल स्वीकार्य है)
• आउटपुट पात्रों की सूचियों की एक सूची हो सकती है, इसलिए जब तक यह दिखता है कि यह पात्रों की बारिश कर रहा है
• कोई अग्रणी न्यूलाइन नहीं
• हमारे नॉर्डिक उपयोगकर्ताओं के लिए जिनके "AZ" वर्णमाला में कुछ अतिरिक्त अक्षर हैं, उनका समर्थन करने के लिए स्वतंत्र महसूस करते हैं, लेकिन यह चुनौती का हिस्सा नहीं है

Comments

क्या एक एकल अग्रणी \n स्वीकार्य है?

— लिन

@ लियोन, कोई अग्रणी न्यूलाइन्स नहीं, पहली पंक्ति इनपुट स्ट्रिंग / चरित्र सूची होनी चाहिए - मैं पोस्ट अपडेट करूंगा!

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

FWIW, मुझे लगता है कि वे बारिश की तुलना में

— आइकल्स की

@cairdcoinheringaahing लगभग उत्सव लगता है

— प्योरफ्रेट

:( जस्ट नॉर्डिक?

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

Answer 1

6502 मशीन कोड (C64), 113 बाइट्स

00 C0 20 FD AE 20 9E AD 85 FB 20 A3 B6 A0 00 84 FC B1 22 99 6F C1 C9 41 90 14 
C9 5B B0 04 E9 40 B0 0E C9 C1 90 08 C9 DB B0 04 E9 C0 B0 02 A9 00 99 6F C0 C5 
FC 30 02 85 FC C8 C4 FB D0 D3 A9 00 99 6F C1 A0 C1 A9 6F 20 1E AB A9 0D 20 D2 
FF A6 FC D0 01 60 C6 FC A0 00 B9 6F C1 F0 E6 BE 6F C0 D0 07 A9 20 99 6F C1 D0 
05 CA 8A 99 6F C0 C8 D0 E7

ऑनलाइन डेमो

उपयोग: sys49152,"[string]" जैसे sys49152,"Programming Puzzles & Code Golf!"।

महत्वपूर्ण: यदि प्रोग्राम डिस्क से लोड किया गया था (जैसे ऑनलाइन डेमो में), तो newपहले एक कमांड जारी करें ! यह आवश्यक है क्योंकि मशीन प्रोग्राम लोड करने पर कुछ C64 बुनियादी बिंदुओं को चकरा देता है।

नोट: C64 निचले अक्षरों के बिना एक मोड में डिफ़ॉल्ट रूप से है - मिश्रित-केस स्ट्रिंग में प्रवेश करने में सक्षम होने के लिए, पहले SHIFT+ दबाकर लोअरकेस मोड में स्विच करें CBM।

---

व्याख्या

यहाँ एक टिप्पणी disassembly सूची है:

         00 C0       .WORD $C000        ; load address
.C:c000  20 FD AE    JSR $AEFD          ; consume comma
.C:c003  20 9E AD    JSR $AD9E          ; evaluate expression
.C:c006  85 FB       STA $FB            ; store string length
.C:c008  20 A3 B6    JSR $B6A3          ; free string
.C:c00b  A0 00       LDY #$00           ; initialize counter
.C:c00d  84 FC       STY $FC            ; and number of "extra" lines
.C:c00f   .copyloop:                    
.C:c00f  B1 22       LDA ($22),Y        ; load next character
.C:c011  99 6F C1    STA .outbuf,Y      ; store to buffer
.C:c014  C9 41       CMP #$41           ; compare with 'a'
.C:c016  90 14       BCC .zerocount     ; smaller -> no repetition
.C:c018  C9 5B       CMP #$5B           ; compare with 'z'
.C:c01a  B0 04       BCS .checkupper    ; larger -> check for uppercase
.C:c01c  E9 40       SBC #$40           ; subtract 'a' ('a' - 1 and carry)
.C:c01e  B0 0E       BCS .cl_storecount ; and jump to store in repeat count
.C:c020   .checkupper:                  
.C:c020  C9 C1       CMP #$C1           ; compare with 'A'
.C:c022  90 08       BCC .zerocount     ; smaller -> no repetition
.C:c024  C9 DB       CMP #$DB           ; compare with 'Z'
.C:c026  B0 04       BCS .zerocount     ; larger -> no repetition
.C:c028  E9 C0       SBC #$C0           ; subtract 'A' ('A' - 1 and carry)
.C:c02a  B0 02       BCS .cl_storecount ; and jump to store in repeat count
.C:c02c   .zerocount:                   
.C:c02c  A9 00       LDA #$00           ; store 0 ...
.C:c02e   .cl_storecount:               
.C:c02e  99 6F C0    STA .repcount,Y    ; ... in repeat count
.C:c031  C5 FC       CMP $FC            ; compare with number of extra lines
.C:c033  30 02       BMI .cl_next       ; smaller -> go on with loop
.C:c035  85 FC       STA $FC            ; repeat count to number of extra lines
.C:c037   .cl_next:                     
.C:c037  C8          INY                ; next
.C:c038  C4 FB       CPY $FB            ; compare with string length
.C:c03a  D0 D3       BNE .copyloop      ; not yet reached? -> repeat
.C:c03c  A9 00       LDA #$00           ; terminate string in buffer
.C:c03e  99 6F C1    STA .outbuf,Y      ; with 0 byte
.C:c041   .outloop:                     
.C:c041  A0 C1       LDY #>.outbuf      ; output ...
.C:c043  A9 6F       LDA #<.outbuf      ; ...
.C:c045  20 1E AB    JSR $AB1E          ; ... string
.C:c048  A9 0D       LDA #$0D           ; and output ...
.C:c04a  20 D2 FF    JSR $FFD2          ; ... newline
.C:c04d  A6 FC       LDX $FC            ; load extra line count
.C:c04f  D0 01       BNE .ol_step       ; not zero -> go on
.C:c051  60          RTS                ; WE ARE DONE HERE ;)
.C:c052   .ol_step:                     
.C:c052  C6 FC       DEC $FC            ; decrease extra line count
.C:c054  A0 00       LDY #$00           ; initialize counter
.C:c056   .eraseloop:                   
.C:c056  B9 6F C1    LDA .outbuf,Y      ; load next character from buffer
.C:c059  F0 E6       BEQ .outloop       ; 0 byte? -> end of string, output
.C:c05b  BE 6F C0    LDX .repcount,Y    ; load repeat count for this characer
.C:c05e  D0 07       BNE .el_step       ; not 0 yet? -> jump to decrement
.C:c060  A9 20       LDA #$20           ; load code for space
.C:c062  99 6F C1    STA .outbuf,Y      ; store in current string position
.C:c065  D0 05       BNE .el_next       ; and jump to next loop iteration
.C:c067   .el_step:                     
.C:c067  CA          DEX                ; decrease repeat count ...
.C:c068  8A          TXA                ; ... and ...
.C:c069  99 6F C0    STA .repcount,Y    ; ... store back
.C:c06c   .el_next:                     
.C:c06c  C8          INY                ; increase counter ...
.C:c06d  D0 E7       BNE .eraseloop     ; and jump back to loop

.C:c06f   .repcount:
.C:c06f              .RES $100          ; 256 bytes for repeat count
.C:c16f   .outbuf:
.C:c16f              .RES $100          ; 256 bytes as buffer for output

Comments

c64 मशीन कोड। मैं प्रसन्न हूँ।

— Dschoni

@ ड्सकोनी धन्यवाद, लेकिन यह अभी भी सरल कोड है (और यह मजेदार है, मेरे लिए!) - आपको वास्तव में प्रभावशाली C64 कार्यों के लिए डेमो दृश्य पर एक नज़र रखना चाहिए;)

— फेलिक्स पालमेन

यदि हम इन्हें प्राप्त करते रहेंगे, तो हम एक जावास्क्रिप्ट C64 एमुलेटर के लिंक स्थापित करना चाह सकते हैं ताकि लोग उन्हें चला सकें।

— त्रिकली

@trlkly मेरे पास इस तरह की एक लिंक है, जो "ऑनलाइन डेमो" पर क्लिक करें;)

— फेलिक्स पालमेन

Answer 2

05AB1E , 13 12 बाइट्स

,εDlAsk×}ζ»,

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

व्याख्या

,             # print input
 ε      }     # apply to each char in input
  D           # duplicate
   l          # convert to lower case
    Ask       # get index of current char in the lower case alphabet
       ×      # repeat the char that many times
         ζ    # transpose with space as filler
          »,  # join on newlines and print

Comments

लोअरकेस वर्णमाला में चार का सूचकांक प्राप्त करने की आवश्यकता है? बस इसके Askलिए

— यूरिल

Answer 3

पायथ, 12 10 9 बाइट्स

.tm+*xGr0

परीक्षण सूट।

स्पष्टीकरण:

.tm+*xGr0dddQ   Expanded program with autofilled input variable
  m      dddQ    For each character d in the input:
       r0d     get its lowercase variant
     xG        and return its 0-based index in the alphabet 
                   (-1 if not found, for special chars)
                (empty string for A/a and special characters)
    *     d    that many of the corresponding character
   +       d   and one more for good measure (because x is 0-indexed)
.t             Transpose it and fill blanks with spaces

12 बाइट्स:

j.t*VmxGr0d

(अनुगामी न्यूलाइन के साथ)

परीक्षण सूट।

स्पष्टीकरण:

j.t*VmxGr0d
QQ              Expanded program with autofilled input variable
Q               print the input verbatim
     m    dQ    For each character d in the input:
        r0      get its lowercase variant
      xG        and return its 0-based index in the alphabet 
                    (-1 if not found, for special chars)
   *V       Q   multiply the corresponding characters in (the second autofilled input)
                 by their alphabet indices we just calculated
                 (empty string for A/a and special characters)
 .t             Transpose it and fill blanks with spaces
j               Join the result on newlines

Comments

आउटपुट पात्रों की सूची की एक सूची हो सकती है, इसलिए जब तक यह दिखता है कि यह पात्रों की बारिश कर रहा है - इसलिए आपको ज़रूरत नहीं हैj

— श्री एक्सकोडर

आह, तुम सही हो! मैं इसे बनाए रख रहा था क्योंकि 12-बाइट संस्करण एक पंक्ति को शब्दशः प्रिंट कर रहा था और मैं उस तरह के स्वरूपों को नहीं मिला सकता था, और मैं भूल गया कि अब मैं इसे हटा सकता हूं कि सब कुछ संक्रमण में है। धन्यवाद!

— स्टीवन एच।

Answer 4

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

f=lambda s,k=65:[*{*s}-{' '}]and[s]+f([[' ',c][91>ord(c.upper())>k]for c in s],k+1)

इसे ऑनलाइन आज़माएं! पात्रों की एक सूची लेता है। पात्रों की सूची की एक सूची देता है।

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

f=lambda s,k=65:s.strip()and s+'\n'+f(''.join([' ',c][91>ord(c.upper())>k]for c in s),k+1)

इसे ऑनलाइन आज़माएं! एक तार लेता है। एक स्ट्रिंग लौटाता है।

Answer 5

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

यह पात्रों कीinput एक सूची के रूप में लेता है [{"a", "b", "c", "d", "a"}]और पात्रों की सूची की एक सूची को आउटपुट करता है

Thread[PadRight[Table[#,Max@Position[Alphabet[]/."a"->#,#|ToLowerCase@#]]&/@#]/. 0->" "]&

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

-26 बाइट्स मीशा लावरोव से

उपयोगकर्ता 202729 से -5 बाइट्स

लेकिन अगर आप आउटपुट को देखना चाहते हैं जैसा कि परीक्षण के मामले में है, तो यह (128 बाइट्स) कोड
आज़माएं!

Comments

भविष्य के पाठकों के लिए: भाग "यह उत्तर केवल गणितज्ञ पर काम करता है ..." थोड़ा भ्रामक है, समस्या यह है कि गणितज्ञ केवल नोटबुक (REPL) मोड में यूनिकोड चरित्र का समर्थन करते हैं। में स्क्रिप्ट मोड इसमें केवल ASCII और विशेष वर्ण जो ASCII करने के लिए बदल दिया गया है (उदाहरण के लिए, समझने ∞-> (3 बाइट्स) \[Infinity](11 बाइट्स))।

— user202729

@ user202729 ठीक है, मैं आपकी टिप्पणी पढ़ने के लिए लोगों को संपादित करूंगा और उन्हें संबोधित

— करूंगा। धन्यवाद

गणित के लिए गोल्फ सुझाव (स्क्रिप्ट मोड): \[Infinity](11 बाइट्स) Infinity(8 बाइट्स) या \:221e(6 बाइट्स) द्वारा प्रतिस्थापित किया जा सकता है । अंतिम नाम के बिना विशेष वर्णों का डिफ़ॉल्ट प्रतिनिधित्व है। (हालाँकि यह मुख्य भाग नहीं है)

— user202729

हम Infinityपूरी तरह से बच सकते हैं । समस्याग्रस्त हिस्सा है If[(d=Min@Position[Alphabet[],If[UpperCaseQ@#,ToLowerCase@#,#]])==∞,1,d]और हम इसे बदल सकते हैं Max@Position[Alphabet[]/."a"->#,#|ToLowerCase@#]। (सूची में खोज करते हुए {#,b,c,d,...,y,z}, हम #कम से कम एक बार खोजने की गारंटी देते हैं ।)

— मिशा लावरोव

@ मिशालारोव बहुत अच्छा। ठीक कर दिया!

— J42161217

Answer 6

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

5 बाइट्स @ Adám की बदौलत बच गए

⍉∘↑⊢⍴¨⍨1⌈27|⎕A⍳819⌶⍨∘1

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

कैसे?

⍴¨⍨ - लंबाई के लिए प्रत्येक चार को आकार दें

    1⌈ - कम से कम एक या

    ⎕A⍳819⌶⍨∘1 - वर्णमाला में बड़े अक्षर का सूचकांक

        27| - मोडुलो २ 27

↑ - एक मैट्रिक्स को समतल करें

⍉ - और संक्रमण

Comments

22 बाइट्स:⍉∘↑⊢⍴¨⍨1⌈27|⎕A⍳819⌶⍨∘1

— एडेम

@ Adám धन्यवाद! अद्यतन

— यूरिल

Answer 7

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

θ↙↓Ｅ⮌θ×ι⌕α↥ι

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

-3 नील को धन्यवाद ।

Answer 8

पायथन, 105 103 बाइट्स

2 बाइट्स @TFeld की बदौलत बच गए

lambda s:'\n'.join(''.join((' '+l)[i<1or 91>ord(l.upper())>i+64]for l in s)for i in range(26)).rstrip()

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

Comments

१०३ बाइट्स

— ४eld पर TFeld

@TFeld अच्छा पकड़, धन्यवाद!

— यूरिल

Answer 9

अजगर 2 , 111 106 99 98 97 87 93 बाइट्स

s=input()
i=65
while s.strip():print s;s=''.join([' ',c][91>ord(c.upper())>i]for c in s);i+=1

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

Comments

whileexecकुछ बाइट्स को बचाने के लिए प्रतिस्थापित किया जा सकता है , i65 के साथ शुरू हो सकता है 87 बाइट्स तक पहुंचने के लिए

— Rod

ओपी का कहना है कि बाहरी अनुगामी न्यूलाइन्स की अनुमति नहीं है , लेकिन आपका कोड उनमें से कई को प्रिंट करता है जब इनपुट शामिल नहीं होता है zया Z।

— लिन

@ लियन फिक्स्ड, मैं execबदलाव को दोबारा जांचना भूल गया ...

— TFeld

Answer 10

सी # (.NET कोर) , 162 बाइट्स

s=>{string A="abcdefghijklmnopqrstuvwxyz",r=s;for(int i=-1;++i<s.Max(A.IndexOf);)r+='\n'+string.Concat(s.Select(c=>A.IndexOf(char.ToLower(c))>i?c:' '));return r;}

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

Comments

PPCG में आपका स्वागत है और पहला उत्तर अच्छा है। आप कुछ ट्रिक्स का उपयोग करके अपने कोड को छोटा कर सकते हैं। यहाँ आपके कोड का अधिक गोल्फ संस्करण है: इसे ऑनलाइन आज़माएं! ।

— इयान एच।

टिप्पणियों के लिए धन्यवाद, मुझे लगता है कि मेरे कोड को खुद ही निष्पादन योग्य होना था, इसलिए मैंने इसे उस धारणा पर बनाया! टिप्पणी और सलाह के लिए धन्यवाद।

— नोजोसन

यदि आप C # में गोल्फ कैसे करें, इसके बारे में कुछ और तरकीबें तलाशना चाहते हैं, तो इस पोस्ट पर नज़र डालें , या मौजूदा C # उत्तरों पर एक नज़र डालें। हैप्पी गोल्फिंग!

— इयान एच।

अच्छा जवाब। चलते रहो :)

— aloisdg का कहना है कि Monica

नमस्ते, PPCG में आपका स्वागत है! महान पहला जवाब, खासकर अब जब कि यह गोल्फ है। मुझ से +1। Btw, यह वर्तमान में 180 बाइट्स है, नहीं 162. आवश्यक आयात using System.Linq;दुर्भाग्य से बाइट गिनती में जोड़ने के लिए अनिवार्य है (या आप बदलना चाहिए Maxकरने के लिए System.Linq.Maxऔर Selectकरने के लिए System.Linq.Max, बस की तुलना में अधिक होगा जो using System.Linq;एक बार।) फिर से स्वागत करते हैं, और अपने रहने का आनंद लें। ओह, और मुझे @IHH दिखाई देता है। पहले से ही C # में गोल्फिंग के लिए दिए गए टिप्स। <सभी भाषाओं में गोल्फिंग के लिए टिप्स> के माध्यम से पढ़ने के लिए भी दिलचस्प हो सकता है।

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

Answer 11

बैश, 78 , 76 71 बाइट्स

for c in {B..a};{ [[ -n ${1// } ]]&&echo "$1";set "${1//[!$c-Z${c,}-z]/ }";}

टकराव के आधार पर (डिफ़ॉल्ट LC_ALL) कुछ और बाइट्स बचा सकता है

for c in {b..z} _;{ [[ -n ${1// } ]]&&echo "$1";set "${1//[!$c-Z]/ }";}

यह ऑनलाइन की कोशिश करो

Answer 12

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

के लिए 41 बाइट्स कोड + 2 -nl।

$c=A;print,s/$c|[^a-z]/ /gi,$c++while/\S/

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

Comments

[_0-9] वर्णों के लिए लूप, हो सकता है s/["-$c]/ /giऔर -lज़रूरत न हो

— नाहुएल फ़ौइलुल

@ नाहुएलफौइलुल आह, हां, मैं परीक्षण के मामलों में बहुत जल्दी था। उन्हें ओपी में जोड़ा जाना चाहिए! :) धन्यवाद! +4 :(

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

मेरा सुझाव 32 और 126 के बीच किसी भी वर्ण के लिए काम नहीं करता है (Z से अधिक गैर अल्फा)

— नहुएल फौलीउल

@NahuelFouilleul एक छोटा रास्ता नहीं खोज सकता जो सभी आवश्यकताओं को पूरा करता है ... मैं खेलता रहूंगा ...

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

Answer 13

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

-9 बाइट्स @RickHitchcock की बदौलत ।
-2 बाइट्स @Neil की बदौलत ।

f=(s,i=10)=>s.trim()&&s+`
`+f(s.replace(/./g,c=>parseInt(c,36)>i?c:" "),i+1)

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

परीक्षण के मामलों

f=(s,i=10)=>s.trim()&&s+`
`+f(s.replace(/./g,c=>parseInt(c,36)>i?c:" "),i+1)

;["hello", "Programming Puzzles & Code Golf!", "~|[abc<0>cba]|~", "abcdefg0123456789"]
.forEach(s=>console.log(f(s)));

.as-console-wrapper{max-height:100%!important}

Comments

76 बाइट्स (एक नई लाइन के पीछे): f=(s,i=10)=>s.trim()&&s+'newline'+f(s.replace(/./g,c=>parseInt(c,36)-i?c:" "),i+1)

— रिक

@RickHitchcock एक इनपुट स्ट्रिंग वाले नंबर के लिए अनंत लूप लगता है: इसे ऑनलाइन आज़माएं! । चरण-दर-चरण परिवर्तनों का विचार sवास्तव में अच्छा है, हालांकि।

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

आह, अच्छी बात है। यह 2 बाइट्स की लागत पर तय किया जा सकता है:parseInt(c,36)-i>0

— रिक हिचकॉक

@RickHitchcock क्या आप parseInt(c,36)>i2 बाइट बचाने के लिए उपयोग नहीं कर सकते ?

— नील

@ नील, दुह। जस्टिन: नील ने क्या कहा। :)

— रिक हिचकॉक

Answer 14

आर, 118 114 बाइट्स

function(a)while(grepl("[^ ]",a)){F=F+1;cat(a,"\n");for(j in c("[^a-zA-Z]",letters[F],LETTERS[F]))a=gsub(j," ",a)}

उन 4 बाइट्स के लिए @Giuseppe को धन्यवाद

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

संक्षिप्त विवरण:

function(a)
    while(grepl("[^ ]",a)){ #As long as the string is not just spaces.
        F=F+1 #Increment letter counter (F is FALSE, hence 0 by default)
        cat(a,"\n") #Print string
        for(j in c("[^a-zA-Z]",letters[F],LETTERS[F])) #Get rid of non-letters, and the current letter in lower and upper case
             a=gsub(j," ",a)
    }

Comments

ओह, रुको, संभावित मुद्दा: यदि aसभी रिक्त स्थान हैं, तो यह कुछ भी प्रिंट नहीं करेगा ... लेकिन आप उस whileस्थिति को बदल सकते हैं grepl()|!Fजो अभी भी आपके मूल उत्तर से कम बाइट है।

— Giuseppe

Answer 15

आर , 125 123 बाइट्स

प्लैनपस द्वारा बहिष्कृत

for(i in 1:max(p<-pmax(1,match(tolower(S<-el(strsplit(scan(,""),''))),letters),na.rm=T)))cat(ifelse(p<i," ",S),'\n',sep='')

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

एक एकल अनुगामी न्यूलाइन के साथ प्रिंट करने के लिए प्रिंट और से पढ़ता है stdin()।

चलो इसे तोड़ दो:

S <- el(strsplit(scan,""))            # split the string to characters

m <- match(tolower(S),letters)        # 1-based index in letters (lowercase a-z)
p <- pmax(1,m,na.rm=T)                # parallel max, replaces NA (non-alphabet) or 0 with 1
for(i in 1:max(p)){                   # iterate
 cat(                                 # print
  ifelse(p<1,' ',S),                  # the corresponding letter in S if p>=1, space otherwise
  '\n',sep='')                        # newline, and no spaces between chars
}

वैकल्पिक उत्तर, 106 बाइट्स

function(S)for(i in 1:max(p<-pmax(1,match(tolower(S),letters),na.rm=T)))cat(ifelse(p<i,' ',S),'\n',sep='')

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

समारोह; प्रिंट करने के लिए प्रिंट करता है, लेकिन यह मूल रूप से मेरी प्रतिक्रिया है जो स्ट्रिंग को विभाजित करने के बजाय वर्णों की एक सूची को स्वीकार करने के लिए चित्रित किया गया है, इसलिए मुझे ऐसा लगता है कि यह "धोखा" है। साथ ही, रेनेक्स के साथ प्लेनैपस का दृष्टिकोण काफी साफ-सुथरा है!

Answer 16

ऑक्टेव / MATLAB, 74 66 बाइट्स

@(s)char(arrayfun(@(c){repmat(c,1,prod(find(upper(c)==65:90)))},s))'

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

Answer 17

जाप , 15 14 11 10 बाइट्स

पहला मौका जाप की नई स्ट्रिंग पैडिंग विधियों के साथ खेलने का है ताकि सुधार के लिए अभी भी जगह मिल सके।

y_ùZInZu c

कोशिश करो

---

व्याख्या

स्ट्रिंग का निहित इनपुट U।

y_

Uफ़ंक्शन के माध्यम से प्रत्येक कॉलम को पास करें , जहां Zवर्तमान तत्व (या पत्र, इस मामले में) है।

InZu c

Zअपरकेस ( u) में कनवर्ट करें , उसका चारकोड प्राप्त करें ( c) और घटाएं ( u) 64 ( I)।

ùZ

Zजब तक यह उस लंबाई तक नहीं पहुंच जाता, तब तक अपने आप से शुरुआत करें ।

---

विकल्प

y_ùZ9aZn36

कोशिश करो

Comments

लेकिन क्या आप एक बी को बचाने के ùZलिए नहीं बदल सकते हैं p... कोई बात नहीं, यह वास्तव में चालाक है ...

— ETHproductions

@ETHproductions: मैंने कुछ प्रयास किए p( संपादन इतिहास में 1 हो सकता है) लेकिन ùअंत में जीत हासिल की।

— झबरा

Answer 18

हास्केल , 137 136 127 119 बाइट्स

import Data.Char
p c=last$0:[k|k<-[0..25],k+65==ord(toUpper c)]
f s=[[last$c:[' '|i>p c]|c<-s]|i<-[0..maximum$map p s]]

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

बहुत लंबा है, लेकिन मैं इसे छोटा करने के लिए किसी भी तरह के बारे में नहीं सोच सकता। मुझे लगता है कि अगर-तब सिंटैक्स की तुलना में कोई रास्ता छोटा होना चाहिए, लेकिन मैं इसे नहीं देखता।

संपादित करें: मुझे एक बाइट से दाढ़ी बनाने में मदद करने के लिए @streetster धन्यवाद! मैं toUpperपहली बार आयात करने की लागत के कारण उपयोग नहीं किया था , Data.Charलेकिन मैं भूल गया कि यह भी प्रदान करता है ordजो की तुलना में बहुत कम हैfromEnum

संपादित 2: एक और 6 बाइट्स को शेव करने और एक बग की पहचान करने के लिए @ लिकोनी का धन्यवाद जो मैंने अब तय किया है। मैंने 25 के बजाय 26 का उपयोग किया क्योंकि मैं भूल गया कि हास्केल सरणियाँ समावेशी हैं। फिर मैंने देखा कि मैं lastइसके बजाय उपयोग कर सकता हूं headजिससे मैं इसके बजाय उपयोग करने की अनुमति 0:दूंगा ++[0]।

EDIT 3: उन 8 बाइट्स के लिए फिर से लकोनी का धन्यवाद। मैं वास्तव में उस जगह के बारे में भूल गया था। किसी कारण के बिना Sublime Text इससे बाहर निकल जाता है और मैं इसे निकालना भूल गया। मुझे पता नहीं था कि लाइनों की सूची की अनुमति थी, मुझे नियमों को अधिक ध्यान से पढ़ना चाहिए।

Comments

क्या आप AZ के साथ-साथ az और फिर mod'ing की जाँच करने से बचने के लिए इनपुट को कम कर सकते हैं?

— 16

@streetster tokower toLower and topper फ़ंक्शन में Data.Char को आयात करने की आवश्यकता होती है, जिसकी लागत से अधिक चार्ज़ बचते हैं। TIO

— user1472751

आप हास्केल में गोल्फ के लिए युक्तियों पर एक नज़र रखना चाह सकते हैं । जैसे if i>p c then ' ' else cछोटा किया जा सकता है last$c:[' '|i>p c]।

— लकोनी

दो और बातें: एक अनावश्यक जगह है [k | और लाइनों की एक सूची को वापस करने की अनुमति है, इसलिए आपको इसकी आवश्यकता नहीं है unlines। अंत में, आप हमारे हास्केल चैट रूम में दिलचस्पी ले सकते हैं ।

— लकोनी

Answer 19

एक्सेल VBA, 110 बाइट्स

बेनामी VBE तत्काल विंडो फ़ंक्शन जो कि Variant\Stringरेंज से अपेक्षित प्रकार के रूप में इनपुट लेता है [A1]और इसका उपयोग VV तत्काल विंडो में वर्णमाला की बारिश करने के लिए करता है।

?[A1]:For i=1To 26:For j=1To[Len(A1)]:c=Mid([A1],j,1):d=Asc(UCase(c)):?IIf((d>64+i)*(d<91),c," ");:Next:?:Next

नमूना I / O

[A1]="qwertyuiop[]ASDFGHJKL:'zxcvbnm,./"
?[A1]:For i=1To 26:For j=1To[Len(A1)]:c=Mid([A1],j,1):d=Asc(UCase(c)):?IIf((d>64+i)*(d<91),c," ");:Next:?:Next
qwertyuiop[]ASDFGHJKL:'zxcvbnm,./
qwertyuiop   SDFGHJKL  zxcvbnm   
qwertyuiop   SDFGHJKL  zxcv nm   
qwertyuiop   SDFGHJKL  zx v nm   
qwertyuiop   S FGHJKL  zx v nm   
qw rtyuiop   S FGHJKL  zx v nm   
qw rtyuiop   S  GHJKL  zx v nm   
qw rtyuiop   S   HJKL  zx v nm   
qw rtyuiop   S    JKL  zx v nm   
qw rtyu op   S    JKL  zx v nm   
qw rtyu op   S     KL  zx v nm   
qw rtyu op   S      L  zx v nm   
qw rtyu op   S         zx v nm   
qw rtyu op   S         zx v n    
qw rtyu op   S         zx v      
qw rtyu  p   S         zx v      
qw rtyu      S         zx v      
 w rtyu      S         zx v      
 w  tyu      S         zx v      
 w  tyu                zx v      
 w   yu                zx v      
 w   y                 zx v      
 w   y                 zx        
     y                 zx        
     y                 z         
                       z 

Comments

क्रूर!!! यह आप भी बना सकते हैं?A1:...

— LS_ᴅᴇᴠ

@ LS_ the, दुर्भाग्य से, जैसा कि []इंगित करता है कि निहित स्ट्रिंग का मूल्यांकन किसी ऑब्जेक्ट में / पर / कार्यपुस्तिका के रूप में किया जाना चाहिए, [A1]कॉल कम नहीं हो सकती है A1- क्योंकि यह रेंज से प्रारंभिक इनपुट को नहीं लेगा और प्रिंट नहीं करेगा [A1]; बल्कि यह सिर्फ एक खाली लाइन छोड़ देगा और बाद की सभी लाइनें मुद्रित होंगी

— टेलर स्कॉट

अप्स, आप सही हैं ... इस पर ध्यान नहीं दिया!

— LS_ᴅᴇᴠ 12

Answer 20

PHP, 69 78 77 85 + 1 बाइट्स

for($c=A;!$c[1]&&~trim($s=&$argn);$s=eregi_replace("[^".++$c."-Z]"," ",$s))echo"$s
";

PHP <7 की आवश्यकता है। ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

Comments

@ शगुन ने इशारा किया। यह अब पूरा हो गया है।

— टाइटस

के लिए +1 $c=A;!$c[1];$c++। अच्छा है! दुख की बात है extraneous trailing newlines are not allowed (single \n on final line is acceptable)। तो यह सभी तार युक्त नहीं होने के लिए विफल रहता है z।

— क्रिस्टोफ

@ क्रिसटोफ़ तय

— टाइटस

Answer 21

बैश + सेड, ३ 37

sed -rne"/^ *$/q;p;s/\W|"{a..z}/\ /gi

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

Comments

ऐसा लगता है कि यह वर्णमाला में वर्णों को दोहरा रहा है-बहुत बार

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

@streetster मुझे लगता है कि अब यह तय हो गया है।

— डिजिटल ट्रॉमा

Answer 22

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

#define F for(q=c,p=s;*p;++p,++q)
char*p,*q,s[99],c[99];main(h){gets(s);F{*q=*p>64&&*p<91?*p-65:*p>96&&*p<123?*p-97:0;h=h>*q?h:*q;}for(puts(s);h--;){F{putchar(*q?--*q,*p:32);}putchar(10);}}

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

Comments

puts("");इसके बजाय की कोशिश करेंputchar(10)

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

178 बाइट्स

— सीलिंगकैट

Answer 23

रूबी, 70 67 74 बाइट्स

f=->s{puts s;(?b..?z).each{|c|s.gsub! /[^#{c}-z]/i,' ';puts s if s=~/\S/}}

@TuukkaX को इंगित करने के लिए कुछ पार्न्स को गिराया जा सकता है (-3 बाइट्स)

दुर्भाग्य से मुझे तब 7 बाइट्स जोड़ना पड़ा क्योंकि मूल संस्करण "z" को संभालने में विफल रहा।

इसे कॉल करना:

f.call('The quick brown fox jumps over the lazy dog!')
The quick brown fox jumps over the lazy dog!
The quick brown fox jumps over the l zy dog
The quick  rown fox jumps over the l zy dog
The qui k  rown fox jumps over the l zy dog
The qui k  rown fox jumps over the l zy  og
Th  qui k  rown fox jumps ov r th  l zy  og
Th  qui k  rown  ox jumps ov r th  l zy  og
Th  qui k  rown  ox jumps ov r th  l zy  o
T   qui k  rown  ox jumps ov r t   l zy  o
T   qu  k  rown  ox jumps ov r t   l zy  o
T   qu  k  rown  ox  umps ov r t   l zy  o
T   qu     rown  ox  umps ov r t   l zy  o
T   qu     rown  ox  umps ov r t     zy  o
T   qu     rown  ox  u ps ov r t     zy  o
T   qu     row   ox  u ps ov r t     zy  o
T   qu     r w    x  u ps  v r t     zy
T   qu     r w    x  u  s  v r t     zy
T    u     r w    x  u  s  v r t     zy
T    u       w    x  u  s  v   t     zy
T    u       w    x  u     v   t     zy
     u       w    x  u     v         zy
             w    x        v         zy
             w    x                  zy
                  x                  zy
                                     zy
                                     z

Comments

लंबोदर परिभाषा में कोष्ठक को हटाया जा सकता है। +1।

— यति

Answer 24

Oracle SQL, 186 बाइट्स

मान लें कि स्ट्रिंग tस्तंभ में एक तालिका में होगी v:

WITH a(s,l)AS(SELECT v,64 FROM t UNION ALL SELECT REGEXP_REPLACE(s,'[^'||CHR(l+1)||'-Z]',' ',1,0,'i'),l+1 FROM a WHERE l<90)SELECT LISTAGG(RTRIM(s),CHR(10))WITHIN GROUP(ORDER BY l)FROM a

एसक्यूएल फिडल

Oracle 11g R2 स्कीमा सेटअप :

CREATE TABLE t ( v ) AS
SELECT '~|[abc<0>cba]|~' FROM DUAL
/

क्वेरी 1 :

WITH a(s,l)AS(
  SELECT v,64 FROM t
UNION ALL
  SELECT REGEXP_REPLACE(s,'[^'||CHR(l+1)||'-Z]',' ',1,0,'i'),l+1
  FROM a
  WHERE l<90
)
SELECT LISTAGG(RTRIM(s),CHR(10))WITHIN GROUP(ORDER BY l)
FROM a

परिणाम :

|      LISTAGG(RTRIM(S),CHR(10))WITHINGROUP(ORDERBYL) |
|-----------------------------------------------------|
| ~|[abc<0>cba]|~                                     |
|    abc   cba                                        |
|     bc   cb                                         |
|      c   c                                          |

Answer 25

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

ØaḊiЀŒl‘⁸ẋ"z⁶Y

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

Answer 26

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

p c=sum[length[a..c]|a:e<-["B[","b{"],[c]<e]
f s=[[last$c:[' '|i>p c]|c<-s]|i<-[0..maximum$p<$>s]]

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

उदाहरण का उपयोग: f "[Abc]"लाइनों की एक सूची देता है ["[Abc]"," bc "," c "]:। putStr.unlines.f $ "[Abc]"सुंदर-मुद्रित आउटपुट के लिए उपयोग करें :

[एबीसी]
  बीसी
   सी

आंशिक रूप से अब उपयोगकर्ता सीधे 141475751 के हास्केल उत्तर पर आधारित है ।

---

पिछला दृष्टिकोण ( 100 99 बाइट्स)

f s=[h|i<-[0..26],h<-[[(c:concat[c<$[a..c]|[a,e]<-["B[","b{"],c<e]++cycle" ")!!i|c<-s]],any(>' ')h]

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

Answer 27

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

param($a)$a;(1..25|%{$i=$_;(-join([char[]]$a|%{(' ',$_)[$_-match'[a-z]'-and[math]::Max(0,($_-bor32)-96-$i)]})).TrimEnd()})-ne''

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

PowerShell गतिशील रूप से कैसे [char]और के बीच कैसे डाली जा सकती है, इसके लिए लघु धन्यवाद [int], लेकिन लंबे समय तक बाहर के व्हाट्सएप को हटाने और अंतरिक्ष या चरित्र को आउटपुट करने की गणना के कारण।

बुक्सफिक्स बीटक्रैकर के लिए धन्यवाद।

Comments

दुर्भाग्य से, यह ~|[abc<0>cba]|~परीक्षण के मामले में विफल रहता है । इसे आज़माएं:param($a)$a;(1..25|%{$i=$_;(-join([char[]]$a|%{(' ',$_)[$_-match'[a-z]'-and[math]::Max(0,($_-bor32)-96-$i)]})).TrimEnd()})-ne''

— बीटक्रैकर

@beatcracker अच्छा कैच। यह तुलना से निपटने का एक चतुर तरीका है। धन्यवाद!

— AdmBorkBork

Answer 28

जावा 8, 151 147 144 143 139 बाइट्स

s->{String x="\n"+s;for(int i=64,t;++i<91;)for(char c:x.toCharArray())s+=(t=c&~32)>64&t<91&t>i|c<11?c:" ";return s.replaceAll("\\s+$","");}

स्पष्टीकरण:

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

s->{                   // Method with String as both parameter and return-type
  String x="\n"+s;     //  Temp-String (equal to leading new-line + input)
  for(int i=64,        //  Index-integer `i` (starting at 64)
          t;           //  Temp-integer
      ++i<91;)         //  Loop (1) from 'A' (65) to 'Z' (90) (inclusive)
    for(char c:x.toCharArray())
                       //   Inner loop (2) over the character of the array
      s+=(t=c&~32)>64  //    If the current character as uppercase is larger than 'A'
         &t<91         //    and smaller or equal to 'Z'
         &t>i          //    and larger than the current index
         |c<11?        //    or the current character is a new-line
          c            //     Append the current character to `s`
         :             //    Else:
          " ";         //     Append a space to `s` instead
                       //   End of inner loop (2) (implicit / single-line body)
                       //  End of loop (1) (implicit / single-line body)
  return s             //  Return the result,
    .replaceAll("\\s+$",""); 
                       //   after we've removed all trailing spaces and new-lines
}                      // End of method

Answer 29

क्यू , 42 37 बाइट्स

{(+)max[m]$(m:1+mod[.Q.a?(_)x]26)#'x}

-5 स्ट्रीटस्टर को धन्यवाद!

---

पुराना समाधान + स्पष्टीकरण:

{(+)max[m]$'(m:1+mod[.Q.a?lower x;26])#'x}


{                                        }  / lambda func
                     .Q.a?lower x           / get lowercase of input (ignores non-alpha values) and find (?) their index in "a...z" (.Q.a). non-alpha values return `26`
                 mod[.Q.a?lower x;26]       / get mod 26 of each index, this returns 0 where index is 26
            (m:1+mod[.Q.a?lower x;26])      / add 1 and assign to m
            (m:1+mod[.Q.a?lower x;26])#'x   / m and x conform, so we can take (#) m copies of each (') x at corresponding indices
    max[m]$'(m:1+mod[.Q.a?lower x;26])#'x   / get max of m, and pad each ($') of right-side list to that length
 (+)                                        / transpose the char matrix

Comments

{(+)max[m]$(m:1+mod[.Q.a?(_)x]26)#'x}37 के लिए, खिचड़ी भाषा याद है कि मैंने प्रश्न बनाते समय इसे कैसे हल किया, शायद बहुत समान था!

— सड़क चौकी

@streetster, धन्यवाद! अपडेट किया गया। k's के बारे में नहीं पता था _, मैंने lowerq दुभाषिया में टाइप किया और मिला k){$[~t&77h>t:abs@@x;.z.s'x;19<t;.z.s@. x;~t in 10 11h;'`type;_x]}। इसलिए क्ष haha में मेरा जवाब देने

— घसीट

Answer 30

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

ā,{Z⁴UW1Χ∙┼

यह कोशिश करो!

स्पष्टीकरण:

ā            push an empty array
 ,{          for each character in the input, pushing it
   Z           push the uppercase alphabet
    ⁴          push a duplicate of the character
     U         uppercase it
      W        find its index in that alphabet
       1Χ      get the maximum of that and 1
         ∙     repeat the character that many times
          ┼    append horizontally to that array