Quando a vida lhe der limões, faça uma limonada

21

Desafio

Você será dado uma cadeia de entrada, em qualquer lugar a palavra "Lemon"é encontrada deve ser convertido para "Lemonade" , mas o a, de edeve ser emprestado de outro lugar na sentença.


Exemplo

Exemplo de entrada:

Encontrei limão quando criança

Saída de exemplo:

Eu encontro uma limonada quando eu era criança

A limonada foi criada roubando as seguintes letras sobrescritas do original

I foun d uma limonada wh e n eu era um garoto

Este é apenas um exemplo de saída possível, o "e", "d" e "a" podem ter sido obtidos de qualquer lugar ( exceto pela palavra, é lemonclaro )


Comentários

• Se não há o suficiente e, aou dé você deve saída o que era capaz de fazer com as cartas dadas. Por exemplo, a entrada bdblemonproduziriabblemond

• O lemontexto nem sempre pode ser autônomo (espaço em cada lado). Por exemplo, você pode ter a palavra lemonsem algum lugar da entrada e a saída deve serlemonades

• A entrada pode conter qualquer número de lemons, até 0 lemons (nesse caso, a saída seria idêntica à entrada)

• Você pode fazer sua limonada com letras maiúsculas e minúsculas, por exemplo, leMonpode se tornar leMonadee o adeemprestado pode ser qualquer caso (por isso, também pode ter se tornado leMonADe).
O caso da carta emprestada deve permanecer como era quando você a emprestou.
(Exemplo de entrada -> saída, he hAD lemOn-> h h lemOnADe)

• Não precisa ser um programa completo, apenas uma função é adequada.

• Você pode assumir que a entrada será apenas o conjunto de caracteres CP437


Code Golf

Este é , então o menor número de bytes vitórias!


Pseudo-TestCases

* Nota: Para qualquer entrada específica, pode haver várias saídas possíveis, para que seu programa não seja exibido exatamente como esses casos de teste, isso é mais apenas para que as pessoas possam entender a lógica:

Entrada: Limões EpaD
Saída: p LeMonaDEs

Entrada: Olá mundo
Saída: Olá mundo

Entrada: limão limão
saída: limão limão
* ( A e, a, dcartas nunca deve ser tirado de outra "Lemon")

Entrada: ELE TINHA limonada
Saída: HH lemonADEade

Entrada: Você gosta de limões? Você me adora no limão!
Saída: o você gosta de limão? Você hum limonada!

Entrada: AE lemon
Saída: lemonAE

Entrada: 55bad lemon
Saída: 55b lemonad

Albert Renshaw
fonte

Respostas:

6

JavaScript (ES6), 159 157 155 162 bytes

Edit: +7 bytes para "gerar o que era possível com as letras dadas" em vez de emitir um erro


Uma função recursiva que retorna a string modificada.

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

Como funciona

A expressão s.split(/(lemon)/i)divide a sequência de entrada, lemonmas preserva os grupos de captura no resultado.

Por exemplo, "foo lemon bar LEMON baz".split(/(lemon)/i)produzirá a matriz [ 'foo ', 'lemon', ' bar ', 'LEMON', ' baz' ].

Nós recursivamente iterar nesta matriz, extraindo os caracteres a, de eou os seus homólogos maiúsculas a partir das entradas situadas numa posição mesmo, e anexando-os para as entradas situadas numa posição estranho.

Comentado

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
fonte
Lançar um erro de recursão não parece estar de acordo com a primeira regra (" Se não houver o suficiente e, aou ds, você deve exibir o que era possível com as letras dadas. Por exemplo, a entrada bdblemonseria exibidabblemond ")?
Kevin Cruijssen
11
@KevinCruijssen Hmm, você está certo. Eu tinha quase certeza de que lançar um erro foi inicialmente permitido. Foi uma edição durante o período de carência da postagem inicial? (Ou isso ou eu sonhei.) De qualquer forma, vou tentar consertar isso. Obrigado por perceber.
Arnauld
Eu olhei para trás na história antes de fazer o meu comentário, para o caso de ter sido realmente editado. Você pode estar certo de que pode ter sido editado nos primeiros 5 minutos, mas não faz ideia de como verificar isso. E não há problema, sua resposta ainda é bastante impressionante, por isso vou marcar com +1 com antecedência. Não tenho dúvidas de que você será capaz de corrigir o problema (espero sem causar muitos bytes adicionados).
Kevin Cruijssen
@KevinCruijssen Isso está corrigido ao custo de 7 bytes por enquanto.
Arnauld #
2
@Arnauld Sim desculpe, eu editado que dentro dos primeiros 2 minutos da pós talvez haha, as minhas desculpas
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/\.{}

Isso é dividido em duas linhas para maior clareza; a nova linha não é contada.

Pseudo-código:

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
fonte
Estou triste isso não tem mais upvotes, grande resposta 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

Experimente online!

Certamente estou fazendo algo errado aqui.

Neil
fonte