Lorsque la vie vous donne des citrons, faites de la limonade


21

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

code-golf  string  code-golf  parsing  internet  stack-exchange-api  code-challenge  kolmogorov-complexity  restricted-source  brain-flak  python  logic  pyth  code-golf  string  search  optimized-output  code-golf  tips  language-design  golfing-language  code-golf  tips  language-design  code-golf  number  sorting  pi  code-golf  math  number  code-golf  string  balanced-string  classification  brain-flak  code-golf  math  number-theory  decision-problem  code-golf  tips  code-golf  number  sequence  code-golf  balanced-string  brain-flak  code-golf  math  sequence  arithmetic  fibonacci  code-golf  math  parsing  code-golf  string  keyboard  code-golf  code-golf  string  source-layout  whitespace  code-golf  math  rational-numbers  code-golf  string  code-golf  string  code-golf  math  sequence  code-golf  number  floating-point  code-golf  string  decision-problem  subsequence  code-golf  string  kolmogorov-complexity  code-golf  string  permutations  balanced-string  brain-flak  code-golf  string  math  number  code-golf  string  primes  cipher  code-golf  string  ascii-art  chemistry  code-golf  ascii-art  grid  counting  code-golf  math  arithmetic  integer  code-golf  number  kolmogorov-complexity  code-golf  ascii-art  kolmogorov-complexity  sequence  metagolf  brain-flak  code-golf  ascii-art  kolmogorov-complexity  code-golf  string  whitespace 

Réponses:


6

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


Lancer une erreur de récursivité ne semble pas conforme à la première règle (" S'il n'y en a pas assez e, aou ds vous devez afficher ce qui était faisable avec les lettres données. Par exemple, l'entrée bdblemongénéreraitbblemond ")?
Kevin Cruijssen

1
@KevinCruijssen Hmm, vous avez raison. J'étais presque certain que lancer une erreur était initialement autorisé. S'agit-il d'une modification pendant la période de grâce du message initial? (Soit ça, soit j'en ai rêvé.) Quoi qu'il en soit, je vais essayer de résoudre ce problème. Merci d'avoir remarqué.
Arnauld

J'ai regardé en arrière dans l'histoire avant de faire mon commentaire au cas où il aurait été édité. Vous avez peut-être raison, il a peut-être été modifié dans les 5 premières minutes, mais vous ne savez pas comment vérifier cela. Et pas de problème, votre réponse est encore assez impressionnante, donc je vais la +1 à l'avance. Je ne doute pas que vous serez en mesure de résoudre le problème (si tout va bien sans causer trop d'octets ajoutés).
Kevin Cruijssen

@KevinCruijssen C'est fixé au coût de 7 octets pour l'instant.
Arnauld

2
@Arnauld Oui désolé, je l'ai édité dans les 2 premières minutes du message peut-être haha, mes excuses
Albert Renshaw

5

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

Je suis triste que cela n'ait pas plus de votes positifs, excellente réponse imo
Albert Renshaw

4

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.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.