Ils disent que hatec'est un mot fort. Je voulais savoir pourquoi, alors j'ai bien regardé le mot.

J'ai remarqué que chaque consonne avait une voyelle après. Cela me donnait l'air assez fort, alors j'ai décidé que c'était ce qui rend un mot fort.

Je veux trouver des mots plus forts, alors il me faut un programme pour ça!

Trouver des mots forts

Les mots forts sont des mots où chaque consonne (lettres de l'ensemble BCDFGHJKLMNPQRSTVWXZ) est suivie d'une voyelle (lettres de l'ensemble AEIOUY). C'est ça. Rien d'autre ne compte.

Si le mot commence par une voyelle, vous n'avez pas à vous soucier des lettres avant la première consonne. Si le mot n'a pas de consonnes, c'est automatiquement un mot fort!

Quelques exemples de mots forts sont agate, hateet you. agateest toujours un mot fort car, bien qu’il commence par une voyelle, chaque consonne est toujours suivie d’une voyelle. youest un mot fort car il n’a pas de consonnes.

Il n'y a pas de restriction de longueur pour les mots forts.

Le défi

Ecrivez un programme ou une fonction qui prend une chaîne non vide en entrée et génère une valeur de vérité si c'est un mot fort ou une valeur de faux si ce n'est pas le cas.

Des clarifications

• Vous pouvez décider de saisir l’entrée en minuscule ou en majuscule. Spécifiez lequel dans votre réponse.
• Les mots ne contiendront aucune ponctuation. Ils ne contiendront que des lettres en clair dans le jeu ABCDEFGHIJKLMNOPQRSTUVWXYZ.
• Au lieu de valeurs de vérité et de fausseté, vous pouvez choisir deux valeurs distinctes et cohérentes à retourner pour vrai et faux. Si vous faites cela, spécifiez les valeurs que vous avez choisies dans votre réponse.
  • Vous pouvez également indiquer une valeur de fausseté pour un mot fort et une valeur de vérité pour un mot non fort.

Cas de test

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

Notation

Puisqu'il s'agit de code-golf , la réponse avec le moins d'octets gagne!

JavaScript (ES6), 36 28 27 octets

^{Enregistré 1 octet en inversant le résultat, comme suggéré par LarsW}

Prend la saisie en minuscule. Retourne falsepour un mot fort et truepour un mot non fort.

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

Comment?

Nous ajoutons un 0(non-voyelle) à la fin de la chaîne d'entrée et cherchons deux caractères consécutifs non-voyelles. Cela nous permet de couvrir les deux cas qui rendent un mot pas fort:

• il contient deux consonnes consécutives
• ou il se termine par une consonne

Cas de test

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 octets

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

Fonction non nommée prenant une chaîne (en minuscule) set renvoyée Falsesi forte ou Truenon.

Essayez-le en ligne!(inverse les résultats pour correspondre à l'OP)

Comment?

Les mots non forts ont une consonne suivie d'une consonne ou se terminent par une consonne.

Le code ajoute une consonne à la fin (s+'b' ) pour que le test requis soit juste pour deux consonnes consécutives.

Il découvre si chaque lettre du mot modifié est une voyelle avec la compréhension de liste [v in'aeiouy'for v in s+'b'] .

Il doit maintenant vérifier deux Falserésultats dans une ligne (signalant un mot non fort), il le fait en obtenant une représentation sous forme de chaîne (using `...`) de cette liste et en recherchant l'existence de 'se, F'. Ceci est la chaîne la plus courte trouvée dans 'False, False'mais aucune des 'True, True':; 'False, True'; ou'True, False' .

À titre d'exemple considérer 'nut', la compréhension de la liste évalue chaque lettre, v, de l' 'nutb'existence en 'aeiouy'donnant la liste [False, True, False, False], la représentation de chaîne de cette liste est '[False, True, False, False]'qui contient 'e, F'ici: d' '[False, True, Fals>>e, F<<alse]'où la fonction retourne Truece qui signifie que l' écrou est pas un mot fort.

Gelée ,  10 à  9 octets

e€ØY;Ạ11ẇ

Un lien monadique prenant une liste de caractères et renvoyant:

• 0 si fort
• 1 si non

Essayez-le en ligne! ou voir la suite de tests .

Comment?

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]

Note: La raison de l’utilisation Ạest juste de sauvegarder un octet avant d’être utilisé 1(puisque nous voulons alors l’utiliser 11tout de suite).

05AB1E , 8 octets

Code

žPS¡¦õÊP

Utilise le codage 05AB1E . Essayez-le en ligne!

Explication

ž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

Exemple

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

R , 43 octets

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

Essayez-le en ligne!

Une réponse JavaScript du port d'Arnauld; renvoie 1 pour les mots faibles et integer(0)pour les mots forts; il ajoute un (espace) à la fin de la chaîne.

Ceci est réellement vectorisé; avec un vecteur de chaînes, il renvoie les indices (basés sur 1) des mots faibles.

Dyalog APL, 20 octets

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

Essayez-le en ligne!

Haskell , 61 54 octets

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

Essayez-le en ligne!

Je devais ajouter un zà la fin de la chaîne pour gérer le cas d'une consonne de fin.

Java (OpenJDK 8) , 93 81 octets

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

Essayez-le en ligne!

Décortiquer , 12 octets

ΛΣX_2m€¨γaıu

Essayez-le en ligne!

Merci à H.PWiz pour l'aide avec -4. Renvoie des valeurs incohérentes mais appropriées de vérité ou de fausseté.
Merci à Leo pour -1, retourne maintenant une valeur conforme vérité / fausseté.

Pyth , 18 octets

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

Vérifiez tous les cas de test.

"Emprunté" la regex de la réponse JS . Cela retourne Falsepour les mots forts, Truesinon

Brachylog , 18 11 10 octets

,Ḷs₂{¬∈Ẉ}ᵐ

Essayez-le en ligne!

Propre et simple (sauf peut-être pour les 2 octets initiaux supplémentaires pour traiter le cas de consonne final, comme "perakeet").

Est falsey pour les mots forts et la vérité pour les mots non forts.

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

-30 octets en réalisant que cela peut être aussi simple que la réponse JS d'Arnauld .

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

Essayez-le en ligne!

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