Они говорят, что hateэто сильное слово. Я хотел выяснить, почему, поэтому я хорошо посмотрел на слово.

Я заметил, что у каждого согласного был гласный после этого. Это показалось мне достаточно сильным, поэтому я решил, что именно это делает слово сильным.

Я хочу найти более сильные слова, поэтому мне нужна программа для этого!

Находить сильные слова

Сильные слова - это слова, в которых после каждого согласного (буквы в наборе BCDFGHJKLMNPQRSTVWXZ) следует гласная (буквы в наборе AEIOUY). Вот и все. Остальное не важно.

Если слово начинается с гласной, вам не нужно беспокоиться ни о одной из букв перед первым согласным. Если в слове вообще нет согласных, это автоматически сильное слово!

Некоторые примеры сильных слов agate, hateи you. agateэто все еще сильное слово, потому что, хотя оно начинается с гласной, за каждой согласной все еще следует гласная. youэто сильное слово, потому что оно не имеет согласных.

Для сильных слов нет ограничений по длине.

Соревнование

Напишите программу или функцию, которая принимает непустую строку в качестве входных данных и выводит истинное значение, если оно является сильным словом или ложным значением, если это не так.

Разъяснения

• Вы можете принять ввод в нижнем или верхнем регистре. Укажите, какой в ​​вашем ответе.
• Слова не будут содержать знаков препинания любого рода. Они будут содержать только простые буквы в наборе ABCDEFGHIJKLMNOPQRSTUVWXYZ.
• Вместо истинных и ложных значений вы можете выбрать два разных и непротиворечивых значения, которые будут возвращаться как истинные и ложные. Если вы сделаете это, укажите значения, которые вы выбрали в своем ответе.
  • В качестве альтернативы вы можете вывести ложное значение для сильного слова и правдивое для не сильного слова.

Контрольные примеры

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

счет

Поскольку это код-гольф , выигрывает ответ с наименьшим количеством байтов!

JavaScript (ES6), 36 28 27 байт

^{Сохранено 1 байт путем инвертирования результата, как предлагает LarsW}

Принимает ввод в нижнем регистре. Возвращает falseдля сильного слова и trueдля не сильного слова.

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

Как?

Мы добавляем 0(не гласный) в конец входной строки и ищем два последовательных не гласных символа. Это позволяет нам охватить оба случая, которые делают слово не сильным:

• он содержит две последовательные согласные
• или это заканчивается согласной

Контрольные примеры

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 байт

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

Неименованная функция, принимающая (строчную) строку sи возвращающая, Falseесли она сильная или Trueнет.

Попробуйте онлайн! (инвертирует результаты в соответствии с ОП)

Как?

У не сильных слов есть согласная, сопровождаемая согласной, или конец согласной.

Код добавляет согласную в end ( s+'b'), чтобы сделать обязательный тест только для двух согласных подряд.

Он выясняет, является ли каждая буква в измененном слове гласной с пониманием списка [v in'aeiouy'for v in s+'b'].

Теперь ему нужно проверить два Falseрезультата подряд (сигнализируя не сильное слово), это делается путем получения строкового представления (использования `...`) этого списка и поиска существования 'se, F'. Это самая короткая строка, найденная в, 'False, False'но ни одна из 'True, True':; 'False, True'; или 'True, False'.

В качестве примера рассмотрим 'nut'список постижение оценивает каждую букву, v, из 'nutb'существования в 'aeiouy'давая список [False, True, False, False], строковое представление этого списка , '[False, True, False, False]'который содержит 'e, F'здесь: '[False, True, Fals>>e, F<<alse]'следовательно , функция возвращает это Trueозначает , что гайка не сильное слово.

Желе ,  10  9 байт

e€ØY;Ạ11ẇ

Монадическая ссылка, содержащая список символов и возвращающая:

• 0 если сильный
• 1 если не

Попробуйте онлайн! или посмотрите набор тестов .

Как?

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]

Примечание. Причиной использования Ạявляется просто сохранение байта сверх использования 1(поскольку мы хотим сразу использовать 11).

05AB1E , 8 байтов

Код

žPS¡¦õÊP

Использует кодировку 05AB1E . Попробуйте онлайн!

объяснение

ž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

пример

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

R , 43 байта

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

Попробуйте онлайн!

Порт ответа Арнаулда на JavaScript; возвращает 1 для слабых слов и integer(0)для сильных; он добавляет (пробел) к концу строки.

Это на самом деле векторизация; с вектором строк он возвращает индексы (на основе 1) слабых слов.

Dyalog APL, 20 байтов

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

Попробуйте онлайн!

Haskell , 61 54 байта

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

Попробуйте онлайн!

Мне пришлось добавить zв конце строки, чтобы обработать регистр в конце.

Java (OpenJDK 8) , 93 81 байт

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

Попробуйте онлайн!

Шелуха , 12 байт

ΛΣX_2m€¨γaıu

Попробуйте онлайн!

Спасибо H.PWiz за помощь с -4. Возвращает противоречивые, но соответственно истинные или ложные значения.
Спасибо Лео за -1, теперь возвращает непротиворечивое истинное / ложное значение.

Pyth, 18 bytes

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

Verify all the test cases.

"Borrowed" the regex from the JS answer. This returns False for strong words, True otherwise

Brachylog, 18 11 10 bytes

,Ḷs₂{¬∈Ẉ}ᵐ

Try it online!

Neat and simple (except maybe for the 2 extra initial bytes to handle the final consonant case, like "parakeet").

Is falsey for strong words and truthy for non-strong words.

,Ḷ               % 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 bytes

-30 bytes by realizing it can be as simple as Arnauld's JS answer.

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

Try it online!

Perl 5, 31 bytes (30 + 1)

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

+1 byte for -p command line flag. Prints the word if it's a strong word, or the empty string if it is not.

Jelly, 11 bytes

e€ØY;1a2\¬Ȧ

Try it 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

Yes I know I've been beaten a lot by Jonathan Allan but I wanted to share my approach anyway :P

-4 bytes by stealing a little bit of Jonathan Allan's answer (instead of appending a consonant to check for last-letter edge case, just append 1)
-1 byte thanks to miles

Awk, 39 bytes

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

prints n for non-strongword, nothing (or, just a newline) for strongword

following the pack and searching for two consecutive non-vowels on lowercase input

testing

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

Kotlin, 49 bytes

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

True and false are swapped

Beautified

{
    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

Based on @Arnauld's Answer

Retina, 23 18 bytes

$
$
1`[^aeiouy]{2}

Try it online! Outputs 0 for strong, 1 if not. Add 1 byte to support mixed case. Edit: Saved 5 bytes thanks to @ovs.

Java 8, 53 42 bytes

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

-11 bytes by using the same regex as in @jrtapsell's Kotlin answer instead.

Try it here. (false if strong; true if not)

Explanation:

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)

So it basically checks if we can find two adjacent consonants, or if the String ends with a consonant.

Old answer (53 bytes):

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

Try it here. (true if strong; false if not)

Uses regex to see if the input-String matches the 'strong'-regex. Note that String#matches in Java automatically adds ^...$ to check if the String entirely matches the given regex.

Explanation":

 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)

A search instead of matches (like a lot of other answers use) is actually longer in Java:
70 bytes:

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

Try it here. (false if strong; true if not)

Ruby, 25 bytes

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

Try it online!

Everybody else is doing it, so why can't Ruby?

SOGL V0.12, 19 18 bytes

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

Try it Here!

Explanation:

æ                   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 bytes

žP¹SåJ1«11å

Try it online!

Uses Jonathan's algorithm, returns 0 for true and 1 for false.

Swift 3.1, 85 bytes

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

Try it here!

This borrows Arnauld's regex.

Lua, 41 bytes

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

Reads from standard input

Lua (loadstring'ed), 37 bytes

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

Reads from function parameter(s)

Input is lowercase

Sees if there is a string of length 2 or more, consisting only of not vowels (consonants) or if the string ends with a non-vowel

Returns true/false

C++, 195 194 bytes

-1 bytes thanks to Zacharý

Uppercase, return true if input is a strong word, false otherwise ( C++ have simple int to bool implicit cast rules, 0 => false, true otherwise )

#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);}

Code to test :

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 Bytes

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;}

Returns 1 for strong word and 0 for weak word. Tested with the words given in the main post.

C (gcc), 59 bytes

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

Try it online!

PHP, 69 bytes

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

Returns 1 is the word is not strong.

CJam, 57 bytes

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

Try it online!

Reads input, converts to 1s for consonants, 0s for vowels. For every consonant, AND predefined variable X (predefined to 1) with next character's value. Output X