Tantangan

Anda akan diberikan string input, di mana saja kata "Lemon"yang ditemukan harus dikonversi ke "Lemonade" tapi yang a, ddan eharus dipinjam dari tempat lain dalam kalimat.

Contoh

Contoh Input:

Saya menemukan lemon ketika saya masih kecil

Contoh Output:

Aku mengeluarkan limun ketika aku masih kecil

The Lemonade diciptakan dengan mencuri surat-surat superscript berikut dari aslinya

Aku foun ^d limun wh ^e n aku ^seorang anak

Ini hanya satu contoh keluaran yang mungkin, "e", "d", dan "a", bisa diambil dari mana saja ( kecuali dari kata lemontentu saja )

Komentar

• Jika tidak cukup e,, aatau dAnda harus menampilkan apa yang bisa dilakukan dengan huruf yang diberikan. Misalnya input bdblemonakan di-outputbblemond

• lemonTeks mungkin tidak selalu mandiri (ruang di setiap sisi). Misalnya Anda mungkin memiliki kata lemonsdi suatu tempat di input dan output seharusnyalemonades

• Input mungkin mengandung sejumlah lemons, bahkan 0lemon s (dalam hal ini output akan identik dengan input)

• Anda dapat membuat limun dengan huruf besar dan kecil, misalnya leMonbisa jadi leMonade, dan yang adedipinjam bisa jadi kasus apa saja (jadi bisa juga jadi leMonADe).
Kasus surat yang Anda pinjam harus tetap seperti apa saat Anda meminjamnya.
(Contoh input -> output, he hAD lemOn->h h lemOnADe )

• Tidak harus menjadi program penuh, fungsi saja tidak masalah.

• Anda dapat mengasumsikan input hanya Set Karakter CP437

Golf kode

Ini adalah kode-golf , sehingga jumlah byte terendah menang!

Pseudo-TestCases

* Catatan: Untuk setiap input yang diberikan mungkin ada beberapa kemungkinan output sehingga program Anda mungkin tidak menghasilkan persis seperti yang dilakukan oleh test case ini, ini lebih supaya orang-orang dapat memahami logikanya:

Input:
Output leMons EpaD : p LeMonaDEs

Input: hello world
Output: hello world

Input: lemon lemon
Output: lemon lemon
* ( The e, a, dsurat tidak boleh diambil dari yang lain "Lemon")

Input: HE HAD lemonade
Output: HH lemonADEade

Input: Apakah Anda suka lemon? Anda memiliki saya di lemon!
Keluaran: o Anda suka lemonADes? Anda hmt limun!

Input: AE lemon
Output: lemonAE

Input: 55 lada lemon
Output: 55b lemonad

JavaScript (ES6), 159 157 155 162 byte

Sunting: +7 byte ke "output apa yang bisa dilakukan dengan huruf yang diberikan" daripada membuang kesalahan

Fungsi rekursif yang mengembalikan string yang dimodifikasi.

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

Bagaimana itu bekerja

Ekspresi s.split(/(lemon)/i)membagi string input pada lemontetapi mempertahankan kelompok tangkapan dalam hasilnya.

Misalnya, "foo lemon bar LEMON baz".split(/(lemon)/i)akan menghasilkan array [ 'foo ', 'lemon', ' bar ', 'LEMON', ' baz' ].

Kami mengulang secara berulang pada larik ini, mengekstraksi karakter a, ddan eatau rekan-rekan huruf besar mereka dari entri yang terletak di posisi genap, dan menambahkannya ke entri yang terletak di posisi aneh.

Berkomentar

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

Demo

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 byte

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

Ini dibagi menjadi dua garis untuk kejelasan; baris baru tidak dihitung.

Kodesemu:

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

Retina , 303 byte

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

Cobalah online!

Tentunya saya melakukan sesuatu yang salah di sini.