Reto

Se le dará una cadena de entrada, en cualquier lugar de la palabra "Lemon"se encuentra que debe ser convertido a "Lemonade" , pero el a, dy edebe ser tomado de otra parte de la frase.

Ejemplo

Entrada de ejemplo:

Encontré un limón cuando era niño

Salida de ejemplo:

Encontré una limonada cuando era niño

La limonada se creó robando las siguientes letras superíndice del original

Me foun ^d una limonada qu ^e n yo era ^un niño

Este es solo un posible ejemplo de salida, la "e", la "d" y la "a" podrían haberse tomado de cualquier parte ( excepto de la palabra, lemonpor supuesto )

Comentarios

• Si no hay suficientes e, ao ds, debe generar lo que fue posible con las letras dadas. Por ejemplo, la entrada bdblemonsaldríabblemond

• Es lemonposible que el texto no siempre sea independiente (espacio en cada lado). Por ejemplo, puede tener la palabra lemonsen algún lugar de la entrada y la salida debe serlemonades

• La entrada puede contener cualquier número de lemons, incluso 0 lemons (en cuyo caso la salida sería idéntica a la entrada)

• Puede hacer su limonada con letras mayúsculas y minúsculas, por ejemplo, leMonpodría convertirse leMonade, y el adeprestado puede ser cualquier caso (por lo que también podría haberse convertido leMonADe).
El caso de la carta que tomó prestada debe seguir siendo lo que era cuando la tomó prestada.
(Ejemplo de entrada -> salida, he hAD lemOn-> h h lemOnADe)

• No tiene que ser un programa completo, solo una función está bien.

• Puede suponer que la entrada será solo el conjunto de caracteres CP437

Code Golf

Este es el código de golf , por lo que gana el menor número de bytes.

Pseudo-TestCases

* Nota: Para cualquier entrada dada, puede haber múltiples salidas posibles, por lo que su programa puede no salir exactamente como lo hacen estos casos de prueba, esto es más para que las personas puedan entender la lógica:

Entrada: EpaD leMons
Salida: p LeMonaDEs

Entrada: hola mundo
Salida: hola mundo

Entrada: Limón Limón
Salida: Limón Limón
* ( La e, a, dlas cartas no deben ser tomadas de otra "Lemon")

Entrada: HE TENÍA limonada
Salida: HH lemonADEade

Entrada: ¿Te gustan los limones? ¡Me tenías en el limón!
Salida: o te gusta lemonADes? ¡Hmt limonada!

Entrada: AE lemon
Salida: lemonAE

Entrada: 55bad lemon
Salida: 55b lemonad

JavaScript (ES6), 159 157 155 162 bytes

Editar: +7 bytes para "mostrar lo que era factible con las letras dadas" en lugar de arrojar un error

Una función recursiva que devuelve la cadena 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``

Cómo funciona

La expresión s.split(/(lemon)/i)divide la cadena de entrada lemonpero conserva los grupos de captura en el resultado.

Por ejemplo, "foo lemon bar LEMON baz".split(/(lemon)/i)producirá la matriz [ 'foo ', 'lemon', ' bar ', 'LEMON', ' baz' ].

Nos recursiva iterar sobre esta matriz, la extracción de los personajes a, dy e, o sus equivalentes en mayúsculas de las entradas situadas en una posición aún más, y añadiéndolas a las entradas situadas en una posición extraña.

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

Manifestación

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

Esto se divide en dos líneas para mayor claridad; la nueva línea no se cuenta.

Pseudocó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

Pruébalo en línea!

Seguramente estoy haciendo algo mal aquí.