जब भी जीवन में मुश्किलें आएं तो उनका भी लाभ उठाएं

Question

चुनौती

आपके पास कोई इनपुट स्ट्रिंग दी जाएगी, कहीं भी शब्द "Lemon"पाया जाता है यह करने के लिए परिवर्तित किया जाना चाहिए "Lemonade" लेकिनa , dहै, और eवाक्य में उधार किया जाना चाहिए कहीं और से।

---

उदाहरण

उदाहरण इनपुट:

मुझे एक नींबू मिला जब मैं एक बच्चा था

उदाहरण आउटपुट:

मैं एक नींबू पानी फेन मैं बच्चा था

लेमोनेड मूल से निम्नलिखित सुपरस्क्रिप्ट पत्र चोरी द्वारा बनाया गया था

मैं फाउंडेशन ^घ एक नींबू पानी क ^ई एन मैं था ^एक बच्चा

यह केवल एक संभावित आउटपुट उदाहरण है, "ई", "डी", और "ए", कहीं से भी लिया जा सकता है ( पाठ्यक्रम के शब्द को छोड़करlemon )

---

टिप्पणियाँ

• अगर वहाँ पर्याप्त नहीं हैं e, aया dआप ही चाहिए उत्पादन क्या दिया पत्र के साथ क्या-सक्षम था। उदाहरण के लिए इनपुट bdblemonआउटपुट होगाbblemond

• lemonपाठ हमेशा स्टैंडअलोन नहीं हो सकता (प्रत्येक पक्ष पर स्थान)। उदाहरण के लिए यदि आप शब्द हो सकता है lemonsइनपुट में कहीं और उत्पादन होना चाहिएlemonades

• इनपुट में कोई भी संख्या हो सकती है lemon, यहां तक ​​कि 0 lemonएस (जिस स्थिति में आउटपुट इनपुट के समान होगा)

• आप अपने नींबू पानी को अपरकेस और लोअरकेस अक्षरों के साथ बना सकते हैं, उदाहरण के लिए leMonबन सकता है leMonade, और adeउधार किसी भी मामले में हो सकता है (इसलिए यह भी बन सकता है leMonADe)।
आपके द्वारा उधार लिए गए पत्र का मामला वही रहना चाहिए जब आपने इसे उधार लिया था।
(उदाहरण इनपुट -> आउटपुट, he hAD lemOn-> h h lemOnADe)

• एक पूर्ण कार्यक्रम होना जरूरी नहीं है, अकेले एक समारोह ठीक है।

• आप मान सकते हैं कि इनपुट केवल CP437 कैरेक्टर सेट होगा

---

कोड गोल्फ

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

---

छद्म testcases

* नोट: किसी भी दिए गए इनपुट के लिए कई संभावित आउटपुट हो सकते हैं ताकि आपका प्रोग्राम ठीक से उत्पादन न कर सके जैसा कि ये परीक्षण मामले करते हैं, यह अधिक है ताकि लोग तर्क को समझ सकें:

इनपुट: EpaD leMons
आउटपुट: p LeMonaDEs

इनपुट: हैलो वर्ल्ड
आउटपुट: हैलो वर्ल्ड

इनपुट: नींबू नींबू
आउटपुट: नींबू नींबू
* ( , , पत्र कभी नहीं एक और "नींबू" से लिया जाना चाहिए)ead

इनपुट: महामहिम नींबू पानी
आउटपुट: HH नींबू पानी

इनपुट: क्या आपको नींबू पसंद है? तुम मुझे नींबू पर डाल दो!
आउटपुट: ओ आपको नींबू पानी पसंद है? आप नींबू पानी पीते हैं!

इनपुट: AE नींबू
आउटपुट: नींबू

इनपुट: 55bad नींबू
आउटपुट: 55b नींबू पानी

Answer 1

जावास्क्रिप्ट (ईएस 6), 159 157 155 162 बाइट्स

संपादित करें: +7 बाइट्स "एक त्रुटि को बाहर फेंकने के बजाय" दिए गए अक्षरों के साथ आउटपुट करने में सक्षम था "

---

एक पुनरावर्ती फ़ंक्शन जो संशोधित स्ट्रिंग लौटाता है।

f=(s,a=s.split(/(lemon)/i),n=(a.length-1)*1.5)=>n?f(n,a.map((s,i)=>i&1|!n||(a[i]=s.replace([/a/i,/e/i,/d/i][n%3],c=>(a[--n/3<<1|1]+=c,''))))&&a,n-(n==s)):a.join``

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

भाव s.split(/(lemon)/i) इनपुट स्ट्रिंग को विभाजित करती है lemonलेकिन परिणाम में कैप्चर समूहों को संरक्षित करती है।

उदाहरण के लिए, "foo lemon bar LEMON baz".split(/(lemon)/i) सरणी का उत्पादन करेगा [ 'foo ', 'lemon', ' bar ', 'LEMON', ' baz' ]।

हम वर्णों को निकालते हुए इस सरणी पर पुनरावृत्ति करते हैं a , dऔर eउनके बड़े को एक समान स्थान पर स्थित प्रविष्टियों से , और उन्हें विषम स्थिति में स्थित प्रविष्टियों से जोड़ते हैं।

टिप्पणी की गई

f = (                                   // given:
  s,                                    //   s = input string or previous value of 'n'
  a = s.split(/(lemon)/i),              //   a = split array, as described above
  n = (a.length - 1) * 1.5              //   n = total number of characters to be found
) =>                                    //
  n ?                                   // if there's still at least one character to find:
    f(                                  //   do a recursive call with:
      n,                                //     1) the current value of 'n'
      a.map((s, i) =>                   //     2) an updated version of 'a', where
        i & 1 | !n || (                 //       for even positions:
          a[i] = s.replace(             //         we look for the next character
            [/a/i, /e/i, /d/i][n % 3],  //           'a', 'e' or 'd' (case insensitive)
            c => (                      //           append it to
              a[--n / 3 << 1 | 1] += c, //           one of the entries at an odd position
              ''                        //           and remove it from the original entry
            )                           //           end of replace() callback
          )                             //         end of replace()
        )                               //       end of position condition
      ) && a,                           //     end of map() -> yield the updated 'a'
      n -                               //     3) the updated value of 'n', skipping the
      (n == s)                          //        current character if not found at all
    )                                   //   end of recursive call
  :                                     // else:
    a.join``                            //   success: join 'a' and return it

डेमो

f=(s,a=s.split(/(lemon)/i),n=(a.length-1)*1.5)=>n?f(n,a.map((s,i)=>i&1|!n||(a[i]=s.replace([/a/i,/e/i,/d/i][n%3],c=>(a[--n/3<<1|1]+=c,''))))&&a,n-(n==s)):a.join``

console.log(f("I found a lemon when I was a kid"))
console.log(f("I found a lemon when I was a kid. I found another lemon when I was older."))
console.log(f("bdblemon"))
console.log(f("he hAD lemOn"))

Comments

एक प्रत्यावर्तन त्रुटि फेंकने पहला नियम को पालन करने के लिए प्रतीत नहीं होता है ( " अगर वहाँ पर्याप्त नहीं हैं e, aया dएस चीज़ें आवश्यक उत्पादन क्या था देखते हुए पत्र के साथ क्या करने योग्य। उदाहरण के लिए इनपुट bdblemonआउटपुट होगाbblemond ")?

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

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

— अरनौलद

वास्तव में इसे संपादित किए जाने के मामले में मैंने अपनी टिप्पणी करने से पहले इतिहास में वापस देखा। आप सही हो सकते हैं इसे पहले 5 मिनट में संपादित किया जा सकता है, लेकिन इस बात की कोई जानकारी नहीं है कि इसे कैसे जांचना है। और कोई बात नहीं, आपका जवाब अभी भी बहुत प्रभावशाली है, इसलिए मैं इसे पहले से +1 करूंगा। मुझे कोई संदेह नहीं है कि आप इस मुद्दे को ठीक करने में सक्षम होंगे (उम्मीद है कि बहुत जोड़े बाइट्स के कारण के बिना)।

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

@ केविनक्रूजसेन यह अब के लिए 7 बाइट्स की कीमत पर तय किया गया है।

— अरनौलद

@Arnauld हाँ क्षमा करें मैंने संपादित किया है कि पोस्ट के पहले 2 मिनट के भीतर ही शायद, मेरी क्षमा याचना

— अल्बर्ट रेनशॉ

Answer 2

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

LqY5m*{"lemon"_eu}%3/:z{~?}f%{_@\/_:,[{1$+}*]);@f{[\]}@+\1a*}/\{1
=}$0f=\1$,{"ade"{__C#)\Ceu#)|(\0+We\)@_N=@+N\t\}fC}fN0a/L*1a/\.{}

यह स्पष्टता के लिए दो लाइनों में विभाजित है; न्यूलाइन की गिनती नहीं की जाती है।

स्यूडोकोड:

FLAG_1 = object()
FLAG_2 = object()
lemon_instances = [] # CJam: L
input_chars = list(all_input()) # CJam: q
lemons = [
    "LEMON", "LEMOn", "LEMoN", "LEMon", "LEmON", "LEmOn", "LEmoN", "LEmon",
    "LeMON", "LeMOn", "LeMoN", "LeMon", "LemON", "LemOn", "LemoN", "Lemon",
    "lEMON", "lEMOn", "lEMoN", "lEMon", "lEmON", "lEmOn", "lEmoN", "lEmon",
    "leMON", "leMOn", "leMoN", "leMon", "lemON", "lemOn", "lemoN", "lemon"
] # CJam: Y5m*{"lemon"_eu}%3/:z{~?}f%
for i in lemons: # CJam: { ... }/
    temp = input_chars.split(i) # CJam: _@\/
    lengths = temp.map(len) # CJam: _:,
    # Here, accum turns an array like [1,2,3] into [1,3,6].
    indices = accum(lengths) # CJam: [{1$+}*]
    indices.pop() # CJam: );
    temp2 = zip(temp, indices) # CJam: @f{[\]}
    lemon_instances = temp2 + lemon_instances # CJam: @+
    input_chars = join_array(temp, FLAG_1) # CJam: 1a*
lemon_instances.sort(key=lambda x: x[1]) # CJam: {1=}$
lemon_instances = [i[0] for i in lemon_instances] # CJam: 0f=
for i in range(len(lemon_instances)): # CJam: \1$,{...}fN
    for c in "ade": # CJam: "ade"{...}fC
        # list_index returns -1 if not found
        lower = list_index(input_chars, c)+1 # CJam: __C#)
        upper = list_index(input_chars, upper(c))+1 # CJam: \Ceu#)
        char_index = (lower or upper) - 1 # CJam: |(
        input_chars.append(FLAG_2) # CJam: \0+
        # -1 refers to the last element in the list
        swap_list_elements(input_chars, char_index, -1) # CJam: e\
        extracted = input_chars.pop() # CJam: )
        lemon_instances[i] += extracted # CJam: @_N=@+N\t\
remove_all(input_chars, FLAG_2) # CJam: 0a/L*
temp1 = input_chars.split(FLAG_1) # CJam: 1a/
# interleave([1, 2, 3], ["a", "b"]) gives [1, "a", 2, "b", 3]
temp2 = interleave(temp1, lemon_instances) # CJam: \.{}
print("".join(temp2))

Comments

मैं दुखी हूँ यह अधिक upvotes नहीं है, महान जवाब imo

— अल्बर्ट Renshaw

Answer 3

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

i+`(?<!lemon)(a)(.*)(lemon)(?!a)
$2$3$1
i+`(lemon)(?!a)(.*)(?<!lemon)(a)
$1$3$2
i+(?<!lemona?)(d)(.*)(lemona?)(?![ad])
$2$3$1
i+`(lemona?)(?![ad])(.*)(?<!lemona?)(d)
$1$3$2
i+(?<!lemona?d?)(e)(?!(?<=le)mon)(.*)(lemona?d?)(?![ade])
$2$3$1
i+`(lemona?d?)(?![ade])(.*)(?<!lemona?d?)(e)(?!(?<=le)mon)
$1$3$2

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

निश्चित रूप से मैं यहां कुछ गलत कर रहा हूं।