Et tout le monde a dit…

14

Objectif Étant donné une entrée de texte ne contenant pas de caractères [ou ], effectuez les actions suivantes:

  1. Pour chaque instance d' Amenau moins une lettre majuscule (donc toutes les instances d' Amenexclusion amen), sortez la même chose Amen(conservez les majuscules).
  2. Pour chaque instance de /all the people said[?: ]/i(c'est une expression régulière), également sortie Amen(dans tous les cas, ça va .)

Après chaque sortie, vous pouvez choisir n'importe quel séparateur constant , par exemple une nouvelle ligne, un espace ou rien.

Il s'agit d'un code-golf , donc le programme le plus court en octets l'emporte.

Exemples d'E / S

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

Prime

  • -20 octets si vous le pouvez « saisir » la ponctuation qui suit le Amen, à savoir Amen! => Amen!, AmEN. => AmEN., I said Amen, bruh. => Amen,et AMEN!!!! => AMEN!!!!. !est le seul caractère à être conservé plusieurs fois. .?!,sont les seuls caractères à être conservés ainsi.
  • -40 octets si, il y a une instance de amensortie, Heresy! at index [i]au lieu de rien, où [i]est l'index du mot incriminé ie amen.

IO bonus

L'entrée et la sortie sont de la forme input => output. (Le séparateur ici est un espace.)

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!

Classements

Voici un extrait de pile pour générer à la fois un classement régulier et un aperçu des gagnants par langue.

Pour vous assurer que votre réponse s'affiche, veuillez commencer votre réponse avec un titre, en utilisant le modèle de démarque suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les barrant. Par exemple:

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

Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou que vous souhaitez répertorier les pénalités de drapeau d'interprète séparément), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

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

Afficher l'extrait de code

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
la source
Les amens doivent-ils être en règle?
Zach Gates
@ZachGates Oui.
Conor O'Brien
Comment déterminez-vous «l'indice de la phrase incriminée»?
Zach Gates
@ZachGates être l'indice de adans amen. Par exemple, G amen => 2si votre langue est indexée zéro; 3 s'il est à un index.
Conor O'Brien
AMEN!!!! => AMEN!!!!et pourtant and a final Amen... => Amen.?
ThisSuitIsBlackNot

Réponses:

11

Rétine , 37 octets

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

Le code si 57 octets de long et se qualifie pour le bonus de -20 octets . Essayez-le en ligne!

Merci à @ MartinBüttner d'avoir porté ma réponse Perl sur Retina!

Comment ça fonctionne

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
la source
1
Puis-je utiliser votre ([.,?]|!*)modèle de correspondance de ponctuation pour ma réponse? Je l'ai vu et je ne pouvais pas le voir (et je n'ai certainement pas pu trouver de meilleure solution!). Cela ne va certainement pas battre le vôtre :), mais je ne veux pas plagier, et je ne suis pas totalement sûr de l'étiquette pour emprunter des solutions à des sous-problèmes comme celui-ci.
apsillers
3
@apsillers Légalement, tout le contenu ici est sous licence CC-BY-SA, ce qui signifie que vous pouvez l'utiliser librement avec attribution. Moralement, porter la solution de quelqu'un dans une autre langue pour le surpasser est plus ou moins mal vu, mais prendre une petite partie de la réponse de quelqu'un est toujours bien.
Dennis
7

VBA, 193 octets

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

Pas de séparation, pas de regex, pas de bonus. Avait une version qui a obtenu les deux Bonus mais était BEAUCOUP plus longue.

JimmyJazzx
la source
Vous pouvez perdre 1 octet en changeant for i=1 toenfor i=1To
Taylor Scott
5

Perl, 51 octets

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

Le code source réel contient 70 octets , il doit être exécuté avec perl -nE( +1 octet ) et il bénéficie du bonus de -20 octets .

Dennis
la source
4

Python 2, 155 octets

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

Exemple

$ python2 test.py
"All the people said Amen! And all the people said AMEN!"
AMen
Amen
AMen
AMEN
Portes Zach
la source
3

JavaScript, 88 octets

108 octets - 20 octets (capture la ponctuation)

alert(prompt().replace(/amen/g,' ').replace(/all the people said[?: ]/ig,'Amen').match(/amen(\??!?\.?)+/ig))
Tobsta
la source
Ceci imprime Amen?!.pour l'entrée Amen?!.et Amen!pour l'entrée Amen!!!.
Dennis
@Dennis Désolé, je n'ai pas pensé à utiliser plusieurs signes de ponctuation à la fois, je vais le réparer.
Tobsta
@Dennis vient de le corriger.
Tobsta
@apsillers Je ne l'ai pas remarqué non plus. J'essaierai de le réparer plus tard.
Tobsta
@apsillers Fixed
Tobsta
3

grep et sed, 85 83 84 77-20 = 57 octets

sed 's/all the people said[?: ]/Amenx/ig'|grep -oi 'amen[.,!?]*'|grep \[AMEN]
Thor
la source
1
Cela s'imprimera Amen?pour l'entrée all the people said??. La meilleure solution de contournement que j'ai pu trouver était de remplacer la chaîne par Amenx.
Dennis
Merci @Dennis, j'ai utilisé votre solution de contournement et mis à jour le score.
Thor
1
Cela s'imprimera amen.pour l'entrée amen.. La résolution de ce problème raccourcira votre réponse: passez simplement grep -v '^[amen]*$'à grep \[AMEN].
hvd
@hvd: Tu as raison, c'est beaucoup mieux :-)
Thor
3

Perl, 103 - 60 = 43 octets

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

En comptant le shebang comme un, l'entrée provient de stdin. Maintient la ponctuation pour -20 octets et identifie l'hérésie pour -40 .

Exemple d'utilisation

$ 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 octets

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

En comptant le shebang comme un, l'entrée provient de stdin. Maintient la ponctuation pour -20 octets.

Exemple d'utilisation

$ echo All the people said Amen, and all the people said AMEN!! | perl primo-amen.pl
AmenAmen,AmenAMEN!!
primo
la source
Votre première solution échoue pour la saisie comme ha]. (
Peu importe
@ThisSuitIsBlackNot Je ne pense pas que l'OP ait répondu à cette question.
Dennis
@ Dennis Ah, tu as raison. Encore un autre inconnu.
ThisSuitIsBlackNot
3

𝔼𝕊𝕄𝕚𝕟, 66-20 = 46 caractères / 80-20 = 60 octets

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

Essayez-le ici - Firefox uniquement.

Première fois ici à PPCGSE. J'espère que ce golf est plutôt bon.

EDIT: En fait, je bat CJam (en nombre de caractères), donc c'est plutôt bien!


la source
1
Oui, quelqu'un utilise ma langue! Pas mal pour votre premier post.
Mama Fun Roll
2

CJam, 57 octets

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

Le code est de 97 octets et se qualifie pour les -40 octets bonus de .

Essayez-le en ligne dans l' interpréteur CJam .

Dennis
la source
1
CJam est plus long que Perl? o_O
Conor O'Brien
CJam n'a pas d'expressions régulières, ce n'est donc pas du tout surprenant.
Dennis
Ohhh ... écrit cela
Conor O'Brien
2

JavaScript, 100 octets

alert(prompt().replace(/all the people said[?: ]/ig,'Amen').replace(/amen/g,'x').match(/amen/ig));
Nautile
la source
3
Vous pouvez utiliser x=prompt();et vous pouvez également utiliseralert(prompt().replace(...).replace(...).match)
Conor O'Brien
Terminé. Il fait maintenant 100 caractères.
Nautilus
2

JavaScript, 136 135 - 40 - 20 = 75 octets

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

Explication:

Ce code est piloté par une expression régulière en trois parties qui alimente les résultats dans un replacerappel . Les pièces sont:

  • all the people said[?: ]- correspond simplement au all the people saidmodèle requis
  • (amen)([.,?]|!*)- Autorise tout cas amenet la ponctuation (un .,?ou zéro ou plus !, ce qui rend l'option de ponctuation) en groupes séparés match - crédit à Dennis pour le modèle de ponctuation
  • . - correspond à tout autre personnage, ne faisant pas partie des modèles ci-dessus, un à la fois

Par conséquent, toute correspondance doit être soit une chaîne destinée à tous, une correspondance Amen avec une ponctuation facultative, soit un seul caractère ne faisant partie d'aucune de ces expressions. Nous utilisons la logique dans le rappel de remplacement pour enregistrer et remplacer les parties appropriées de la chaîne et changer tous les autres caractères en chaîne vide.

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
  )
)
absides
la source
1

Python 2, 191 - 40 = 151 octets

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

Pas de regex et Bonus 2

TFeld
la source