Dicono che hatesia una parola forte. Volevo scoprire perché, quindi ho visto bene la parola.

Ho notato che ogni consonante aveva una vocale dopo di essa. Questo mi ha fatto sembrare abbastanza forte, quindi ho deciso che questo è ciò che rende forte una parola.

Voglio trovare parole più forti, quindi avrò bisogno di un programma per farlo!

Trovare parole forti

Le parole forti sono parole in cui ogni consonante (lettere nel set BCDFGHJKLMNPQRSTVWXZ) è seguita da una vocale (lettere nel set AEIOUY). Questo è tutto. Non importa nient'altro.

Se la parola inizia con una vocale, non devi preoccuparti di nessuna delle lettere prima della prima consonante. Se la parola non contiene consonanti, è automaticamente una parola forte!

Alcuni esempi di parole forti sono agate, hatee you. agateè ancora una parola forte perché sebbene inizi con una vocale, ogni consonante è ancora seguita da una vocale. youè una parola forte perché non ha consonanti.

Non ci sono restrizioni sulla lunghezza per parole forti.

La sfida

Scrivi un programma o una funzione che accetta come input una stringa non vuota e genera un valore di verità se è una parola forte o un valore di falsa se non lo è.

chiarimenti

• È possibile decidere di accettare l'input in minuscolo o maiuscolo. Specifica quale nella tua risposta.
• Le parole non conterranno punteggiatura di alcun tipo. Conterranno solo lettere semplici nel set ABCDEFGHIJKLMNOPQRSTUVWXYZ.
• Invece di valori di verità e falsità, puoi scegliere due valori distinti e coerenti da restituire per vero e falso. Se lo fai, specifica i valori che hai scelto nella tua risposta.
  • In alternativa, puoi generare un valore falso per una parola forte e uno sincero per una parola non forte.

Casi 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

punteggio

Dato che si tratta di code-golf , la risposta con il minor numero di byte vince!

JavaScript (ES6), 36 28 27 byte

^{Salvato 1 byte invertendo il risultato, come suggerito da LarsW}

Accetta input in minuscolo. Restituisce falseper una parola forte e trueper una parola non forte.

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

Come?

Aggiungiamo un 0(non vocale) alla fine della stringa di input e cerchiamo due caratteri consecutivi non vocali. Questo ci permette di coprire entrambi i casi che rendono una parola non forte:

• contiene due consonanti consecutive
• o termina con una consonante

Casi 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 byte

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

Una funzione senza nome che prende una stringa (minuscola) se restituisce Falsese forte o Trueno.

Provalo online! (inverte i risultati in modo che corrispondano all'OP)

Come?

Le parole non forti hanno una consonante seguita da una consonante o finiscono in una consonante.

Il codice aggiunge una consonante alla fine ( s+'b') per rendere il test richiesto solo per due consonanti di fila.

Scopre se ogni lettera nella parola alterata è una vocale con la comprensione dell'elenco [v in'aeiouy'for v in s+'b'].

Ora ha bisogno di controllare due Falserisultati di seguito (segnalando una parola non forte), lo fa ottenendo una rappresentazione di stringa (usando `...`) di questo elenco e cercando l'esistenza di 'se, F'. Questa è la stringa più corta trovata in 'False, False'ma nessuna di 'True, True':; 'False, True'; oppure 'True, False'.

Come esempio si consideri 'nut', l'elenco comprensione valuta ogni lettera v, di 'nutb'per esistenza nel 'aeiouy'cedere nell'elenco [False, True, False, False], la rappresentazione di stringa di questa lista è '[False, True, False, False]'che contiene 'e, F'qui: '[False, True, Fals>>e, F<<alse]'quindi la funzione restituisce Trueil che significa che il dado è non una parola forte.

Gelatina ,  10  9 byte

e€ØY;Ạ11ẇ

Un collegamento monadico che prende un elenco di personaggi e che ritorna:

• 0 se forte
• 1 altrimenti

Provalo online! o vedi la suite di test .

Come?

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: il motivo dell'utilizzo Ạè solo quello di salvare un byte sull'uso 1(poiché quindi vogliamo utilizzarlo 11immediatamente).

05AB1E , 8 byte

Codice

žPS¡¦õÊP

Utilizza la codifica 05AB1E . Provalo online!

Spiegazione

ž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

Esempio

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

R , 43 byte

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

Provalo online!

Una porta della risposta JavaScript di Arnauld; restituisce 1 per le parole deboli e integer(0)per quelle forti; aggiunge uno (spazio) alla fine della stringa.

Questo è in realtà vettorializzato; con un vettore di stringhe, restituisce gli indici (basati su 1) delle parole deboli.

Dyalog APL, 20 byte

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

Provalo online!

Haskell , 61 54 byte

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

Provalo online!

Ho dovuto aggiungere za alla fine della stringa per gestire il caso di una consonante finale.

Java (OpenJDK 8) , 93 81 byte

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

Provalo online!

Buccia , 12 byte

ΛΣX_2m€¨γaıu

Provalo online!

Grazie a H.PWiz per l'aiuto con -4. Restituisce valori incoerenti ma adeguatamente veritieri o falsi.
Grazie a Leo per -1, ora restituisce un valore di verità / falsa coerente.

Pyth , 18 byte

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

Verifica tutti i casi di test.

"Preso in prestito" la regex dalla risposta di JS . Questo ritorna Falseper parole forti, Truealtrimenti

Brachylog , 18 11 10 byte

,Ḷs₂{¬∈Ẉ}ᵐ

Provalo online!

Pulito e semplice (tranne forse per i 2 byte iniziali aggiuntivi per gestire il caso consonante finale, come "parrocchetto").

È falsità per parole forti e verità per parole non forti.

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

-30 byte rendendosi conto che può essere semplice come la risposta JS di Arnauld .

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

Provalo online!

Perl 5, 31 byte (30 + 1)

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

+1 byte per -pflag della riga di comando. Stampa la parola se è una parola forte o la stringa vuota se non lo è.

Gelatina , 11 byte

e€ØY;1a2\¬Ȧ

Provalo 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

Sì, lo so che sono stato battuto molto da Jonathan Allan ma volevo comunque condividere il mio approccio: P

-4 byte rubando un po 'della risposta di Jonathan Allan (invece di aggiungere una consonante per verificare il caso limite dell'ultima lettera, basta aggiungere 1)
-1 byte grazie alle miglia

Awk, 39 byte

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

stampa nper non-strongword, niente (o solo una nuova riga) per strongword

seguendo il pacchetto e cercando due non vocali consecutive su input minuscoli

analisi

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

Kotlin , 49 byte

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

Vero e falso vengono scambiati

Abbellire

{
    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

Basato sulla risposta di @ Arnauld

Retina , 23 18 byte

$
$
1`[^aeiouy]{2}

Provalo online! Emette 0 per forte, 1 in caso contrario. Aggiungi 1 byte per supportare il caso misto. Modifica: 5 byte salvati grazie a @ovs.

Java 8, 53 42 byte

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

-11 byte usando invece lo stesso regex della risposta Kotlin di @jrtapsell .

Provalo qui. ( falsese forte; in truecaso contrario)

Spiegazione:

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)

Quindi controlla sostanzialmente se possiamo trovare due consonanti adiacenti o se la stringa termina con una consonante.

Vecchia risposta ( 53 byte ):

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

Provalo qui. ( truese forte; in falsecaso contrario)

Usa regex per vedere se input-String corrisponde a 'strong'-regex. Si noti che String#matchesin Java aggiunge automaticamente ^...$per verificare se la stringa corrisponde interamente alla regex fornita.

Spiegazione":

 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)

Una ricerca invece di corrispondenze (come molte altre risposte utilizzano) è in realtà più lunga in Java:
70 byte :

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

Provalo qui. ( falsese forte; in truecaso contrario)

Rubino , 25 byte

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

Provalo online!

Lo stanno facendo tutti gli altri, quindi perché non può Ruby?

SOGL V0.12 , 19 18 byte

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

Provalo qui!

Spiegazione:

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

žP¹SåJ1«11å

Provalo online!

Utilizza l'algoritmo di Jonathan, restituisce 0per vero e 1per falso.

Swift 3.1 , 85 byte

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

Provalo qui!

Questo prende in prestito la regex di Arnauld .

Lua, 41 byte

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

Legge da input standard

Lua (con stringhe di carico), 37 byte

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

Legge dai parametri di funzione

L'ingresso è in minuscolo

Verifica se esiste una stringa di lunghezza 2 o superiore, composta solo da non vocali (consonanti) o se la stringa termina con una non vocale

Restituisce vero / falso

C ++, 195 194 byte

-1 byte grazie a Zacharý

Maiuscolo, restituisce vero se l'input è una parola forte, falso altrimenti (C ++ ha un semplice int per booleare regole di cast implicite, 0 => falso, vero altrimenti)

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

Codice da testare:

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 byte

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

Restituisce 1 per la parola forte e 0 per la parola debole . Testato con le parole riportate nel post principale.

C (gcc) , 59 byte

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

Provalo online!

PHP, 69 byte

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

Restituisce 1 è la parola non è forte.

CJam , 57 byte

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

Provalo online!

Legge l'input, converte in 1s per consonanti, 0s per vocali. Per ogni consonante, AND variabile predefinita X (predefinita a 1) con il valore del carattere successivo. Uscita X