तीसरा स्ट्रिंग

Question

दो तारों को देखते हुए, एक तीसरी स्ट्रिंग का उत्पादन होता है जो दोनों इनपुट्स में से किसी के बराबर नहीं है, लेकिन दोनों इनपुट्स की समान लंबाई (अक्षरों में) है। कम से कम एक वैध आउटपुट होने की गारंटी है।

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

टेस्ट मामलों को यह दिखाने के लिए उद्धृत किया जाता है कि वे तार हैं। आउटपुट कई संभावितों में से एक हैं।

input, input -> output

"test", "test" -> "tttt"
"do", "don't" -> "dnut_"
"ye s", "yes" -> "fals"
"yes", "yes" -> "noo"
"maybe", "mayue" -> "false"
"false", "false" -> "truee"
"false", "true" -> "fatr"
"1", "" -> "0"
"", "t" -> "s"
"", "abcabc" -> "testst"
"abcdefghijklmnopqrstuvwxyz", "aaaaaaaaaaaaaaaaaaaaaaaaaa" -> "zbcdefghijklmnopqrstuvwxya"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" -> "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"

नियम

• आपने अपना इनपुट डोमेन चुना हो सकता है, लेकिन यह कम से कम मुद्रण योग्य ASCII से बना होना चाहिए, और आपका आउटपुट डोमेन आपके इनपुट डोमेन के समान होना चाहिए।
• इनपुट की लंबाई समान या अलग हो सकती है।
• आउटपुट संभावना 1 के साथ मान्य होना चाहिए; वह यह है कि, आप एक वैध होने तक यादृच्छिक तार उत्पन्न कर सकते हैं (और सैद्धांतिक रूप से आप अनंत लूप हो सकते हैं), लेकिन आप सिर्फ एक यादृच्छिक स्ट्रिंग का उत्पादन नहीं कर सकते हैं और आशा है कि यह मान्य है। ध्यान दें कि इसका मतलब है कि आपको आउटपुट नियतात्मक होने की आवश्यकता नहीं है।
• स्वचालित अनुगामी न्यूलाइन्स की अनुमति है, लेकिन वे आउटपुट की लंबाई की ओर नहीं आते हैं।
• मेमोरी एरर के संबंध में सवालों के कारण, यह इनपुट लंबाई तक 60 सेकंड के भीतर काम करना चाहिए 6। एक उत्तर जो उसके लिए काम करता है और सैद्धांतिक रूप से लंबे समय तक तार के लिए काम करता है, ठीक है, लेकिन इनपुट लंबाई के लिए आधुनिक कंप्यूटर पर मेमोरी त्रुटियां कुछ 4मान्य नहीं है।

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।

Comments

ऐसा लगता है कि इस साइट पर सवालों की एक दिलचस्प नई श्रेणी है जो मनुष्यों के लिए आसान है और कंप्यूटर के लिए कठिन है। क्योंकि कंप्यूटर डाइवर्जेंट सोच में अच्छे नहीं हैं! यह मुझे Spongebob प्रकरण की याद दिलाता है जहां वह सारी रात एक निबंध लिखने की कोशिश कर रहा है जो स्टॉपलाइट पर नहीं करना है।

— geokavel

मैं समझता हूं कि आउटपुट डोमेन इनपुट डोमेन का सबसेट हो सकता है, हां?

— लुइस मेन्डो

अच्छा प्रश्न! मुझें यह पसंद है।

— isaacg

@Quelklef नहीं, यह दोनों इनपुट से अलग नहीं है।

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

मेरा सुझाव है कि "", "1" को एक परीक्षण मामले के रूप में जोड़ा जाना चाहिए, क्योंकि मुझे एहसास हुआ कि मेरा उत्तर इसके लिए विफल रहता है, भले ही यह सभी प्रदान किए गए परीक्षण मामलों के लिए काम करता है

— धीमे लोरिस

Answer 1

05AB1E , 8 7 बाइट्स

øvAyм¬?

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

Comments

क्या यह काम तब होता है जब एक इनपुट खाली स्ट्रिंग है?

— बीटावर्क्स

अगर पहला तार खाली है तो काम नहीं करता है। टीआईओ

— जो किंग

Answer 2

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

x!y=[s|s<-(<$max x y)<$>"abc",s/=x,s/=y]!!0

अधिकतम (लेक्सिकोग्राफ़िक रूप से बाद में) स्ट्रिंग लेता है, जिसे हम जानते हैं कि गैर-रिक्त है; "a", "b", और "c" का उपयोग करके सभी वर्णों को प्रतिस्थापित करता है <$; और पहला है कि न तो आदानों का है। मुझे लगता है कि यह नील के चारकोल जवाब और / या जियोकॉवेल के सीजेम उत्तर के समान है ।

(मैं थोड़ी देर के लिए दुबक गया लेकिन यह इस साइट पर जवाब देने वाला मेरा पहला मौका है; हाय!)

Answer 3

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

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

ऑनलाइन कोड चलाएँ (ध्यान दें कि "डायनेमिक मेमोरी" को नीचे-दाएं में चुना जाना चाहिए)

बहुत बढ़िया चुनौती! मुझे लगा कि यह तुच्छ होगा, लेकिन यह वास्तव में मुश्किल हो रहा है। मैं इसके लिए वापस आ रहा हूं क्योंकि मुझे लगता है कि कुछ सुरुचिपूर्ण 20-या-तो-बाइट बीएफ समाधान होना चाहिए । इस बिंदु पर, मैं बहुत खुश हूं (प्रतीत होता है) इसे बीएफ में काम करने के लिए मिला।

इनपुट को str1+ \0+ के रूप में लिया जाता है str2, जहां तार लगातार गैर-शून्य 1-बाइट वर्ण होते हैं।

लौटता है (first str1 + first str2) or (first str1 + 1) or 2। यह एल्गोरिथ्म शानदार @ brokenrjanJohansen, (संभवतः) मेरे (टूटे हुए) मूल के आधार पर सोचा गया था।

टिप्पणी की:

# Let (Kn) be the nth character of K
# Let (^) designate the pointer
# Let F be the first string inputted
# Let S be the second string inputted

+>+[-  # Twice do
,[>>,]  # Input string (characters separated by 1)
<<[<<]>  # Go to left of beginning of string
]>  # End on first character of second string
# If second string is null we will end one too far to the left
>[>]<<<[<]>  # If first string is null we will end there too
# We will use this to do flow control

[  # Only run if both strings were non null

# Tape:    S0 ' F0 ' S1 ' F1 ' S2 ' F2 ' etc
#          ^

<+>>  # Let F0* = F0 (plus) 1  (is 1 as of now; F0 will be added later)
[-<+<+>>] # Let A = S0 (plus) F0
# A may or may not be zero
# F0* may or may not be zero
# Tape:    F0* ' A ' 0  ' S1 ' F1 ' etc
#                ^

[>]<[->+<]  # Let B = A or F0*
# B may or may not be zero
<[-]>>  # Clear F0*
# Tape:     0 ' B ' 0 ' S1 ' F1 ' etc    (if A was zero)
#               ^
# OR        0 ' 0 ' B ' s1 ' F1 ' etc    (if A was nonzero)
#                   ^

# Let C = B or 2
# C will be guaranteed nonzero and unique from S0 and F0
>++<[<]>  # Create C
[.>>]  # Print (using S or F; does not matter)

>[>>]  # End on a zero cells with zero cells all to the right
# This is necessary for the coming functionality
# also as to not loop
]  # End non null block

# Now we consider if one of the strings was null
# Tape:    0 ' E0 ' 0 ' E1 ' etc    (if one string was null)
#          ^
# Tape:    0 '  0 ' 0 '  0 ' etc    (if neither string was null)
#          ^
# Where E is F or S (we don't care)

>[  # Execute only if one string was null

+  # Let A = E0 (plus) 1
# A may or many not be zero
# Tape: 0 ' A ' 0 ' E1 ' etc
#           ^

[>]+[<]>  # Let B = A or 1
# B is guaranteed nonzero and != E0
# Tape: 0 ' B ' ? ' E1 ' 0 ' E2 ' etc
#           ^

[.>>]  # Print

# End on zero cell as not to loop
]  # End null block

Comments

आपका "तथ्य" गलत है, उदाहरण के लिए a=2, b=1। आपको घटाने के बजाय जोड़ने की आवश्यकता है।

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

मुझे लगता है कि आप शुरुआत में Sजोड़कर >और बाद [<]>में सबसे बाईं ओर की खाली समस्या को ठीक कर सकते हैं S- अगर यह नॉनज़रो है तो यह कुछ नहीं करता है, अन्यथा यह स्ट्रिंग्स को स्विच करता है।

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

@ ItrjanJohansen ओह तुम सही हो, यह बराबर हो सकता है b। लेकिन नहीं a।

— Quelklef

@ TorjanJohansen आह, कि काम करने के लिए प्रकट होता है! अच्छी सोच!

— Quelklef

@ FactrjanJohansen इस तथ्य के बारे में फॉलो अप करें: चूंकि यह != aकेवल है, अगर मैं S/0, S/1, ...इसके बजाय प्रिंट करता हूं तो S/0, F/1, ...यह काम करना चाहिए।

— Quelklef

Answer 4

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

żḟ@€ØAZḢ

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

कैसे?

żḟ@€ØAZḢ - Link: list of characters, a; list of characters, b
ż        - zip a and b
    ØA   - uppercase alphabet
 ḟ@€     - filter discard for €ach (swap @rguments)
      Z  - transpose the result
       Ḣ - head

Comments

यह B TIO

— जोनाथन एलन

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

— जोनाथन एलन

मेरे दिमाग में स्पष्ट रूप से कोई चाल Xया चाल देखने के बाद से मेरे दिमाग में कोई बात नहीं है Ẋ...

— एरिक द आउटग्राफर

Answer 5

पायथन 3 , 62 47 57 54 51 बाइट्स

संपादित करें: - @ Mr.Xcoder को 5 बाइट्स धन्यवाद

संपादित करें: बग को ठीक करने के लिए +10 बाइट्स

संपादित करें: @ बाइटवरोस को -3 बाइट्स धन्यवाद

संपादित करें: पॉप के बजाय अधिकतम का उपयोग करके -3 बाइट्स

lambda x,y:max({*"abc"}-{x[:1],y[:1]})+max(x,y)[1:]

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

Comments

{"a","b","c"}==> {*"abc"}(

— ५oder

(x[1:]or y[1:])==> max(x,y)[1:]?

— बीटावेरोस

या बस (x or y)[1:], मुझे लगता है कि आपको केवल खाली स्ट्रिंग से बचने की आवश्यकता है।

— बीटावेरोस

संयोग से, यह शर्म की बात है पायथन 2 में सेट शाब्दिक रूप से तारांकित नहीं है, क्योंकि मैं वास्तव {*"abc"}में गोल्फ करना चाहता था {*`id`}...

— बीटावेरोस

के *len(x or y)बजाय 1 के साथ सहेजें +max(x,y)[1:]।

— चास ब्राउन

Answer 6

चारकोल , 22 बाइट्स

ＦＥα×ι⌈⟦ＬθＬη⟧¿¬№⟦θη⟧ιＰι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। लंबे इनपुट की लंबाई के लिए दोहराया अपरकेस वर्णों के सभी तारों को उत्पन्न करता है और उन सभी को प्रकट करता है जो इनपुट में दिखाई नहीं देते हैं। दूसरे शब्दों में, आउटपुट आम तौर पर ZZZ...तब तक होता है जब तक कि इनपुट में से एक है, जिस स्थिति में यह हैYYY... जब तक कि वह दूसरा इनपुट नहीं होता है, किस स्थिति में है XXX...।

Answer 7

गणितज्ञ, 111 बाइट्स

(c=Characters;a=#2;While[f=Alphabet[]~RandomChoice~Length@#;f==#||f==c@a]&[#&@@c@{##}~MaximalBy~Length];""<>f)&

इसे ऑनलाइन आज़माएँ (ctrl + v के साथ पेस्ट कोड, अंत में इनपुट रखें और शिफ्ट + एंटर करें)

इनपुट

["मुझे परखें"]

thanx @ जाँच और गोल्फ -21 बाइट्स के लिए एक पेड़

Comments

मैं इसे फिर से ऑनलाइन कैसे परीक्षण करूं?

— स्टीफन

जोड़ा गया लिंक + जानकारी

— J42161217

@ जेनी_मैथी फेल होने पर लगता है अगर पहला तार खाली है

— हलवार्ड विल्म्स

@HalvardHummel तय!

— J42161217

@ नोटात्री ने तय किया। अगर आपको लगता है कि "आसान गोल्फिंग" डाउनवॉटिंग का कारण है तो आपका ऐसा करने का स्वागत है

— J42161217

Answer 8

पर्ल 6 , 38 30 बाइट्स

{(1 x.max.comb...*∉$_).tail}

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

अज्ञात कोडब्लॉक जो इनपुट को दो स्ट्रिंग्स की सूची के रूप में लेता है, और पहले नंबर 1111...को 1s की गैर-खाली राशि के साथ देता है जो इनपुट में नहीं है।

स्पष्टीकरण:

{                          }   # Anonymous code block
  1 x.max.comb                 # String multiply 1 by the size of the non-empty string
              ...              # Create a sequence increasing by 1
                 *∉$_          # Until the number is not in the input
 (                   ).tail    # And take the last number

Comments

क्या इंक्रीमेंट करने वाला एक बड़ा प्रकार है, या यह पर्याप्त रूप से बड़े तारों के लिए अतिप्रवाह होगा?

— गामाफंक्शन

@ GammaFunction पर्ल 6 में, डिफ़ॉल्ट संख्या का प्रकार Int है, जिसमें असीम सटीकता है

— Jo King

ओह अच्छा। मैं Zsh के लिए इसे अनुकूलित करने जा रहा था, लेकिन यह long longदुर्भाग्य से उपयोग करता है ।

— गामा फंक्शन

आप केवल ००, ६ .., १११ .., २२ .. को गिनती और अनुक्रमों के बजाय ६ बाइट्स ट्रिम कर सकते हैं: tio.run/…

— फिल एच

@PhilH अच्छा विचार है! मैंने इसे दृश्य विचार के साथ थोड़ा और छोटा कर दिया है

— जो किंग

Answer 9

Zsh , 51 47 37 36 बाइट्स

-4 सरणी builtin का उपयोग करके बाइट्स argv, -10 उपसर्ग हटाने और का उपयोग करके बाइट्स RC_EXPAND_PARAM, -1 ब्रेस विस्तार इनलाइन करने से बाइट।

<<<${${${:-{1..3}${^@#?}}:|argv}[1]}

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

सबसे पहले, यह एक भयानक चुनौती थी, मैं इस एक पर उतरने से पहले एक टन विचारों से गुज़रा।

<<<${${${:-{1..3}${^@#?}}:|argv}[1]}
       ${:-             }            # empty fallback
                 ${ @#?}             # remove first character from each parameter
                 ${^@  }             # enable brace expansion (set -P)
           {1..3}${^@#?}             # expand to 1foo 2foo 3foo 1bar 2bar 3bar
     ${                  :|argv}     # Set difference with 'argv'
   ${                           [1]} # The first found element
<<<                                  # print to stdout

@और *नहीं पहचानकर्ता इसलिए कर रहे हैं, ${ :|@}और ${ :|*}इसलिए के उपयोग के काम नहीं करते हैं,${ :|argv}

यह विधि 93 इनपुट तक काम करेगी और एक 94 वीं खोज करेगी जो अद्वितीय है। बस {1..3}अधिकतम संभव सीमा के साथ बदलें {~..!}।

Zsh , 48 47 बाइट्स *

for ((;$#i<${#${1:-$2}}||$@[(I)$i];i++)):
<<<$i

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

पूरी तरह से नई विधि जोकिंग के पर्ल 6 प्रस्तुत करने के सौजन्य से, लेकिन पूर्णांक आकार प्रतिबंध के कारण बड़े स्ट्रिंग्स (एन> 20) पर काम नहीं करता है। $@[(I)$i]सबसे बड़ी अनुक्रमणिका के लिए रिवर्स एरे लुकअप है, यह कमांड लाइन मापदंडों में $ i नहीं पाए जाने पर शून्य (अंकगणितीय विस्तार में झूठा) का उत्पादन करेगा।

Answer 10

MATL , 12 बाइट्स

c"1Y2@X-1)&h

इनपुट मुद्रण योग्य ASCII वर्ण वाले तारों का एक सेल सरणी है। आउटपुट अक्षरों से बनता है 'ABC', और इसलिए इनपुट डोमेन के अंतर्गत आता है।

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

व्याख्या

आउटपुट सबसे लंबा इनपुट स्ट्रिंग जितना लंबा है। इसका n -th कैरेक्टर पहला अक्षर है 'ABC'जो दोनों इनपुट स्ट्रिंग्स के n -th कैरेक्टर से अलग है ।

c        % Concatenate the two strings vertically. If one is shorter it is
         % right-padded with spaces. Gives a 2-row character matrix
"        % For each column
  1Y2    %   Push the string 'ABC...Z' (the upper-case letters)
  @      %   Push current column
  X-     %   Set difference
  1)     %   Get first character
  &h     %   Horizontally concatenate the results so far
         % End (implicit). Display stack (implicit)

Answer 11

हास्केल, 56 52 48 बाइट्स

x#y|_:t<-max x y=[c:t|c<-"abc",c:t/=x,c:t/=y]!!0

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

दो इनपुट स्ट्रिंग्स के अधिकतम के पहले चार को बदलें a, bऔर cपहले एक को चुनें जो दोनों इनपुट स्ट्रिंग्स से अलग है।

Answer 12

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

->a,b{([?a,?b,?c].map{|e|e*[a,b].max.size}-[a,b])[0]}

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

मूल रूप से तार उत्पन्न करता है a...a, b...bऔर c...cऔर पहला इनपुट में नहीं चुनता है।

Comments

यदि पहला इनपुट खाली स्ट्रिंग है तो विफल हो जाता है।

— सिल्वियो मायोलो

@ सिल्वियो मयोलो तय

— कॉनर ओ'ब्रायन

42 बाइट्स

— iamnotmaynard

Answer 13

ईएस 6, 54 बाइट्स

a=>b=>(a[0]+b[0]|0?'a':9-(a[0]^b[0]))+(a||b).substr(1)

Comments

पीपीसीजी में आपका स्वागत है :)

— झबरा

Answer 14

पायथ, 7 8 बाइट्स

hC-LG.T

1 बाइट जेक्यूब के लिए धन्यवाद

परीक्षण सूट

हम उपयोग करते हैं .T, लंबाई को संरक्षित करते हैं, बजाय Cट्रांसजेकिंग ट्रांसपोज़ के, ताकि यह उन इनपुट पर काम करे जहां एक स्ट्रिंग खाली है।

टपल के रूप में दो तारों को देखते हुए, हम उन्हें स्थानांतरित करते हैं ( .T), फिर वर्णों या एकल वर्णों के परिणामस्वरूप युग्म को चरित्र को निचली वर्णमाला से घटाकर मानचित्रित करते हैं -LG, फिर अनुपयोगी तारों के तारों की परिणामी सूची को स्थानांतरित करते हैं C, फिर वापस आते हैं। के साथ इस तरह के पहले स्ट्रिंग h। इसमें पहला अक्षर वर्णानुक्रम में होता है जो प्रत्येक स्थिति के लिए स्ट्रिंग में नहीं होता है।

Answer 15

जावा (ओपनजेडके 8) , 100 73 बाइट्स

-27 बाइट्स @ नेवादा के जादुई स्पर्श के लिए धन्यवाद! :)

a->b->{b=b.length<1?a:b;if(a.length<1||(b[0]^=2)==a[0])b[0]^=1;return b;}

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

इनपुट डोमेन = मुद्रण योग्य ASCII + कोडपॉइंट 127।

Comments

73 बाइट्स

— नेवई

Answer 16

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

->a,b{a,b=b,a if a<b;a[0]=([?a,?b,?c]-[a[0],b[0]])[0];a}

Answer 17

पायथ , 23 22 बाइट्स

+.)-.{<G3.{,<Q1<KE1t|K

यहाँ कोशिश करो!

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

+eS-.{<G3.{,<Q1<KE1t|K

परीक्षण सूट!

---

व्याख्या

+.)-.{<G3.{,<Q1<KE1t|K  - Full program.
      <G3               - Yields the String "abc"; Alphabet[:3].
    .{                  - Set formed by the above.
         .{,<Q1<KE1     - Set formed by input_1[:1] and input_2[:1]
   -                    - Set subtraction.
 .)                     - Pop the last element.
+                       - Append.
                   t|K  - input_1[1:] or input_2[1:], relying on the result of Logical OR.

Answer 18

पर्ल 5, 82 79 बाइट्स

sub{$_=$_[0];$_=$_[1]||$_ if/^(xz*)?$/;s/[^z]/z/||s/./y/;$_ eq$_[1]&&s/./x/;$_}

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

सबरूटीन पहले स्ट्रिंग के समान एक स्ट्रिंग का उत्पादन करने का प्रयास करता है, लेकिन पहले गैर- zचरित्र के साथ बदल दिया जाता है z। फिर यह कोने के मामलों को पहले चरित्र के साथ yया xआवश्यकता के अनुसार बदल देता है, अगर यह पाता है कि इनपुट में से एक वास्तव में सभी का एक क्रम था z।

Answer 19

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

sub{$_="a"x length $_[0]||$_[1];$_++while $_ eq$_[0]||$_ eq$_[1];$_}

स्पष्टीकरण:

• अक्षर से शुरू होता है ("स्ट्रिंग a" जब तक कि पहली स्ट्रिंग है) या दूसरी स्ट्रिंग यदि गलत है अर्थात शून्य-लंबाई
• बढ़ाता रहता है कि जब तक यह पहले और दूसरे दोनों से अलग न हो

"ए" से शुरू करना उस बिंदु पर वृद्धि से बचने के लिए था जहां पर्ल स्ट्रिंग को लंबा करता है; केवल दो तारों के समान होने से बचने के लिए, यह अतिप्रवाह नहीं कर सकता है।

के साथ निष्पादित करें:

perl -e '$s = ' -E 'sub{$_="a"x length $_[0]||$_[1];$_++while $_ eq$_[0]||$_ eq$_[1];$_}' -E ';say $s->("z", "true")'

Comments

मुझे लगता है कि यदि पहला तार खाली है तो यह विफल हो जाएगा।

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

बिलकुल सही! फिक्स्ड।

— एड।

Answer 20

सी (जीसीसी) ,70 65 73 67 61 बाइट्स

फ़ंक्शन को प्रदान किए जाने वाले स्ट्रिंग्स को परस्पर (यानी या तो सरणियों या गतिशील रूप से आवंटित) होने की आवश्यकता है।

f(a,b)char*a,*b;{a=*a?a:b;*a=*a>70?33:99;*a+=*a==*b;puts(a);}

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

मानक ASCII रेंज के लिए काम करता है

स्पष्टीकरण:

a=*a?a:b           // If a is empty, point to b instead
*a=*a>70?33:99     // Choose a different value for the 1st character of a,
                   // while giving enough space to increment it without 
                   // going back to its previous value
*a+=*a==*b         // Increment the 1st character of a if the arbitrary
                   // chosen value is equal to the value of the 1st 
                   // character of b
puts(a)            // Outputs a

Comments

मुझे यकीन नहीं है कि यह नियमों को संतुष्ट करने वाला एक सुसंगत इनपुट डोमेन दिया जा सकता है। क्या होगा अगर *a==255और *b==0?

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

आप सही हे। फिक्स्ड, 8 बाइट्स की कीमत पर।

— स्कूटनीट

वहाँ। मैं इस समाधान को एक जावा की तुलना में एक ही bytecount नहीं दे सकता था! :-)

— स्कूटनीट

यदि आप मुद्रण योग्य ASCII तक सीमित नहीं हैं तो आप एकल अंकों की संख्याओं का उपयोग कर सकते हैं।

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

जब तक मैंने गलत नहीं समझा, यह चुनौती नियमों के खिलाफ होगा।

— स्कूटनीट

Answer 21

आर, 89 67 बाइट्स

@Giuseppe ने 9 बाइट्स बचाए, @ user2390246 ने 13 बाइट्स बचाए

समारोह

function(x,y)sub("^.",letters[!letters%in%substr(c(x,y),1,1)][1],x)

डेमो

# define function
f <- function(x,y)sub("^.",letters[!letters%in%substr(c(x,y),1,1)][1],x)

# test cases
f("test","test")
[1] "aest"
f("do","don't")
[1] "ao"
f("ye s","yes")
[1] "ae s"
f("maybe","mayue")
[1] "aaybe"
f("false","false")
[1] "aalse"
f("false","true")
[1] "aalse"
f("1","")
[1] "a"
f("art","bug")
[1] "crt"

Comments

आप रख सकते हैं xऔर yएक ही भीतर substrआदेश। इसके अलावा, घुंघराले ब्रेसिज़ और returnअनावश्यक हैं:function(x,y)sub("^.",letters[!letters%in%substr(c(x,y),1,1)][1],x)

— user2390246

आप returnएक समारोह है, और यह एक लाइनर है क्योंकि ब्रेसिज़ से छुटकारा पा सकते हैं ।

— Giuseppe

गोली मारो, मुझे अभी पता चला है कि f("","1")पैदावार "", जो पहले इनपुट के बराबर है ... शायद इसे एक अन्य परीक्षण के मामले के रूप में जोड़ा जाना चाहिए

— धीमे लोरिस

Answer 22

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

लैम्ब्डा (curried) से Stringलैम्ब्डा से Stringकरने के लिए String। को सौंपे Function<String, Function<String, String>>।

s->t->{String r=s.length()>t.length()?s:t;while((s+t).contains(r))r=r.substring(1)+(char)(Math.random()*128);return r;}

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

अघोषित लंबोदर

s ->
    t -> {
        String r = s.length() > t.length() ? s : t;
        while ((s + t).contains(r))
            r = r.substring(1) + (char) (Math.random() * 128);
        return r;
    }

यह समाधान यादृच्छिक ASCII वर्णों को तब तक लंबे समय तक स्ट्रिंग में घुमाता है जब तक आवश्यक शर्तें संतुष्ट नहीं हो जाती हैं। इनपुट्स UTF-8 हैं और आउटपुट ASCII हैं।

मैं यूनिकोड के गंभीर विवरणों को नहीं जानता, लेकिन यह मेरे लिए प्रशंसनीय है कि यह समाधान तब विफल हो सकता है जब charएक एकल कोड इकाई बनाने के लिए पूर्ववर्ती कोड बिंदु में एक जोड़ा जाता है। यदि कोई व्यक्ति जो इसके बारे में अधिक जानता है, वह इसे सत्यापित कर सकता है, तो मैं इनपुट डोमेन को ASCII में बदल दूंगा।

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

ऊपर के समान।

s->t->{String r;for(byte[]o=(s.length()>t.length()?s:t).getBytes();(s+t).contains(r=new String(o));o[0]%=128)o[0]++;return r;}

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

अघोषित लंबोदर

s ->
    t -> {
        String r;
        for (
            byte[] o = (s.length() > t.length() ? s : t).getBytes();
            (s + t).contains(r = new String(o));
            o[0] %= 128
        )
            o[0]++;
        return r;
    }

जब तक आवश्यक शर्तों को पूरा नहीं किया जाता है, यह ASCII के भीतर लपेटकर, लंबे स्ट्रिंग के पहले बाइट को बढ़ाता है। इनपुट और आउटपुट ASCII स्ट्रिंग्स हैं।

Comments

आपके तीसरे परीक्षण मामले के आउटपुट को देखते हुए, यह लंबाई तीन की एक स्ट्रिंग को आउटपुट करता है: इसे ऑनलाइन आज़माएं!

— स्टीफन

आह, बकवास। अब मुझे सीखना है कि यूनिकोड कैसे काम करता है ताकि बाइट काउंट को विस्फोट किए बिना इसे ठीक किया जा सके ...

— जैकब

Answer 23

एपीएल (Dyalog यूनिकोड) , 11 बाइट्स ^SBCS

पूर्ण कार्यक्रम, इनपुट को 2-तत्व नेस्टेड सूची के रूप में लेता है।

⊃¨⎕A∘~¨,⌿↑⎕

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

Answer 24

बैश, 115 .. 77 बाइट्स

1,2,3 के साथ पहले (गैर-खाली) इनपुट स्ट्रिंग के पहले चार को बदल देता है जब तक कि इनपुट से कोई मेल नहीं मिलता है। इसे ऑनलाइन आज़माएं!

-9, -12, -9, -8 सभी गामाफंक्शन के लिए धन्यवाद

x="${1:-$2}"
for s in {1..3}"${x:1}"
{ [[ $s = @($1|$2) ]]||break;}
echo "$s"

( मूल पर काफी सुधार ... )

Comments

अच्छी विधि! आप उपयोग कर सकते हैं =और ||अंतिम पंक्ति में, और ${x:-empty_fallback}शुरुआती टर्नरी को हटाने के लिए उपयोग कर सकते हैं । इसके अलावा, आपको रिक्त स्थान के मामले के लिए अंतिम प्रतिध्वनि पर उद्धरण की आवश्यकता है। अनिवार्य TIO

— GammaFunction

यहां

— टीआईओ

मुझे पसंद है कि आप किसके साथ जा रहे हैं shift, मुझे यह अपनी विधि को दो अलग-अलग तरीकों से बाँधने के लिए मिला ।

— गामा फंक्शन

वूप्स, मुझे एक और बदलाव मिला: @($1|$2)पैटर्न मैचिंग

— गामाफंक्शन

उम्म, आई .. उह ... कुछ और बातें की

— गामाफंक्शन २ 10:

Answer 25

पर्ल 5 , 79 + 1 (-पी) = 80 बाइट्स

$"=<>;chop;$_=length($,=$_)>length$"?$_:$";s/./chr$&+65+$i++/e while/^($"|$,)$/

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

Comments

यदि दो तार अलग-अलग लंबाई के हैं तो फेल हो जाते हैं

— हैलवार्ड शेमर्स

मैंने गौर किया। बस इसे संशोधित किया।

— Xcali

Answer 26

जाप , 17 बाइट्स

;B¬£ñl g1 çXÃkU v

अक्षरों A-Zको लंबी इनपुट की लंबाई तक दोहराता है, इनपुट में मूल्यों को हटाता है, और सरणी में पहला आइटम प्राप्त करता है।

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

पुराना घोल, 18 बाइट्स

;@!UøX}a@ñl g1 çBö

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

वर्णमाला से एक यादृच्छिक चरित्र को चुनता है और इसे लंबे समय तक इनपुट स्ट्रिंग की लंबाई तक दोहराता है, जब तक कि यह इनपुट में मौजूद न हो।

Comments

के लिए असफल रहा ["abcdefghijklmnopqrstuvwxyz", "AAAAAAAAAAAAAAAAAAAAAAAAAA"]। इसे कई बार चलाने पर, यह वापस आ गया "AAAAAAAAAAAAAAAAAAAAAAAAAA"(जैसे कि मेरे पाइथ ने उत्तर दिया, जब तक मैंने यह तय नहीं किया)

— श्री एक्सकोडर

यह ["डी", ""] के लिए विफल रहता है। यदि आप इसे कई बार चलाते हैं तो आपको "D"

— J42161217

धन्यवाद, मुझे लगा कि कुछ ऐसे मामले थे जिनका मैंने परीक्षण नहीं किया था। केवल +1 बाइट के लिए निश्चित किया गया।

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

Ìg1 एक 2 बाइट की बचत के लिए काम करना चाहिए (एक 2 तत्व सरणी g1= में gJ) लेकिन Ìउपयोग करते समय एक बग प्रतीत होता है ;।

— झबरा

@Shaggy हाँ, मुझे लगता है कि के कारण Jअब नहीं है -1की वजह से ;करने के लिए इसे बदलने ,। इसलिए मैंने 1पहली जगह का इस्तेमाल किया ।

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

Answer 27

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

चरण बाइट के लिए धन्यवाद

def f(x,y,i=1):
 while i*10<10**len(x or y)or str(i)in x+y:i*=2
 print(i)

गैर-लंबाई वाले इनपुट के पहले के समान लंबाई के साथ सबसे कम पूर्णांक प्रिंट करता है।

Comments

iडिफ़ॉल्ट फ़ंक्शन पैरामीटर के रूप में एक बाइट सहेजें def f(x,y,i=1)::। मुझे लगता है कि आप एक और बाइट बचा सकते हैं while10*iलेकिन मुझे यकीन नहीं है।

— स्टीफन

आप बदल सकते हैं while i*10<10**len(x or y)or str(i)in x+yके साथ while i<10**~-len(x or y)or str(i)in x+y ( 72 बाइट्स )

— श्री Xcoder

और आप बाइट्स को बचाने के लिए पुनरावर्तन का उपयोग भी कर सकते हैं: f=lambda x,y,i=1:(i<10**~-len(x or y)or str(i)in x+y)and f(x,y,i*2)or i( 71 बाइट्स )

— श्री एक्सकोडर

Answer 28

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

a=input()
b=ord(a[0][0])+1
if b==ord(a[1][0]):b+=1
print unichr(b)+a[0][1:-1]

मुझे लगता है कि इसमें कुछ क्षमता है। विचार यह है कि यह 1 स्ट्रिंग में 1 से 1 चार्ट जोड़ता है, फिर जांचता है कि क्या अन्य इनपुट का 1 चार्ट समान है।

** ध्यान दें, ^ 0 लंबाई के तारों को नहीं संभालता है, इसलिए यह वास्तव में इस लंबाई पर काम नहीं करता है।

यहां एक सुपर लंबा समाधान है जो 0 लंबाई के साथ काम करता है

146 बाइट्स

a=input()
def c(i):print unichr(ord(a[i][0])+1)+a[i][1:];exit();
for x in range(2):if len(a[x-1])<1:c(x)
if a[0]==a[1]:c(1)
print a[1][0]+a[0][1:]

किसी भी सुधार की सराहना की जाएगी!

Answer 29

CJam, 31 30 23 बाइट्स

q~:A:e>,3,sf*{A\f=:+!}=

इनपुट के रूप में मुद्रण योग्य ASCII लेता है। आउटपुट या तो 0, 1, या 2 की एक स्ट्रिंग है जो इनपुट स्ट्रिंग्स में से एक के समान लंबाई है। तर्क यह है कि उनमें से एक भी इनपुट तार नहीं हो सकता है!

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

q~:A    e# Store input array as var 'A'
:e>,    e# Take the length of the lexicographically greater string in the input array
3,s     e# Generate "012"
f*      e# Repeat each number as many times as the longer string length, yielding something like ["000","111","222"]
{       e# Search array of number strings for first that returns true for this function
A\f=    e# Map each string in the input array to whether it equals the current number string (0,1)
:+!     e# Add up the array of bits and take the logical not. This returns true iff both array values were not equal to the current number string.
}=      e# Return the first number string that returns true.

Comments

किसी के पास कोई विचार है कि कैसे सच में वापस लौटा जाए यदि सरणी में दोनों बिट झूठे हैं (NOR)? वर्तमान में, मैं कर रहा हूँ :+!।

— जियोकावेल

Answer 30

सी # (मोनो) , 94 बाइट्स

s=>t=>{var r=s!=""?s:t;while(r==s|r==t)r=r.Substring(1).Insert(0,(char)(r[0]+1)+"");return r;}

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