他们说这hate是一个有力的词。我想找出原因，因此很好地了解了这个词。

我注意到每个辅音后面都有一个元音。这使它看起来对我来说很坚强，所以我认为这就是使一个词更坚强的原因。

我想找到更强的词，因此需要一个程序！

寻找强词

强词是每个辅音（集合中的字母BCDFGHJKLMNPQRSTVWXZ）后跟元音（集合中的字母AEIOUY）的单词。而已。别的都无所谓。

如果单词以元音开头，则不必担心第一个辅音之前的任何字母。如果这个词根本没有辅音，那么它就自动成为一个强词！

强话的一些例子是agate，hate和you。agate仍然是一个很强的词，因为尽管它以元音开头，但每个辅音仍然跟着元音。you这个词很强大，因为它没有辅音。

强词的长度没有限制。

挑战

编写一个程序或函数，该程序或函数将非空字符串作为输入，如果它是一个强词，则输出一个真实值，否则，则输出一个虚假值。

澄清说明

• 您可以决定采用小写或大写形式输入。指定答案中的哪个。
• 单词将不包含任何标点符号。它们只包含纯字母ABCDEFGHIJKLMNOPQRSTUVWXYZ。
• 您可以选择两个不同且一致的值来代替true和false，以返回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

计分

由于这是代码高尔夫，因此，字节数最少的答案会获胜！

JavaScript（ES6），36 28 27字节

^{根据LarsW的建议，通过反转结果节省了1个字节}

以小写形式输入。返回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返回。FalseTrue

在线尝试！（反转结果以匹配OP）

怎么样？

非强词有辅音后跟辅音或以辅音结尾。

该代码在结尾（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,""))

在线尝试！

Arnauld的JavaScript答案端口；对于弱词和integer(0)强词返回1 ；它在字符串的末尾附加一个（空格）。

这实际上是矢量化的；使用字符串向量，它返回弱词的索引（从1开始）。

Dyalog APL，20个字节

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

在线尝试！

Haskell，61 54字节

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

在线尝试！

我必须z在字符串的末尾添加a 来处理尾随辅音的情况。

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提供帮助。返回不一致但适当的真实或虚假值。
感谢Leo的-1，现在返回一致的真实/错误值。

Pyth，18个字节

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

验证所有测试用例。

从JS答案中 “借用”正则表达式。这将返回False强词，True否则

Brachylog，18 11 10字节

,Ḷs₂{¬∈Ẉ}ᵐ

在线尝试！

整洁而简单（可能还有2个额外的初始字节来处理最终的辅音情况，例如“ parakeet”）。

强壮的单词为假，非强壮的单词为真。

,Ḷ               % 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 answer一样简单。

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

在线尝试！

Perl 5，31字节（30 +1）

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

+1个字节用于-p命令行标志。如果单词是一个强词，则打印该单词；否则，则打印一个空字符串。

果冻，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

是的，我知道我被乔纳森·艾伦打败了很多，但我还是想分享自己的方法：P

通过窃取乔纳森·艾伦（Jonathan Allan）的一点答案得到-4个字节（而不是附加一个辅音以检查最后一个字母的边沿大小写，仅附加1个）
-1个字节（由于英里）

Awk，39个字节

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

打印n非强词，不打印（或换行）强词

跟随包并在小写输入上搜索两个连续的非元音

测试

$ 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")
}

在线试用

基于@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)

因此，它基本上检查我们是否可以找到两个相邻的辅音，或者字符串是否以辅音结尾。

旧答案（53个字节）：

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

在这里尝试。（true如果强壮，false如果没有）

使用正则表达式查看输入字符串是否与“ strong”正则表达式匹配。注意，String#matches在Java中会自动添加^...$以检查String是否完全匹配给定的正则表达式。

说明”：

 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如果没有）

Ruby，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å

在线尝试！

使用乔纳森算法，返回0true和1false。

Swift 3.1，85字节

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

在这里尝试！

这借用了Arnauld的正则表达式。

Lua，41个字节

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

从标准输入读取

Lua（loadstring'ed），37个字节

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

从函数参数读取

输入为小写

查看是否存在长度为2或更大的字符串，该字符串仅由非元音（辅音）组成，或者该字符串是否以非元音结尾

返回true / false

C ++，195个 194字节

-1个字节，感谢Zacharý

大写，如果输入是一个强词，则返回true，否则返回false（C ++具有简单的int布尔值隐式转换规则，0 => false，否则返回true）

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

测试代码：

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字节

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

对于强词返回1，对于弱词返回0 。测试了主要帖子中给出的单词。

C（gcc），59个字节

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

在线尝试！

PHP，69字节

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

返回1表示单词不强。

CJam，57个字节

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

在线尝试！

读取输入，将辅音转换为1，将元音转换为0。对于每个辅音，AND预定义变量X（预定义为1）与下一个字符的值。输出X