Herausforderung

Sie erhalten eine Eingabezeichenfolge, überall das Wort gegeben , "Lemon"es zu finden ist umgewandelt werden soll , "Lemonade" aber das a, dund emuss von irgendwo anders in dem Satz ausgeliehen werden.

Beispiel

Beispiel Eingabe:

Ich habe als Kind eine Zitrone gefunden

Beispielausgabe:

Ich trinke eine Limonade, als ich noch ein Kind war

Die Limonade wurde erstellt, indem die folgenden hochgestellten Buchstaben aus dem Original gestohlen wurden

Ich foun ^d eine Limonade wh ^e n Ich war ^ein Kind

Dies ist nur ein mögliches Ausgabebeispiel, das "e", "d" und "a" hätte von überall her genommen werden können ( außer lemonnatürlich vom Wort )

Bemerkungen

• Wenn nicht genug e, aoder ds vorhanden sind, müssen Sie ausgeben, was mit den angegebenen Buchstaben möglich war. Zum Beispiel würde die Eingabe bdblemonausgebenbblemond

• Der lemonText ist möglicherweise nicht immer eigenständig (Leerzeichen auf jeder Seite). Zum Beispiel können Sie das Wort lemonsirgendwo in der Eingabe haben und die Ausgabe sollte seinlemonades

• Die Eingabe kann eine beliebige Anzahl von lemons enthalten, auch 0 lemons (in diesem Fall wäre die Ausgabe identisch mit der Eingabe).

• Sie können Ihre Limonade mit Groß- und Kleinbuchstaben machen, zum Beispiel leMonwerden könnten leMonade, und die adegeliehenen kann jeder Fall sein (so ist es auch hätte werden können leMonADe).
Der Fall des Briefes, den Sie ausgeliehen haben, muss so bleiben, wie er war, als Sie ihn ausgeliehen haben.
(Beispiel Eingabe -> Ausgabe, he hAD lemOn-> h h lemOnADe)

• Muss kein vollständiges Programm sein, eine Funktion alleine ist in Ordnung.

• Sie können davon ausgehen, dass nur der CP437-Zeichensatz eingegeben wird

Code Golf

Das ist Code-Golf , also gewinnt die niedrigste Anzahl von Bytes!

Pseudo-Testfälle

* Hinweis: Für eine bestimmte Eingabe gibt es möglicherweise mehrere mögliche Ausgaben, sodass Ihr Programm möglicherweise nicht genau so ausgibt wie in diesen Testfällen.

Eingabe: epad leMons ausgabe
: p leMonaDEs

Eingabe: Hallo Welt
Ausgabe: Hallo Welt

Input: Zitrone Zitrone
Ausgang: Zitrone Zitrone
* ( Die e, a, dsollten Briefe nie von einer anderen "Lemon" entnommen werden)

Input: Er hatte Limonade
Output: HH Limonade

Input: Magst du Zitronen? Du hast mich an Zitrone!
Output: Magst du lemonADes? Sie hmt Limonade!

Input: AE Zitrone
Output: lemonAE

Input: 55bad Zitrone
Output: 55b Limonade

JavaScript (ES6), 159 157 155 162 Bytes

Bearbeiten: +7 Bytes, um "auszugeben, was mit den angegebenen Buchstaben möglich war", anstatt einen Fehler auszugeben

Eine rekursive Funktion, die die geänderte Zeichenfolge zurückgibt.

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

Wie es funktioniert

Der Ausdruck s.split(/(lemon)/i)teilt die Eingabezeichenfolge auf lemon, behält jedoch die Erfassungsgruppen im Ergebnis bei.

Zum Beispiel "foo lemon bar LEMON baz".split(/(lemon)/i)wird das Array erzeugt [ 'foo ', 'lemon', ' bar ', 'LEMON', ' baz' ].

Wir iterieren rekursiv auf dieser Anordnung, Extraktion der Zeichen a, dund eoder deren Groß Pendants aus den Einträgen in einer geraden Stellung befindet, und sie in den Einträgen an einer ungeraden Position anhängt.

Kommentiert

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

Dies ist aus Gründen der Klarheit auf zwei Zeilen aufgeteilt. Der Zeilenumbruch wird nicht gezählt.

Pseudocode:

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

Probieren Sie es online!

Sicher mache ich hier etwas falsch.