एक स्ट्रिंग को विखंडू द्वारा उल्टा करें

Question

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

नियम

आपके कार्यक्रम को एक सकारात्मक पूर्णांक प्राप्त होगा n, साथ ही साथ एक स्ट्रिंग sजिसमें लंबाई कम से कम केवल मुद्रण योग्य ASCII से युक्त होगी (व्हाट्सएप सहित नहीं)। स्ट्रिंग को लंबाई के टुकड़ों में विभाजित किया जाना चाहिए n, अगर स्ट्रिंग की लंबाई nकिसी भी बचे हुए से विभाज्य नहीं है , तो अंत में इसे अपना हिस्सा माना जाना चाहिए। फिर, विखंडू के क्रम को उल्टा करें और उन्हें फिर से एक साथ रखें।

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

n   s           Output

2   abcdefgh    ghefcdab
3   foobarbaz   bazbarfoo
3   abcdefgh    ghdefabc
2   a           a
1   abcdefgh    hgfedcba
2   aaaaaa      aaaaaa
2   baaaab      abaaba
50  abcdefgh    abcdefgh
6   abcdefghi   ghiabcdef

यह कोड-गोल्फ है , इसलिए आपको यथासंभव कम बाइट्स के लिए लक्ष्य बनाना चाहिए।

Comments

संबंधित ।

— AdmBorkBork

Answer 1

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

sṚ

एक पूर्ण कार्यक्रम जो परिणाम प्रिंट करता है।

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

कैसे?

sṚ - Main link: string, number                                   e.g. 'abcdefg', 3
s  - split string into chunks of length number (keeping any overflow) ["abc","def","g"]
 Ṛ - reverse the resulting list                                       ["g","def","abc"]
   - implicit print                                                   gdefabc

Comments

मुझे पसंद है कि कैसे दो बाइट्स ने स्पष्टीकरण की 4 लाइनें उत्पन्न कीं।

— पावेल

Answer 2

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

f=lambda s,n:s and f(s[n:],n)+s[:n]

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

Comments

andकीवर्ड यहाँ कैसे काम करता है? @ डेनिस

— शिनमिगामी १३

@ ShinMigami13 खाली स्ट्रिंग सत्य नहीं है इसलिए यह पुनरावृत्ति को समाप्त करता है

— माइकल क्लेन

Answer 3

05AB1E , 5 4 3 बाइट्स

डेनिस के लिए
-1 धन्यवाद - कारुसोकोम्पुटिंग के लिए धन्यवाद

ôRJ

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

     # Implicit: push input
 ô   # Split in pieces of length b
  RJ # Reverse and join

Comments

¹जरूरत नहीं है।

— मैजिक ऑक्टोपस Urn

Answer 4

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

n=>F=s=>s&&F(s.slice(n))+s.slice(0,n)

इनपुट करके इनपुट लेता है: पहले नंबर, फिर स्ट्रिंग, लाइक f(2)("abcdefgh")।

let f =
n=>F=s=>s&&F(s.slice(n))+s.slice(0,n)

let g = (n, s) => console.log(`f(${n})("${s}"): ${f(n)(s)}`)

g(2, "abcdefgh")
g(3, "foobarbaz")
g(3, "abcdefgh")
g(2, "a")
g(1, "abcdefgh")
g(2, "aaaaaa")
g(2, "baaaab")
g(50, "abcdefgh")

Answer 5

पर्ल 6 ,  28  20 बाइट्स

{$^b.comb($^a).reverse.join}

कोशिश करो

{[R~] $^b.comb($^a)}

कोशिश करो

विस्तारित:

{  # bare block lambda with placeholder parameters ｢$a｣ and ｢$b｣
  [R[~]] # reduce the following using the reverse meta operator `R`
         # combined with the string concatenation operator

    # `comb` with a number splits the invocant into chunks of that size
    $^b.comb($^a)
}

Answer 6

बैश + कोरुटिल्स, 22

fold -$1|tac|tr -d \\n

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

Comments

मैंने इस हफ्ते 4 नए linux कमांड सीखे हैं PPCG फोल्ड उनमें से एक है, धन्यवाद!

— वोसनेम

Answer 7

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

n#""=""
n#s=n#drop n s++take n s

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

Comments

सुंदर हे। यह अच्छा है जब पूर्वता गोल्फ में काम करता है

— माइकल क्लेन

Answer 8

PHP, 53 बाइट्स

<?=join(array_reverse(str_split($argv[2],$argv[1])));

Answer 9

रोड़ा , 36 बाइट्स

f n{[[_]..[try head n-1]]|reverse|_}

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

यह एक फ़ंक्शन है जो एक तर्क लेता है। स्ट्रिंग के पात्र धारा में होने चाहिए।

tryउस स्थिति में त्रुटियों को छोड़ने के लिए उपयोग किया जाता है जो headफ़ंक्शन n-1मानों को नहीं पढ़ सकता है।

स्पष्टीकरण:

f n{[[_]..[try head n-1]]|reverse|_}
f n{                               } /* Function declaration */
                                     /* In a loop: */
      _                              /*   Pull one value */
           try head n-1              /*   Pull n-1 values (or less) */
     [ ]..[            ]             /*   Make an array */
    [                   ]            /*   Push it to the stream */
                         |reverse    /* Reverse all values in the stream */
                                 |_  /* Flat all arrays in the stream */
                                     /* Characters in the stream are printed */

जैसा कि आमतौर पर नहीं होता है। मुझे लगता है कि यह काफी खूबसूरत है। :)

Comments

आप जेली समाधान की तुलना में एक कार्यक्रम को कम पठनीय बनाने में कामयाब रहे।

— पावेल

[[try head n]]इसके बजाय काम क्यों नहीं करता है [[_]..[try head n-1]]?

— कृति लिथोस

@KritiiLithos क्योंकि _अभिव्यक्ति को लूप करता है। [[try head n]]n मानों को एक बार लेगा , लेकिन n मान तब तक लेगा [[_]..[try head n-1]]जब तक कि मान शेष हैं।

— फर्ग्यूसक

Answer 10

सीजाम , 5 बाइट्स

q~/W%

इनपुट एक संख्या और डबल कोट्स में संलग्न स्ट्रिंग है, जिसे व्हाट्सएप द्वारा अलग किया गया है।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

q~   e# Read all input and evaluate: pushes a number and a string
/    e# Split string into chunks of that size. Last chunk may be
     e# smaller. Gives an array of strings
W%   e# Reverse the array. Implicitly display

Answer 11

बैच, 74 बाइट्स

@if %2=="" (echo %~3)else set s=%~2&call %0 %1 "%%s:~%1%%" "%%s:~,%1%%%~3"

बल्कि गुस्से से यह पूंछ पुनरावर्ती के बजाय पुनरावर्ती होने का कारण बनता है।

Answer 12

वी , 13 10 बाइट्स

òÀ|lDÏpòÍî

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

ò      ò    ' Recursively
 À|         ' Go to the "nth" column
   l        ' Move one character right (breaks loop when no more chunks)
    D       ' Delete from here to the end of the line
     Ï      ' Add a line above the current line (now contains one chunk)
      p     ' Paste the remainder of the line that was deleted
        Íî  ' Remove all newlines

कार्रवाई में:

abcdefghijkl

में बदल जाता है

efghijkl
abcd

जो बन जाता है

ijkl
efgh
abcd

इससे पहले कि सभी नई लाइनें हटा दी जाएं

Answer 13

ब्रेनफक , 78 बाइट्स

,<<<+[[>]>+>[[>],<[<]>+>-]<-[->>[>]>>+<<<[<]<]>>]<<<<[[<]>[-[+.[-]]+>]<[<]<<<]

इनपुट का पहला बाइट, चंक आकार है, जो बाइट मान द्वारा दिया गया है। बाकी बाइट्स को स्ट्रिंग माना जाता है।

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

विस्तार किया और टिप्पणी की

Read the chunk size byte
This cell will become a counter cell
,

Move left a few cells an increment; 
this is to make the starting position 
line up with the relative positioning
needed to fit in with the loop
<<<+

While the current cell is nonzero:
[

 Move right to the first zero cell
 [>]

 Move right once and increment and then move right to the counter cell
 The increment is required because of "move to zero cell" loops
 >+>

 This loop will store one chunk of the input in consecutive memory cells
 [
  [>]   Move right until a zero cell is hit
  ,     Store 1 byte of input there
  <[<]  Move back left until a zero cell (other than the current one) is hit
  >+>-  Increment the temporary cell by 1 and decrement the counter
 ] (end loop once the counter hits zero)

 Decrement the temp cell (because we needed to have 1 there initially to make the cell location work)
 <-

 Move the temp cell to three cells after the end of the chunk
 This is the new counter cell for the next chunk
 [->>[>]>>+<<<[<]<]

 Move two cells right from where the temp cell was
 This is the first cell of the chunk; if it's 0
 then the input is finished and the loop should end
 >>
]

Due to the way the counter is kept track of the tape head
will always be four cells to the right of the last input cell
when the loops breaks
<<<<

Now the chunks are printed one by one
At the start of an iteration the tape head is at the end of a chunk
[
 Locate the start of the last chunk
 [<]>

 Print the chunk:
 [
  Print the byte held in the current cell if it isn't 1
  This is necessary because we left a stray 1 in a cell at
  the start which shouldn't be printed
  -[+.[-]]+

  Move to the next cell
  >
 ]

 Move to just left of the chunk
 <[<]

 Move three cells over to the end of the next chunk
 <<<
]

Answer 14

शक्ति कोशिका, 56 49 बाइट्स

-7 बाइट्स mazzy के लिए धन्यवाद

param($n,$s)$s-split"(.{$n})"-ne''|%{$r=$_+$r};$r

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

Comments

1) 49 बाइट्स 2) कृपया, एक पूर्ण प्रोग्राम पोस्ट करें, कोडनिपेट नहीं। किस प्रकार जांच करें? एक्सटेंशन के साथ एक अलग फ़ाइल में अपना कोड निकालें और अपने कोड के .ps1बजाय इस स्क्रिप्ट को कॉल करने का प्रयास करें। यदि यह काम करता है, तो परीक्षण सफल रहा।

— माज़ी

Answer 15

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

""<>Reverse@Partition[Characters@#2,#,#,1,{}]&

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

Answer 16

जावास्क्रिप्ट - 54 47 46 बाइट्स

पुनर्निर्माण:

(s,n)=>s.match(eval(`/.{1,${n}}/g`)).reverse()

इसके समान इस्तेमाल किया

f=(s,n)=>s.match(eval(`/.{1,${n}}/g`)).reverse()
alert(f("abcdefgh",2));

कुछ RegEx जल्दी के लिए @ETHproductions के लिए धन्यवाद @ eval में एक अतिरिक्त बाइट के लिए @ धन्यवाद!

मूल:

(s,n)=>s.match(new RegExp('.{1,'+n+'}','g')).reverse()

Comments

अच्छा जवाब! मेरा मानना ​​है कि आप कुछ युगल बाइट्स को बचाने के लिएeval('/.{1,'+n+'}/g')

— ETHproductions

@ETHproductions आह हाँ। यही मैं करने की कोशिश कर रहा हूं। मैं हालांकि यह करने के लिए regex के साथ पर्याप्त परिचित नहीं था!

— ब्लू ओकिरिस

मुझे लगता है कि आप एक बाइट को करीने से बचा सकते हैं,s=>n=> ...

— पावेल

eval("/.{1,${n}}/g")उद्धरण चिह्नों के बजाय बैकटिक्स का उपयोग करके एक बाइट को सहेजें ।

— झबरा

Answer 17

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

s_c.*

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

व्याख्या

   .*  splat implicit input
  c    split into chunks length n
 _     reverse
s      join

Answer 18

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

1 बाइट ने @LeakyNun को धन्यवाद दिया

^

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

(दूसरी पंक्ति, और अनुगामी स्थान पर स्थान नोट करें)

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

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

परीक्षण सूट! (ज़रा - सा संशोधित)

व्याख्या

पहला कदम एक स्थान को तैयार करना है (बाद में महत्वपूर्ण हो जाएगा)।

^
 

अब हम उलटा करते हैं। यह .NET के बैलेंसिंग समूहों का उपयोग करता है। यह ध्यान रखना महत्वपूर्ण है कि यहां समूह ढेर के रूप में कार्य करते हैं, इसलिए प्रत्येक मैच अनिवार्य रूप से स्टैक पर धकेल दिया जाता है। यहाँ हम प्रत्येक अंक को समूह 2 में एकरी संख्या में कैप्चर करते हैं। अब हर बार स्ट्रिंग में एक वर्ण पाए जाने पर, समूह 2 से एक मैच पॉप होता है। यह सुनिश्चित करता है कि वर्णों की संख्या एकात्मक संख्या से अधिक न हो।

+`(.* (1)+¶)                       Capture the unary number in group 2
             ((?<-2>.)+)           Balancing group for substrings
$3$1                               Reverse

और अंत में अनरी नंबर और न्यूलाइन को हटा दें।

 1+¶

Comments

मुझे लगता है कि संख्या को एकात्मकता में लेना स्वीकार्य है।

— लीक नून

किसी भी तरह, आप की जगह ले सकता \dसे .एक बाइट को बचाने के लिए।

— लीक

दूसरा ^भी बेमानी है।

— लीकी नून

@LeakyNun कार्यक्रम अब एकात्मकता में इनपुट लेता है, इसलिए मुझे अब इसकी कोई आवश्यकता \dनहीं है। और

— देखभाल को

आलसी (गैर-लालची) मैच का उपयोग करके 33 बाइट्स ।

— लीक नून

Answer 19

जावा, 147 138 बाइट्स

String r(String s,int n){String r="";int l=s.length();for(int i=l/n*n;i>=0;i-=n)if(!(i>=l))r+=(i+n)>=l?s.substring(i):s.substring(i,i+n);return r;}

सेवित 9 बाइट्स केविन क्रूज़सेन को धन्यवाद!

String r(String s,int n){String r="";int l=s.length(),i=l/n*n;for(;i>=0;i-=n)if(i<l)r+=i+n>=l?s.substring(i):s.substring(i,i+n);return r;}

विस्तारित रूप में:

String r(String s,int n){
    String r="";
    int l=s.length(),i=l/n*n;
    for(;i>=0;i-=n)
        if(i<l)
            r+=i+n>=l?s.substring(i):s.substring(i,i+n);
    return r;
}

यह वास्तव में मेरी पहली बार कोडगोल्फ की कोशिश है, इसलिए किसी भी प्रतिक्रिया का स्वागत है!

Comments

PPCG में आपका स्वागत है!

— पावेल

नमस्ते, PPCG में आपका स्वागत है! यह पहले से ही बहुत अच्छा है, लेकिन वहां अभी भी गोल्फ के लिए कुछ चीजें कुछ और कर रहे हैं: int l=s.length();for(int i=l/n*n;हो सकता है int l=s.length(),i=l/n*n;for(;तो आप केवल int एक बार। और if(!(i>=l))हो सकता है if(l<i)। और r+=(i+n)>=l?कोष्ठक के बिना हो सकता है r+=i+n>=l?:। इसके अलावा, अगर आपने इसे अभी तक नहीं देखा है, तो मैं सुझाव दे सकता हूं कि आप कुछ बेहतरीन कूल गोल्फिंग युक्तियों के लिए जावा में गोल्फिंग के लिए टिप्स देखें। :) एक बार फिर से, स्वागत है।

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

Answer 20

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

-lnM5.010झंडे का उपयोग करता है ।

say reverse<>=~/.{1,$_}/g

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

मेरे बारे में बताने के लिए ग्रिनज़ को चिल्लाओ =~ m/.{1,$n}/g

-M5.010sayफ़ंक्शन के उपयोग को सक्षम करता है, जो हमारे उद्देश्यों के लिए एक छोटे नाम के साथ प्रिंट होता है।

-nइनपुट की पहली पंक्ति डालता है $_, और -lअनुगामी न्यूलाइन को बंद कर देता है।

फिर हम इनपुट का उपयोग करने की दूसरी पंक्ति प्राप्त करते हैं <>, और इसे रेगेक्स पर लागू करते हैं .{1,$_}: किसी भी वर्ण, 1 और $ _ (पहला इनपुट समय) के बीच। चूंकि यह डिफ़ॉल्ट रूप से लालची है, यह हमेशा $ _ वर्णों से मेल खाने की कोशिश करता है। 1,अंत में संभव बचे हुए हिस्से के लिए आवश्यक है।

/gसंशोधक हमें देता है हर एक सूची है, जो तब को उलट दिया और प्रिंट किया जाता है के रूप में इनपुट स्ट्रिंग में है कि regex के मैच। पर्ल में, sayडिफ़ॉल्ट रूप से किसी भी सीमांकक के बिना इसमें शामिल होने के लिए एक सूची पारित करना ।

Answer 21

डायलॉग एपीएल विस्तारित , 16 15 बाइट्स

{∊⌽⍵⊂⍨(≢⍵)⍴=⍳⍺}

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

Comments

आप की जरूरत नहीं हैf←

— पावेल

क्यों, ,/→∊

— आदम

@ Adám ओह हे, जो मेरे उत्तर पर भी लागू होता है, धन्यवाद

— पावेल

पावेल: हाँ, जाहिर है .. @ एडम धन्यवाद!

— दिजिमा

14:∊∘⌽⊢⊂⍨≢⍤⊢⍴1↑⍨⊣

— शुक्र

Answer 22

पायथन, 62 बाइट्स

lambda n,s:''.join([s[i:i+n]for i in range(0,len(s),n)][::-1])

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

Comments

पायथन 3 का उत्तर छोटा है और अजगर 2.7 के लिए भी काम करता है:f=lambda n,s:s and f(n,s[n:])+s[:n]

— F1Rumors

Answer 23

स्टैक्ड , 9 बाइट्स

#<rev''#`

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

#<रिक्त स्ट्रिंग द्वारा विखंडू, revउलट और ''#`जुड़ जाते हैं। काफी सरल।

Answer 24

QBIC , 24 बाइट्स

:;[1,_lA|,a|Z=_sA,b,a|+Z

यह हाल ही में QBIC में जोड़े गए नए प्रतिस्थापन-फ़ंक्शन का उत्कृष्ट उपयोग करता है:

:;          Read in the cmd line params a (number) and A$ (text)
[1,_lA|,a|  Set up a FOR loop: FOR b = 1; b <= A$.length; b += a
Z=          Modify Z$; Z$ is autoprinted at the end of QBIC code
_sA,b,a|    SUBSTRING: _s is the function followed by the string 
               to take from, the starting pos and the # of chars
+Z          Take chunks from further into A$, put them before Z$

Answer 25

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

s_cF

इनपुट के रूप में लेता है "s",n: इसे अपने लिए आज़माएं!

Answer 26

उत्तल , 2 बाइट्स

/¥

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

Answer 27

सी, 69 बाइट्स

i;f(s,n)char*s;{i=strlen(s);for(i-=i%n;printf("%.*s",n,s+i),i;i-=n);}

परिणाम मानक आउटपुट पर मुद्रित होता है।

Answer 28

स्काला, 57 55 बाइट्स

(n:Int,s:String)=>(""/:s.grouped(n).toSeq.reverse)(_+_)

धन्यवाद जैकब! इसे यहाँ आज़माएँ ।

नोट: foldLeft ("/:") के प्रतीक रूप का उपयोग करके, मैं कुछ और बाइट्स लेने में सक्षम था।

Comments

इसे अनाम कार्य करें, और mkStringइसके बजाय उपयोग करें reduceLeft, और 7 बाइट्स से दाढ़ी बनाएं :(n:Int,s:String)=>s.grouped(n).toSeq.reverse.mkString("")

— याकूब

Answer 29

ओम , 5 बाइट्स

σ]QWJ

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

व्याख्या

σ]QWJ
σ         # Split input1 into input2 pieces
 ]        # Flatten array
  Q       # Reverses stack
   W      # Wraps stack to array
    J     # Joins stack
          # Implicit print

Answer 30

आर , 69 60 बाइट्स

function(s,n)cat(substring(s,(x=nchar(s):0*n)+1,x+n),sep="")

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

हटाने के सुझाव के लिए किरिल एल का धन्यवाद seq।

Comments

ऐसा लग रहा है कि यह 66 के लिए भी काम करता है ।

— किरिल एल।

@KirillL। हम 60 बाइट्स पर जा सकते हैं यदि हम तर्कों के क्रम को उलट देते हैं :और कुछ हेरफेर से हमें अनुगामी से छुटकारा मिल जाता है -1।

— ग्यूसेप

स्मार्ट, बहुत अच्छा!

— किरिल एल।