Mówią, że hateto mocne słowo. Chciałem dowiedzieć się, dlaczego, więc dobrze się temu przyjrzałem.

Zauważyłem, że każda spółgłoska ma po sobie samogłoskę. To sprawiło, że wyglądało to dość mocno, więc zdecydowałem, że to właśnie sprawia, że ​​słowo jest mocne.

Chcę znaleźć mocniejsze słowa, więc potrzebuję do tego programu!

Znajdowanie mocnych słów

Silne słowa to słowa, w których po każdej spółgłosce (litery w zestawie BCDFGHJKLMNPQRSTVWXZ) następuje samogłoska (litery w zestawie AEIOUY). to jest to! Nie ma niczego ważniejszego.

Jeśli słowo zaczyna się od samogłoski, nie musisz się martwić o żadną z liter przed pierwszą spółgłoską. Jeśli słowo w ogóle nie ma spółgłosek, automatycznie jest silnym słowem!

Niektóre przykłady są mocnymi słowami agate, hatei you. agatejest wciąż mocnym słowem, ponieważ chociaż zaczyna się od samogłoski, po każdej spółgłosce występuje samogłoska. youto mocne słowo, ponieważ nie ma spółgłosek.

Mocne słowa nie mają ograniczenia długości.

Wyzwanie

Napisz program lub funkcję, która pobiera niepusty ciąg znaków jako dane wejściowe i wyświetla prawdziwą wartość, jeśli jest to mocne słowo lub wartość fałszowania, jeśli tak nie jest.

Wyjaśnienia

• Możesz zdecydować się na wprowadzenie danych małymi lub dużymi literami. Określ w odpowiedzi.
• Słowa nie będą zawierać żadnych znaków interpunkcyjnych. Będą zawierać tylko zwykłe litery w zestawie ABCDEFGHIJKLMNOPQRSTUVWXYZ.
• Zamiast wartości prawdy i fałszu możesz wybrać dwie odrębne i spójne wartości, aby zwrócić wartość prawda i fałsz. Jeśli to zrobisz, podaj wartości wybrane w odpowiedzi.
  • Alternatywnie możesz podać wartość fałsz dla silnego słowa i prawdę dla niewystarczającego słowa.

Przypadki testowe

Input      -> Output
hate       -> true
love       -> true
popularize -> true
academy    -> true
you        -> true
mouse      -> true
acorn      -> false
nut        -> false
ah         -> false
strong     -> false
false      -> false
parakeet   -> false

Punktacja

Ponieważ jest to golf golfowy , wygrywa odpowiedź z najmniejszą liczbą bajtów!

JavaScript (ES6), 36 28 27 bajtów

^{Zapisano 1 bajt, odwracając wynik, jak sugeruje LarsW}

Pobiera dane pisane małymi literami. Zwraca falseza mocne słowo i trueza słabe słowo.

s=>/[^aeiouy]{2}/.test(s+0)

W jaki sposób?

Dołączamy 0(nie-samogłoskę) na końcu łańcucha wejściowego i szukamy dwóch kolejnych znaków innych niż samogłoska. To pozwala nam objąć oba przypadki, w których słowo nie jest mocne:

• zawiera dwie kolejne spółgłoski
• lub kończy się spółgłoską

Przypadki testowe

let f =

s=>/[^aeiouy]{2}/.test(s+0)

;[
  "hate", "love", "popularize", "academy", "you", "mouse", "a", "euouae",
  "acorn", "nut", "ah", "strong", "false", "parakeet"
]
.forEach(s => console.log(s + ' --> ' + f(s)))

Python 2 , 48 bajtów

lambda s:'se, F'in`[v in'aeiouy'for v in s+'b']`

Funkcja bez nazwy, która pobiera (małe) ciągi si zwraca, Falsejeśli jest mocna lub Truenie.

Wypróbuj online! (odwraca wyniki, aby pasowały do ​​PO)

W jaki sposób?

Słabe słowa mają albo spółgłoskę, po której następuje spółgłoska, albo kończą się spółgłoską.

Kod dodaje spółgłoskę do końca ( s+'b'), aby wymagany test był tylko dla dwóch spółgłosek z rzędu.

Sprawdza, czy każda litera w zmienionym słowie jest samogłoską ze zrozumieniem listy [v in'aeiouy'for v in s+'b'].

Musi teraz sprawdzić dwa Falsewyniki z rzędu (sygnalizując niewystarczające słowo), robi to poprzez uzyskanie reprezentacji ciągu (za pomocą `...`) tej listy i szukanie istnienia 'se, F'. Jest to najkrótszy ciąg znaleziony w, 'False, False'ale żaden z 'True, True':; 'False, True'; lub 'True, False'.

Jako przykład rozważ 'nut', lista zrozumieniem ocenia każdą list v, z 'nutb'istnienia w 'aeiouy'wyniku czego otrzymuje listę [False, True, False, False], reprezentacja ciąg tej liście jest '[False, True, False, False]'który zawiera 'e, F'tutaj: '[False, True, Fals>>e, F<<alse]'stąd funkcja zwróci Trueten sposób, że nakrętka nie mocne słowo.

Galaretka ,  10  9 bajtów

e€ØY;Ạ11ẇ

Monadyczny link zawierający listę znaków i zwracający:

• 0 jeśli silny
• 1 Jeśli nie

Wypróbuj online! lub zobacz zestaw testowy .

W jaki sposób?

e€ØY;Ạ11ẇ - Link: list of characters, s      e.g. "hate"  or  "you"  or  "not"
  ØY      - consonant yield                   "BCDFGHJKLMNPQRSTVWXZbcdfghjklmnpqrstvwxz"
e€        - exists in? for €ach letter            [1,0,1,0]   [0,0,0]    [1,0,1]
     Ạ    - all truthy? (1 for any valid input)   1           1          1
    ;     - concatenate                           [1,0,1,0,1] [0,0,0,1]  [1,0,1,1]
      11  - literal eleven
        ẇ - sublist exists?                       0           0          1
          -  N.B.: left of ẇ implicitly makes digits so it looks for the sublist [1,1]

Uwaga: Powodem użycia Ạjest po prostu zaoszczędzić bajt za pomocą 1(ponieważ chcemy od 11razu użyć ).

05AB1E , 8 bajtów

Kod

žPS¡¦õÊP

Wykorzystuje kodowanie 05AB1E . Wypróbuj online!

Wyjaśnienie

žPS¡         # Split the string on consonants (bcdfghjklmnpqrstvwxz)
    ¦        # Remove the first element of the array to handle cases when the
               string starts with a consonant
     õÊP     # Check if the empty string is not in the array

Przykład

             # "popularize"
žPS¡         # ['', 'o', 'u', 'a', 'i', 'e']
    ¦        # ['o', 'u', 'a', 'i', 'e']
     õÊ      # [1, 1, 1, 1, 1]
       P     # 1

R , 43 bajty

function(s)grep("[^aeiouy]{2}",paste(s,""))

Wypróbuj online!

Port odpowiedzi JavaScript na Arnauld; zwraca 1 dla słabych słów i integer(0)dla mocnych; dołącza (spację) na końcu ciągu.

To jest wektoryzowane; z wektorem ciągów zwraca indeksy (1) słabych słów.

Dyalog APL, 20 bajtów

⎕←∧/2∨/0,⍨⍞∊'aeiouy'

Wypróbuj online!

Haskell , 61 54 bajtów

f=and.(zipWith(||)=<<tail).(map(`elem`"aeiouy")).(++"z")

Wypróbuj online!

Musiałem dodać zna końcu łańcucha, aby obsłużyć przypadek końcowej spółgłoski.

Java (OpenJDK 8) , 93 81 bajtów

s->{int w=0,p=w,l;for(char c:s)w|=p&(p=l="aeiouy".indexOf(c)>>31);return w+p>=0;}

Wypróbuj online!

Łuska , 12 bajtów

ΛΣX_2m€¨γaıu

Wypróbuj online!

Podziękowania dla H.PWiz za pomoc przy -4. Zwraca niespójne, ale odpowiednio prawdziwe lub fałszywe wartości.
Dzięki Leo dla -1, teraz zwraca spójną wartość prawda / fałsz.

Pyth , 18 bajtów

:+Q1."2}M>åYà

Sprawdź wszystkie przypadki testowe.

„Pożyczono” wyrażenie regularne z odpowiedzi JS . To zwraca Falsemocne słowa, w Trueprzeciwnym razie

Brachylog , 18 11 10 bajtów

,Ḷs₂{¬∈Ẉ}ᵐ

Wypróbuj online!

Schludny i prosty (z wyjątkiem może 2 dodatkowych bajtów początkowych do obsługi końcowego przypadku spółgłoski, takich jak „papuga długoogonowa”).

Jest falsey dla mocnych słów i prawdę dla słabych słów.

,Ḷ               % append a newline (non-vowel) at the end of input, 
                 %   to catch final consonants
     s₂          % the result has some substring of length 2
       {¬∈Ẉ}ᵐ    % where neither of its elements belong to  
                 %   the set of alternate vowels (with "y")

Python 2 , 58 bajtów

-30 bajtów, wiedząc, że może być tak proste, jak odpowiedź JS Arnaulda .

lambda s:re.search('[^aeiouy]([^aeiouy]|$)',s)<1
import re

Wypróbuj online!

Perl 5, 31 bajtów (30 + 1)

$_=''if/[^aeiouy](?![aeiouy])/

+1 bajt dla -pflagi wiersza poleceń. Drukuje słowo, jeśli jest to mocne słowo, lub pusty ciąg, jeśli nie jest.

Galaretka , 11 bajtów

e€ØY;1a2\¬Ȧ

Wypróbuj online!

e€ØY;1a2\¬Ȧ  Main link
 €           For each letter
e            Is it an element of
  ØY         The consonants (excluding Yy)?
    ;1       Append 1 (true) (consonant) to make sure last letter isn't consonant
       2\    For all (overlapping) slices of length 2 (the <link><nilad>\ functionality)
      a      Logical AND of the two values; is it a consonant pair?
         ¬   Logical NOT vectorizing; for each (overlapping) pair, is it not a consonant pair?
          Ȧ  Any and all; make sure all pairs are not consonant pairs

Tak, wiem, że zostałem bardzo pobity przez Jonathana Allana, ale i tak chciałem się podzielić moim podejściem: P.

-4 bajty poprzez kradzież odrobiny odpowiedzi Jonathana Allana (zamiast dodawać spółgłoskę w celu sprawdzenia, czy wielkość liter na ostatniej liście jest dołączona, wystarczy dołączyć 1)
-1 bajt dzięki milom

Awk, 39 bajtów

/([^aeiouy]{2}|[^aeiouy]$)/{print "n"}

drukuje ndla nie-silnego słowa, nic (lub po prostu nowa linia) dla silnego słowa

śledzenie paczki i poszukiwanie dwóch kolejnych nie-samogłosek na małych literach

testowanie

$ awk -f strongwork.awk
hate
love
popularize
academy
you
mouse
acorn
n
nut
n
ah
n
strong
n
false
n
parakeet
n

Kotlin , 49 bajtów

{Regex(".*[^aeiouy]([^aeiouy].*|$)").matches(it)}

Prawda i fałsz są zamieniane

Upiększony

{
    Regex(".*[^aeiouy]([^aeiouy].*|$)").matches(it)
}

Test

var s:(String)->Boolean =
{Regex(".*[^aeiouy]([^aeiouy].*|$)").matches(it)}
data class TestData(val input: String, val output: Boolean)

fun main(args: Array<String>) {
    val items = listOf(
            TestData("hate", true),
            TestData("love", true),
            TestData("popularize", true),
            TestData("academy", true),
            TestData("you", true),
            TestData("mouse", true),
            TestData("acorn", false),
            TestData("nut", false),
            TestData("ah", false),
            TestData("strong", false),
            TestData("false", false),
            TestData("parakeet", false)
    )

    items
            .filter { s(it.input) == it.output }
            .forEach { throw AssertionError(it.toString()) }

    println("Test Passed")
}

TryItOnline

Na podstawie @ Arnauld za Odpowiedź

Siatkówka , 23 18 bajtów

$
$
1`[^aeiouy]{2}

Wypróbuj online! Wykazuje 0 dla silnych, 1 jeśli nie. Dodaj 1 bajt, aby obsługiwać mieszane wielkości liter. Edycja: Zapisano 5 bajtów dzięki @ovs.

Java 8, 53 42 bajty

s->s.matches(".*[^aeiouy]([^aeiouy].*|$)")

-11 bajtów przy użyciu tego samego wyrażenia regularnego, co w odpowiedzi Kotlin @jrtapsell .

Wypróbuj tutaj. ( falsejeśli silny; truejeśli nie)

Wyjaśnienie:

s->               // Method with String parameter and boolean return-type
  s.matches(      //  Checks if the String matches the following regex:
    ".*           //   One or more characters
     [^aeiouy]    //   Followed by a consonant
     ([^aeiouy].* //   Followed by another consonant (+ any more characters)
      |$)")       //   Or the end of the String
                  // End of method (implicit / single-line return statement)

Więc w zasadzie sprawdza, czy możemy znaleźć dwie sąsiadujące spółgłoski, czy też Łańcuch kończy się spółgłoską.

Stara odpowiedź ( 53 bajty ):

s->s.matches("[aeiouy]*([a-z&&[^aeiouy]][aeiouy]+)*")

Wypróbuj tutaj. ( truejeśli silny; falsejeśli nie)

Używa wyrażenia regularnego, aby sprawdzić, czy ciąg wejściowy pasuje do wyrażenia regularnego „strong”. Zauważ, że String#matchesw Javie automatycznie dodaje, ^...$aby sprawdzić, czy Łańcuch całkowicie pasuje do podanego wyrażenia regularnego.

Wyjaśnienie":

 s->                   // Method with String parameter and boolean return-type
  s.matches(           //  Checks if the String matches the following regex:
    "[aeiouy]*         //   0 or more vowels
    ([a-z&&[^aeiouy]]  //     { A consonant,
     [aeiouy]+)        //       plus one or more vowels }
    *")                //    Repeated 0 or more times
                       // End of method (implicit / single-line return statement)

Wyszukiwanie zamiast dopasowań (jak w przypadku wielu innych odpowiedzi) jest w rzeczywistości dłuższe w Javie:
70 bajtów :

s->java.util.regex.Pattern.compile("[^aeiouy]{2}").matcher(s+0).find()

Wypróbuj tutaj. ( falsejeśli silny; truejeśli nie)

Ruby , 25 bajtów

->w{w+?t!~/[^aeiouy]{2}/}

Wypróbuj online!

Wszyscy to robią, więc dlaczego Ruby nie może?

SOGL V0.12 , 19 18 bajtów

æ"[^ŗy]”ŗ(ŗ|$)”øβ=

Wypróbuj tutaj!

Wyjaśnienie:

æ                   push "aeiou"
 "[^ŗy]”            push "[^ŗy]" with ŗ replaced with pop
        ŗ(ŗ|$)”     push `ŗ(ŗ|$)` with ŗ replaced with pop
               øβ   replace in the input that regex with nothing
                 =  check for equality with the original input

05AB1E , 11 bajtów

žP¹SåJ1«11å

Wypróbuj online!

Wykorzystuje algorytm Jonathana, zwraca wartość 0prawda i 1fałsz.

Swift 3.1 , 85 bajtów

import Foundation
{($0+"0").range(of:"[^aeiouy]{2}",options:.regularExpression)==nil}

Wypróbuj tutaj!

To pożycza regex Arnauld za .

Lua, 41 bajtów

return#(io.read()..0):match"[^aeiouy]+"<2

Odczytuje ze standardowego wejścia

Lua (loadstring'ed), 37 bajtów

return#((...)..0):match"[^aeiouy]+"<2

Odczytuje z parametrów funkcji

Dane są pisane małymi literami

Sprawdza, czy istnieje łańcuch o długości 2 lub większej, składający się tylko z samogłosek (nie spółgłosek) lub łańcuch ten kończy się samogłoską

Zwraca true / false

C ++, 195 194 bajtów

-1 bajty dzięki Zacharýowi

Wielkie litery, zwróć true, jeśli dane wejściowe są silnym słowem, false w przeciwnym razie (C ++ mają proste int do boolowania niejawne reguły rzutowania, 0 => false, true w przeciwnym razie)

#include<string>
#define C(p)(v.find(e[p])==size_t(-1))
std::string v="AEIOUY";int s(std::string e){for(int i=0;i<e.size()-1;++i)if(e[i]>64&&e[i]<91&&C(i)&&C(i+1))return 0;return!C(e.size()-1);}

Kod do przetestowania:

auto t = {
    "HATE",
    "LOVE",
    "POPULARIZE",
    "ACADEMY",
    "YOU",
    "MOUSE",
    "ACORN",
    "NUT",
    "AH",
    "STRONG",
    "FALSE",
    "PARAKEET"
};

for (auto&a : t) {
    std::cout << (s(a) ? "true" : "false") << '\n';
}

C, 107 bajtów

i,v,w,r,t;a(char*s){w=0;for(r=1;*s;s++){v=1;for(i=6;v&&i;)v=*s^" aeiouy"[i--];r=w&&v?0:r;w=v;}return r&~v;}

Zwraca 1 dla silnego słowa i 0 dla słabego słowa. Testowany ze słowami podanymi w głównym poście.

C (gcc) , 59 bajtów

f(char*s){return*s?strcspn(s,"aeiouy")+!s[1]<2?f(s+1):0:1;}

Wypróbuj online!

PHP, 69 bajtów

preg_match("/([^AEIOUY][^AEIOUY]+|[^AEIOUY]$)/",$_SERVER['argv'][1]);

Zwraca 1 to słowo nie jest mocne.

CJam , 57 bajtów

q{"aeiouy"#W=}%_,:B{_A={_A_)\B(<{=!X&:X;}{0:X;;;}?}&}fA;X

Wypróbuj online!

Odczytuje dane wejściowe, konwertuje na 1s dla spółgłosek, 0s dla samogłosek. Dla każdej spółgłoski ORAZ predefiniowana zmienna X (predefiniowana do 1) z wartością następnego znaku. Wyjście X