Когда жизнь дает тебе лимоны, делай лимонад

21

Вызов

Вам будет предоставлена входной строки, везде слово "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 лимонад

Альберт Реншоу
источник

Ответы:

6

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

демонстрация

Arnauld
источник
Бросок ошибки рекурсии, кажется, не соответствует первому правилу (« Если их недостаточно e, aили ds, вы должны вывести то, что было выполнимо с данными буквами. Например, ввод вывел bdblemonбыbblemond »)?
Кевин Круйссен
1
@KevinCruijssen Хм, ты прав. Я был почти уверен, что сначала было разрешено выдавать ошибку. Было ли это редактирование в течение льготного периода первоначального сообщения? (Либо так, либо мне приснилось.) В любом случае, я постараюсь это исправить. Спасибо, что заметили.
Арно
Я оглянулся в историю, прежде чем сделать свой комментарий, если он действительно был отредактирован. Вы могли бы быть правы, это могло быть отредактировано в первые 5 минут, но не знаете, как это проверить. И нет проблем, ваш ответ по-прежнему впечатляет, так что я заранее добавлю +1. Я не сомневаюсь, что вы сможете решить эту проблему (надеюсь, не вызывая большого количества добавленных байтов).
Кевин Круйссен
@KevinCruijssen На данный момент исправлено 7 байт.
Арно
2
@Arnauld Да, извините, я отредактировал это в течение первых 2 минут после публикации, может быть, ха-ха, мои извинения
Альберт Реншоу
5

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))
Esolanging Fruit
источник
Я опечален, у этого нет большего количества голосов, отличный ответ imo
Альберт Реншоу
4

Сетчатка , 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

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

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

Нил
источник