Кажуть, 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ні.

Спробуйте в Інтернеті! (інвертує результати, щоб вони відповідали ОП)

Як?

Несильні слова мають або приголосний, за яким йде приголосний, або закінчуються на приголосний.

Код додає приголосний в кінці ( 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) слабких слів.

Діалог APL, 20 байт

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

Спробуйте в Інтернеті!

Haskell , 61 54 байт

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

Спробуйте в Інтернеті!

Мені довелося додати a 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, тепер повертає стійке значення truthy / falesy.

Піт , 18 байт

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

Перевірте всі тестові випадки.

«Позичив» регекс з відповіді JS . Це повертається Falseза сильні слова, Trueінакше

Брахілог , 18 11 10 байт

,Ḷs₂{¬∈Ẉ}ᵐ

Спробуйте в Інтернеті!

Акуратний і простий (за винятком, можливо, 2 додаткових початкових байта для обробки остаточного приголосного випадку, як-от "папуга").

Це фальси для сильних слів і правда для несильних слів.

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

-30 байт, усвідомлюючи це, може бути таким же простим, як відповідь Арнаульда на JS .

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

Спробуйте в Інтернеті!

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

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

принти nдля несильних слів, нічого (або, просто новий рядок) для strongword

слідкуючи за пакетом та пошуком двох послідовних неголосних на введення з малих літер

тестування

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

Котлін , 49 байт

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

Істинна і хибна обмінюються

Прикрасили

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

Тест

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

На основі @ Arnauld в Відповідь

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