Y toda la gente dijo ...

14

Objetivo Dada una entrada de texto que no contiene caracteres [o ], realice las siguientes acciones:

  1. Para cada instancia Amencon al menos una letra mayúscula (por lo que todas las instancias de Amenexclusión amen), produzca lo mismo Amen(retener mayúsculas)
  2. Para cada instancia de /all the people said[?: ]/i(que es una Expresión regular), también salida Amen(cualquier caso está bien).

Después de cada salida, puede elegir cualquier separador constante , por ejemplo, una nueva línea, espacio o nada.

Este es un código de golf , por lo que gana el programa más corto en bytes.

Ejemplo IOs

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

Prima

  • -20 bytes si se puede "agarrar" la puntuacion que sigue el Amen, es decir, Amen! => Amen!, AmEN. => AmEN., I said Amen, bruh. => Amen,, y AMEN!!!! => AMEN!!!!. !es el único personaje que se conserva varias veces. .?!,son los únicos personajes que se conservan así.
  • -40 bytes si, hay una instancia de amensalida, en Heresy! at index [i]lugar de nada, donde [i]está el índice de la palabra ofensiva, es decir amen.

Bonus IOs

Entrada y salida es de la forma input => output. (El separador aquí es un espacio).

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!

Tablas de clasificación

Aquí hay un fragmento de pila para generar una tabla de clasificación regular y una descripción general de los ganadores por idioma.

Para asegurarse de que su respuesta se muestre, comience con un título, usando la siguiente plantilla de Markdown:

# Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento de la tabla de clasificación:

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

Mostrar fragmento 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
fuente
¿Los amens tienen que estar en orden?
— Zach Gates
@ZachGates Sí.
— Conor O'Brien
¿Cómo se determina el "índice de la frase ofensiva"?
— Zach Gates
@ZachGates como el índice de la aen amen. Por ejemplo, G amen => 2si su idioma está indexado a cero; 3 si está un índice.
— Conor O'Brien
AMEN!!!! => AMEN!!!!y aun and a final Amen... => Amen.?
— ThisSuitIsBlackNot

Respuestas:

11

Retina , 37 bytes

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

El código tiene 57 bytes de longitud y califica para la bonificación de -20 bytes . Pruébalo en línea!

¡Gracias a @ MartinBüttner por portar mi respuesta de Perl a Retina!

Cómo 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
fuente
1
¿Puedo usar su ([.,?]|!*)patrón de puntuación para mi respuesta? Lo vi y no pude verlo (¡y ciertamente no pude encontrar una mejor solución!). Ciertamente no va a vencer a los tuyos :), pero no quiero plagiar, y no estoy totalmente seguro de la etiqueta para tomar prestadas soluciones a subproblemas como este.
— apsillers
3
@apsillers Legalmente, todo el contenido aquí está licenciado como CC-BY-SA, lo que significa que puede usarlo libremente con atribución. Moralmente, portar la solución de alguien a otro idioma para superarlo es más o menos mal visto, pero tomar una pequeña parte de la respuesta de alguien siempre está bien.
— 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

Sin separación, sin expresión regular, sin bonificación. Tenía una versión que obtuvo ambos Bonus pero fue MUCHO más larga.

— JimmyJazzx
fuente
Usted pierde 1 byte byte cambiando for i=1 toafor i=1To
— Taylor Scott
5

Perl, 51 bytes

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

El código fuente real contiene 70 bytes , debe ejecutarse con perl -nE( +1 byte ) y califica para el bono de -20 bytes .

— Dennis
fuente
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

Ejemplo

$ python2 test.py
"All the people said Amen! And all the people said AMEN!"
AMen
Amen
AMen
AMEN
— Puertas de Zach
fuente
3

JavaScript, 88 bytes

108 bytes - 20 bytes (captura puntuación)

alert(prompt().replace(/amen/g,' ').replace(/all the people said[?: ]/ig,'Amen').match(/amen(\??!?\.?)+/ig))
— Tobsta
fuente
Esto imprime Amen?!.para entrada Amen?!.y Amen!para entrada Amen!!!.
— Dennis
@Dennis Lo siento, no pensé en usar múltiples signos de puntuación a la vez, lo arreglaré.
— Tobsta
@ Dennis Solo lo arregló.
— Tobsta
@apsillers Tampoco lo noté. Intentaré arreglarlo más tarde.
— Tobsta
@apsillers Fixed
— Tobsta
3

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

sed 's/all the people said[?: ]/Amenx/ig'|grep -oi 'amen[.,!?]*'|grep \[AMEN]
— Thor
fuente
1
Esto imprimirá Amen?para la entrada all the people said??. La mejor solución que pude encontrar fue reemplazar la cadena con Amenx.
— Dennis
Gracias @Dennis, he usado tu solución y he actualizado la puntuación.
— Thor
1
Esto imprimirá amen.para la entrada amen.. Arreglar esto acortará su respuesta: simplemente cambie grep -v '^[amen]*$'a grep \[AMEN].
— hvd
@hvd: Tienes razón, esto es mucho mejor :-)
— 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 el shebang como uno, la entrada se toma de stdin. Mantiene la puntuación para -20 bytes e identifica la herejía para -40 .

Uso de muestra

$ 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 el shebang como uno, la entrada se toma de stdin. Mantiene la puntuación para -20 bytes.

Uso de muestra

$ echo All the people said Amen, and all the people said AMEN!! | perl primo-amen.pl
AmenAmen,AmenAMEN!!
— primo
fuente
Su primera solución falla por entrada como ha]. (No importa, acaba de ver el comentario de la OP que la entrada no puede contener corchetes ... esta pregunta se ha transformado tantas veces que no puedo llevar la cuenta.)
— ThisSuitIsBlackNot
@ThisSuitIsBlackNot No creo que el OP haya respondido esa pregunta.
— Dennis
@ Dennis Ah, tienes razón. Sin embargo, otro desconocido.
— ThisSuitIsBlackNot
3

𝔼𝕊𝕄𝕚𝕟, 66-20 = 46 caracteres / 80-20 = 60 bytes

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

Pruébalo aquí , solo Firefox.

Primera vez aquí en PPCGSE. Espero que este golf sea bastante bueno.

EDITAR: En realidad, estoy superando a CJam (en el recuento de char), ¡así que eso es bastante bueno!

1
¡Alguien está usando mi lenguaje! No está mal para tu primera publicación.
— 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}

El código tiene 97 bytes de longitud y califica para el bono de -40 bytes .

Pruébelo en línea en el intérprete de CJam .

— Dennis
fuente
1
CJam es más largo que Perl? o_O
— Conor O'Brien
CJam no tiene expresiones regulares, por lo que no es para nada sorprendente.
— Dennis
Ohhh ... escribe eso
— Conor O'Brien
2

JavaScript, 100 bytes

alert(prompt().replace(/all the people said[?: ]/ig,'Amen').replace(/amen/g,'x').match(/amen/ig));
— Nautilo
fuente
3
Puedes usar x=prompt();y puedes usar tambiénalert(prompt().replace(...).replace(...).match)
— Conor O'Brien
Hecho. Ahora tiene 100 caracteres de largo.
— Nautilus
2

JavaScript, 136135 - 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:""))

Explicación:

Este código está impulsado por una expresión regular de tres partes que alimenta los resultados en una replacedevolución de llamada . Las partes son:

  • all the people said[?: ]- simplemente coincide con el all the people saidpatrón requerido
  • (amen)([.,?]|!*)- coincide con cualquier caso ameny puntuación (uno .,?o cero o más !, lo que hace que la puntuación sea opcional) en grupos de coincidencia separados - crédito a Dennis por el patrón de puntuación
  • . - coincide con cualquier otro personaje, que no sea parte de los patrones anteriores, uno a la vez

Por lo tanto, cualquier coincidencia debe ser una cadena para todas las personas, una coincidencia de Amén con puntuación opcional o un solo carácter que no forme parte de ninguna de esas frases. Usamos la lógica en la devolución de llamada de reemplazo para guardar y reemplazar las partes apropiadas de la cadena, y cambiar cada otro carácter a la cadena vacía.

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

Sin expresiones regulares y Bonus 2

— TFeld
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.