Dicen que hatees una palabra fuerte. Quería saber por qué, así que eché un buen vistazo a la palabra.

Noté que cada consonante tenía una vocal después. Eso me hizo parecer bastante fuerte, así que decidí que eso es lo que hace que una palabra sea fuerte.

Quiero encontrar palabras más fuertes, ¡así que necesitaré un programa para ello!

Encontrar palabras fuertes

Las palabras fuertes son palabras donde cada consonante (letras en el conjunto BCDFGHJKLMNPQRSTVWXZ) es seguida por una vocal (letras en el conjunto AEIOUY). Eso es. Nada más importa.

Si la palabra comienza con una vocal, no tiene que preocuparse por ninguna de las letras antes de la primera consonante. Si la palabra no tiene consonantes, ¡es automáticamente una palabra fuerte!

Algunos ejemplos de palabras fuertes son agate, hatey you. agatesigue siendo una palabra fuerte porque, aunque comienza con una vocal, a cada consonante todavía le sigue una vocal. youes una palabra fuerte porque no tiene consonantes.

No hay restricción de longitud para palabras fuertes.

El reto

Escriba un programa o función que tome una cadena no vacía como entrada y genere un valor verdadero si es una palabra fuerte o un valor falso si no lo es.

Aclaraciones

• Puede decidir tomar la entrada en minúsculas o mayúsculas. Especifique cuál en su respuesta.
• Las palabras no contendrán signos de puntuación de ningún tipo. Solo contendrán letras simples en el conjunto ABCDEFGHIJKLMNOPQRSTUVWXYZ.
• En lugar de valores de verdad y falsedad, puede elegir dos valores distintos y consistentes para obtener verdadero y falso. Si hace esto, especifique los valores que ha elegido en su respuesta.
  • Alternativamente, puede generar un valor falso para una palabra fuerte y uno verdadero para una palabra no fuerte.

Casos de prueba

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

Tanteo

Como se trata de código de golf , ¡la respuesta con la menor cantidad de bytes gana!

JavaScript (ES6), 36 28 27 bytes

^{Se guardó 1 byte invirtiendo el resultado, como lo sugiere LarsW}

Toma entrada en minúsculas. Devuelve falsepara una palabra fuerte y truepara una palabra no fuerte.

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

¿Cómo?

Agregamos un 0(sin vocal) al final de la cadena de entrada y buscamos dos caracteres consecutivos sin vocal. Esto nos permite cubrir ambos casos que hacen que una palabra no sea fuerte:

• contiene dos consonantes consecutivas
• o termina con una consonante

Casos de prueba

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 bytes

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

Una función sin nombre que toma una cadena (minúscula), s , y regresa Falsesi es fuerte o Trueno.

Pruébalo en línea! (invierte los resultados para que coincidan con el OP)

¿Cómo?

Las palabras no fuertes tienen una consonante seguida de una consonante o terminan en una consonante.

El código agrega una consonante al final (s+'b' ) para que la prueba requerida sea solo para dos consonantes seguidas.

Descubre si cada letra en la palabra alterada es una vocal con la comprensión de la lista [v in'aeiouy'for v in s+'b'] .

Ahora necesita verificar dos Falseresultados seguidos (indicando una palabra no fuerte), lo hace obteniendo una representación de cadena (usando `...`) de esta lista y buscando la existencia de 'se, F'. Esta es la cadena más corta encontrada 'False, False'pero ninguna de 'True, True':; 'False, True'; o'True, False' .

Como un ejemplo 'nut', considere , la comprensión de la lista evalúa cada letra, vde la 'nutb'existencia en el 'aeiouy'rendimiento de la lista [False, True, False, False], la representación de cadena de esta lista es la '[False, True, False, False]'que contiene 'e, F'aquí: '[False, True, Fals>>e, F<<alse]'por lo tanto, la función devuelve Truelo que significa que nuez no es una palabra fuerte.

Jalea ,  10  9 bytes

e€ØY;Ạ11ẇ

Un enlace monádico que toma una lista de caracteres y regresa:

• 0 si fuerte
• 1 si no

Pruébalo en línea! o ver el conjunto de pruebas .

¿Cómo?

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]

Nota: La razón para usar Ạes solo para guardar un byte sobre el uso 1(ya que luego queremos usarlo de 11inmediato).

05AB1E , 8 bytes

Código

žPS¡¦õÊP

Utiliza la codificación 05AB1E .Pruébalo en línea!

Explicación

ž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

Ejemplo

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

R , 43 bytes

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

Pruébalo en línea!

Un puerto de la respuesta JavaScript de Arnauld; devuelve 1 para palabras débiles yinteger(0) para fuertes; agrega un (espacio) al final de la cadena.

Esto en realidad está vectorizado; con un vector de cadenas, devuelve los índices (basados ​​en 1) de las palabras débiles.

Dyalog APL, 20 bytes

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

Pruébalo en línea!

Haskell , 61 54 bytes

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

Pruébalo en línea!

Tuve que agregar un zal final de la cadena para manejar el caso de una consonante final.

Java (OpenJDK 8) , 93 81 bytes

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

Pruébalo en línea!

Casco , 12 bytes

ΛΣX_2m€¨γaıu

Pruébalo en línea!

Gracias a H.PWiz por su ayuda con -4. Devuelve valores inconsistentes pero apropiadamente verdaderos o falsos.
Gracias a Leo por -1, ahora devuelve un valor verdadero / falso constante.

Pyth , 18 bytes

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

Verifique todos los casos de prueba.

"Prestó" la expresión regular de la respuesta de JS . Esto vuelve Falsepara palabras fuertes, de lo Truecontrario

Brachylog , 18 11 10 bytes

,Ḷs₂{¬∈Ẉ}ᵐ

Pruébalo en línea!

Limpio y simple (excepto tal vez por los 2 bytes iniciales adicionales para manejar el caso de la consonante final, como "periquito").

Es falsey para palabras fuertes y verdadero para palabras no fuertes.

,Ḷ               % 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 al darse cuenta de que puede ser tan simple como la respuesta JS de Arnauld .

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

Pruébalo en línea!

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.

Jalea , 11 bytes

e€ØY;1a2\¬Ȧ

Pruébalo en línea!

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

Sí, sé que Jonathan Allan me ha golpeado mucho, pero de todos modos quería compartir mi enfoque: P

-4 bytes al robar un poco de la respuesta de Jonathan Allan (en lugar de agregar una consonante para verificar el caso del borde de la última letra, solo agregue 1)
-1 byte gracias a millas

Awk, 39 bytes

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

imprime npara palabras no seguras, nada (o simplemente una nueva línea) para palabras fuertes

siguiendo el paquete y buscando dos no vocales consecutivas en minúsculas

pruebas

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

Verdadero y falso se intercambian

Embellecido

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

Prueba

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

Basado en la respuesta de @ 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