रोसेन्क्रांट्ज़ और गिल्डेनस्टर्न कोड हैं

Question

बेतुके नाटक में रोसेंक्रेन्त्ज़ और गिल्डेनस्टर्न मृत हैं , दो मुख्य पात्र रोसेंक्रेन्त्ज़ और गिल्डेर्नस्टर्न (या वे हैं?) हमेशा मिश्रण कर रहे हैं कि उनमें से कौन है-या कभी-कभी अपने स्वयं के भागों में से एक है - एक कथित कमी के कारण? व्यक्तिगत पहचान। क्या यह बेतुका नहीं होगा यदि वे अपने नाम के इर्द-गिर्द घूमते हैं?

आपका कार्य यह एक फ़ंक्शन लिखने के लिए है जो एक समान लंबाई (और डिजाइन द्वारा, 4 का एक बहु) में लेता है जो 7 वर्णों से अधिक है, इसे विभाजित करें और इसे फेरबदल करें।

बंटवारा निम्नानुसार होगा : स्ट्रिंग प्रारूप का होगा "abscd", जिसमें सेपरेटर चरित्र के रूप में कार्य किया जाएगा। पहला खंड और विभाजक, absस्ट्रिंग का पहला आधा भाग होगा, जबकि दूसरा आधा भाग होगाcd

की लंबाई aहोगी(string length / 4) - 1

की लंबाई bहोगी(string length / 4)

की लंबाई sहोगी1

इसकी लंबाई cहोगी(string length / 4) + 1

इसकी लंबाई dहोगी(string length / 4) - 1

यह वास्तव में भ्रामक हो सकता है, इसलिए मैं आपको कुछ उदाहरणों के साथ दिखाता हूं

("a" + "bb" + "s" + "ccc" + "d").length //8
  1     2      1      3      1
|-------4--------|  |----4-----| <--- (4 is half of 8)

("rosen" + "crantz" + "&" + "guilden" + "stern").length  //24
    5         6        1        7          5

("foo" + "barr" + "?" + "barry" + "foo").length
   3       4       1      5         3

आखिरकार:

तुम तो चारों ओर भागों फेरबदल, outputting adscb

पूर्व। "rosencrantz&guildenstern" --> "rosenstern&guildencrantz"

"foobarr?barryfoo" --> "foofoo?barrybarr"

Rulez:

1. मानक लोफॉल्स निषिद्ध हैं
2. स्वीकार्य उत्तर: एक फ़ंक्शन जो एक इनपुट स्ट्रिंग के माध्यम से इनपुट लेता है और एक आउटपुट स्ट्रिंग देता है
3. यदि इनपुट स्ट्रिंग उपरोक्त प्रदान की गई आवश्यकताओं से मेल नहीं खाती है, तो आपका कोड MUST एरर आउट हो जाता है (इससे कोई फर्क नहीं पड़ता कि किस तरह का है Exceptionया नहीं Error )
4. ये है code-golf , इसलिए सबसे छोटा (मान्य) उत्तर (प्रत्येक भाषा में) जीतता है!
5. एक-लाइनर के लिए बोनस अंक :-) (वास्तव में थोड़े नहीं, सिर्फ शांत अंक)

Comments

अपने गैंगस्टा शासन के बारे में: यह आमतौर पर "कार्यों" के पक्ष में हतोत्साहित किया जाता है, क्योंकि वे सामान्य रूप से परिभाषित करने में कठिन होते हैं। इसके अलावा, अमान्य इनपुट से निपटने से भी बचा जाता है, क्योंकि यह आमतौर पर कष्टप्रद बॉयलर-प्लेट कोड को उबालता है।

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

@JonathanFrech मुझे लगता है कि इनपुट सत्यापन की चुनौती एक दिलचस्प समस्या है, क्योंकि इसमें सरणी ट्रैवर्सल से लेकर ब्रांचिंग लॉजिक से लेकर RegEx परीक्षण तक कई तरह के काम संभाले जा सकते हैं, इसलिए इनका अनुकूलन अतिरिक्त चुनौती ¯_ (ツ) _ जोड़ सकता है। / :-) मैं कोशिश करूँगा कि एक और कोड गोल्फ चुनौती के लिए हालांकि :-)

— माइकल

हर कोई अपने पसंदीदा गोल्फ लैंग में कोड बनाने के लिए अधिक लचीले io तरीके प्राप्त करने की कोशिश कर रहा है। और लगभग सभी सवालों पर ऐसा होता है

— विंडमिल कुकीज़

चुनौतियों को लिखने से बचने के लिए चीजें (इनपुट सत्यापन) ।

— जो राजा

@NathanMerrill यह कल्पना में उल्लेख किया गया है कि इनपुट की लंबाई 7 वर्णों से अधिक होनी चाहिए और इसकी लंबाई चार से विभाज्य होनी चाहिए, जो किंग लंबाई 4 के एक परीक्षण मामले में प्रवेश करने का सुझाव दे रहा था, जैसे कि "abcd" जिसमें त्रुटि होनी चाहिए

— थफफी नो

Answer 1

के (ओके) , _{35 34} 33 बाइट्स

{$[8>#x;.;<x!4!-&4#-1 0 2+-4!#x]}

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

इनपुट सत्यापन के बिना (ngn's bounty के लिए), _{25 24} 23 बाइट्स

{<x!4!-&4#-1 0 2+-4!#x}

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

जल्दी से के को थोड़ा सीखा और क्रियाओं की सूची को देखते हुए, मैंने सोचा कि एक वैकल्पिक दृष्टिकोण ( नहीं) कट का उपयोग करना) यहां काम कर सकता है। और इसने पूरी तरह से काम किया।

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

{<x!4!-&4#-1 0 2+-4!#x}
                 -4!#x    Length divided by four (floor division)
        4#-1 0 2+         Generate lengths (x/4-1, x/4, x/4+2, x/4-1)
       &                  Generate that many 0, 1, 2, 3's
    4!-                   Negate and modulo 4; effectively swap 1 and 3
 <x!                      Sort the original string by above

{$[8>#x;.; <code> ]}  Input validation
 $[8>#x           ]   If the length is less than 8
        .             Dynamically generate an error
           <code>     Otherwise, run the main code

Comments

@ngn मेरी आँखों ऊ का क्या हुआ

— Bubbler

Answer 2

पर्ल 6 , 60 58 बाइट्स

-2 बाइट्स जो किंग को धन्यवाद

{[~] .rotor($_/4 X-1,0,+^-$_+>2,-1,1)[0,4,2,3,1;*]}o*.comb

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

त्रुटि के मामले में "रोटराइज़िंग सबलिस्ट की लंबाई सीमा से बाहर है"।

व्याख्या

{               # Anonymous block
 [~]            # Join
   .rotor(      # Split into sublists of specific length
     $_/4 X-    # Subtract from len/4
     1,
     0,
     +^-$_+>2,  # (len-1)>>2
                #   subtraction yields 1 if len is multiple of 4
                #   otherwise a value less than 1 causing an error
     -1,       
     1)
   [0,4,2,3,1;*]  # Rearrange sublists and take inner elements
}o*.comb          # Split into characters and feed into block

Answer 3

जे , ₃₆ 35 बाइट्स

5;@A.](<;.2~;)1<@{."+~1 0 _2 1-4%~#

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

-1 बाइट {.+ नकारात्मक लंबाई और;.2 इसके बजाय "समाप्त" मार्कर के रूप में लोगों को काटता है।

मूल उत्तर, 36 बाइट्स

5;@A.](<;.1~;)1<@{."+~_1 0 2 _1+4%~#

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

ngn ने पहले K उत्तर की टिप्पणी पर "कट" का उल्लेख किया , और इसने मुझे J की कोशिश की, जिसमें समान "कट" है (मुझे नहीं पता कि K कैसे काम करता है)।

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

5;@A.](<;.1~;)1<@{."+~_1 0 2 _1+4%~#  Monadic train.
                                4%~#  Length divided by four
                      _1 0 2 _1+      Generate the four segment lengths
              1<@{."+~  Generate [1 0 0...] boxed arrays of those lengths
      (     ;)          Raze; unbox and concatenate
     ] <;.1~            Cut the input string on ones as starting marker, then box each
5  A.  Rearrange the boxes in the order 0 3 2 1
 ;@    Raze again

ध्यान दें कि यह फ़ंक्शन स्वचालित रूप से अमान्य इनपुट संभालता है:

• यदि इनपुट लंबाई चार से अधिक नहीं है, तो {.फेंकता हैdomain error इसकी लंबाई तर्क पूर्णांक होने के बाद से ।
• यदि इनपुट लंबाई 4 है, तो कट केवल दो खंडों का उत्पादन करता है, और 5 A.फेंकता हैindex error ।
• यदि इनपुट लंबाई 0 है, तो काटने के लिए दो तर्क समान लंबाई नहीं है, इसलिए length errorफेंक दिया गया है।

Answer 4

पायथन 3 , 103 102 101 97 88 86 84 बाइट्स

def f(s):l=len(s);l//=4*(l%4<1<l/4);return s[:l-1]+s[1-l:]+s[2*l-1:1-l]+s[l-1:2*l-1]

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

वास्तव में वन-लाइनर नहीं, लेकिन ; लाइनब्रेक और इंडेंट की तुलना में प्रति पंक्ति एक बाइट कम है।

फेंकता ZeroDivisionError है, तो इनपुट स्ट्रिंग की लंबाई कम से कम 8 या नहीं 4 के एक पूर्णांक एकाधिक है।

पायथन 2 में भी काम करता है।

_{-4 किंग जोए को धन्यवाद}

_{-9 बाइट्स ओव्स के लिए धन्यवाद}

_{-2 बाइट्स जोनाथन फ्रेच को धन्यवाद}

_{-2 बाइट्स बब्बलर को धन्यवाद}

Comments

युक्तियों के लिए @JoKing धन्यवाद, बहुत सराहना की :)

— Axim

88 बाइट्स

— ओवीस

@ovs आसन्न अनुक्रमितों पर अच्छी पकड़ है, जैसा कि परेंसियों के लिए है, मैंने कम से कम 20 मिनट तक यह देखने की कोशिश की कि क्या मैं उनमें से कुछ से छुटकारा पा सकता हूं, तो मैं पूरी तरह से चूक गया कि //=बाहरी जोड़ी में परिवर्तन के साथ बेमानी हो गया। बहुत बहुत धन्यवाद!

— Axim

-l+1<-> 1-l?

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

84 बाइट्स के लिए दो असमानताओं को मिलाएं ।

— बुबलर

Answer 5

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

*.comb[0..*/4-2,3* */4+1..*,*/2-1/(*>7)..3* */4,*/4-1/(*%%4)..*/2-2].flat.join

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

अनाम कोड ब्लॉक जो एक स्ट्रिंग लेता है और यदि वैध है तो संशोधित स्ट्रिंग लौटाता है, अन्यथा शून्य त्रुटि द्वारा एक विभाजन लौटाता है। मुझे पता है कि मैं एक सरणी को सीधे संशोधित कर सकता हूं, इसलिए मैं स्ट्रिंग के दो खंडों को स्वैप कर सकता हूं, लेकिन मैं इसे समझ नहीं सकता।

Answer 6

कश्मीर (NGN / ट) , 120 113 103 99 95 बाइट्स

{$[(r>7)&0=4!r:#:x;{g:(s:*|(y*2)#x)\x;((y-1)#*g),((-y-1)#*|g),s,((y+1)#*|g),(-y)#*g}[x;r%4];l]}

उम्मीद है कि अधिक नीचे गिराया जा सकता है, परीक्षण के लिए एक अतिरिक्त कार्य शामिल है यदि स्ट्रिंग की लंबाई चार से विभाज्य है, तो इनपुट अमान्य होने पर अघोषित चर के संदर्भ में त्रुटि उत्पन्न करता है।

संपादित करें: 7 से अधिक की लंबाई पर छूटी हुई स्थिति, शामिल

संपादित करें: एक फ़ंक्शन में संयुक्त, निरर्थक चर घोषणाओं को हटा दिया गया

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

Comments

यह बहुत छोटा हो सकता है। क्या आप "कट" ( indices_string) के बारे में जानते हैं ? मुझे बाग में पिंग करो अगर मैं यह व्याख्या करनी चाहिए

— NGN

मैं इसे 34 बाइट्स में कर सकता हूं :)

— ngn

मैं कटौती के बारे में जानता हूं, लेकिन मैंने इसका उपयोग करने के बारे में नहीं सोचा ... 34 बाइट्स ?! जब मैं घर जाऊंगा और यह देखने

— जाऊंगा

मुझे उल्लेख करना चाहिए: मेरा समाधान यह सुनिश्चित नहीं करता है कि अमान्य इनपुट (लंबाई <= 7) एक त्रुटि का कारण है

— ngn

Answer 7

रेटिना 0.8.2 , 58 या 73 या 83 या 93 बाइट्स

((((.)))*?)(.(?<-2>.)+)(...(?<-3>.)+)((?<-4>.)+)$
$1$7$6$5

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

((((.)))*?)

कब्जा a में $1है, और संभव के रूप में कम के रूप में यह कर *?। $#2, $#3और $#4की लंबाई के रूप में अंत a।

(.(?<-2>.)+)

कैद bमें $4। की (?<-2>.)+लंबाई तक कैप्चर करता है a, जबकि दूसरा .आवश्यकतानुसार अपनी लंबाई में 1 जोड़ता है।

(...(?<-3>.)+)

कैद sऔर cमें $6। उनकी संयुक्त लंबाई लंबाई की तुलना में तीन अधिक है a।

((?<-4>.)+)

कैद dमें $7। इसकी लंबाई लंबाई से अधिक नहीं है a।

$

हमने aयथासंभव छोटा कर दिया , लेकिन हम अभी भी इनपुट के अंत तक पहुंचना चाहते हैं।

$1$7$6$5

विनिमय bऔर d।

उपरोक्त चरण इसके इनपुट को मान्य नहीं करता है। चूंकि रेटिना में कोई रन-टाइम त्रुटियां नहीं हैं, इसलिए इनपुट सत्यापन के लिए कई विकल्प हैं:

G`^(....){2,}$

आउटपुट कुछ भी नहीं अगर लंबाई 8 से कम है या 4. 4 से अधिक नहीं है (+15 बाइट्स)

^(?!(....){2,}$).*
Error

आउटपुट Errorयदि लंबाई 8 से कम है या 4 के गुणक से अधिक नहीं है तो (+25 बाइट्स)

+`^(....)*..?.?$|^(....)?$
.....$1

यदि लंबाई 8 से कम है या 4 के 4 से अधिक नहीं है तो लटका हुआ है (+35 बाइट्स)

Comments

यह अमान्य इनपुट्स (जैसा कि कष्टप्रद है) पर कोई त्रुटि नहीं फेंकता है

— Jo King

Answer 8

सी (जीसीसी) के साथ -Dx=memcpyऔर -DL=(l-1), 154 158 160 बाइट्स

यदि इनपुट स्ट्रिंग की लंबाई 4 या 8 वर्णों से कम नहीं है, तो NULL लौटाता है।

सुझाव के लिए रोजम और जोनाथन फ्रेच को धन्यवाद।

संपादित करें: पूर्वप्रक्रमक कमांड लाइन को परिभाषित करता है और स्ट्रिंग को गतिशील रूप से आवंटित किया जाता है ताकि यह पहेली के साथ सख्ती से अनुरूप हो सके।

f(s,t,l)char*s,*t;{l=strlen(s);l%4|l<8?t=0:(t=malloc(l+1),l/=4,x(t,s,L),x(t+L,s+3*l+1,L),x(t+2*L,s+L+l,l+2),x(t+3*l,s+L,l),t[4*l]=0);l=t;}//-Dx=memcpy -DL=(l-1)

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

Comments

क्यों t[80]? इनपुट लंबाई के संबंध में ऊपरी सीमा नहीं लगती है।

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

@JonathanFrech मैंने बाइट्स बचाने के लिए ऐसा किया था लेकिन आप सही हैं। मैंने malloc()इसके बजाय उपयोग करने के लिए समाधान बदल दिया है ।

— ErikF

संशोधन द्वारा रिटर्न, रिटर्न वैल्यू NULLअमान्य आउटपुट के लिए है, memcpy()प्रकारों को छोड़ने के लिए फ़ंक्शन-जैसे मैक्रो का उपयोग करता है , प्रकार और C99 चर-लंबाई सरणियों को छोड़ने के लिए malloc()।

क्यों 160 बाइट्स, आप गिनती //या -w?

— l4m2

@ l4m2 -wचेतावनी को दबाने के लिए सिर्फ एक सुविधा है (ताकि त्रुटियों को ढूंढना आसान हो)। मैं आमतौर //पर TIO को मेरे लिए अपनी बाइट्स गिनने के बाद कमांड लाइन की दलीलें जोड़ता हूं, और फिर एक अतिरिक्त चरित्र के लिए कुल में से 1 को घटा देना चाहिए।

Answer 9

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

L7»4ḍİ×L:4;;ĖÄƲFÄœṖ⁸⁽%[D¤ị$F

(यदि एक पूर्ण कार्यक्रम की अनुमति है तो हम अनुगामी को निकाल सकते हैं F)
यदि लंबाई 8 से कम है या चार से विभाज्य नहीं ValueErrorहै, तो पूर्णांक विभाजन inf(एक फ्लोट) के दौरान 4- विभाजन पैदावार NaN(एक फ्लोट) के दौरान उठाया जाता है, जो तब नहीं हो सकता है में डाल दिया जाए int।

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

कैसे?

L7»4ḍİ×L:4;;ĖÄƲFÄœṖ⁸⁽%[D¤ị$F - Link: list of characters
L                            - length
 7                           - literal seven
  »                          - maximum (of length & 7)
   4ḍ                        - divisible by four? (yields 1 for good inputs; 0 otherwise)
     İ                       - inverse (1 yields 1; 0 yields inf)
      ×L                     - multiply by length (length or inf)
        :4                   - integer divide by 4 (errors given inf)
              Ʋ              - last four links as a monad (f(x)):
          ;                  -   concatenate -> [x,x]
            Ė                -   enumerate -> [1,x]
           ;                 -   concatenate -> [x,x,[1,x]]
             Ä               -   cumulative sum (vectorises at depth 1) -> [x,x,[1,1+x]]
               F             - flatten -> [x,x,1,1+x]
                Ä            - cumulative sum -> [x,2x,2x+1,3x+2]
                   ⁸         - chain's left argument (the input)
                 œṖ          - partition at indices (chops up as per requirements)
                          $  - last two links as a monad (f(z)):
                        ¤    -   nilad followed by link(s) as a nilad:
                    ⁽%[      -     10342
                       D     -     decimal digits -> [1,0,3,4,2]
                         ị   -   index into z (rearranges the pieces as per requirements)
                           F - flatten (back to a list of characters)

Answer 10

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

L:4’+“¡¢¢£¡‘Ṡ3¦ÄṬk⁸Ṛ2,5¦Ẏ

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

Ẏएक पूर्ण कार्यक्रम में यह सुनिश्चित करने के लिए हटाया जा सकता है।

Answer 11

रूबी , 64 बाइट्स

->s{a=s.size/4;s[1-a,a],s[a-1,a]=s[a-1,a],s[1-a,a];s[a*4]?1/0:s}

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

Answer 12

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

@ L4m2 के लिए 8 बाइट्स को सहेजा गया

s=>(l=s.length/4)<2||l%1?Z:s.replace(eval(`/(.{${l}})(.{${l+2}})(.{${l-1}})$/`),'$3$2$1')

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

Comments

89B

— l4m2

Answer 13

जावास्क्रिप्ट (Node.js) , 80 बाइट्स

s=>(g=s.substr.bind(s))(0,l=s.length/4-1)+g(-l)+g(l-~l,l+3)+g(l,l+1,l<1==l%1||Z)

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

जावास्क्रिप्ट (Node.js) , 84 बाइट्स

s=>(g=(a,b)=>s.substr(a,b))(0,l=s.length/4-1)+g(-l)+g(l-~l,l+3)+g(l,l+1,l<1==l%1||Z)

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

जावास्क्रिप्ट (Node.js) , 87 बाइट्स

s=>(l=s.length/4)<2||l%1?Z:(g=(a,b)=>s.substr(a,b))(0,l-1)+g(1-l)+g(l+l-1,l+2)+g(l-1,l)

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

RegExp से छोटा

Answer 14

जावा 8, 135 बाइट्स

s->{int l=s.length();l=l>7&l%4<1?l/4:l/0;return s.substring(0,l-1)+s.substring(3*l+1)+s.substring(2*l-1,3*l+1)+s.substring(l-1,2*l-1);}

ArithmeticExceptionयदि इनपुट स्ट्रिंग आवश्यकताओं से मेल नहीं खाता है तो फेंकता है (शून्य से विभाजित)। इसे यहाँ ऑनलाइन आज़माएँ ।

Ungolfed:

s -> { // lambda function taking a String argument and returning a String
    int l = s.length(); // take the length of the input ...
    l = l > 7 &         // ... if it's  greater than 7 and ...
        l % 4 < 1       // ... a multiple of 4 ...
      ? l / 4           // ... divide by 4; otherwise ...
      : l / 0;          // ... error out (division by zero throws ArithmeticException)
    return // concatenate and return:
           s.substring(0, l - 1)             // a
         + s.substring(3 * l + 1)            // d
         + s.substring(2 * l - 1, 3 * l + 1) // sc
         + s.substring(l - 1, 2 * l - 1);    // b
}

Comments

l/=l>7&l%4<1?4:0;इसके बजाय सुझाव देंl=l>7&l%4<1?l/4:l/0;

— छत पर 2

Answer 15

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

संशोधन द्वारा लौटाता है। संकलन:

-Df(s)=({char t[l=strlen(s)];l%4|l<8?0:(l/=4,x(t,s+l*2-1,l-~l),x(x(x(s+l*3,s+l-1,l)-l-2,t,l+2)-l+1,t+l+2,l-1),s);}) -Dx=memcpy

मूल फाइल:

l;

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

Degolf

-Df(s)=({ // Function-like macro f. Takes a char* as a parameter.
          // Return value is a pointer to s if successful, and to NULL if string was invalid.
     char t[l=strlen(s)]; // Allocate a local temp string.
     l%4|l<8?0: // Detect invalid strings. Return 0 (NULL) on invalid string.
         (l/=4, // We're only really concerned with floor(len/4), and this will yield that.
             memcpy(t,s+l*2-1,l-~l), // Copy the second half of chars to the temp storage.
             memcpy( // Because memcpy returns the address of the destination, we can chain
                     // the calls to save quite a few bytes, even after x->memcpy substitution.
                 memcpy(memcpy(s+l*3,s+l-1,l) // Next, copy the second quarter to the end.
                     -l-2,t,l+2) // After that, we copy back the third quarter to its place.
                          -l+1,t+l+2,l-1) // Finally, copy the fourth quarter to where the second
                                          // quarter was.
                      ,s);}) // And return the pointer.