मुझे कुछ स्ट्रिंग सीढ़ियों का निर्माण

Question

स्ट्रिंग सीढ़ियाँ

अस्वीकरण: यह पहली चुनौती है जिसका मैंने प्रस्ताव किया है। किसी भी और सभी प्रतिक्रिया का स्वागत है। यदि यह एक डुप्लिकेट है, तो कृपया इसे इंगित करें।

यहां सैंडबॉक्स पोस्ट का लिंक दिया गया है।

लक्ष्य

इस चुनौती का लक्ष्य है, एक स्ट्रिंग और पूर्णांक दिया जाना, स्ट्रिंग को उस पूर्णांक के आकार के ब्लॉक में प्रिंट करना। यदि किसी शब्द में ब्लॉक के आकार से अधिक वर्ण हैं, तो उसे एक अवरोही "सीढ़ी" पैटर्न में प्रिंट करें।

नियम

• ऊपर वर्णित "सीढ़ी पैटर्न" का अर्थ है कि, एक ही शब्द के प्रत्येक ब्लॉक के लिए, उस ब्लॉक को ठीक उसी स्थान से शुरू करना चाहिए जहां इसके ऊपर का ब्लॉक समाप्त होता है। यदि आपके कोई प्रश्न हैं, तो परीक्षण मामलों की जाँच करें (या पूछें)।
• यदि एक शब्द कई ब्लॉकों में टूट गया है, तो निम्नलिखित शब्द को पर्याप्त संख्या में रिक्त स्थान के साथ मुद्रित किया जाना चाहिए, अर्थात, इसे पूर्ववर्ती शब्द के सबसे निचले ब्लॉक से बिल्कुल एक व्हाट्सएप द्वारा अलग किया जाना चाहिए। स्पष्टीकरण के लिए परीक्षण मामलों (या पूछें) की जाँच करें।
• आप मान सकते हैं कि इनपुट स्ट्रिंग में केवल मुद्रण योग्य ASCII वर्ण शामिल होंगे। इसके अलावा, इसमें एक पंक्ति में कई व्हाट्सएप नहीं होंगे।
• आप यह भी मान सकते हैं कि पूर्णांक हमेशा [1, +।) श्रेणी में होगा।
• अनुगामी व्हाट्सएप या न्यूलाइन की अनुमति है।
• आप I / O के लिए किसी भी उचित विधि का उपयोग कर सकते हैं ।
• स्टैंडर्ड लोफॉल्स लागू होते हैं।
• यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड (बाइट्स में, प्रति भाषा) जीतता है। एक सप्ताह (या तो) के बाद, मैं समग्र उत्तर को स्वीकार करूंगा।

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

(String, Integer) => (Output)

"This is a large string", 3 => Thi is a lar  str
                                 s        ge   ing

"This is an even larger string!", 2 => Th  is an ev  la   st
                                        is        en  rg   ri
                                                       er   ng
                                                             !
"Ooooh dear, what a big string you have!", 3 
=> Ooo  dea  wha a big str   you hav
     oh   r,   t         ing       e!

"Staphylococcus saprophyticus", 4 => Stap        sapr
                                        hylo        ophy
                                           cocc        ticu
                                              us          s

"I hope you find this challenge interesting", 2
=> I ho  yo fi  th  ch    in
      pe  u  nd  is  al    te
                      le    re
                       ng    st
                        e     in
                               g

"Well, this test case looks kinda pointless now doesn't it?", 15
=> Well, this test case looks kinda pointless now doesn't it?

"This one looks a lot more interesting!", 1 => T o l a l m i
                                               h n o   o o n
                                               i e o   t r t
                                               s   k     e e
                                                   s       r
                                                           e
                                                           s
                                                           t
                                                           i
                                                           n
                                                           g
                                                           !
"Keep in mind, people: 'Punctuation! Does! Matter!'", 2
=> Ke  in mi  pe   'P      Do  Ma
    ep     nd  op   un      es  tt
            ,   le   ct      !   er
                 :    ua          !'
                       ti
                        on
                         !

Comments

क्या प्रत्येक पंक्ति पर प्रमुख स्थानों की बराबर मात्रा हो सकती है?

— दिजिमा

बोनस: ब्लॉक आकार -1 t̳͖̬̥̱͓̭̙̤͇̘̲ț͎̣̫̪̩̟̯͈͙͈̗̳͕̹̙̣ͅx

— Luis के

@dzaima मुझे यकीन नहीं है कि आपका क्या मतलब है, लेकिन मैं नहीं देखता कि क्यों। एक उदाहरण देने के लिए देखभाल?

— जे। सेले

@ J.Salle इस

— dzaima

@dzaima हाँ यकीन है, कोई बात नहीं।

— जे। सेले

Answer 1

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

Ｆ⪪θ «↑⸿⸿ＦＬι«Ｍ¬﹪κＩη↙§ικ

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

  θ                      First input
 ⪪                      Split on spaces
Ｆ   «                   Loop over each word
     ↑⸿⸿                Move the cursor to the top row and two columns right*
          ι             Current word
         Ｌ              Length
        Ｆ  «            Loop over implicit range
               κ        Current index
                 η      Second input
                Ｉ       Cast to integer
              ﹪         Modulo
             ¬          Logical not
            Ｍ     ↙     Move that many characters down and left
                    ι   Current word
                     κ  Current index
                   §    Index into word and implicitly print

* अधिक सटीक रूप से, "अगली पंक्ति की शुरुआत में दो बार जाएं, लेकिन जैसे कि कैनवास घुमाया गया था।" संपादित करें: इस चुनौती के सेट होने और इस उत्तर को स्वीकार किए जाने के बीच, चारकोल ने वास्तव में पात्रों के जोड़े में एक स्ट्रिंग को विभाजित करने का एक साधन प्राप्त किया, जिससे कोड 16 बाइट्स कम हो गए:
Ｆ⪪θ «↑⸿⸿Ｆ⪪ιＩη«κ↙ इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

  θ                 First input
 ⪪                  Split on spaces
Ｆ   «               Loop over each word
     ↑⸿⸿            Move the cursor to the top row and two columns right
          ι         Current wordＩη
            η       Second input
           Ｉ        Cast to integer
         ⪪          Split into substrings of that length
        Ｆ    «      Loop over each substring
              κ     Print the substring
               ↙    Move the cursor down and left

Comments

चुनौती के नियमों का पालन करते हुए, मैंने इसे सबसे छोटा उत्तर (अक्टूबर 6, 2017 के अनुसार) स्वीकार किया है।

— जे। सल्ल।

Answer 2

SOGL V0.12 , 28 27 26 बाइट्स

ā,θ{0Eā;{ēb÷eb‰⁴bH*+I;Iž}┼

यह कोशिश करो!

मैंने इसे ‰बनाते समय लागू किया था , लेकिन इसके लिए प्रलेखन पहले मौजूद था।

स्पष्टीकरण:

ā                            push an empty array - the main canvas
 ,                           push the first input
  θ{                         for each word (pushing the word each time)
    0E                         set the variable E to 0
      ā;                       below the current word place an empty array - current word canvas
        {               }      for each character of the word
         ēb÷                     push (E++ // B) - note that E is incremented after being used
            eb‰                  push E positive modulo B - like regular modulo but in the 0 output case it gives B
               ⁴                 duplicate the item below ToS
                bH               push B-1
                  *              multiply [(E++ // B) and B-1]
                   +             add [that multiplication to E‰B] - current letters X position
                    I            increase the X position to have one leading space row
                     ;           swap top 2 items - current X position and (E++ // B)
                      I          increase to create current letters Y position
                       ž         in those positions insert the current letter in the current words canvas
                         ┼     append to main canvas current word canvas horizontally

Answer 3

जावास्क्रिप्ट ES6, 187 183 174 166 163 148 145 143 141 140 138 बाइट्स

• पठनीयता के लिए कोड में कुछ बाइट्स जोड़े गए और बाइट्स की गिनती में उन्हें हटा दिया
• के बजाय s = "", j = 0 मैंने किया j = s = ""
• के बजाय (मैं के लिए) - लूप के लिए नियमित - 1 बाइट हटा दिया गया
• सरणियों के सूचकांक में पहले से ही उत्पन्न मूल्यों का उपयोग करना - 8 बाइट्स हटा दिया गया
• पहले से ही मूल्य के साथ उपयोग करना i = s.length (पहले लूप से) eval में - वास्तविक सरणी लंबाई के बजाय - अनुगामी स्थान का कारण बनता है जिसकी अनुमति है
• eval के बजाय S के मानचित्र का उपयोग करना - 3 बाइट्स को कम करता है
• खाली सरणी को शुरू करने के बजाय भरण का उपयोग करें- इसलिए मानचित्र परिणाम में लूप की आवश्यकता नहीं है
• बदल सकता है || के साथ | - 2 बाइट्स से कम
• @Justin मेरिनर के लिए धन्यवाद - घटनाओं को प्रतिस्थापित करें == "" <के साथ! "" 2 बाइट्स कम करता है
• एक "यू <" को कम करने के लिए एक [I] से दूसरे बयान में शर्तों को ले जाया गया - 2 बाइट्स को कम करता है
• के बजाय (I + = 2, j = 0) - j =! (I + = 2) - 1 बाइट घटा दी
• के बजाय "के लिए"

  F=(s,n)=>{R=[I=j=i=0]
  for(u of s)
  a=R[z=u<"!"?j=!(I+=2):(j%n&&I++,j++/n|0)]=R[z]||[...s].fill` `,a[I]=u
  return R.map(x=>x.join``).join`
  `}
  console.log(F("This is a large string", 3));
  console.log(F("This is an even larger string!", 2));
  console.log(F("Ooooh dear, what a big string you have!", 3));
  console.log(F("Staphylococcus saprophyticus", 4));
  console.log(F("I hope you find this challenge interesting", 2));
  console.log(F("Well, this test case looks kinda pointless now doesn't it?", 15));
  console.log(F("This one looks a lot more interesting!", 1))
  console.log(F("Keep in mind, people: 'Punctuation! Does! Matter!'", 2));

Comments

आपको <"!"इसके बजाय का उपयोग करके एक जोड़े बाइट्स को बचाने में सक्षम होना चाहिए ==" "।

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

Answer 4

सी #, 200 बाइट्स

int x=-2,y=0;Regex.Split(i,@"\s+").ToList().ForEach(w =>{y=0;Regex.Matches(w,".{0,"+s+"}").Cast<Match>().ToList().ForEach(c=>{x+=(y==0?2:s-1);Console.SetCursorPosition(x,y);Console.Write(c);y++;});});

जहां स्ट्रिंग i द्वारा निर्दिष्ट की जाती है और आकार s द्वारा निर्दिष्ट किया जाता है ।

उदाहरण के लिए

string i = "Staphylococcus saprophyticus";
int s = 2;    
int x=-2,y=0;Regex.Split(i,@"\s+").ToList().ForEach(w =>{y=0;Regex.Matches(w,".{0,"+s+"}").Cast<Match>().ToList().ForEach(c=>{x+=(y==0?2:s-1);Console.SetCursorPosition(x,y);Console.Write(c);y++;});});

मूल रूप से, पहले भाग Regex.Split शब्दों में सजा विभाजित करने के लिए सफेद रिक्त स्थान का उपयोग करता है, और Regex.Matches द्वारा निर्दिष्ट टुकड़ों में प्रत्येक शब्द विभाजन रों । चंक को Cursor स्थिति (x, y) के लिए लिखा जाता है, जहाँ Y हर नए शब्द के लिए 0 पर सेट होता है, और x को एक शब्द के पहले भाग के लिए 2 और बाद में प्रत्येक चंक के लिए (s-1) बढ़ा दिया जाता है।

x शुरू होता है -2 पर यह जीवन है यह सुनिश्चित करने के लिए कि यह पहला उपयोग 0 पर सेट है।

मैं सी # ट्रिविया में पर्याप्त रूप से परिचित नहीं हूं, जो इसे छोटा बनाने में सक्षम है, लेकिन संदेह है कि यह संभवतः हो सकता है।

Comments

किसी भी विशेष कारण से आप एक इंट के लिए एस का उपयोग करते हैं, और मैं एक स्ट्रिंग के लिए, इसके बजाय अन्य तरीके से?

— ताहग

हा हा! कोई विचार नहीं है - मेरे दोपहर के भोजन के ब्रेक पर सिर्फ एक त्वरित समय का प्लास्टर। मैं आकार के लिए इनपुट और एस के लिए, शायद?

— सुपरमेकरैट

Answer 5

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

s,l=input()
S=s.split()
x=[]
for w in S:L=len(w);W=[i/l*~-l*' '+w[i:i+l]for i in range(0,L,l)];x+=[[c.ljust(L/l*~-l+L%l)for c in W+['']*len(s)]]
for l in zip(*x):
 L=' '.join(l)
 if L.strip():print L

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

Comments

' '*(i/l*(l-1))हो सकता है i/l*~-l*' '।

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

202 बाइट्स ।

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

Answer 6

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

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

$-=s/.{$^I}\K(?=.)/\x1b[1B\x1b[1D/g,print$_,"\x1b[1A"x$-,$"for@F

नोट: \x1bएस शाब्दिक ESCवर्ण हैं, लेकिन आसान प्रतिलिपि और पेस्ट के लिए यहां से भाग गए।

यह स्क्रिप्ट ANSI एस्केप अनुक्रम का उपयोग करता है और इसके माध्यम से इनपुट की आवश्यकता होती है -i ध्वज के जो गैर-मानक है। यदि इनमें से कोई भी स्वीकार्य नहीं है, तो कृपया मुझे बताएं और मैं अपडेट कर दूंगा।

उदाहरण चलता है

perl -ai3 string-stairs.pl <<< 'This is a large string' 2>/dev/null
Thi is a lar  str   
  s        ge   ing

perl -ai2 string-stairs.pl <<< 'This is an even larger string!' 2>/dev/null
Th  is an ev  la   st   
 is        en  rg   ri
                er   ng
                      !

perl -ai3 string-stairs.pl <<< 'Ooooh dear, what a big string you have!' 2>/dev/null
Ooo  dea  wha a big str   you hav  
  oh   r,   t         ing       e!

perl -ai4 string-stairs.pl <<< 'Staphylococcus saprophyticus' 2>/dev/null
Stap        sapr       
   hylo        ophy
      cocc        ticu
         us          s

perl -ai2 string-stairs.pl <<< 'I hope you find this challenge interesting' 2>/dev/null
I ho  yo fi  th  ch    in     
   pe  u  nd  is  al    te
                   le    re
                    ng    st
                     e     in
                            g

perl -ai15 string-stairs.pl <<< "Well, this test case looks kinda pointless now doesn't it?" 2>/dev/null
Well, this test case looks kinda pointless now doesn't it? 

perl -ai1 string-stairs.pl <<< 'This one looks a lot more interesting!' 2>/dev/null
T o l a l m i 
h n o   o o n
i e o   t r t
s   k     e e
    s       r
            e
            s
            t
            i
            n
            g
            !

perl -ai2 string-stairs.pl <<< "Keep in mind, people: 'Punctuation! Does! Matter!'" 2>/dev/null
Ke  in mi  pe   'P       Do   Ma    
 ep     nd  op   un       es   tt
         ,   le   ct       !    er
              :    ua            !'
                    ti
                     on
                      !