Desafio

Você será dado uma cadeia de entrada, em qualquer lugar a palavra "Lemon"é encontrada deve ser convertido para "Lemonade" , mas o a, de edeve ser emprestado de outro lugar na sentença.

Exemplo

Exemplo de entrada:

Encontrei limão quando criança

Saída de exemplo:

Eu encontro uma limonada quando eu era criança

A limonada foi criada roubando as seguintes letras sobrescritas do original

I foun ^d uma limonada wh ^e n eu era ^um garoto

Este é apenas um exemplo de saída possível, o "e", "d" e "a" podem ter sido obtidos de qualquer lugar ( exceto pela palavra, é lemonclaro )

Comentários

• Se não há o suficiente e, aou dé você deve saída o que era capaz de fazer com as cartas dadas. Por exemplo, a entrada bdblemonproduziriabblemond

• O lemontexto nem sempre pode ser autônomo (espaço em cada lado). Por exemplo, você pode ter a palavra lemonsem algum lugar da entrada e a saída deve serlemonades

• A entrada pode conter qualquer número de lemons, até 0 lemons (nesse caso, a saída seria idêntica à entrada)

• Você pode fazer sua limonada com letras maiúsculas e minúsculas, por exemplo, leMonpode se tornar leMonadee o adeemprestado pode ser qualquer caso (por isso, também pode ter se tornado leMonADe).
O caso da carta emprestada deve permanecer como era quando você a emprestou.
(Exemplo de entrada -> saída, he hAD lemOn-> h h lemOnADe)

• Não precisa ser um programa completo, apenas uma função é adequada.

• Você pode assumir que a entrada será apenas o conjunto de caracteres CP437

Code Golf

Este é o código-golf , então o menor número de bytes vitórias!

Pseudo-TestCases

* Nota: Para qualquer entrada específica, pode haver várias saídas possíveis, para que seu programa não seja exibido exatamente como esses casos de teste, isso é mais apenas para que as pessoas possam entender a lógica:

Entrada: Limões EpaD
Saída: p LeMonaDEs

Entrada: Olá mundo
Saída: Olá mundo

Entrada: limão limão
saída: limão limão
* ( A e, a, dcartas nunca deve ser tirado de outra "Lemon")

Entrada: ELE TINHA limonada
Saída: HH lemonADEade

Entrada: Você gosta de limões? Você me adora no limão!
Saída: o você gosta de limão? Você hum limonada!

Entrada: AE lemon
Saída: lemonAE

Entrada: 55bad lemon
Saída: 55b lemonad

JavaScript (ES6), 159 157 155 162 bytes

Edit: +7 bytes para "gerar o que era possível com as letras dadas" em vez de emitir um erro

Uma função recursiva que retorna a string modificada.

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

Como funciona

A expressão s.split(/(lemon)/i)divide a sequência de entrada, lemonmas preserva os grupos de captura no resultado.

Por exemplo, "foo lemon bar LEMON baz".split(/(lemon)/i)produzirá a matriz [ 'foo ', 'lemon', ' bar ', 'LEMON', ' baz' ].

Nós recursivamente iterar nesta matriz, extraindo os caracteres a, de eou os seus homólogos maiúsculas a partir das entradas situadas numa posição mesmo, e anexando-os para as entradas situadas numa posição estranho.

Comentado

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 bytes

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

Isso é dividido em duas linhas para maior clareza; a nova linha não é contada.

Pseudo-código:

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 bytes

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

Experimente online!

Certamente estou fazendo algo errado aqui.