E tutte le persone hanno detto ...

14

Obiettivo Dato un input di testo che non contiene caratteri [o ], eseguire le seguenti azioni:

  1. Per ogni istanza di Amencon almeno una lettera maiuscola (quindi tutte le istanze di Amenesclusione amen), restituire la stessa Amen(conservare le maiuscole).
  2. Per ogni istanza di /all the people said[?: ]/i(che è un'espressione regolare), anche l'output Amen(comunque va bene).

Dopo ogni uscita, è possibile scegliere qualsiasi separatore costante , ad esempio una nuova riga, spazio o niente.

Questo è un codice-golf , quindi vince il programma più breve in byte.

IO di esempio

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

indennità

  • -20 byte se potete "afferrare" la punteggiatura che segue il Amen, cioè Amen! => Amen!, AmEN. => AmEN., I said Amen, bruh. => Amen,, e AMEN!!!! => AMEN!!!!. !è l'unico personaggio da conservare più volte. .?!,sono gli unici personaggi da conservare così.
  • -40 byte se, c'è un'istanza di amen, output, Heresy! at index [i]invece di niente, dove si [i]trova l'indice della parola offensiva amen.

IO bonus

L'input e l'output sono nella forma input => output. (Il separatore qui è uno spazio.)

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!

Classifiche

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad esempio perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

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

Mostra snippet di codice

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
Devono amenessere in ordine?
— Zach Gates,
@ZachGates Sì.
— Conor O'Brien,
Come si determina l '"indice della frase offensiva"?
— Zach Gates,
@ZachGates Per essere l'indice di ain amen. Ad esempio, G amen => 2se la lingua non è indicizzata; 3 se è un indice.
— Conor O'Brien,
AMEN!!!! => AMEN!!!!e ancora and a final Amen... => Amen.?
— ThisSuitIsBlackNon

Risposte:

11

Retina , 37 byte

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

Il codice è lungo 57 byte e si qualifica per il bonus di -20 byte . Provalo online!

Grazie a @ MartinBüttner per il porting della mia risposta Perl a Retina!

Come funziona

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 usare il ([.,?]|!*)modello di corrispondenza della punteggiatura per la mia risposta? L'ho visto e non potevo vederlo (e certamente non sono riuscito a trovare una soluzione migliore!). Certamente non battere il tuo :), ma non voglio plagiarmi, e non sono del tutto sicuro dell'etichetta per prendere in prestito soluzioni a problemi secondari come questo.
— apsillers,
3
@apsillers Legalmente, tutto il contenuto qui è concesso in licenza come CC-BY-SA, il che significa che è possibile utilizzarlo liberamente con attribuzione. Moralmente, portare la soluzione di qualcuno in un'altra lingua per superarlo è più o meno disapprovato, ma prendere una piccola parte della risposta di qualcuno va sempre bene.
— Dennis,
7

VBA, 193 byte

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

Nessuna separazione, nessun Regex, nessun bonus. Aveva una versione che aveva entrambi i bonus ma era MOLTO più lunga.

— JimmyJazzx
fonte
Si perde 1 byte byte cambiando for i=1 toinfor i=1To
— Taylor Scott
5

Perl, 51 byte

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

Il codice sorgente effettivo contiene 70 byte , deve essere eseguito con perl -nE( +1 byte ) e si qualifica per il bonus di -20 byte .

— Dennis
fonte
4

Python 2, 155 byte

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

Esempio

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

JavaScript, 88 byte

108 byte - 20 byte (cattura la punteggiatura)

alert(prompt().replace(/amen/g,' ').replace(/all the people said[?: ]/ig,'Amen').match(/amen(\??!?\.?)+/ig))
— Tobsta
fonte
Questo stampa Amen?!.per input Amen?!.e Amen!per input Amen!!!.
— Dennis,
@Dennis Spiacente, non ho pensato a più segni di punteggiatura utilizzati contemporaneamente, lo aggiusterò.
— Tobsta,
@Dennis L'ho appena risolto.
— Tobsta,
@apsillers Non l'ho notato neanche. Proverò a ripararlo più tardi.
— Tobsta,
@apsillers Fixed
— Tobsta
3

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

sed 's/all the people said[?: ]/Amenx/ig'|grep -oi 'amen[.,!?]*'|grep \[AMEN]
— Thor
fonte
1
Questo stamperà Amen?per l'input all the people said??. La soluzione migliore che ho trovato è stata quella di sostituire la stringa con Amenx.
— Dennis,
Grazie @Dennis, ho usato la tua soluzione alternativa e aggiornato il punteggio.
— Thor,
1
Questo stamperà amen.per l'input amen.. Risolvere questo accorcia la tua risposta: basta passare grep -v '^[amen]*$'a grep \[AMEN].
— hvd,
@hvd: hai ragione, va molto meglio :-)
— Thor,
3

Perl, 103 - 60 = 43 byte

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

Contando lo shebang come uno, l'input viene preso dallo stdin. Mantiene la punteggiatura per -20 byte e identifica l'eresia per -40 .

Esempio di utilizzo

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

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

Contando lo shebang come uno, l'input viene preso dallo stdin. Mantiene la punteggiatura per -20 byte.

Esempio di utilizzo

$ echo All the people said Amen, and all the people said AMEN!! | perl primo-amen.pl
AmenAmen,AmenAMEN!!
— Primo
fonte
La tua prima soluzione non riesce per input simili ha]. (Non importa, ho appena visto il commento del PO che l'input non può contenere parentesi quadre ... questa domanda si è trasformata così tante volte che non riesco a tenere traccia.)
— ThisSuitIsBlackNon
@ThisSuitIsBlackNot Non credo che l'OP abbia risposto a questa domanda.
— Dennis,
@Dennis Ah, hai ragione. Ancora un altro sconosciuto.
— ThisSuitIsBlackNon
3

𝔼𝕊𝕄𝕚𝕟, 66-20 = 46 caratteri / 80-20 = 60 byte

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

Provalo qui - solo Firefox.

Prima volta qui a PPCGSE. Spero che questo golf sia abbastanza buono.

EDIT: In realtà, sto battendo CJam (nel conteggio dei caratteri), quindi è abbastanza buono!

1
Yay, qualcuno sta usando la mia lingua! Non male per il tuo primo post.
— Mama Fun Roll,
2

CJam, 57 byte

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

Il codice è lungo 97 byte e si qualifica per il bonus di -40 byte .

Provalo online nell'interprete CJam .

— Dennis
fonte
1
CJam è più lungo di Perl? o_O
— Conor O'Brien,
CJam non ha espressioni regolari, quindi non è affatto sorprendente.
— Dennis,
Ohhh ... lo scrive giù
— Conor O'Brien il
2

JavaScript, 100 byte

alert(prompt().replace(/all the people said[?: ]/ig,'Amen').replace(/amen/g,'x').match(/amen/ig));
— nautilo
fonte
3
Puoi usare x=prompt();e puoi anche usarealert(prompt().replace(...).replace(...).match)
— Conor O'Brien il
Fatto. Ora è lungo 100 caratteri.
— Nautilus,
2

JavaScript, 136 135 - 40 - 20 = 75 byte

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

Spiegazione:

Questo codice è guidato da una regex in tre parti che inserisce i risultati in un replacecallback . Le parti sono:

  • all the people said[?: ]- corrisponde semplicemente al all the people saidmodello richiesto
  • (amen)([.,?]|!*)- abbina ogni caso amene punteggiatura (uno .,?o zero o più !, il che rende facoltativa la punteggiatura) in gruppi di corrispondenza separati - credito a Dennis per il modello di punteggiatura
  • . - corrisponde a qualsiasi altro personaggio, non parte dei modelli precedenti, uno alla volta

Pertanto, ogni corrispondenza deve essere una stringa di tutte le persone, una corrispondenza di Amen con punteggiatura opzionale o un singolo carattere che non fa parte di nessuna di queste frasi. Usiamo la logica nel callback del sostituto per salvare e sostituire le parti appropriate della stringa e cambiare ogni altro carattere nella stringa vuota.

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 byte

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

Nessuna regex e Bonus 2

— TFeld
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.