E todas as pessoas disseram ...

14

Objetivo Dada uma entrada de texto que não contém caracteres [ou ], execute as seguintes ações:

  1. Para todas as instâncias Amencom pelo menos uma letra maiúscula (todas as instâncias de Amenexclusão amen), produza a mesma Amen(retenha maiúsculas).
  2. Para cada instância de /all the people said[?: ]/i(que é uma expressão regular), também a saída Amen(qualquer caso é bom).

Após cada saída, você pode escolher qualquer separador constante , por exemplo, uma nova linha, espaço ou nada.

Este é um código de golfe , portanto o programa mais curto em bytes vence.

Exemplos de veiculação

Input: I said AMEN! AMEN, PEOPLE!
Output: AMENAMEN         ; any separator is fine, I choose none.

Input: amen amen amen amen
Output:                  ; nothing

Input:                   ; empty
Output:                  ; nothing

Input: *blah blah blah* And all the people said?
Output: Amen

Input: all the people said:
Output: Amen

Input: AMEN AMeN AmeN aMEN amen AmEn
Output: AMEN AMeN AmeN aMEN AmEn

Input: All the people said Amen! And all the people said AMEN!
Output: Amen Amen Amen AMEN

Input: LAMEN! Amen.
Output: AMEN Amen

Input: AmenAmenAmenAmenAMENamen
Output: Amen Amen Amen Amen AMEN

Input: And he was like, "Amen", then we were all like, "Amen, bruh."
Output: Amen Amen

Input: And all the aMen people said.
Output: aMen

Bônus

  • -20 bytes se você pode "agarrar" a pontuação que segue o Amen, ou seja, Amen! => Amen!, AmEN. => AmEN., I said Amen, bruh. => Amen,, e AMEN!!!! => AMEN!!!!. !é o único caractere a ser preservado várias vezes. .?!,são os únicos caracteres a serem preservados dessa maneira.
  • -40 bytes se, houver uma instância de amenoutput, em Heresy! at index [i]vez de nada, onde [i]está o índice da palavra incorreta, ie amen.

IOs de bônus

Entrada e saída é da forma input => output. (Separador aqui é um espaço.)

BONUS 1
Can I get an Amen! => Amen!
AMEN! and AMEN! and a final Amen... => AMEN! AMEN! Amen.
Amen? Amen, and amEn! => Amen? Amen, amEn!

BONUS 2
The man sighed and said, "amen," and left. It's AMEN! => Heresy! at index [26] AMEN!

Classificação

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma.

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

# Perl, 43 + 2 (-p flag) = 45 bytes

Você também pode transformar o nome do idioma em um link que será exibido no snippet do placar de líderes:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Mostrar snippet de código

code-golf string code-golf tips burlesque code-golf typography fastest-code set-theory code-golf math arithmetic metagolf stack starry code-golf ascii-art grid code-golf typography code-golf ascii-art kolmogorov-complexity code-golf parsing code-golf string parsing balanced-string code-golf number sequence binary balanced-string code-golf parsing Conor O'Brien
fonte
Os amens precisam estar em ordem?
Zach Gates,
@ZachGates Sim.
Conor O'Brien
Como você determina o "índice da frase incorreta"?
Zach Gates,
@ZachGates Para ser o índice do ain amen. Por exemplo, G amen => 2se o seu idioma for indexado a zero; 3 se for um indexado.
Conor O'Brien
AMEN!!!! => AMEN!!!!e ainda and a final Amen... => Amen.?
carregar a caixa de mensagens

Respostas:

11

Retina , 37 bytes

S`amen
i`all the people said[?: ]
amenx
!i`amen([.,?]|!*)

O código tem 57 bytes de comprimento e se qualifica para o bônus de -20 bytes . Experimente online!

Obrigado a @ MartinBüttner por enviar minha resposta Perl para Retina!

Como funciona

S`                          Split the input at...
  amen                      matches of "amen".
i`                          Case-insensitively search for
  all the people said[?: ]  matches of "all the people said",
                            followed by '?', ':' or ' '...
    amenx                   and replace them with "amenx"
!i`                         Print all case-insensitive matches of...
  amen([.,?]|!*)            "amen", followed either by a single '.',
                            ',' or '?', or by 0 or more '!'s.
Dennis
fonte
1
Posso usar seu ([.,?]|!*)padrão de correspondência de pontuação para minha resposta? Eu o vi e não pude deixar de vê-lo (e certamente não consegui encontrar uma solução melhor!). Certamente não vai superar o seu :), mas não quero plagiar, e não tenho certeza absoluta da etiqueta para pedir soluções emprestadas para subproblemas como esse.
Apsillers
3
@apsillers Legalmente, todo o conteúdo aqui é licenciado como CC-BY-SA, o que significa que você pode usá-lo livremente com atribuição. Moralmente, portar a solução de alguém para outro idioma para derrotá-lo é mais ou menos desaprovado, mas tirar uma pequena parte da resposta de alguém é sempre bom.
Dennis
7

VBA, 193 bytes

Function v(b)
For i=1 To Len(b)
If StrConv(Mid(b,i,19),2) Like "all the people said" Then v=v& "Amen"
q=Mid(b,i,4):k="amen"
If StrConv(q,2) Like k And Not q Like k Then v=v& q
Next
End Function

Sem separação, sem Regex, sem bônus. Tinha uma versão que recebia os dois bônus, mas era muito mais longa.

JimmyJazzx
fonte
Você perde 1 byte byte alterando for i=1 toparafor i=1To
Taylor Scott
5

Perl, 51 bytes

s/amen/x/g;s/all the people said[?: ]/amenx/ig;say/amen[.,?]|amen!*/ig

O código fonte real contém 70 bytes , deve ser executado com perl -nE( +1 byte ) e se qualifica para o bônus de -20 bytes .

Dennis
fonte
4

Python 2, 155 bytes

from re import*
F,m=findall,"((?i)amen)"
for i in split(m,input()):
 if F("((?i)all the people said[?: ])",i):print'AMen'
 elif F(m,i)and i!="amen":print i

Exemplo

$ python2 test.py
"All the people said Amen! And all the people said AMEN!"
AMen
Amen
AMen
AMEN
Zach Gates
fonte
3

JavaScript, 88 bytes

108 bytes - 20 bytes (captura a pontuação)

alert(prompt().replace(/amen/g,' ').replace(/all the people said[?: ]/ig,'Amen').match(/amen(\??!?\.?)+/ig))
Tobsta
fonte
Isso imprime Amen?!.para entrada Amen?!.e Amen!para entrada Amen!!!.
Dennis
@ Dennis Desculpe, não pensei em vários sinais de pontuação sendo usados ​​ao mesmo tempo, eu vou consertar.
Tobsta
@ Dennis Apenas consertou.
Tobsta
@apsillers Também não percebeu isso. Vou tentar consertar isso mais tarde.
Tobsta
@apsillers Fixed
Tobsta
3

grep e sed, 85 83 84 77 - 20 = 57 bytes

sed 's/all the people said[?: ]/Amenx/ig'|grep -oi 'amen[.,!?]*'|grep \[AMEN]
Thor
fonte
1
Isso será impresso Amen?para a entrada all the people said??. A melhor solução alternativa que pude encontrar foi substituir a string Amenx.
Dennis
Obrigado @Dennis, usei sua solução alternativa e atualizei a pontuação.
Thor
1
Isso será impresso amen.para a entrada amen.. Corrigir isso diminuirá sua resposta: basta alterar grep -v '^[amen]*$'para grep \[AMEN].
hvd
@hvd: Você está certo, isso é muito melhor :-)
Thor
3

Perl, 103 - 60 = 43 bytes

#!perl -p
s/amen/Heresy! at index [@-]/g;s/all the people said[?: ]/Amen /gi;s/(amen([.,?]|!*)|h[^h]+\])\K|.//gi

Contando o shebang como um, a entrada é obtida de stdin. Mantém pontuação para -20 bytes e identifica heresia para -40 .

Uso da amostra

$ echo amen amen, and all the people said?? amen amen | perl amen.pl
Heresy! at index [0]Heresy! at index [5]AmenHeresy! at index [37]Heresy! at index [42]

$ echo AMEN AMeN AmeN aMEN amen AmEn | perl amen.pl
AMENAMeNAmeNaMENHeresy! at index [20]AmEn

$ echo The man sighed and said, "amen," and left. It's AMEN! | perl amen.pl
Heresy! at index [26]AMEN!

Perl, 70 - 20 = 50 bytes

#!perl -p
s/all the people said[?: ]/Amen /gi;s/amen|(?i:amen([.,?]|!*))\K|.//g

Contando o shebang como um, a entrada é obtida de stdin. Mantém pontuação para -20 bytes.

Uso da amostra

$ echo All the people said Amen, and all the people said AMEN!! | perl primo-amen.pl
AmenAmen,AmenAMEN!!
primo
fonte
Sua primeira solução falha para entrada como ha]. (Não importa, só vi o comentário do OP que a entrada não pode conter colchetes ... esta questão se transformou tantas vezes eu não consigo acompanhar.)
ThisSuitIsBlackNot
@ThisSuitIsBlackNot Não acho que o OP tenha respondido a essa pergunta.
Dennis
@ Dennis Ah, você está certo. Mais um desconhecido.
carregar a caixa de mensagens
3

66, 66 - 20 = 46 caracteres / 80 - 20 = 60 bytes

ïċ/all the people said[?: ]⍀,`Amen”ċ(/amen⌿,`x”ĉ/amen(\??!?\.?)+⍀)

Experimente aqui - apenas no Firefox.

Primeira vez aqui no PPCGSE. Espero que este golfe seja muito bom.

Edição: Na verdade, eu estou batendo CJam (em contagem de caracteres), então isso é muito bom!


fonte
1
Sim, alguém está usando o meu idioma! Nada mal para o seu primeiro post.
Mama Fun Roll
2

CJam, 57 bytes

 q_,,\f{\:I>_4<_el"amen":A=*_A="Heresy! at index ["I+']+@?oK<)"?: "&,*el"all the people said"=A*o}

O código tem 97 bytes de comprimento e se qualifica para o bônus de -40 bytes .

Experimente on-line no intérprete CJam .

Dennis
fonte
1
CJam é mais longo que Perl? o_O
Conor O'Brien
CJam não tem expressões regulares, então isso não é de todo surpreendente.
Dennis
Ohhh ... escreve isso abaixo
Conor O'Brien
2

JavaScript, 100 bytes

alert(prompt().replace(/all the people said[?: ]/ig,'Amen').replace(/amen/g,'x').match(/amen/ig));
Nautilus
fonte
3
Você pode usar x=prompt();e também pode usaralert(prompt().replace(...).replace(...).match)
Conor O'Brien
Feito. Agora são 100 caracteres.
Nautilus
2

JavaScript, 136 135 - 40 - 20 = 75 bytes

alert(prompt(A="ameN").replace(/all the people said[?: ]|(amen)([.,?]|!*)|./ig,(v,a,p,i)=>a?a>A?`Heresy! at index [${i}]`:v:v[1]?A:""))

Explicação:

Esse código é direcionado por um regex de três partes que alimenta resultados em um replaceretorno de chamada . As peças são:

  • all the people said[?: ]- simplesmente corresponde ao all the people saidpadrão necessário
  • (amen)([.,?]|!*)- corresponde a qualquer caso amene pontuação (um .,?ou zero ou mais !, o que torna a pontuação opcional) em grupos de correspondência separados - atribui a Dennis o padrão de pontuação
  • . - corresponde a qualquer outro caractere, que não faça parte dos padrões acima, um de cada vez

Portanto, qualquer correspondência deve ser uma sequência de pessoas comuns, uma correspondência de Amém com pontuação opcional ou um único caractere que não faça parte de nenhuma dessas frases. Usamos a lógica no retorno de chamada substituto para salvar e substituir as partes apropriadas da sequência e alteramos todos os outros caracteres para a sequência vazia.

alert(
  // store "ameN" in `A` and then prompt
  prompt(A="ameN")
    .replace(
      // three-part regex:
      /all the people said[?: ]|(amen)([.,?]|!*)|./ig,

      // replacer callback, with arguments
      //   v - total match
      //   a - "amen" match group
      //   p - punctuation match group (unused)
      //   i - index of match
     (v,a,p,i)=>
        a?           // if there is an Amen match
          a>A?      //   if the Amen is lowercase (lexically more than "ameN")
               `Heresy! at index [${i}]`
              :v     //   otherwise, output full Amen with punctuation
         :v[1]?      // if there is no Amen, but more than one character
          A          //   this must be all-the-people; output "ameN"
         :""         // otherwise, not an Amen or all-the-people
  )
)
apsillers
fonte
1

Python 2, 191 - 40 = 151 bytes

i=input()
a='amen'
for j in range(len(i)):
 s=i[j:j+20];w=s[:4]
 if s[:-1].lower()=="all the people said"and s[-1]in'?: ':print a
 if w.lower()==a:print'Heresy! at index[%d]'%j if w==a else w

Sem regex e bônus 2

TFeld
fonte