Eles dizem que hateé uma palavra forte. Eu queria descobrir o porquê, então dei uma boa olhada na palavra.

Percebi que toda consoante tinha uma vogal depois dela. Isso fez parecer muito forte para mim, então eu decidi que é isso que torna uma palavra forte.

Quero encontrar palavras mais fortes, então vou precisar de um programa para isso!

Encontrar palavras fortes

Palavras fortes são aquelas em que cada consoante (letras do conjunto BCDFGHJKLMNPQRSTVWXZ) é seguida por uma vogal (letras do conjunto AEIOUY). É isso aí. Nada mais importa.

Se a palavra começar com uma vogal, você não precisa se preocupar com nenhuma das letras antes da primeira consoante. Se a palavra não tem consoantes, é automaticamente uma palavra forte!

Alguns exemplos de palavras fortes são agate, hatee you. agateainda é uma palavra forte porque, embora comece com uma vogal, toda consoante ainda é seguida por uma vogal. youé uma palavra forte porque não tem consoantes.

Não há restrição de comprimento para palavras fortes.

O desafio

Escreva um programa ou função que use uma string não vazia como entrada e emita um valor verdadeiro se for uma palavra forte ou um valor falso se não for.

Esclarecimentos

• Você pode optar por receber a entrada em minúsculas ou maiúsculas. Especifique qual em sua resposta.
• As palavras não conterão pontuação de nenhum tipo. Eles conterão apenas letras simples no conjunto ABCDEFGHIJKLMNOPQRSTUVWXYZ.
• Em vez de valores verdadeiros e falsos, você pode escolher dois valores distintos e consistentes para retornar para verdadeiro e falso. Se você fizer isso, especifique os valores que você escolheu na sua resposta.
  • Como alternativa, você pode gerar um valor falso para uma palavra forte e um valor verdadeiro para uma palavra não forte.

Casos de teste

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

Pontuação

Como se trata de código-golfe , a resposta com o mínimo de bytes vence!

JavaScript (ES6), 36 28 27 bytes

^{Economizou 1 byte invertendo o resultado, conforme sugerido por LarsW}

Recebe entrada em minúsculas. Retorna falsepara uma palavra forte e truepara uma palavra não forte.

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

Quão?

Anexamos um 0(não vogal) no final da sequência de entrada e procuramos dois caracteres consecutivos que não sejam vogais. Isso nos permite cobrir os dois casos que tornam uma palavra não forte:

• contém duas consoantes consecutivas
• ou termina com uma consoante

Casos de teste

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']`

Uma função sem nome que pega uma sequência (minúscula) se retorna Falsese forte ou Truenão.

Experimente online! (inverte os resultados para corresponder ao OP)

Quão?

Palavras não fortes têm uma consoante seguida por uma consoante ou terminam em uma consoante.

O código adiciona uma consoante ao final ( s+'b') para fazer com que o teste necessário seja apenas para duas consoantes seguidas.

Ele descobre se cada letra da palavra alterada é uma vogal com a compreensão da lista [v in'aeiouy'for v in s+'b'].

Agora, ele precisa verificar dois Falseresultados seguidos (sinalizando uma palavra não forte), obtendo uma representação de string (usando `...`) desta lista e procurando a existência de 'se, F'. Esta é a string mais curta encontrada em, 'False, False'mas nenhum de 'True, True':; 'False, True'; ou 'True, False'.

Como exemplo, considere 'nut', a compreensão da lista avalia cada letra, v, da 'nutb'para a existência em 'aeiouy'ceder a lista [False, True, False, False], a representação de cadeia desta lista é '[False, True, False, False]'que contém 'e, F'aqui: '[False, True, Fals>>e, F<<alse]'portanto, a função retorna Trueo que significa que a porca é não uma palavra forte.

Geléia ,  10  9 bytes

e€ØY;Ạ11ẇ

Um link monádico que pega uma lista de caracteres e retorna:

• 0 se forte
• 1 se não

Experimente online! ou veja a suíte de testes .

Quão?

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: O motivo do uso Ạé apenas para salvar um byte em excesso 1(já que queremos usá-lo 11imediatamente).

05AB1E , 8 bytes

Código

žPS¡¦õÊP

Usa a codificação 05AB1E . Experimente online!

Explicação

ž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

Exemplo

             # "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,""))

Experimente online!

Um porto da resposta JavaScript de Arnauld; retorna 1 para palavras fracas e integer(0)fortes; anexa um (espaço) ao final da sequência.

Isso é realmente vetorizado; com um vetor de strings, ele retorna os índices (com base em 1) das palavras fracas.

Dyalog APL, 20 bytes

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

Experimente online!

Haskell , 61 54 bytes

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

Experimente online!

Eu tive que adicionar um zno final da string para lidar com o caso de uma consoante à direita.

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

Experimente online!

Casca , 12 bytes

ΛΣX_2m€¨γaıu

Experimente online!

Agradecemos a H.PWiz pela ajuda com -4. Retorna valores inconsistentes, mas adequadamente verdadeiros ou falsos.
Graças a Leo por -1, agora retorna um valor consistente de verdade / falsidade.

Pitão , 18 bytes

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

Verifique todos os casos de teste.

"Emprestou" a regex da resposta JS . Isso retorna Falsepara palavras fortes, Truecaso contrário

Brachylog , 18 11 10 bytes

,Ḷs₂{¬∈Ẉ}ᵐ

Experimente online!

Puro e simples (exceto talvez os 2 bytes iniciais extras para lidar com o caso consoante final, como "periquito").

É falsey para palavras fortes e verdade para palavras não fortes.

,Ḷ               % 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 ao perceber que pode ser tão simples quanto a resposta JS de Arnauld .

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

Experimente online!

Perl 5, 31 bytes (30 + 1)

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

+1 byte para -psinalizador de linha de comando. Imprime a palavra se for uma palavra forte ou a sequência vazia, se não for.

Gelatina , 11 bytes

e€ØY;1a2\¬Ȧ

Experimente 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

Sim, eu sei que fui derrotado por Jonathan Allan, mas eu queria compartilhar minha abordagem de qualquer maneira: P

-4 bytes roubando um pouco da resposta de Jonathan Allan (em vez de anexar uma consoante para verificar a última letra da caixa de letras, basta acrescentar 1)
-1 byte graças às milhas

Awk, 39 bytes

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

imprime npara palavras não fortes, nada (ou apenas uma nova linha) para palavras fortes

seguindo o pacote e procurando duas não vogais consecutivas na entrada em minúsculas

teste

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

Verdadeiro e falso são trocados

Embelezado

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

Teste

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

Baseado na resposta de @ Arnauld

Retina , 23 18 bytes

$
$
1`[^aeiouy]{2}

Experimente online! Saídas 0 para forte, 1 se não. Adicione 1 byte para oferecer suporte a maiúsculas e minúsculas. Editar: salvou 5 bytes graças a @ovs.

Java 8, 53 42 bytes

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

-11 bytes usando o mesmo regex que na resposta Kotlin de @jrtapsell .

Experimente aqui. ( falsese forte; truese não)

Explicação:

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)

Portanto, basicamente verifica se podemos encontrar duas consoantes adjacentes ou se a String termina com uma consoante.

Resposta antiga ( 53 bytes ):

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

Experimente aqui. ( truese forte; falsese não)

Usa regex para verificar se a string de entrada corresponde ao regex 'strong'. Observe que String#matchesem Java é adicionado automaticamente ^...$para verificar se a String corresponde inteiramente ao regex especificado.

Explicação":

 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)

Uma pesquisa em vez de correspondências (como muitas outras respostas usam) é realmente mais longa em Java:
70 bytes :

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

Experimente aqui. ( falsese forte; truese não)

Ruby , 25 bytes

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

Experimente online!

Todo mundo está fazendo isso, então por que o Ruby não pode?

SOGL V0.12 , 19 18 bytes

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

Experimente aqui!

Explicação:

æ                   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å

Experimente online!

Usa o algoritmo de Jonathan, retorna 0para verdadeiro e 1para falso.

Swift 3.1 , 85 bytes

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

Experimente aqui!

Isso toma emprestado a expressão regular de Arnauld .

Lua, 41 bytes

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

Lê da entrada padrão

Lua (string de carregamento), 37 bytes

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

Lê do (s) parâmetro (s) da função

Entrada em minúscula

Vê se existe uma sequência de comprimento 2 ou mais, consistindo apenas de não vogais (consoantes) ou se a sequência termina com uma não vogal

Retorna verdadeiro / falso

C ++, 195 194 bytes

-1 bytes graças a Zacharý

Maiúsculas, retorne verdadeiro se a entrada for uma palavra forte, caso contrário, false (C ++ tem int simples para boolar regras de conversão implícitas, 0 => falso, verdadeiro caso contrário)

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

Código a testar:

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

Retorna 1 para palavra forte e 0 para palavra fraca . Testado com as palavras dadas no post principal.

C (gcc) , 59 bytes

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

Experimente online!

PHP, 69 bytes

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

Retorna 1 é a palavra não é forte.

CJam , 57 bytes

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

Experimente online!

Lê entrada, converte para 1s para consoantes, 0s para vogais. Para cada consoante, AND variável predefinida X (predefinida para 1) com o valor do próximo caractere. Saída X