चुनौती

एक स्ट्रिंग और एक संख्या को देखते हुए, स्ट्रिंग को कई समान-आकार वाले भागों में विभाजित करें । उदाहरण के लिए, यदि संख्या 3 है, तो आपको स्ट्रिंग को 3 टुकड़ों में विभाजित करना चाहिए, चाहे स्ट्रिंग कितनी भी लंबी हो।

यदि स्ट्रिंग की लंबाई प्रदान की गई संख्या में समान रूप से विभाजित नहीं होती है, तो आपको प्रत्येक टुकड़े के आकार को गोल करना चाहिए और "शेष" स्ट्रिंग को वापस करना चाहिए। उदाहरण के लिए, यदि इनपुट स्ट्रिंग की लंबाई 13 है, और संख्या 4 है, तो आपको आकार 3 में से प्रत्येक के चार तार वापस करना चाहिए, साथ ही आकार 1 के शेष स्ट्रिंग।

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

प्रदान की गई संख्या स्ट्रिंग की लंबाई से कम या उसके बराबर होने की गारंटी है। उदाहरण के लिए, इनपुट "PPCG", 7नहीं होगा क्योंकि "PPCG"7 स्ट्रिंग्स में विभाजित नहीं किया जा सकता है। (मुझे लगता है कि उचित परिणाम होगा (["", "", "", "", "", "", ""], "PPCG")। यह केवल इनपुट के रूप में इसे अस्वीकार करना आसान है।)

हमेशा की तरह, I / O लचीला होता है। आप तार की एक जोड़ी और शेष स्ट्रिंग, या अंत में शेष के साथ तार की एक सूची वापस कर सकते हैं।

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

"Hello, world!", 4 -> (["Hel", "lo,", " wo", "rld"], "!") ("!" is the remainder)
"Hello, world!", 5 -> (["He", "ll", "o,", " w", "or"], "ld!")
"ABCDEFGH", 2 -> (["ABCD", "EFGH"], "") (no remainder; optional "")
"123456789", 5 -> (["1", "2", "3", "4", "5"], "6789")
"ALABAMA", 3 -> (["AL", "AB", "AM"], "A")
"1234567", 4 -> (["1", "2", "3", "4"], "567")

स्कोरिंग

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

आपके समाधान बनाने के लिए बोनस अंक (वास्तव में 😛 नहीं) वास्तव में आपकी भाषा के डिवीजन ऑपरेटर का उपयोग करते हैं।

code-golf string

— musicman523
स्रोत

1

बोनस अंक? अरे यार मैं यह करना चाहता हूँ

— मैथ्यू रो

बोनस के लिए, जेली, 3 बाइट्स;⁹/

— जोनाथन एलन

संबंधित , लेकिन न तो हिस्सा इस चुनौती के समान है।

— म्यूज़िकमैन 523

इसे स्पष्ट करने के लिए कृपया एक PPCG7PPCG

— टेस्टकेस

@ JörgHülsermann वह इनपुट अस्वीकृत है। मैंने उस प्रकार के इनपुट से संबंधित अधिक विवरण जोड़े हैं और अधिक स्पष्ट होने के लिए सुधारित चीजें हैं।

— म्यूज़िकमैन 523

6

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

s,n=input()
b=len(s)/n
while n:print s[:b];s=s[b:];n-=1
print s

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

— OVS
स्रोत

बहुत बढ़िया! मुझे सच में नहीं लगता कि यह किसी भी आगे बढ़ाया जा सकता है।

— संगीतज्ञ ५२३

5

PHP> = 7.1, 75 बाइट्स

[,$s,$d]=$argv;print_r(preg_split('/.{'.(strlen($s)/$d^0).'}\K/',$s,$d+1));

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

PHP> = 7.1, 52 बाइट्स

केवल शेष प्रिंट करें

[,$s,$d]=$argv;echo substr($s,(strlen($s)/$d^0)*$d);

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

— जार्ग हुल्सरमैन
स्रोत

5

पिप , 21 बाइट्स

-nध्वज के लिए कोड के 20 बाइट्स, +1 ।

a~C(#a//b*XX)XbP$$$'

कमांड-लाइन तर्कों के रूप में इनपुट लेता है; आउटपुट स्ट्रिंग्स और शेष न्यूलाइन-अलग। इसे ऑनलाइन आज़माएं!

व्याख्या

रेगेक्स संचालन के साथ मज़ा!

चलो abcdefgहमारे स्ट्रिंग के 3रूप में और हमारी संख्या के रूप में लेते हैं । हम रेगेक्स का निर्माण करते हैं (.{2})(.{2})(.{2}), जो दो पात्रों के तीन रन से मेल खाता है और उन्हें तीन कैप्चर समूहों में संग्रहीत करता है। फिर, पिप के रेगेक्स मैच चर का उपयोग करते हुए, हम 1) कैप्चर समूहों की सूची को प्रिंट कर सकते हैं ["ab";"cd";"ef"], और 2) शेष स्ट्रिंग जो मिलान नहीं किया गया था "g"।

                      a,b are cmdline args; XX is the regex `.` (match any one character)
    #a//b             Len(a) int-divided by b: the length of each chunk
         *XX          Apply regex repetition by that number to `.`, resulting in something
                        that looks like `.{n}`
  C(        )         Wrap that regex in a capturing group
             Xb       Repeat the whole thing b times
a~                    Match the regex against a
               P$$    Print $$, the list of all capture groups (newline separated via -n)
                  $'  Print $', the portion of the string after the match

— DLosc
स्रोत

5

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

#एक ऑपरेटर ए Stringऔर ए ले रहा है Int, और Stringएस की सूची लौटा रहा है ।

के रूप में उपयोग करें "Hello, world!"#4।

s#n|d<-length s`div`n=[take(d+n*0^(n-i))$drop(i*d)s|i<-[0..n]]

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

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

sइनपुट स्ट्रिंग है और nगैर-शेष टुकड़ों की संख्या है।
dप्रत्येक "सामान्य" टुकड़े की लंबाई है। divपूर्णांक विभाजन है।
सूची समझ n+1टुकड़ों का निर्माण करती है, जिसमें अंतिम शेष रहता है।
- iसे दोहराता 0को nसमावेशी,।
- प्रत्येक टुकड़े के लिए, i*dशुरुआती वर्णों की पहली सही मात्रा ( ) की dropशुरुआत से पेड है s, फिर एक प्रारंभिक सबस्ट्रिंग takeपरिणाम से n है।
- स्थानापन्न लंबाई ली जानी चाहिए d, शेष टुकड़े को छोड़कर।
  - वास्तविक शेष की तुलना में कम होना चाहिए n, अन्यथा सामान्य टुकड़ों के बजाय लंबा हो जाएगा।
  - takeपूरी स्ट्रिंग लौटाता है यदि दी गई लंबाई बहुत बड़ी है, इसलिए हम >=n-1शेष टुकड़े के लिए किसी भी संख्या का उपयोग कर सकते हैं ।
  - अगर और अगर अभिव्यक्ति d+n*0^(n-i)देता है । इसका उपयोग तब होता है जब वह होता है , लेकिन यदि ।di<nd+ni==n0^x1x==00x>0

— अर्जन जोहान्सन
स्रोत

मुझे यह देखने की आवश्यकता होगी कि मैं सूची समझ का उपयोग कहां कर सकता हूं।

— qfwfq

4

पायथन 2 , 68 67 65 बाइट्स

@ musicman123 ने 2 बाइट्स बचाए: उत्पादन बिना संलग्न किए []
@ बाइट के लिए 1 बाइट का धन्यवाद: x[p*i:p+p*i]जैसा किx[p*i][:p]

def f(x,n):p=len(x)/n;print[x[p*i:][:p]for i in range(n)],x[p*n:]

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

— officialaimm
स्रोत

1

बदल कर सहेजें 1 बाइट x[p*i:p+p*i]के साथx[p*i:][:p]

— चास भूरा

1

+1 के लिए :pth अन्य पायथन जवाबों को अच्छी तरह से किया गया!

— संगीतज्ञ ५२३

हाहा .. जो बिल्कुल भी इरादा नहीं था ....: पी

— आधिकारिक

1

इस उत्तर अब कर दिया गया है outgolfed

— musicman523

4

सी ++ 14, 209 180 बाइट्स

यह थोड़ा लंबा है, लेकिन डिवीजन ऑपरेटर का उपयोग करता है:

#include<bits/stdc++.h>
using q=std::string;using z=std::vector<q>;z operator/(q s,int d){int p=s.length()/d,i=0;z a;for(;i<d+1;){a.push_back(s.substr(i++*p,i^d?p:-1));}return a;}

उपयोग:

vector<string> result = string("abc")/3;

ऑनलाइन संस्करण: http://ideone.com/hbBW9u

— Ra8
स्रोत

4

अजगर, 9 बाइट्स

cz*L/lzQS

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

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

पहले करने के Qलिए autoinitialized है eval(input())और करने के zलिए autoinitialized है input()।

cz*L/lzQSQ
     lz      length of z
    /  Q     integer division by Q
  *L         times every element of
        SQ       [1, 2, …, Q]
cz           chop z at those locations

— एंडर्स कसीगोर
स्रोत

3

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

Ld⁹x,1$}R⁸ṁ

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

— डेनिस
स्रोत

"123456789" के लिए असफल, 5 टेस्टकेस

— अर्जन जोहान्सन

चुनौती पूरी तरह से गलत। धन्यवाद!

— डेनिस

3

जंग , 107 बाइट्स

fn f(s:&str,n:usize)->(Vec<&str>,&str){let c=s.len()/n;((0..n).map(|i|&s[i*c..i*c+c]).collect(),&s[c*n..])}

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

प्रारूपित:

fn q129259(s: &str, n: usize) -> (Vec<&str>, &str) {
    let c = s.len() / n;
    ((0..n).map(|i| &s[i * c..i * c + c]).collect(), &s[c * n..])
}

यह बस mapस्रोत के सही स्लाइस str( collectएक में Vec) और शेष बाहर स्लाइस पर सूचकांक है ।

दुर्भाग्य से, मैं इसे बंद नहीं कर सकता (74 बाइट्स):

|s,n|{let c=s.len()/n;((0..n).map(|i|&s[i*c..i*c+c]).collect(),&s[c*n..])}

संकलक के साथ विफल रहता है

error: the type of this value must be known in this context
 --> src\q129259.rs:5:18
  |
5 |          let c = s.len() / n;
  |                  ^^^^^^^

और यदि मैं प्रकार प्रदान करता हूं s:&str, तो जीवनकाल गलत हैं:

error[E0495]: cannot infer an appropriate lifetime for lifetime parameter in function call due to conflicting requirements
 --> src\q129259.rs:6:27
  |
6 |          ((0..n).map(|i| &s[i * c..i * c + c]).collect(), &s[c * n..])
  |                           ^^^^^^^^^^^^^^^^^^^
  |
note: first, the lifetime cannot outlive the anonymous lifetime #1 defined on the body at 4:18...
 --> src\q129259.rs:4:19
  |
4 |       (|s: &str, n| {
  |  ___________________^
5 | |          let c = s.len() / n;
6 | |          ((0..n).map(|i| &s[i * c..i * c + c]).collect(), &s[c * n..])
7 | |      })(s, n)
  | |______^
note: ...so that reference does not outlive borrowed content
 --> src\q129259.rs:6:27
  |
6 |          ((0..n).map(|i| &s[i * c..i * c + c]).collect(), &s[c * n..])
  |                           ^
note: but, the lifetime must be valid for the lifetime 'a as defined on the body at 3:58...
 --> src\q129259.rs:3:59
  |
3 |   fn q129259<'a>(s: &'a str, n: usize) -> (Vec<&str>, &str) {
  |  ___________________________________________________________^
4 | |     (|s: &str, n| {
5 | |          let c = s.len() / n;
6 | |          ((0..n).map(|i| &s[i * c..i * c + c]).collect(), &s[c * n..])
7 | |      })(s, n)
8 | | }
  | |_^
note: ...so that expression is assignable (expected (std::vec::Vec<&'a str>, &'a str), found (std::vec::Vec<&str>, &str))
 --> src\q129259.rs:4:5
  |
4 | /     (|s: &str, n| {
5 | |          let c = s.len() / n;
6 | |          ((0..n).map(|i| &s[i * c..i * c + c]).collect(), &s[c * n..])
7 | |      })(s, n)
  | |_____________^

— CAD97
स्रोत

3

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

(.+)¶(.+)
$2$*1¶$.1$*1¶$1
(1+)¶(\1)+
$1¶$#2$*1¶
\G1(?=1*¶(1+))
$1¶
¶¶1+

O^$`.

¶1+$

O^$`.

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

— नील
स्रोत

3

पर्ल 6 , 36 बाइट्स

{$^a.comb.rotor($a.comb/$^b xx$b,*)}

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

स्ट्रिंग्स की सूची की एक सूची लौटाता है, जहां अंतिम तत्व शेष है (यदि एक है)।

स्पष्टीकरण:

{                                  }  # Anonymous code block
 $^a.comb                             # Split the string into a list of chars
         .rotor(                  )   # And split into
                            xx$b      # N lists
                $a.comb/$^b           # With string length/n size
                                ,*    # And whatever is left over

— मजाक कर रहा है
स्रोत

2

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

(s,d,n=s.length)=>[s.match(eval(`/.{${n/d|0}}/g`)).slice(0,d),s.slice(n-n%d)]

दो तत्वों की एक सरणी लौटाता है: विभाजित स्ट्रिंग भाग और शेष भाग।

टेस्ट स्निपेट

f=
(s,d,n=s.length)=>[s.match(eval(`/.{${n/d|0}}/g`)).slice(0,d),s.slice(n-n%d)]

<div oninput="O.innerHTML=I.value&&J.value?JSON.stringify(f(I.value,+J.value)):''">String: <input id=I> Number: <input id=J size=3></div>
<pre id=O>

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

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

2

जाप , 18 बाइट्स

¯W=Ul fV)òW/V pUsW

इसे ऑनलाइन टेस्ट करें! ( -Qआउटपुट का अनुमान लगाने के लिए ध्वज का उपयोग करता है )

व्याख्या

¯W=Ul fV)òW/V pUsW  : Implicit: U = input string, V = input integer
   Ul fV            : Floor U.length to a multiple of V.
 W=                 : Assign this value to variable W.
¯       )           : Take the first W characters of U (everything but the remainder).
         òW/V       : Partition this into runs of length W / V, giving V runs.
              pUsW  : Push the part of U past index W (the remainder) to the resulting array.
                    : Implicit: output result of last expression

— ETHproductions
स्रोत

2

पायथन, 82 76 74 बाइट्स

def G(h,n):l=len(h);r=l/n;print[h[i:i+r]for i in range(0,n*r,r)],h[l-l%n:]

खैर, ऐसा लगता है कि यह बोनस अंक के लिए योग्य है। _{_{क्या मुझे इसके बदले एक कुकी प्राप्त हो सकती है?}} ^{^{ओह रुको, वे असली नहीं हैं? अरे ...}}

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

— आर। कप
स्रोत

1

क्या आप एक कुकी पसंद करेंगे , या फैक्टरिंग करके 6 बाइट्स बचाएंगेlen(h) ? :)

— संगीतज्ञ ५२३

2

पायथन, 95, 87, 76 73 बाइट्स

def f(s,n):
 a=[];i=len(s)/n
 while n:a+=s[:i],;s=s[i:];n-=1
 print a+[s]

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

— अंकित
स्रोत

PPCG में आपका स्वागत है! मैंने आपकी पोस्ट पर "इसे ऑनलाइन आज़माएं" लिंक जोड़ा। मुझे लगता है कि आप इसे फ़ंक्शन के बजाय पूर्ण कार्यक्रम बनाकर अपने समाधान को थोड़ा छोटा कर सकते हैं। इसे ऑनलाइन आज़माएं!

— संगीतज्ञ ५२३

2

05AB1E , 12 बाइट्स

²g¹‰`s¹.D)R£

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

व्याख्या

²g¹‰`s¹.D)R£
²g           # Push length of string
  ¹          # Push amount of pieces
   ‰         # divmod of the two
    `s       # Flatten the resulting array and flip it around
      ¹.D    # Repeat the resulting length of the pieces amount of pieces times(wow that sounds weird)
         )   # Wrap stack to array
          R  # Reverse (so the remainder is at the end)
           £ # Split the input string into pieces defined by the array

— Datboi
स्रोत

1

9 बाइट्स इनपुट-ऑर्डर को उल्टा करके।

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

2

ब्रेकीलॉग , 16 बाइट्स

kʰ↙Xḍ₎Ylᵛ&ht↙X;Y

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

एक सूची के रूप में इनपुट लेता है [string, number]और एक सूची के रूप में आउटपुट करता है[remainder, parts] । (Commas को "हैलो, दुनिया में अर्धविरामों से बदल दिया गया था" स्पष्टता के लिए परीक्षण के मामले, क्योंकि स्ट्रिंग के टुकड़े उद्धरणों के साथ मुद्रित नहीं होते हैं।)

                    The input
 ʰ                  with its first element
k ↙X                having the last X elements removed
    ḍ               and being cut into a number of pieces
     ₎              where that number is the last element of the input
      Y             is Y
       lᵛ           the elements of which all have the same length,
         &          and the input
          h         's first element
           t↙X      's last X elements
              ;     paired with
               Y    Y
                    are the output.

(मैं भी लगातार उत्पादन प्रारूप के लिए एक अर्धविराम के साथ कोड में एक अल्पविराम बदल दिया। अल्पविराम के साथ कोई शेष के साथ, मामलों होगा सिर्फ उत्पादन एक खाली शेष बिना भागों, और उस के रूप में अच्छा के रूप में कुछ उद्देश्यों के लिए है, मुझे नहीं पता वास्तव में पता है कि यह इस तरह से क्यों काम करता है ...)

इसके बाद पूरे 16 बाइट्स निकले, मैंने +₁ᵗ⟨ġl⟩काम के आधार पर कुछ बनाने की कोशिश की , लेकिन जैसे-जैसे फ़िक्स और लंबा होता गया, मैंने तय किया कि मैं अभी के लिए अपने मूल समाधान के साथ रहूँगा।

— असंबंधित स्ट्रिंग
स्रोत

2

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

d;f(s,n)char*s;{for(d=strlen(s)/n;n--;puts(""))s+=write(1,s,d);puts(s);}

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

— जोहान डू टिट
स्रोत

2

एक्सेल फॉर्मूला, 185 173 165 161 149 बाइट्स

निम्नलिखित को एक सरणी सूत्र ( Ctrl+ Shift+ Enter) के रूप में दर्ज किया जाना चाहिए :

=MID(A1,(ROW(OFFSET(A1,,,B1+1))-1)*INT(LEN(A1)/B1)+1,INT(LEN(A1)/B1)*ROW(OFFSET(A1,,,B1+1))/IF(ROW(OFFSET(A1,,,B1+1))=B1+1,1,ROW(OFFSET(A1,,,B1+1))))

जहां A1आपके इनपुट शामिल हैं (जैसे 12345678) और B1भाजक शामिल हैं। यह बोनस के लिए एक्सेल के डिवीजन ऑपरेटर का भी उपयोग करता है।

सरणी सूत्र के रूप में सूत्र में प्रवेश करने के बाद, सूत्र पट्टी में इसे हाइलाइट करें और F9परिणाम के लिए इसका उपयोग करके मूल्यांकन करें , उदाहरण के लिए:

-12 बाइट्स: प्रत्येक को 2 बाइट्स प्रति घटना को बचाने के INDIRECT("1:"&B1+1)साथ बदलें OFFSET(A1,,,B1+1), साथ ही कुछ बेमानी कोष्ठक को हटाते हुए।

-8 बाइट्स: अनावश्यक INDEXफ़ंक्शन को हटा दें ।

-4 बाइट्स: "शेष" हैंडलिंग को फिर से काम करना।

-12 बाइट्स: -1 द्वारा INT(LEN(A1)/B1)उत्पन्न सरणी ऑफसेट द्वारा अनावश्यक हटा दें ROW(OFFSET(A1,,,B1+1))।

— i_saw_drones
स्रोत

1

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

-1 बाइट संगीतज्ञ 523 के लिए धन्यवाद।

def f(s,n):l=len(s);print[s[i:i+l/n]for i in range(0,l-n+1,l/n)]+[s[l-l%n:]]

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

— totallyhuman
स्रोत

1

यह एक बाइट एक फ़ंक्शन के रूप में छोटा है। इसे ऑनलाइन आज़माएं!

— संगीतज्ञ ५२३

1

माणिक , 53 बाइट्स

->s,n{a=s.scan(/.{,#{s.size/n}}/);[a[0,n],a[n,n]*'']}

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

— मूल्य स्याही
स्रोत

1

मैथेमेटिका, 58 बाइट्स

{#~Partition~a,#2}&@@TakeDrop[#,(a=Floor[Length@#/#2])#2]&

शुद्ध फ़ंक्शन, पात्रों की सूची और इनपुट के रूप में एक सकारात्मक पूर्णांक। उदाहरण के लिए, अंतिम परीक्षण मामले को कहा जाता है

{#~Partition~a,#2}&@@TakeDrop[#,(a=Floor[Length@#/#2])#2]&[{"1","2","3","4","5","6","7"},4]

और रिटर्न:

{{{"1"}, {"2"}, {"3"}, {"4"}}, {"5", "6", "7"}}

— ग्रेग मार्टिन
स्रोत

1

हास्केल, 120 88 बाइट्स (अर्जन जोहान्सन के लिए धन्यवाद!)

कर देता है div विभाजन ऑपरेटर के रूप में गिनती?

मैं उत्सुक हूं कि मैं इसे कैसे काट सकता हूं, मैंने अभी तक सभी तरकीबें नहीं सीखी हैं।

q=splitAt;x!s|n<-div(length s)x,let g""=[];g s|(f,r)<-q n s=f:g r,(a,b)<-q(n*x)s=(g a,b)

— qfwfq
स्रोत

2

सबसे बुनियादी चाल के साथ एक त्वरित पुनर्लेखन t=splitAt;x!s|n<-div(length s)x,let g""=[];g s|(f,r)<-t n s=f:g r,(a,b)<-t(n*x)s=(g a,b)। तो, (1) एक बार-बार इस्तेमाल किए जाने वाले पहचानकर्ता को संक्षिप्त किया जा सकता है, खासकर अगर यह लंबा है। (2) गार्ड और पैटर्न गार्ड लगभग हमेशा से कम होते हैं let... in, whereऔर if then else। (3) पैटर्न मिलान समानता परीक्षण से अक्सर बेहतर होता है। (ठीक है, कि letएक पैटर्न गार्ड में यह बुनियादी नहीं है, मैंने हाल ही में इसे यहां किसी और से सीखा है।) और कोडगुल्फ़.स्टैकएक्सचेंज . com/questions/19255/… देखें ।

— अर्जन जोहान्सन

1

इसके अलावा, कुछ उपयोगी ट्रिक्स के लिए हास्केल में गोल्फ के लिए टिप्स पर एक नज़र डालें ।

— सूडी जूल

@ ØrjanJohansen धन्यवाद! मैं भूल गया कि अर्धविराम मान्य थे, और वहlet गार्ड बहुत भयावह है। लेकिन कम कोड अधिक पठनीय है, है ना?

— qfwfq

1

ओम, 3 बाइट्स (गैर-प्रतिस्पर्धात्मक?)

lvσ

गैर-प्रतिस्पर्धात्मक क्योंकि अंतर्निहित TIO में अभी तक लागू नहीं किया गया है और मेरे पास यह परीक्षण करने के लिए कोई पीसी काम नहीं है कि यह रेपो में नवीनतम खींचतान में काम करता है या नहीं।

अंतर्निहित-\\ _ (ツ) _ / ¯। मैंने गलत बिल्ट-इन का उपयोग किया है ... लेकिन हे अभी भी एक दूसरे के चारों ओर एक लेटा हुआ है।अब मैंने दो बार गलत बिल्ट-इन का उपयोग किया (या एक बिल्ट-इन वर्क्स गलत रहता है)।

क्या मुझे बोनस अंक मिलते हैं क्योंकि v(मंजिल) विभाजन है?

— रोमन ग्रैफ़
स्रोत

1

यह आवश्यक तरीके से विभाजित नहीं होता है। उदाहरण के लिए Hello, world! 5अंडकोष गलत है। इसे ऑनलाइन आज़माएं!

— अर्जन जोहान्सन

खैर मैं एक और निर्मित में देखने जा रहा हूँ ....

— रोमन ग्रैफ

1

सीजेएम , 16 बाइट्स

{_,2$//_2$<@@>s}

बेनामी ब्लॉक स्टैक पर तर्कों की अपेक्षा करता है और इसके बाद स्टैक पर परिणाम छोड़ता है।

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

व्याख्या

तर्कों की अपेक्षा है number "string"।

_,              e# Copy the string and get its length.
  2$            e# Copy the number.
    /           e# Integer divide the length by the number.
     /          e# Split the string into slices of that size.
      _         e# Copy the resulting array.
       2$       e# Copy the number.
         <      e# Slice the array, keeping only the first <number> elements.
          @@    e# Bring the number and original array to the top.
            >   e# Slice away the first <number> elements,
             s  e# and join the remaining elements into a string.

— बिजनेस कैट
स्रोत

1

जे , 26 बाइट्स

(]$~[,(<.@%~#));]{.~0-(|#)

रिक्त स्थान और मध्यवर्ती चरणों के अलावा, यह गोल्फ नहीं हुआ है। मुझे उम्मीद है कि मैंने किसी भी तरह से लंबा रास्ता तय किया है, जो मेरे कोष्ठक और तर्क संदर्भों के साथ है ( [और] ) के साथ है।

परीक्षण मामलों के लिए बृहस्पति नोटबुक देखें , जैसे कि निम्नलिखित:

   5 chunk test2
┌──┬───┐
│He│ld!│
│ll│   │
│o,│   │
│ w│   │
│or│   │
└──┴───┘

— डेन
स्रोत

धन्यवाद। बहुत तेजी से पढ़ें। टिप्पणी निकाली

— योना

1

आर , 79 63 बाइट्स

इंडेक्स फिक्सिंग Giuseppe से -16

function(s,n,k=nchar(s),l=k%/%n)substring(s,0:n*l+1,c(1:n*l,k))

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

के लिए वेक्टर इनपुट देने के आसपास निर्मित substring()

— CriminallyVulgar
स्रोत

63 बाइट्स - अनुक्रमण को थोड़ा सरल किया।

— ग्यूसेप

@Giuseppe हाहा, मैंने इंडेक्स पर हर वेरिएंट को जोड़ने और गुणा करने की कोशिश की होगी, लेकिन वह चूक गया। अच्छी पकड़।

— आपराधिक रूप से

0

पीएचपी , 152 बाइट्स

धन्यवाद @ JörgHülsermann (कोष्ठक टिप!)

$c=$s=explode('|',readline());
while($s[1]--)$s[0]=preg_replace('/^'.($l[]=substr($s[0],0,strlen($c[0])/$c[1])).'/','',$s[0]);
$l[r]=$s[0];
print_r($l);

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

— रात बिताने का स्थान
स्रोत

1

आपका PHP तरीका काम नहीं करता है क्योंकि यह न केवल शुरुआत में बदलता है। preg_replaceएक विकल्प है या आप उपयोग कर सकते हैं[,$s,$d]=$argv;print_r(array_slice(str_split($s,$l=strlen($s)/$d^0),0,$d)+[$d=>substr($s,$l*$d)]);

— Jörg Hülsermann

क्या आप मुझे एक उदाहरण कोड के साथ समझा सकते हैं कि मेरा PHP कोड काम क्यों नहीं करता है?

— किप करें

1

इसे ऑनलाइन आज़माएं! यह Aपहले रन में सभी को बदल देता है

— जोर्ग हल्सरमन

1

यदि आप कोष्ठक का उपयोग करते हैं तो आप array_walk निर्माण को गिरा सकते हैं इसे ऑनलाइन आज़माएं!

— जॉर्ग हल्सरमैन

अच्छी टिप! मैं पूरी तरह भूल गया

— रात बिताने का स्थान

0

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

i=input().split('|')
s,n=i[0],int(i[1])
c=len(s)//n
while n:print(s[:c]);s=s[c:];n-=1
print(s)

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

— रात बिताने का स्थान
स्रोत

मान लेना इनपुट एक चर में है एक वैध इनपुट विधि नहीं है ।

— अर्जन जोहान्सन

इसका क्या मतलब है हमेशा की तरह, I / O लचीला है। ? वैसे भी धन्यवाद, मैं अपना जवाब संपादित ...

— रात बिताने का स्थान

1

PPCG के मानक तरीकों हैं बहुत लचीला। बस इतना काफी नहीं है।

— अर्जन जोहान्सन

0

PowerShell v3 + , 72 , 80 बाइट्स

मान लेता है $sकि इनपुट स्ट्रिंग है;$n"टुकड़ा" प्रति वर्णों की संख्या समाहित करता है। यह भी मानता है कि "स्ट्रिक्टमोड" बंद है। अन्यथा, एक त्रुटि वास्तव में मौजूद की तुलना में एक सरणी में अनुक्रमित करने के कारण वापस आ जाएगी (यदि सरणी में 4 तत्व हैं और मैं गैर-मौजूद 5 वें तत्व कहता हूं)। स्ट्रिक्टमोड ऑफ के साथ, पीएस परवाह नहीं करता है और यह त्रुटि को अनदेखा करेगा।

for($i = 0;$i -le $s.Length;$i+=$n+1){-join($s|% ToCharA*)[$i..($i+$n)]}

संकेतन का उपयोग करना ($s|% ToCharA*) मैं की तुलना में 1 चरित्र को बचाने के लिए कर रहा था $s.ToCharArray():)

अद्यतन करें:

अद्यतित कोड वास्तव में चुनौतियों की आवश्यकताओं को पूरा करने के लिए। फिर से मानता है $sकि इनपुट स्ट्रिंग शामिल है; हालाँकि, इस समय $nमें "टुकड़े" की संख्या शामिल है। शेष अंतिम रूप से मुद्रित है। और मैंने पॉवरशेल के डिविजन ऑपरेटर का इस्तेमाल किया

0..($n-1)|%{$p=[math]::Floor($s.length/$n)}{$s|% Su*($_*$p) $p}{$s|% Su*($n*$p)}

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

— GAT
स्रोत

मेरा मानना है कि आपने प्रश्न को गलत समझा है, इनपुट टुकड़ों की संख्या है (शेष को छोड़कर)।

— अर्जन जोहान्सन

ओह, तुम सही हो। मैंने कल रात इस प्रश्न को गलत तरीके से पढ़ा:) मैं अपना अद्यतन समाधान पोस्ट करूँगा जब मुझे मौका मिलेगा।

— GAT

एक स्ट्रिंग विभाजित करें

चुनौती

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

स्कोरिंग

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

PHP> = 7.1, 75 बाइट्स

PHP> = 7.1, 52 बाइट्स

पिप , 21 बाइट्स

व्याख्या

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

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

पायथन 2 , 68 67 65 बाइट्स

सी ++ 14, 209 180 बाइट्स

अजगर, 9 बाइट्स

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

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

जंग , 107 बाइट्स

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

पर्ल 6 , 36 बाइट्स

स्पष्टीकरण:

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

टेस्ट स्निपेट

जाप , 18 बाइट्स

व्याख्या

पायथन, 82 76 74 बाइट्स

पायथन, 95, 87, 76 73 बाइट्स

05AB1E , 12 बाइट्स

व्याख्या

ब्रेकीलॉग , 16 बाइट्स

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

एक्सेल फॉर्मूला, 185 173 165 161 149 बाइट्स

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

माणिक , 53 बाइट्स

मैथेमेटिका, 58 बाइट्स

हास्केल, 120 88 बाइट्स (अर्जन जोहान्सन के लिए धन्यवाद!)

ओम, 3 बाइट्स (गैर-प्रतिस्पर्धात्मक?)

सीजेएम , 16 बाइट्स

व्याख्या

जे , 26 बाइट्स

आर , 79 63 बाइट्स

पीएचपी , 152 बाइट्स

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

PowerShell v3 + , 72 , 80 बाइट्स

अद्यतन करें: