Вызов

Вам будет предоставлена входной строки, везде слово "Lemon"встречается оно должно быть преобразовано в "Lemonade" ноa , dи eдолжны быть заимствованы из другого места в предложении.

пример

Пример ввода:

Я нашел лимон, когда я был ребенком

Пример вывода:

Я основал лимонад, когда я был ребенком

Лимонад был создан украв следующие выносные буквы от оригинала

Я foun ^д лимонад WH ^е п я был ребенком

Это только один из возможных выходных примеров: «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

Вход: привет мир
Выход: привет мир

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

Вход: он имел лимонад
Выход: HH lemonADEade

Вход: Вы любите лимоны? Ты дал мне лимон!
Вывод: о тебе нравится лимонад? Вы хмт лимонад!

Вход: AE лимон
Выход: лимон AE

Ввод: 55b лимонный
Выход: 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

Попробуйте онлайн!

Конечно, я делаю что-то не так здесь.