Kiedy życie daje ci cytryny, zrób lemoniadę

21

Wyzwanie

Będziesz mieć ciąg wejściowy i wszędzie słowo "Lemon"występuje powinien być przekształcony "Lemonade" alea , di emuszą być zapożyczone z innego miejsca w zdaniu.


Przykład

Przykładowe dane wejściowe:

Gdy byłem dzieckiem, znalazłem cytrynę

Przykładowe dane wyjściowe:

I Founda na lemoniadę whn byłem dzieckiem

Lemonade został stworzony przez kradzież następujące literami w indeksie górnym od oryginału

I Founda d lemoniady WH e n ja dziecko

Jest to tylko jeden możliwy przykład wyjścia: „e”, „d” i „a” można pobrać z dowolnego miejsca ( z wyjątkiem lemonoczywiście słowa )


Komentarze

• Jeśli nie ma wystarczającej liczby e, alub ds, musisz wypisać, co było możliwe z podanymi literami. Na przykład dane bdblemonwyjściowe zostaną wyprowadzonebblemond

lemonTekst może nie zawsze być samodzielny (spacja po każdej stronie). Na przykład możesz mieć słowo lemonsgdzieś na wejściu, a wynik powinien byćlemonades

• Wejście może zawierać dowolną liczbę lemons, nawet 0 lemons (w takim przypadku dane wyjściowe byłyby identyczne z danymi wejściowymi)

• Można dokonać lemoniadę z wielkich i małych liter, na przykład leMonmoże stać leMonade, a adepożyczone może być każdy przypadek (więc może to też stały leMonADe).
Przypadek pożyczonego listu musi pozostać taki, jak w momencie pożyczenia.
(Przykładowe wejście -> wyjście, he hAD lemOn-> h h lemOnADe)

• Nie musi to być pełny program, sama funkcja jest w porządku.

• Możesz założyć, że wprowadzony będzie tylko zestaw znaków CP437


Code Golf

To jest , więc wygrywa najmniejsza liczba bajtów!


Pseudo-TestCases

* Uwaga: Dla każdego podanego wejścia może być wiele możliwych wyników, więc Twój program może nie generować danych dokładnie tak, jak robią to te przypadki testowe, jest to po prostu po to, aby ludzie mogli zrozumieć logikę:

Wejście: lePony EpaD
Wyjście: p LeMonaDEs

Wejście: witaj świecie
Wyjście: witaj świecie

Wejście: cytryna
wyjściowa: cytryna
* ( , , listów nigdy nie powinny być podejmowane z innej "Lemon")ead

Wejście: HE HAD lemoniada
Wyjście: HH lemonADEade

Wkład: Czy lubisz cytryny? Dajesz mi cytrynę!
Wyjście: o lubisz lemonADes? Hmt lemoniada!

Wejście: cytryna AE
Wyjście: cytryna AE

Wejście: lemoniada
55b Wyjście: lemoniada 55b

Albert Renshaw
źródło

Odpowiedzi:

6

JavaScript (ES6), 159 157 155 162 bajtów

Edycja: +7 bajtów, aby „wypisać, co było możliwe z podanymi literami”, zamiast wyrzucać błąd


Funkcja rekurencyjna, która zwraca zmodyfikowany ciąg.

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

Jak to działa

Wyrażenie s.split(/(lemon)/i)dzieli łańcuch wejściowy, lemonale zachowuje grupy przechwytywania w wyniku.

Na przykład "foo lemon bar LEMON baz".split(/(lemon)/i)wytworzy tablicę [ 'foo ', 'lemon', ' bar ', 'LEMON', ' baz' ].

Mamy rekurencyjnie iterate na tej tablicy, wyodrębnianie znaków a, di eczy ich wielkie odpowiedniki z zapisów znajdujących się na pozycjach parzystych i dołączanie ich do zapisów znajdujących się w dziwnym położeniu.

Skomentował

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

Próbny

Arnauld
źródło
Zgłoszenie błędu rekurencji wydaje się być niezgodne z pierwszą regułą („ Jeśli nie ma wystarczającej liczby e, alub ds, musisz wypisać, co było możliwe z podanymi literami. Na przykład, dane wejściowe bdblemonwypiszebblemond ”)?
Kevin Cruijssen
1
@KevinCruijssen Hmm, masz rację. Byłem prawie pewien, że początkowo dozwolone było zgłoszenie błędu. Czy była to edycja w okresie karencji pierwszego postu? (Albo to, albo mi się śniło.) W każdym razie postaram się to naprawić. Dzięki za zauważenie.
Arnauld
Spojrzałem na historię, zanim wypowiedziałem się na wypadek, gdyby rzeczywiście została wydana. Być może masz rację, być może została zredagowana w ciągu pierwszych 5 minut, ale nie wiesz, jak to sprawdzić. I nie ma problemu, twoja odpowiedź jest wciąż imponująca, więc dawam +1 z góry. Nie mam wątpliwości, że będziesz w stanie rozwiązać problem (mam nadzieję, że nie spowoduje to zbyt dużej liczby dodanych bajtów).
Kevin Cruijssen
@KevinCruijssen Na razie jest to ustalone na 7 bajtów.
Arnauld
2
@Arnauld Tak przepraszam, zredagowałem to w ciągu pierwszych 2 minut postu może haha, przepraszam
Albert Renshaw
5

CJam, 130 bajtów

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

Jest to podzielone na dwie linie dla jasności; nowa linia nie jest liczona.

Pseudo kod:

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
źródło
Jest mi smutno, że nie ma więcej pozytywnych opinii, świetna odpowiedź imo
Albert Renshaw
4

Siatkówka , 303 bajty

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

Wypróbuj online!

Z pewnością robię tu coś złego.

Neil
źródło