Виклик

Вам буде надана вхідного рядка, всюди слово "Lemon"зустрічається воно повинно бути перетворено в "Lemonade" алеa , dі eповинні бути запозичені з іншого місця в реченні.

Приклад

Приклад введення:

Я знайшов лимон, коли був дитиною

Приклад Вихід:

Я підбираю лимонад, коли я був дитиною

Лимонад був створений вкравши наступні виносні літери від оригіналу

Я foun ^д лимонад WH ^е п я був дитиною

Це лише один можливий приклад виведення, "e", "d" та "a", можна було взяти з будь-якого місця ( крім слова lemonзвичайно )

Коментарі

• Якщо їх недостатньо e, aабо dви маєте вивести те, що було в змозі з поданими літерами. Наприклад, вхід bdblemonбуде виводитиbblemond

• lemonТекст не завжди може бути самостійним (пробіл на кожній стороні). Наприклад, у вас може бути слово lemonsдесь на вході, а вихід повинен бутиlemonades

• Вхід може містити будь-яку кількість lemons, навіть 0 lemons (у цьому випадку вихід буде ідентичним вводу)

• Ви можете зробити лимонад з великих і малих літер, наприклад, це leMonможе стати leMonade, а adeзапозичене може бути у будь-якому випадку (так воно могло б і стати leMonADe).
Справа листа, який ви позичили, повинен залишатися таким, яким він був, коли ви позичили його.
(Приклад введення -> вихід, he hAD lemOn->h h lemOnADe )

• Не обов’язково бути повноцінною програмою, одна лише функція прекрасна.

• Ви можете припустити, що введенням буде лише набір символів CP437

Код гольф

Це код-гольф , тому виграє найменша кількість байтів!

Псевдотестові випадки

* Примітка. На будь-якому даному вході може бути декілька можливих виходів, тому програма може виводити не так, як це роблять ці тестові випадки, це більш просто, щоб люди могли зрозуміти логіку:

Введення: EpaD лимони
Вихід: p LeMonaDE

Вхід: привіт світ
Вихід: привіт світ

Вхідний сигнал: лимон лимон
Вихід: лимон лимон
* ( , , листи ніколи не повинні бути взяті з іншого "Lemon")ead

Введення: HE HAD лимонад
Вихід: HH лимонада

Вхід: Чи любите лимони? Ти мене в лимон!
Вихід: o ти як лимонАда? Ви хмт лимонад!

Введення: AE лимон
Вихід: limonAE

Введення: 55bad лимон
Вихід: 55b лимонад

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

Це розділено на дві лінії для наочності; новий рядок не враховується.

Псевдокод:

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

Спробуйте в Інтернеті!

Звичайно, я тут щось неправильно роблю.