Wenn das Leben dir Zitronen gibt, mach Limonade daraus

21

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

Albert Renshaw
quelle

Antworten:

6

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

Arnauld
quelle
Eine Rekursion-Fehler zu werfen scheint nicht auf die erste Regel ( „einzuhalten Wenn es nicht genug e, aoder ds müssen Sie die Ausgabe , was mit den gegebenen Buchstaben war tun können. Zum Beispiel die Eingabe bdblemonausgeben würdebblemond “)?
Kevin Cruijssen
1
@ KevinCruijssen Hmm, du hast recht. Ich war mir fast sicher, dass das Werfen eines Fehlers anfangs erlaubt war. War es eine Bearbeitung während der Kulanzzeit des ersten Beitrags? (Entweder das oder ich habe es geträumt.) Wie auch immer, ich werde versuchen, das zu beheben. Danke fürs bemerken.
Arnauld
Ich habe in den Verlauf zurückgeschaut, bevor ich einen Kommentar abgegeben habe, falls er tatsächlich herausgeschnitten wurde. Sie könnten Recht haben, dass es in den ersten 5 Minuten bearbeitet wurde, aber Sie wissen nicht, wie Sie das überprüfen sollen. Und kein Problem, Ihre Antwort ist immer noch ziemlich beeindruckend, also werde ich sie im Voraus +1 geben. Ich bezweifle nicht, dass Sie das Problem beheben können (hoffentlich ohne zu viele hinzugefügte Bytes zu verursachen).
Kevin Cruijssen
@ KevinCruijssen Das ist auf die Kosten von 7 Bytes für jetzt behoben.
Arnauld
2
@Arnauld Ja, tut mir leid, ich habe das in den ersten 2 Minuten des Beitrags bearbeitet, haha, ich entschuldige mich
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/\.{}

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))
Esolanging Fruit
quelle
Ich bin traurig, dass dies nicht mehr Stimmen hat, tolle Antwort imo
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

Probieren Sie es online!

Sicher mache ich hier etwas falsch.

Neil
quelle