彼らはそれhateが強い言葉だと言います。その理由を知りたかったので、この言葉をよく見てみました。

すべての子音の後に母音が付いていることに気付きました。それは私にとって非常に強く見えたので、私はそれが言葉を強くするものだと決めました。

もっと強い言葉を見つけたいので、そのためのプログラムが必要です！

強い言葉を見つける

強い単語とは、すべての子音（セット内の文字BCDFGHJKLMNPQRSTVWXZ）の後に母音（セット内の文字）が続く単語AEIOUYです。それでおしまい。他には何も関係ありません。

単語が母音で始まる場合、最初の子音の前の文字について心配する必要はありません。単語に子音がまったく含まれていない場合、自動的に強力な単語になります。

強い単語の例はagate、hateおよびyouです。agate母音で始まりますが、すべての子音の後に母音が続くため、まだ強力な単語です。you子音がないため、強い言葉です。

強い単語の長さに制限はありません。

チャレンジ

入力として空でない文字列を受け取り、それが強い単語であれば真理値を出力し、そうでなければ偽値を出力するプログラムまたは関数を作成します。

明確化

• 入力は小文字または大文字のどちらで入力するかを決定できます。回答でどれを指定してください。
• 単語には、いかなる種類の句読点も含まれません。セットにはプレーンな文字のみが含まれABCDEFGHIJKLMNOPQRSTUVWXYZます。
• 真実の値と偽の値の代わりに、2つの異なる一貫した値を選択して、trueとfalseを返します。これを行う場合は、回答で選択した値を指定します。
  • あるいは、強い単語に対しては偽の値を出力し、非強い単語に対しては真実の値を出力することができます。

テストケース

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

得点

これはcode-golfなので、バイト数が最小の答えが勝ちです！

JavaScript（ES6）、36 28 27バイト

^{LarsWが示唆するように、結果を反転して1バイトを保存しました}

小文字で入力します。false強い単語と強い単語trueではないものを返します。

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

どうやって？

0入力文字列の最後に（非母音）を追加し、2つの連続する非母音文字を探します。これにより、単語を強くしない両方のケースをカバーできます。

• 2つの連続した子音が含まれています
• または子音で終わる

テストケース

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そうでない場合に戻ります。

オンラインでお試しください！（OPに一致するように結果を反転します）

どうやって？

非強い単語には、子音の後に子音が続くか、子音で終わるかのいずれかがあります。

コードは末尾に子音を追加します（s+'b'）、必要なテストが2つの子音だけで連続するようにします。

変更された単語の各文字がリスト内包表記の母音であるかどうかを調べます [v in'aeiouy'for v in s+'b']。

次に、2つの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]'したがって、関数はTruenutが強力な単語ではないことを意味します。

ゼリー、 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,""))

オンラインでお試しください！

ArnauldのJavaScript回答の移植版。弱い単語とinteger(0)強い単語に対して1を返します。を追加します文字列の末尾に（スペース）をします。

これは実際にはベクトル化されています。文字列のベクトルでは、弱い単語のインデックス（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

オンラインでお試しください！

-4のサポートをしてくれたH.PWizに感謝します。一貫性はないが適切に真実または偽の値を返します。-1のLeoの
おかげで、一貫した真実/偽の値を返すようになりました。

Pyth、18バイト

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

すべてのテストケースを確認します。

JS回答から正規表現を「借用」しました。これはFalse強い単語に対して返されます。Trueそれ以外の場合は

Brachylog、18 11 10バイト

,Ḷs₂{¬∈Ẉ}ᵐ

オンラインでお試しください！

きちんとしたシンプルな（「parakeet」のような最終的な子音のケースを処理するための余分な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バイトはArnauldのJS回答と同じくらい簡単になります。

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

オンラインでお試しください！

Perl 5、31バイト（30 + 1）

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

-pコマンドラインフラグ用に+1バイト。強い単語の場合は単語を出力し、そうでない場合は空の文字列を出力します。

ゼリー、11バイト

e€ØY;1a2\¬Ȧ

オンラインでお試しください！

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

はい、私はジョナサン・アランにたくさんbeatられましたが、とにかく私のアプローチを共有したかったです：P

-4ジョナサン・アランの答えを少し（代わりに、最後の文字のエッジケースをチェックするために子音を追加すると、わずか1を追加）盗んでバイト
-1バイトをマイルに感謝

Awk、39バイト

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

プリントnstrongwordための非strongword、何も（あるいは、単に改行）について

パックを追跡し、小文字入力で2つの連続する非母音を検索する

検査

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

Kotlin、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の 回答に基づく

網膜、23 18バイト

$
$
1`[^aeiouy]{2}

オンラインでお試しください！強い場合は0、そうでない場合は1を出力します。大/小文字混合をサポートするには、1バイトを追加します。編集：@ovsのおかげで5バイト保存されました。

Java 8、53 42バイト

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

代わりに@jrtapsellのKotlin回答と同じ正規表現を使用して-11バイト。

ここで試してみてください。（false強い場合; trueそうでない場合）

説明：

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)

したがって、基本的には、2つの隣接する子音が見つかるかどうか、または文字列が子音で終わるかどうかをチェックします。

古い回答（53バイト）：

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

ここで試してみてください。（true強い場合;falseそうでない場合）

正規表現を使用して、入力文字列が「強い」正規表現と一致するかどうかを確認します。ご了承くださいString#matchesJavaでは自動的に追加さに^...$、文字列が指定された正規表現に完全に一致するかどうかをにチェックしてするてください。

説明"：

 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)

マッチではなく検索（他の多くの回答が使用するように）は、実際にはJavaでより長くなります：
70バイト：

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

ここで試してみてください。（false強い場合; trueそうでない場合）

ルビー、25バイト

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

オンラインでお試しください！

他の誰もがそれをやっているのに、なぜRubyができないのですか？

SOGL V0.12、19の 18 バイト

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

ここで試してみてください！

説明：

æ                   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バイト

žP¹SåJ1«11å

オンラインでお試しください！

Jonathanのアルゴリズムを使用して0、trueおよび1falseを返します。

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