टूटे हुए तारों का पिरामिड


10

एक स्ट्रिंग n को देखते हुए, वर्तमान पंक्ति के सापेक्ष टुकड़ों में विभाजित स्ट्रिंग का एक पिरामिड बनाएं।

पहली पंक्ति में स्ट्रिंग अनमॉडिफाइड है।

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

तीसरी पंक्ति इसे तिहाई से अलग करती है ...

और इसी तरह। प्रत्येक स्थानापन्न की लंबाई, जहां l स्ट्रिंग n की लंबाई है, के बराबर है

मंजिल (एल / n)

बचे हुए वर्णों को अपने स्थानापन्न में रखा जाता है। उपयोग की गई अंतिम पंक्ति पहले वाली है जहां सबस्ट्रिंग 2 की लंबाई के हैं।

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

इनपुट: हैलो, दुनिया

आउटपुट:

Hello, world.

Hello,| world|.

Hell|o, w|orld|.

Hel|lo,| wo|rld|.

He|ll|o,| w|or|ld|.

इनपुट: abcdefghij

आउटपुट:

abcdefghij

abcde|fghij

abc|def|ghi|j

ab|cd|ef|gh|ij

इनपुट: 01234567890abcdef

आउटपुट:

01234567890abcdef

01234567|890abcde|f

01234|56789|0abcd|ef

0123|4567|890a|bcde|f

012|345|678|90a|bcd|ef

01|23|45|67|89|0a|bc|de|f

अतिरिक्त नियम:

  • आप पूर्ण प्रोग्राम या फ़ंक्शन लिख सकते हैं, जो भी कम कोड का उपयोग करता है।

  • इनपुट हमेशा लंबाई में कम से कम 4 वर्ण का होगा।

  • यदि आपकी भाषा उनका समर्थन करती है, तो आपको लाइन ब्रेक का उपयोग करना होगा। यदि संभव न हो, तो लाइन विराम को बदल दें:

  • इनपुट हमेशा मुद्रण योग्य ASCII होगा।

  • यदि आपका कार्यक्रम P बनाम NP को हल करता है तो माइनस 100%।


लीडरबोर्ड:


0 बाइट्स:return: false
गेब्रियल बेनामी

3
अच्छी पहली चुनौती! कुछ स्पष्टीकरण के प्रश्न - क्या इनपुट केवल मुद्रण योग्य ASCII है (मैं दृढ़ता से "हां" सुझाता हूं)? "संभव होने पर लाइन ब्रेक आवश्यक है" क्या मतलब है?
AdmBorkBork

3
यह एक मज़ाक है। P बनाम NP कंप्यूटिंग में एक अनसुलझी समस्या है। मजाक यह है कि यदि आप इसे हल कर सकते हैं, तो मैं इस तथ्य के बारे में परवाह करना बंद कर दूंगा कि आपका कार्यक्रम चुनौती का समाधान नहीं करता है।
जूलियन लाचनीट

3
कंप्यूटिंग में वास्तविक अनसुलझी समस्या "टैब या रिक्त स्थान" है ...
FlipTack

3
नहीं, असली समस्या इंटरनेट एक्सप्लोरर है।
जूलियन लाचनीट

जवाबों:


0

जावास्क्रिप्ट (ईएस 6), 103 101 91 84 बाइट्स

चुनौती की आवश्यकताओं का सम्मान करने के लिए निश्चित

f=(s,n=0,p=s.length/++n|0)=>p>1?s.match(eval('/.{1,'+p+'}/g')).join`|`+'\n'+f(s,n):''

लैम्ब्डा fजो इनपुट स्ट्रिंग को पहले पैरामीटर के रूप में लेता है sऔर विभाजन स्ट्रिंग को कंसोल करने के लिए पुनरावर्ती प्रिंट करता है। बहुत सीधा: जब तक सबस्ट्रिंग की लंबाई p1 से ऊपर है, स्ट्रिंग स्प्लिट को 'a' | प्रत्येक pवर्ण, तो निम्न स्तर को जोड़कर आगे बढ़ें। यह फिर फ़ंक्शन pको t / nफ़्लॉइड होने के साथ फिर से कॉल करता है , जहां tमूल स्ट्रिंग लंबाई है और nएक बढ़े हुए डिवाइडर है।


मुझे नहीं लगता कि nहर बार 2 से भाग देना सही है।
नील

@ आप सही हैं, मेरी ओर से गलती। मैंने समस्या को ठीक किया और प्रक्रिया में 2 बाइट्स बचाए।
XavCo7

@ETHproductions मैंने इसके बारे में सोचा था, लेकिन मुझे नहीं पता कि क्या यह STDOUT के रूप में गिना जाएगा ... मुझे लगता है कि मुझे alert(f(s))सही करने के बाद क्या करना होगा?
XavCo7

4

पर्ल, 46 + 1 = 47 बाइट्स

-nझंडे के साथ भागो

say s/.{$=}(?=.)/$&|/gr while($==y///c/++$,)-2

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

कोड टूटना

-n                                              #Reads input into the $_ variable
say s/.{$=}(?=.)/$&|/gr while($==y///c/++$,)-2
                                 y///c          #Transliteration.  Implicitly operates on $_, replacing every character with itself and counting replacements
                                                #y///c effectively returns the length of $_
                                      /++$,     #Increments $, (which starts off at 0) and divides the length of $_ by $,
                              $==               #Stores the result of this division into $=
                                                #$= forces its contents to be an integer, so it truncates any decimal
                             (             )-2  #Returns 0 if $= is equal to 2
                        while                   #Evaluates its RHS as the condition.  If truthy, evaluates its LHS.
    s/          /   /gr                         #Substitution.  Implicitly operates on $_.
                                                #Searches for its first argument and replaces it with its second argument, repeating until it's done, and returns the new string.  $_ is not modified.
      .{$=}                                     #Looks for a string of $= characters...
           (?=.)                                #...that is followed by at least one non-newline character, but does not include this character in the match...
                 $&|                            #...and replaces it with itself followed by a pipe character.
say                                             #Output the result of the substitution.

यह लंबे समय तक इनपुट के लिए काम नहीं करता है।
नील

2

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

Vh/lQ3j\|cQ/lQhN

V                # For N in range(1, \/ )
 h/lQ3           # 1+lenght(input)/3
      j\|        # join with '|'
         cQ      # chop input in
           /lQhN # lenght(input)/(N+1) pieces

यहाँ प्रयास करें


1
यह परीक्षण मामलों के लिए काम कर सकता है, लेकिन मुझे नहीं लगता कि यह लंबे समय तक इनपुट के लिए काम करता है।
नील

2

सी, 145 131 128 125 बाइट्स

l,n,i=1,j;f(char*s){l=strlen(s);puts(s);do{n=l/++i;for(j=0;j<l;)j&&(j%n||putchar('|')),putchar(s[j++]);puts("");}while(n>2);}

यह एक फ़ंक्शन है जो अपने तर्क के रूप में एक स्ट्रिंग लेता है और आउटपुट को STDOUT में प्रिंट करता है।

l,n,i=1,j;       // declare some variables
f(char*s){       // declare the function
l=strlen(s);     // get the length of the string
puts(s);         // output the initial version, with trailing newline
do{n=l/++i;      // n is the number of characters per "section",
                 //  and we'll do-while n>2 to stop at the right time
for(j=0;j<l;)    // loop through the characters of the string
j&&(             // if j != 0,
j%n||            // and j % n == 0,
putchar('|')),   // insert a | before this character
putchar(s[j++]); // print the character
puts("");        // print a newline after the loop
}while(n>2);}

यह एक बार कैसे काम करता है i*i>l? ऐसा लगता है कि यह खंडों को दोहराना शुरू कर देगा।
नील

@ नहीं मुझे यकीन नहीं है कि तुम क्या मतलब है। क्या आप एक उदाहरण दे सकते हैं?
दरवाज़े

@ नील आह, कोई बात नहीं, मैं देख रहा हूँ कि तुम क्या कह रहे हो। यह विनिर्देश में एक छेद प्रतीत होता है, जो स्पष्ट रूप से बताता है कि प्रत्येक प्रतिस्थापन की लंबाई है floor(l/n); मुझे यकीन नहीं है कि अभिप्रेत व्यवहार लंबे समय तक इनपुट के लिए है या यदि ओपी ने अनुमान लगाया है कि।
दरवाज़े

1

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

jmj\|cQ/lQdSh/lQ3

व्याख्या

     cQ/lQ         Divide into equal pieces (with the last shorter)
  j\|              Join with pipes
 m        d        Map to each row index...
           Sh/lQ3  ... up to the first row with substrings of length 2
j                  Join with newlines

1

जावास्क्रिप्ट, 98 बाइट्स

a=>{for(b=1;2<=a.length/b;)eval("console.log(a.match(/.{1,"+(a.length/b|0)+"}/g).join('|'))"),b++}

कार्य x(a)। का उपयोग कर कॉल करें

console.log(x("ABCDEF"))



0

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

f=lambda s:print(*['|'.join(s[i:i+n]for i in range(0,len(s),n))for n in[len(s)//i for i in range(1,len(s)//2+1)]],sep='\n')

लंबे समय तक तार कुछ हिस्सों को दोहराया जाएगा, क्योंकि सबस्ट्रिंग की लंबाई के लिए सूत्र है floor(l/n)। उदाहरण के लिए एक स्ट्रिंग के साथ 13 वर्ण लंबा, 5 में विभाजित स्ट्रिंग 6 के रूप में स्ट्रिंग विभाजन के समान है floor(13/5)==floor(13/6)। मुझे यकीन नहीं है कि अगर ओपी को यह उम्मीद है या अगर यह एक निरीक्षण था।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.