ท้าทาย

คุณจะได้รับการป้อนข้อมูลสตริงทุกคำ"Lemon"จะพบว่ามันควรจะเปลี่ยนไป"Lemonade" แต่a , dและeจะต้องยืมมาจากที่อื่นในประโยค

ตัวอย่าง

อินพุตตัวอย่าง:

ฉันพบมะนาวเมื่อตอนเป็นเด็ก

ตัวอย่างผลลัพธ์:

ฉันทำน้ำมะนาวเมื่อฉันยังเด็ก

The Lemonadeสร้างขึ้นโดยการขโมยตัวอักษรยกต่อไปนี้จากต้นฉบับ

ฉัน Foun ^dน้ำมะนาว WH ^E n ผมเป็นเด็ก

นี่เป็นเพียงตัวอย่างหนึ่งที่เป็นไปได้คือ "e", "d" และ "a" ซึ่งอาจถูกนำมาจากที่ใดก็ได้ ( ยกเว้นจากคำว่าlemonแน่นอน )

ความคิดเห็น

•หากมีไม่เพียงพอe, aหรือds คุณส่งออกสิ่งที่สามารถทำด้วยตัวอักษรจะต้องได้รับ ตัวอย่างเช่นการป้อนข้อมูลbdblemonจะส่งออกbblemond

• lemonข้อความอาจไม่ได้เป็นแบบสแตนด์อโลน (เว้นวรรคในแต่ละด้าน) ตัวอย่างเช่นคุณอาจมีคำlemonsบางคำในอินพุตและเอาต์พุตควรเป็นlemonades

•อินพุตอาจมีจำนวนlemons ใด ๆแม้แต่ 0 lemonวินาที (ซึ่งในกรณีนี้เอาต์พุตจะเหมือนกับอินพุต)

•คุณสามารถทำน้ำมะนาวของคุณด้วยตัวอักษรตัวพิมพ์ใหญ่และตัวพิมพ์เล็กตัวอย่างเช่นleMonอาจกลายเป็นleMonadeและการadeยืมสามารถเป็นกรณีใด ๆ (ดังนั้นมันอาจจะกลายเป็นleMonADe)
กรณีของจดหมายที่คุณยืมต้องอยู่ในสภาพเดิมเมื่อคุณยืม
(ตัวอย่างอินพุต -> เอาต์พุตhe hAD lemOn-> h h lemOnADe)

•ไม่จำเป็นต้องเป็นโปรแกรมเต็มรูปแบบฟังก์ชั่นเพียงอย่างเดียวก็ใช้ได้

•คุณอาจสมมติว่าอินพุตเป็นเพียงชุดอักขระ CP437

รหัสกอล์ฟ

นี่คือโค้ดกอล์ฟดังนั้นจำนวนไบต์ต่ำที่สุดจึงเป็นผู้ชนะ!

หลอก TestCases

* หมายเหตุ: สำหรับอินพุตที่กำหนดอาจมีเอาต์พุตที่เป็นไปได้หลายรายการดังนั้นโปรแกรมของคุณอาจไม่เอาต์พุตเหมือนกับกรณีทดสอบเหล่านี้สิ่งนี้เป็นเพียงเพื่อให้ผู้คนเข้าใจตรรกะ:

อินพุต: EpaD leMons
เอาต์พุต: p LeMonaDEs

อินพุต: สวัสดีโลก
เอาต์พุต: สวัสดีโลก

การป้อนข้อมูล: มะนาวมะนาว
เอาท์พุท: มะนาวมะนาว
* ( , , ตัวอักษรไม่ควรจะนำมาจากที่อื่น "มะนาว")ead

อินพุต: HE HAD lemonade
เอาต์พุต: HH lemonadeade

อินพุต: คุณชอบมะนาวไหม? คุณ hAd ฉันที่มะนาว!
เอาท์พุต: คุณชอบน้ำมะนาวหรือไม่ คุณ hmt น้ำมะนาว!

อินพุต: AE มะนาว
เอาต์พุต: lemonAE

อินพุต: 55bad lemon
เอาต์พุต: 55b lemonad

JavaScript (ES6), 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"))

CJam, 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/\.{}

นี่คือการแยกข้ามสองบรรทัดเพื่อความชัดเจน; ขึ้นบรรทัดใหม่จะไม่ถูกนับ

pseudocode:

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))

เรติน่า , 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

ลองออนไลน์!

แน่นอนฉันกำลังทำอะไรผิดที่นี่