Sfida

Vi sarà data una stringa di input, ovunque la parola "Lemon"è trovato che dovrebbe essere convertito "Lemonade" ma la a, de edeve essere preso in prestito da qualche altra parte nella frase.

Esempio

Esempio di input:

Ho trovato un limone da bambino

Esempio di output:

Ho fatto una limonata quando ero bambino

La limonata è stata creata rubando le seguenti lettere in apice dall'originale

Ho foun ^d una limonata wh ^e n ero ^un ragazzino

Questo è solo un possibile esempio di output, "e", "d" e "a" potrebbero essere stati presi da qualsiasi luogo ( tranne che per la parola lemonovviamente )

Commenti

• Se non ci sono abbastanza e, ao dsi S deve uscita che cosa era fattibile con le lettere indicate. Ad esempio, l'input bdblemonverrebbe emessobblemond

• Il lemontesto potrebbe non essere sempre autonomo (spazio su ciascun lato). Ad esempio, potresti avere la parola lemonsda qualche parte nell'input e l'output dovrebbe esserelemonades

• L'ingresso può contenere un numero qualsiasi di lemons, anche 0 lemons (nel qual caso l'uscita sarebbe identica all'ingresso)

• Puoi fare la tua limonata con lettere maiuscole e minuscole, ad esempio leMonpotrebbe diventare leMonade, e il adeprestito può essere comunque (quindi potrebbe anche essere diventato leMonADe).
Il caso della lettera che hai preso in prestito deve rimanere quello che era quando l'hai preso in prestito.
(Esempio input -> output, he hAD lemOn-> h h lemOnADe)

• Non deve essere un programma completo, una sola funzione va bene.

• Si può presumere che l'input sarà solo il set di caratteri CP437

Codice Golf

Questo è code-golf , quindi vince il numero più basso di byte!

Pseudo-testcases

* Nota: per ogni dato input potrebbero esserci più output possibili, quindi il tuo programma potrebbe non essere riprodotto esattamente come fanno questi casi di test, questo è più giusto così le persone possono capire la logica:

Ingresso: Limoni EpaD
Uscita: p LeMonaDE

Input: ciao mondo
Output: ciao mondo

Ingresso: limone limone
uscita: limone limone
* ( Il e, a, dle lettere non dovrebbero mai essere prese da un altro "Lemon")

Input: HE HAD lemonade
Output: HH lemonADEade

Input: Ti piacciono i limoni? Mi dai al limone!
Uscita: o ti piace lemonADes? Hmt limonata!

Input: AE lemon
Uscita: lemonAE

Ingresso: limone 55bad
Uscita: limone 55b

JavaScript (ES6), 159 157 155 162 byte

Modifica: +7 byte per "emettere ciò che è stato possibile con le lettere fornite" anziché eliminare un errore

Una funzione ricorsiva che restituisce la stringa modificata.

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

Come funziona

L'espressione s.split(/(lemon)/i)divide la stringa di input lemonma conserva i gruppi di acquisizione nel risultato.

Ad esempio, "foo lemon bar LEMON baz".split(/(lemon)/i)produrrà l'array [ 'foo ', 'lemon', ' bar ', 'LEMON', ' baz' ].

Abbiamo ricorsivamente iterate su questo array, estrazione dei caratteri a, de eo loro omologhi maiuscole dalle voci situati a una posizione ancora, e aggiungendole alle voci situati in una posizione dispari.

Commentate

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

dimostrazione

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 byte

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

Questo è diviso su due linee per chiarezza; la nuova riga non viene conteggiata.

pseudocodice:

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 byte

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

Provalo online!

Sicuramente sto facendo qualcosa di sbagliato qui.