I wszyscy ludzie mówili…

14

Cel Biorąc pod uwagę tekst, który nie zawiera znaków [lub ]wykonaj następujące czynności:

  1. Dla każdego wystąpienia Amenz co najmniej jedną wielką literą (czyli wszystkie przypadki Amenwykluczenia amen), wypisz to samo Amen(zachowaj wielkie litery ).
  2. Dla każdego wystąpienia /all the people said[?: ]/i(jest to wyrażenie regularne) również dane wyjściowe Amen(każdy przypadek jest w porządku).

Po każdym wyjściu możesz wybrać dowolny stały separator, np. Nowy wiersz, spację lub nic.

To jest golf golfowy , więc wygrywa najkrótszy program w bajtach.

Przykładowe IO

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

Premia

  • -20 bajtów , jeśli można „chwycić” znaki interpunkcyjne, które następuje po Amen, to znaczy Amen! => Amen!, AmEN. => AmEN., I said Amen, bruh. => Amen,, i AMEN!!!! => AMEN!!!!. !jest jedyną postacią, która może zostać zachowana wiele razy. .?!,są jedynymi postaciami, które można w ten sposób zachować.
  • -40 bajtów, jeśli istnieje instancja amenwyjściowa Heresy! at index [i]zamiast niczego, gdzie [i]jest indeks słowa obrażającego tj amen.

Bonusowe operacje wejścia / wyjścia

Dane wejściowe i wyjściowe mają formę input => output. (Separator tutaj jest spacją.)

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!

Liderów

Oto fragment kodu, który pozwala wygenerować zarówno zwykłą tabelę wyników, jak i przegląd zwycięzców według języka.

Aby upewnić się, że twoja odpowiedź się pojawi, zacznij od nagłówka, korzystając z następującego szablonu Markdown:

# Language Name, N bytes

gdzie Njest rozmiar twojego zgłoszenia. Jeśli poprawić swój wynik, to może zachować stare porachunki w nagłówku, uderzając je przez. Na przykład:

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

Jeśli chcesz umieścić w nagłówku wiele liczb (np. Ponieważ twój wynik to suma dwóch plików lub chcesz osobno wymienić kary za flagi tłumacza), upewnij się, że rzeczywisty wynik jest ostatnią liczbą w nagłówku:

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

Możesz także ustawić nazwę języka jako link, który pojawi się we fragmencie tabeli wyników:

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

Pokaż fragment kodu

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
źródło
Czy amens muszą być w porządku?
Zach Gates
@ZachGates Tak.
Conor O'Brien
Jak określasz „indeks wyrażenia naruszającego prawo”?
Zach Gates,
@ZachGates Być indeks ain amen. Np. G amen => 2Jeśli twój język jest indeksowany na zero; 3, jeśli jest indeksowany jednokrotnie.
Conor O'Brien
AMEN!!!! => AMEN!!!!a jednak and a final Amen... => Amen.?
ThisSuitIsBlackNot

Odpowiedzi:

11

Siatkówka , 37 bajtów

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

Kod, jeśli 57 bajtów długości i kwalifikuje się do premii -20 bajtów . Wypróbuj online!

Dzięki @ MartinBüttner za przeniesienie mojej odpowiedzi Perla do Retiny!

Jak to działa

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
źródło
1
Czy mogę użyć ([.,?]|!*)wzoru dopasowania interpunkcyjnego do mojej odpowiedzi? Widziałem to i nie mogłem tego nie zobaczyć (i na pewno nie mogłem znaleźć lepszego rozwiązania!). Z pewnością nie pokona twoich :), ale nie chcę plagiatować i nie jestem całkowicie pewien etykiety pożyczania rozwiązań podobnych problemów.
apsillers,
3
@apsillers Zgodnie z prawem wszystkie treści tutaj są licencjonowane jako CC-BY-SA, co oznacza, że ​​można z nich swobodnie korzystać za pomocą atrybucji. Moralnie, przeniesienie czyjegoś rozwiązania na inny język, aby go obezwładnić, jest mniej lub bardziej rozczarowane, ale przyjęcie małej części odpowiedzi jest zawsze w porządku.
Dennis,
7

VBA, 193 bajty

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

Bez separacji, bez regeksu, bez premii. Miał wersję, która dostała oba bonusy, ale była DUŻO dłuższa.

JimmyJazzx
źródło
Możesz stracić 1 bajt, zmieniając for i=1 tonafor i=1To
Taylor Scott
5

Perl, 51 bajtów

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

Rzeczywisty kod źródłowy zawiera 70 bajtów , należy go uruchomić z perl -nE( +1 bajt ) i kwalifikuje się do premii -20 bajtów .

Dennis
źródło
4

Python 2, 155 bajtów

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

Przykład

$ python2 test.py
"All the people said Amen! And all the people said AMEN!"
AMen
Amen
AMen
AMEN
Zach Gates
źródło
3

JavaScript, 88 bajtów

108 bajtów - 20 bajtów (łapie znaki interpunkcyjne)

alert(prompt().replace(/amen/g,' ').replace(/all the people said[?: ]/ig,'Amen').match(/amen(\??!?\.?)+/ig))
Tobsta
źródło
To drukuje Amen?!.dla danych wejściowych Amen?!.i Amen!danych wejściowych Amen!!!.
Dennis,
@Dennis Niestety, nie myślałem o użyciu wielu znaków interpunkcyjnych jednocześnie, naprawię to.
Tobsta,
@Dennis Właśnie to naprawiłem.
Tobsta,
@apsillers Też tego nie zauważył. Spróbuję to naprawić później.
Tobsta,
@apsillers Naprawiono
Tobsta,
3

grep i sed, 85 83 84 77-20 = 57 bajtów

sed 's/all the people said[?: ]/Amenx/ig'|grep -oi 'amen[.,!?]*'|grep \[AMEN]
Thor
źródło
1
Spowoduje to wydrukowanie Amen?danych wejściowych all the people said??. Najlepszym obejściem, jakie udało mi się znaleźć, było zastąpienie łańcucha Amenx.
Dennis
Dzięki @Dennis, wykorzystałem twoje obejście i zaktualizowałem wynik.
Thor
1
Spowoduje to wydrukowanie amen.danych wejściowych amen.. Naprawienie tego skróci twoją odpowiedź: po prostu zmień grep -v '^[amen]*$'na grep \[AMEN].
hvd,
@hvd: Masz rację, jest o wiele lepiej :-)
Thor
3

Perl, 103–60 = 43 bajty

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

Licząc shebang jako jeden, dane wejściowe są pobierane ze standardowego wejścia. Utrzymuje interpunkcję dla -20 bajtów i identyfikuje herezję dla -40 .

Przykładowe użycie

$ 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 bajtów

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

Licząc shebang jako jeden, dane wejściowe są pobierane ze standardowego wejścia. Utrzymuje interpunkcję dla -20 bajtów.

Przykładowe użycie

$ echo All the people said Amen, and all the people said AMEN!! | perl primo-amen.pl
AmenAmen,AmenAMEN!!
primo
źródło
Twoje pierwsze rozwiązanie nie działa jak wejście ha]. (Nieważne, właśnie widziałem komentarz OP, że dane wejściowe nie mogą zawierać nawiasów kwadratowych ... to pytanie zmieniło się tak wiele razy, że nie mogę śledzić.)
ThisSuitIsBlackNot
@ThisSuitIsBlackNie Nie sądzę, że OP odpowiedział na to pytanie.
Dennis,
@Dennis Ah, masz rację. Jeszcze jedna nieznana.
ThisSuitIsBlackNot
3

𝔼𝕊𝕄𝕚𝕟, 66-20 = 46 znaków / 80-20 = 60 bajtów

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

Wypróbuj tutaj - tylko Firefox.

Pierwszy raz tutaj w PPCGSE. Mam nadzieję, że ten golf jest całkiem niezły.

EDYCJA: Właściwie, pokonuję CJam (według liczby znaków), więc to całkiem nieźle!


źródło
1
Tak, ktoś używa mojego języka! Nieźle jak na twój pierwszy post.
Mama Fun Roll
2

CJam, 57 bajtów

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

Kod ma długość 97 bajtów i kwalifikuje się do bonusu -40 bajtów .

Wypróbuj online w interpretatorze CJam .

Dennis
źródło
1
CJam jest dłuższy niż Perl? o_O
Conor O'Brien
CJam nie ma wyrażeń regularnych, więc nie jest to wcale zaskakujące.
Dennis,
Ohhh ... zapisuje to
Conor O'Brien
2

JavaScript, 100 bajtów

alert(prompt().replace(/all the people said[?: ]/ig,'Amen').replace(/amen/g,'x').match(/amen/ig));
Łodzik
źródło
3
Możesz używać x=prompt();i możesz także używaćalert(prompt().replace(...).replace(...).match)
Conor O'Brien
Gotowy. Teraz ma 100 znaków.
Nautilus,
2

JavaScript, 136 135–40–20 = 75 bajtów

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

Wyjaśnienie:

Ten kod jest oparty na trzyczęściowym wyrażeniu regularnym, które przekazuje wyniki do replacewywołania zwrotnego . Częściami są:

  • all the people said[?: ]- po prostu pasuje do wymaganego all the people saidwzoru
  • (amen)([.,?]|!*)- dopasowuje dowolny przypadek ameni interpunkcję (jeden .,?lub zero lub więcej !, co powoduje, że interpunkcja jest opcjonalna) w osobne grupy dopasowań - podziękowania dla Dennisa za wzór interpunkcyjny
  • . - pasuje do każdej innej postaci, nie będącej częścią powyższych wzorów, pojedynczo

Dlatego każde dopasowanie musi być albo ciągiem wszystkich ludzi, dopasowaniem Amen z opcjonalną interpunkcją lub pojedynczym znakiem nie będącym częścią żadnej z tych fraz. Używamy logiki w wywołaniu zwrotnym zamiennika, aby zapisać i zastąpić odpowiednie części łańcucha oraz zmienić każdy inny znak na pusty łańcuch.

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
  )
)
apsillery
źródło
1

Python 2, 191–40 = 151 bajtów

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

Brak wyrażenia regularnego i Bonus 2

TFeld
źródło