Défi

Vous recevrez une chaîne d'entrée, où le mot "Lemon"est trouvé , il doit être converti en , "Lemonade" mais la a, det edoit être emprunté à un autre endroit dans la phrase.

Exemple

Exemple d'entrée:

J'ai trouvé un citron quand j'étais enfant

Exemple de sortie:

Je trouve une limonade quand j'étais enfant

La limonade a été créée en volant les lettres en exposant suivantes de l'original

Je Foun ^d une limonade wh ^e n J'étais ^un enfant

Ceci n'est qu'un exemple de sortie possible, les "e", "d" et "a", auraient pu être pris de n'importe où ( sauf pour le mot lemonbien sûr )

commentaires

• S'il n'y a pas assez e, aou dvous devez s sortie ce qui était faisable avec les lettres données. Par exemple, l'entrée bdblemonproduiraitbblemond

• Le lemontexte n'est pas toujours autonome (espace de chaque côté). Par exemple, vous pouvez avoir le mot lemonsquelque part dans l'entrée et la sortie doit êtrelemonades

• L'entrée peut contenir n'importe quel nombre de lemons, même 0 lemons (auquel cas la sortie serait identique à l'entrée)

• Vous pouvez faire votre limonade avec des lettres majuscules et minuscules, par exemple leMonpourrait devenir leMonade, et l' adeemprunté peut être n'importe quel cas (il pourrait donc aussi être devenu leMonADe).
Le cas de la lettre que vous avez empruntée doit rester ce qu'elle était lorsque vous l'avez empruntée.
(Exemple entrée -> sortie, he hAD lemOn-> h h lemOnADe)

• Ne doit pas être un programme complet, une fonction seule est très bien.

• Vous pouvez supposer que la saisie sera uniquement le jeu de caractères CP437

Code Golf

C'est du code-golf , donc le plus petit nombre d'octets gagne!

Pseudo-tests

* Remarque: pour une entrée donnée, il peut y avoir plusieurs sorties possibles, de sorte que votre programme peut ne pas produire exactement comme ces cas de test, c'est plus juste pour que les gens puissent comprendre la logique:

Entrée: EpaD leMons
Sortie: p LeMonaDEs

Entrée: hello world
Sortie: hello world

Entrée: citron citron
sortie: citron citron
* ( Le e, a, les dlettres ne doivent jamais être pris d' une autre "Lemon")

Entrée: HE HAD limonade
Sortie: HH lemonADEade

Entrée: Aimez-vous les citrons? Tu m'as eu au citron!
Sortie: o vous aimez les lemonADes? Vous hmt limonade!

Entrée: AE lemon
Sortie: lemonAE

Entrée: 55bad lemon
Sortie: 55b lemonad

JavaScript (ES6), 159 157 155 162 octets

Edit: +7 octets pour "sortir ce qui était faisable avec les lettres données" plutôt que de jeter une erreur

Une fonction récursive qui renvoie la chaîne modifiée.

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

Comment ça marche

L'expression s.split(/(lemon)/i)fractionne la chaîne d'entrée lemonmais conserve les groupes de capture dans le résultat.

Par exemple, "foo lemon bar LEMON baz".split(/(lemon)/i)produira le tableau [ 'foo ', 'lemon', ' bar ', 'LEMON', ' baz' ].

Nous récursive itérer sur ce tableau, l' extraction des caractères a, det eou leurs homologues majuscules des entrées situées à une position même, et en les ajoutant aux entrées situées à une position bizarre.

Commenté

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

Démo

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 octets

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

Ceci est divisé en deux lignes pour plus de clarté; la nouvelle ligne n'est pas comptée.

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

Rétine , 303 octets

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

Essayez-le en ligne!

Je fais sûrement quelque chose de mal ici.