रिक्त स्थान में भरना

Question

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

I went to the ____ store and bought ____ today.

यदि हमने इस फ़ंक्शन को स्ट्रिंग पर लागू किया cheeseतो परिणाम होगा:

I went to the cheese store and bought cheese today.

हम इन कार्यों को स्ट्रिंग की एक गैर-खाली सूची के रूप में दर्शा सकते हैं, जहां रिक्त स्थान केवल तार के बीच अंतराल हैं। उदाहरण के लिए ऊपर हमारा कार्य होगा:

["I went to the ", " store and bought ", " today."]

इस प्रतिनिधित्व के साथ इस प्रकार के प्रत्येक फ़ंक्शन के लिए केवल एक प्रतिनिधित्व है और प्रत्येक प्रतिनिधित्व के लिए केवल एक फ़ंक्शन है।

वास्तव में साफ-सुथरी बात यह है कि ऐसे कार्यों का सेट रचना के तहत बंद है। यह कहना है कि हमारे दो कार्यों की रचना हमेशा इन कार्यों में से एक है। उदाहरण के लिए अगर मैं ऊपर के साथ हमारे फ़ंक्शन की रचना करता हूं

["blue ", ""]

( blueइनपुट के लिए तैयार होने वाला फंक्शन) हमें फंक्शन मिलता है:

["I went to the blue ", " store and bought blue ", " today."]

ये हालांकि थोड़ा अधिक जटिल हो सकते हैं। उदाहरण के लिए अगर हम पहले फंक्शन को कंपोज़ करते हैं

["big ", " and ", ""]

परिणाम है

["I went to the big ", " and ", " store and bought big ", "and", " today."]

कार्य

आपका कार्य स्ट्रिंग्स की गैर-रिक्त सूची के रूप में वर्णित दो कार्यों को लेना है और उनकी रचना को स्ट्रिंग की गैर-रिक्त सूची के रूप में आउटपुट करना है।

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

यह कोड-गोल्फ उत्तर है बाइट्स में कम बाइट के साथ बेहतर स्कोर किया जाएगा।

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

["","xy"] ["ab",""] -> ["ab","xy"]
["x","y","z"] ["a","b"] -> ["xa","bya","bz"]
["xy"] ["ab"] -> ["xy"]
["","",""] ["a",""] -> ["a","a",""]
["x",""] ["","",""] -> ["x","",""]
["x","y","z"] ["a","b","c"] -> ["xa","b","cya","b","cz"]
["x","x","x"] ["a"] -> ["xaxax"]
["w","x","y","z"] ["ab","cd","e"] -> ["wab","cd","exab","cd","eyab","cd","ez"]

Comments

यदि कोई गैर-मुद्रण योग्य ASCII वर्ण इनपुट (SOH, TAB या LF, उत्तर पर निर्भर करता है) में उपयोग किया जाता है, तो सभी 3 मौजूदा उत्तर विफल हो जाते हैं। इसलिए मुझे लगता है कि आपको वास्तव में यह तय करना चाहिए कि इनपुट मुद्रण योग्य ASCII तक ही सीमित है या नहीं।

— अरनुलद

@ अर्नुलद ठीक है अब तक यह अप्रतिबंधित है और मैंने इसे बदलने का कोई कारण नहीं देखा है, इसलिए यह बना रहेगा।

— पोस्ट रॉक गार्फ हंटर

@KevinCruijssen मेरा शून्य के बाद से मान्य चरित्र नहीं है। लकी लैंग्वेज फीचर की मदद

— जोनाथन एलन

@ SriotchilismO'Zaic मेरा 05AB1E नई सुर्खियों में शामिल हो रहा था। जावास्क्रिप्ट और हास्केल उत्तर टैब द्वारा शामिल हो रहे हैं / विभाजित हो रहे हैं, अनपेक्षित वर्ण `` (एसओएच) द्वारा सी # उत्तर, इसलिए वे सभी अमान्य भी हैं। मैं पर्ल 5 को अच्छी तरह से नहीं जानता, हालांकि। ताकि कोई वैध हो सके।

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

@ रमन आप यह नहीं मान सकते हैं कि कोई भी वर्ण इनपुट में दिखाई नहीं देगा ताकि आप इसे एक विभाजक के रूप में उपयोग कर सकें। आपको वास्तव में चुनौती का समाधान करना चाहिए।

— पोस्ट रॉक गार्फ हंटर

Answer 1

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

j0j@ṣ0

एक dyadic लिंक को स्वीकार करने के लिए पहले पर समारोह प्रतिनिधित्व सही और दूसरे पर समारोह प्रतिनिधित्व बाईं जो पैदावार जिसके परिणामस्वरूप समारोह प्रतिनिधित्व। प्रत्येक फ़ंक्शन प्रतिनिधित्व वर्णों की सूची की एक सूची है (जेली में कोई अन्य तार नहीं है)।

इसे ऑनलाइन आज़माएं! (पायथन नोटेशन में पूर्ण-प्रोग्राम तर्क दिए गए हैं; तार सूचियाँ बन जाते हैं। पाद लेख लिंक के आउटपुट का पायथन प्रतिनिधित्व दर्शाता है।)

यहां एक परीक्षण-सूट है जो इनपुट की तरह लिंक के आउटपुट में सुधार करता है।

कैसे?

स्थान-धारक के रूप में पूर्णांक शून्य का उपयोग करके जेली की मिश्रित प्रकार की सूचियों का संपूर्ण डोमेन प्रतिनिधित्व (वर्णों की सूची की कोई भी सूची) की अनुमति देता है:

j0j@ṣ0 - Link: b, a        e.g.    b = [['a','b'],['c','d'],['e']]
       -                   ...and  a = [['w'],['x'],['y'],['z']]
                             (i.e. test-case ["w","x","y","z"] ["ab","cd","e"])
j0     - join b with zeros         ['a','b',0,'c','d',0,'e']    
  j@   - join a with that          ['w','a','b',0,'c','d',0,'e','x','a','b',0,'c','d',0,'e','y','a','b',0,'c','d',0,'e','z']
    ṣ0 - split at zeros            [['w','a','b'],['c','d'],['e','x','a','b'],['c','d'],['e','y','a','b'],['c','d'],['e','z']
                             (i.e.: ["wab","cd","exab","cd","eyab","cd","ez"])

---

अगर हमें जेली की किसी भी मिश्रित सूची (किसी भी गहराई या आकृति वाले) से निपटने की आवश्यकता है, तो हम इस आठ बेटर का उपयोग कर सकते हैं: j,©⁹jœṣ®जो स्थान-धारक के रूप में युग्मित तर्कों का उपयोग करता है।

Answer 2

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

(a:b:r)#t@(x:s)|s>[]=(a++x):init s++((last s++b):r)#t|z<-a++x++b=(z:r)#t
x#_=x

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

Answer 3

पायथन 3.8 (पूर्व-रिलीज़) ,  60  58 बाइट्स

lambda a,b:(v:='&'.join(a+b)+'$').join(b).join(a).split(v)

एक अनाम फ़ंक्शन स्ट्रिंग्स की दो सूचियों को स्वीकार करता है, a और b, जो स्ट्रिंग्स की एक सूची देता है।

इसे ऑनलाइन आज़माएं!या परीक्षण-सूट देखें ।

कैसे?

पहले एक विभाजक स्ट्रिंग बनाता है v, जो अंदर aया नहीं पाया जा सकता है b। फिर की bप्रतियां के साथ तार में शामिल होकर एक स्ट्रिंग बनाता हैv । फिर aउस की प्रतियों के साथ तार को जोड़कर एक स्ट्रिंग बनाता है। अंत vमें तार की सूची देने के लिए उस स्ट्रिंग को विभाजित करता है ।

हालांकि यह सुनिश्चित vनहीं है aया bहमें यह भी सुनिश्चित करना चाहिए कि vअभ्यस्त हमें उस मामले में जल्दी विभाजित कर दें जहां सभी तार समान हैं aऔर bसमान हैं। ऐसा करने के लिए हम vएक स्ट्रिंग के उदाहरण (दोनों) के साथ दोनों सूचियों में सभी तारों को '&'जोड़कर बनाते हैं और एक अतिरिक्त, अलग चरित्र (यहां '$') जोड़ते हैं । ध्यान दें कि या तो अलगाव में करना पर्याप्त नहीं है क्योंकि इनपुट में सभी तार चुने हुए चरित्र के बराबर हो सकते हैं।

Comments

क्या आप एक उदाहरण इनपुट दे सकते हैं जहाँ &आवश्यकता है? और उपयोग ''.join(a+b)+'$'करना पर्याप्त नहीं है?

— पोस्ट रॉक गार्फ हंटर

यह मुझे थोड़ी देर लगी लेकिन ['$','$'] ['$','$']एक होगी।

— पोस्ट रॉक गार्फ हंटर

हाँ, यदि सभी तार चुने गए '$'चरित्र के बराबर हैं और परिणाम एक स्ट्रिंग से अधिक होगा, तो हमें जल्दी से विभाजित होने से बचने के लिए एक अलग चरित्र की आवश्यकता होगी।

— जोनाथन एलन

Answer 4

05AB1E , 4 15 19 9 11 बाइट्स

«TýR©ý¹sý®¡

जेली उत्तर के विपरीत, 05AB1E के स्ट्रिंग "0", पूर्णांक 0और फ्लोट 0.0सभी (कुछ हद तक) समान हैं, इसलिए मैं पूर्णांक द्वारा विभाजित / शामिल नहीं हो सकता। यही कारण है कि वर्कअराउंड के रूप में हमारे पास +15 बाइट्स थे, हालांकि मैंने इसे 9 बाइट्स में वापस कर दिया है। 2 कीड़े खोजने के लिए @JonathanAllan को धन्यवाद ।

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

स्पष्टीकरण:

«            # Merge the two (implicit) input-lists together
 Tý          # Then using a "10" delimiter join all strings together
   R         # Reverse this string
    ©        # Store this string in variable `®` (without popping)
     ý       # Use this string as delimiter to join the second (implicit) input-list
      ¹sý    # Then join the first input-list by this entire string
         ®¡  # And split it back on variable `®` so it's the expected list of strings
             # (after which this result is output implicitly)

Comments

यह विफल हो जाता है यदि इनपुट में नई लाइनें हैं (ओपी ने कहा है कि इनपुट वर्तमान में अप्रतिबंधित है)।

— आउटगॉल्फ जूल

@EriktheOutgolfer हर दूसरे उत्तर में एक ही मुद्दा होता है btw।

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

@EriktheOutgolfer निश्चित रूप से कुछ और गोल्फ हो सकता है, लेकिन अभी के लिए एक त्वरित और गंदे तय किया है।

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

उह, इस बारे में क्षमा करें ... यह काम नहीं करेगा अगर इनपुट सूचियों में केवल नई सीमाएँ हैं: (यह जल्दी विभाजित होगा)

— जोनाथन एलन

@JonathanAllan Lol .. आह ठीक है, मुझे लगता है कि मैं केवल इन बग्स को ढूंढने के लिए आपका धन्यवाद कर सकता हूं .. मुझे उम्मीद है कि यह अब तय हो गया है और आपको कुछ और नहीं मिलेगा .. हालांकि मुझे लग रहा है कि आप हो सकते हैं ..

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

Answer 5

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 62 61 बाइट्स

""<>#&/@Flatten[#~(R=Riffle)~I/.I->#2~R~I]~SequenceSplit~{I}&

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

-1 रोमन को धन्यवाद

---

हालांकि यह एक वैध उत्पादन नहीं है, यह एक ऐसा फ़ंक्शन देता है जो वास्तव में काम करता है .. (34 बाइट्स)

(g=a""<>a~Riffle~#&)[#]@*g[#2]&

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

Comments

रीसाइक्लिंग द्वारा 61 बाइट्सRiffle ।

— रोमन

Answer 6

Japt , 8 बाइट्स

Adapts जोनाथन का दृष्टिकोण ।

qVqN²)qN

कोशिश करो

qVqN²)qN     :Implicit input of arrays U & V (N=[U,V])
q            :Join U with
 Vq          :  V joined with
   N²        :    Push 2 to N (modifying the original), which gets coerced to a string
             >     e.g., N=[["a","b"],["c","d"]] -> N=[["a","b"],["c","d"],2] -> "a,b,c,d,2"
     )       :End join
      qN     :Split on the modified N, which, again, gets coerced to a string
             > e.g., N=[["a","b"],["c","d"],2] -> "a,b,c,d,2"

Comments

Nइस मामले में क्या है ? अगर मैं इसे सही ढंग से समझता हूं (TryIt- लिंक की खोज कार्यक्षमता का उपयोग करके), यह Nदो बार दोहराता है ( N²)। यह तब दूसरे इनपुट V( VqN²) में शामिल होने के लिए उपयोग करता है , और फिर उस पूरे स्ट्रिंग का उपयोग पहले (अंतर्निहित) इनपुट U( q...)) में शामिल होने के लिए करता है । और अंत में परिणामी स्ट्रिंग को विभाजित करता है N( qN)। लेकिन Nइस मामले में क्या है ?

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

आह रुको, मुझे लगता है कि मैंने p(...)खोज में गलत तरीके को देखा है । यह 2दोनों निविष्टियों को जोड़े रखता है जो एक साथ नहीं है। केवल इसमें N²परिणाम होता है [["w","x","y","z"],["ab","cd","e"],2]और यह उस पूरी सूची का उपयोग करता है। अंतिम उस मामले में परिणाम-सूची पर क्यों qNनहीं छोड़ता है 2? या N²मूल को संशोधित करता है N?

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

@ केविनक्रूजसेन ने एक स्पष्टीकरण जोड़ा, लेकिन आपने बहुत सोचा है कि यह पता चला है। और, हाँ, pushजेएस में एक सरणी के लिए तत्वों को मूल सरणी को संशोधित करता है।

— झबरा

Answer 7

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

[a]#(c:d)=(a++c):d
(a:b)#c=a:b#c
[a]%b=[a]
(a:b)%c=[a]#c#(b%c)

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

यहाँ मेरा हास्केल जवाब है। यह किसी भी प्रकार की सूची पर काम करता है।

Answer 8

जे , ^{44 43 42} 29 बाइट्स

_<;._1@,(;@}:@,@,.(,_&,)&.>/)

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

-13 बाइट मील के लिए धन्यवाद!

यह दृष्टिकोण पूर्णांक का उपयोग करता है और मील के कारण होता है।

तार के साथ मूल दृष्टिकोण

g=.[:}.@,,.
f=.(<@0<@;;._1@,];@g<"0@[)<@0<@g]

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

नोट: मैंने खाते के लिए TIO से -3 को समायोजित कर लिया है f=.

जोनाथन एलन की विधि का उपयोग करता है, जे के लिए अनुकूलित।

यह आश्चर्यजनक रूप से गोल्फ के लिए मुश्किल था, क्योंकि J में "जॉइन" विधि नहीं है, और मैं यह देखने के लिए उत्सुक हूं कि क्या इसमें काफी सुधार हो सकता है।

g सहायक क्रिया है जो हमें "जॉइन" करती है

Comments

इनपुट के रूप में पूर्णांक की सूची के साथ काम करना, मुझे एक 29 चर समाधान मिला , _<;._1@,(;@}:@,@,.(,_&,)&.>/)अनंत _को सेंटिनल मान के रूप में उपयोग करता है यह जानने के लिए कि कहां विभाजन करना है <;._1। ज्वाइनिंग पहले /एक बड़े बॉक्स को बनाने के लिए कम का उपयोग करके की जाती है , फिर इसकी सिर्फ शेपिंग होती है।

— मील

यह प्रभावशाली है। धन्यवाद @ मीलों। यह निश्चित रूप से महसूस हुआ कि सुधार करने के लिए जगह थी, लेकिन मैंने नहीं देखा कि कैसे।

— जोनाह

@ मीलों g&.:(a.&i.&.>)बाइट्स की ओर गिनती नहीं होनी चाहिए या क्या मुझे कुछ याद आ रहा है?

— जोनाह

ओपी ने उल्लेख किया कि इनपुट पात्रों की सूची के रूप में या पूर्णांकों की सूची के रूप में हो सकता है, ताकि सहायक कार्य केवल चार सरणियों के बक्से से आसान सरणियों के बॉक्स को आसानी से देखने के लिए परिवर्तित किया जा सके

— मील

आह मैं भूल गया कि, धन्यवाद

— योना

Answer 9

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

([a,...b],[c,...d])=>b.map(e=>r.push(r.pop(r.push(r.pop()+c,...d))+e),r=[a])&&r

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

Answer 10

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

जोनाथन के दृष्टिकोण को भी स्वीकार करता है ।

a=>b=>a.join(b.join(a+=b+0)).split(a)

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

Answer 11

पर्ल 5 (-lp ), 20 बाइट्स

जैसा कि @JonathanAllan ने टिप्पणी की, यह IO के लिए एक पूर्ण-कार्यक्रम है, सूची विभाजक के रूप में एक टैब और दो सूचियों को अलग करने के लिए एक नई पंक्ति।

chop($n=<>);s/  /$n/g

TIO

टैब और न्यूलाइन को इसलिए चुना गया क्योंकि परीक्षण मामलों की जांच करने के लिए अधिक सुविधाजनक, अन्यथा गैर-मुद्रण योग्य वर्णों में बदला जा सकता है \1और\2 ।

( -02l012p)

chop($n=<>);s//$n/g

TIO

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

• -02 : इनपुट रिकॉर्ड विभाजक सेट करने के लिए \2
• -l: डिफ़ॉल्ट विभाजक से इनपुट विभाजक को हटाने के लिए $_और आउटपुट रिकॉर्ड विभाजक को डिफ़ॉल्ट आउटपुट में जोड़ने के लिए
• -012: आउटपुट रिकॉर्ड विभाजक को \012( \n) पर सेट करना ताकि आउटपुट चेक करना आसान हो

• -p : डिफ़ॉल्ट तर्क मुद्रित करने के लिए

• $n=<>; : अगले रिकॉर्ड को पढ़ने और असाइन करने के लिए $n

• chop$n; : सेपरेटर को हटाने के लिए $n
• s/\x1/$n/g: के \1साथ सभी घटनाओं को बदलने के लिए$n

Comments

मेरा पर्ल लगभग न के बराबर है, लेकिन मेरा मानना ​​है कि यह एक पूर्ण-कार्यक्रम का उपयोग कर रहा है, IO के लिए, एक सूची विभाजक के रूप में एक टैब और दो सूचियों को अलग करने के लिए एक नई पंक्ति। यह इन पात्रों के साथ इनपुट को कैसे स्वीकार कर सकता है?

— जोनाथन एलन

@JonathanAllan, आप सही हैं, मेरे पास स्पष्टीकरण जोड़ने का समय नहीं था जब मैं सबमिट करने की कोशिश करूंगा

— नाहुएल फौइउल

Answer 12

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

@ बस्ती के लिए 3 बाइट्स को सहेजा गया

यह सभी पात्रों का समर्थन करने के लिए लुइस के उत्तर (अब हटाए गए) का एक निश्चित संस्करण है ।

a=>b=>a.map(e=escape).join(b.map(e)).split`,`.map(unescape)

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