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

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

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

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.