Cuando la vida te da limones, haz limonada

21

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

Albert Renshaw
fuente

Respuestas:

6

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

Arnauld
fuente
Lanzar un error de recursión no parece cumplir con la primera regla (" Si no hay suficientes e, ao ds, debe generar lo que se puede hacer con las letras dadas. Por ejemplo, la entrada bdblemongeneraríabblemond ").
Kevin Cruijssen
1
@KevinCruijssen Hmm, tienes razón. Estaba casi seguro de que lanzar un error inicialmente estaba permitido. ¿Fue una edición durante el período de gracia de la publicación inicial? (O eso o lo soñé.) De todos modos, intentaré arreglar eso. Gracias por notarlo.
Arnauld
Miré hacia atrás en la historia antes de hacer mi comentario en caso de que fuera editado. Podría tener razón, podría haber sido editado en los primeros 5 minutos, pero no tengo idea de cómo verificar eso. Y no hay problema, su respuesta sigue siendo bastante impresionante, por lo que haré +1 por adelantado. No tengo dudas de que podrá solucionar el problema (con suerte sin causar demasiados bytes agregados).
Kevin Cruijssen
@KevinCruijssen Eso está arreglado al costo de 7 bytes por ahora.
Arnauld
2
@Arnauld Sí, lo siento, lo edité en los primeros 2 minutos de la publicación tal vez jaja, mis disculpas
Albert Renshaw
5

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))
Fruta Esolanging
fuente
Me entristece que esto no tenga más votos a favor, gran respuesta de la OMI
Albert Renshaw
4

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í.

Neil
fuente