Sie sagen, das hateist ein starkes Wort. Ich wollte herausfinden, warum, also habe ich mir das Wort genau angesehen.

Ich bemerkte, dass jeder Konsonant einen Vokal danach hatte. Das machte es ziemlich stark für mich, also entschied ich, dass das, was ein Wort stark macht.

Ich möchte stärkere Wörter finden, deshalb brauche ich ein Programm dafür!

Starke Worte finden

Starke Wörter sind Wörter, bei denen auf jeden Konsonanten (Buchstaben in der Menge BCDFGHJKLMNPQRSTVWXZ) ein Vokal (Buchstaben in der Menge AEIOUY) folgt . Das ist es. Das ist alles, was zählt.

Wenn das Wort mit einem Vokal beginnt, müssen Sie sich vor dem ersten Konsonanten über keinen der Buchstaben Gedanken machen. Wenn das Wort überhaupt keine Konsonanten enthält, ist es automatisch ein starkes Wort!

Einige Beispiele für starke Worte sind agate, hateund you. agateist immer noch ein starkes Wort, denn obwohl es mit einem Vokal beginnt, folgt jedem Konsonanten immer noch ein Vokal. youist ein starkes Wort, weil es keine Konsonanten hat.

Es gibt keine Längenbeschränkung für starke Wörter.

Die Herausforderung

Schreiben Sie ein Programm oder eine Funktion, die eine nicht leere Zeichenfolge als Eingabe verwendet und einen Wahrheitswert ausgibt, wenn es sich um ein starkes Wort handelt, oder einen falschen Wert, wenn dies nicht der Fall ist.

Klarstellungen

• Sie können entscheiden, ob die Eingabe in Klein- oder Großbuchstaben erfolgen soll. Geben Sie in Ihrer Antwort an, welche.
• Wörter enthalten keine Interpunktion. Sie enthalten nur einfache Buchstaben im Satz ABCDEFGHIJKLMNOPQRSTUVWXYZ.
• Anstatt wahrer und falscher Werte können Sie zwei unterschiedliche und konsistente Werte auswählen, die für wahr und falsch zurückgegeben werden. Geben Sie in diesem Fall die Werte an, die Sie in Ihrer Antwort ausgewählt haben.
  • Sie können alternativ einen falschen Wert für ein starkes Wort und einen falschen Wert für ein nicht starkes Wort ausgeben.

Testfälle

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

Wertung

Da es sich um Code-Golf , Bytes die Antwort mit dem geringsten gewinnt!

JavaScript (ES6), 36 28 27 Bytes

^{1 Byte durch Invertieren des Ergebnisses gespeichert, wie von LarsW vorgeschlagen}

Nimmt Eingaben in Kleinbuchstaben vor. Gibt falsefür ein starkes Wort und truefür ein nicht starkes Wort zurück.

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

Wie?

Wir fügen ein 0(Nicht-Vokal) an das Ende der Eingabezeichenfolge an und suchen nach zwei aufeinander folgenden Nicht-Vokal-Zeichen. So können wir beide Fälle abdecken, die ein Wort nicht stark machen:

• es enthält zwei aufeinanderfolgende Konsonanten
• oder es endet mit einem Konsonanten

Testfälle

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

Eine unbenannte Funktion, die eine Zeichenfolge (in Kleinbuchstaben) verwendet sund zurückgibt, Falsewenn sie stark ist oder Truenicht.

Probieren Sie es online! (invertiert die Ergebnisse entsprechend dem OP)

Wie?

Nicht-starke Wörter haben entweder einen Konsonanten gefolgt von einem Konsonanten oder enden in einem Konsonanten.

Der Code fügt am Ende ( s+'b') einen Konsonanten hinzu , damit der erforderliche Test nur für zwei Konsonanten hintereinander gilt.

Es wird herausgefunden, ob jeder Buchstabe im geänderten Wort ein Vokal mit dem Listenverständnis ist [v in'aeiouy'for v in s+'b'].

Es muss nun nach zwei FalseErgebnissen in einer Reihe `...`suchen (was ein nicht starkes Wort signalisiert), indem es eine Zeichenfolgendarstellung (unter Verwendung ) dieser Liste abruft und nach der Existenz von sucht 'se, F'. Dies ist die kürzeste Zeichenfolge gefunden , 'False, False'aber keiner von: 'True, True'; 'False, True'; oder 'True, False'.

Als Beispiel betrachtet 'nut', wertet das Listenverständnis jeden Buchstaben aus, vvon dem, 'nutb'um 'aeiouy'die Liste zu erhalten [False, True, False, False], die Zeichenfolgendarstellung dieser Liste hier '[False, True, False, False]'enthalten 'e, F'ist: '[False, True, Fals>>e, F<<alse]'daher gibt die Funktion zurück, Truewas bedeutet, dass nut kein starkes Wort ist.

Gelee ,  10  9 Bytes

e€ØY;Ạ11ẇ

Ein monadischer Link, der eine Liste von Zeichen aufnimmt und Folgendes zurückgibt:

• 0 wenn stark
• 1 wenn nicht

Probieren Sie es online! oder sehen Sie sich die Testsuite an .

Wie?

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]

Hinweis: Der Grund für die Verwendung Ạist nur, um ein Byte über die Verwendung zu sparen 1(da wir dann 11sofort verwenden möchten ).

05AB1E , 8 Bytes

Code

žPS¡¦õÊP

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

Erläuterung

ž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

Beispiel

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

Probieren Sie es online!

Ein Port von Arnauld's JavaScript-Antwort; gibt 1 für schwache und integer(0)für starke Wörter zurück ; es hängt ein (Leerzeichen) an das Ende der Zeichenkette an.

Dies ist tatsächlich vektorisiert; Mit einem Vektor aus Zeichenfolgen werden die Indizes (1-basiert) der schwachen Wörter zurückgegeben.

Dyalog APL, 20 Bytes

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

Probieren Sie es online!

Haskell , 61 54 Bytes

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

Probieren Sie es online!

Ich musste ein zam Ende der Zeichenfolge hinzufügen , um den Fall eines nachgestellten Konsonanten zu behandeln.

Java (OpenJDK 8) , 93 bis 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;}

Probieren Sie es online!

Schale , 12 Bytes

ΛΣX_2m€¨γaıu

Probieren Sie es online!

Vielen Dank an H.PWiz für die Hilfe bei -4. Gibt inkonsistente, aber entsprechend wahrheitsgemäße oder falsche Werte zurück.
Dank Leo für -1 wird nun ein konsistenter Wahrheits- / Falschwert zurückgegeben.

Pyth , 18 Bytes

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

Überprüfen Sie alle Testfälle.

"Ausgeliehen" der Regex aus der JS-Antwort . Dies Falsegilt Trueansonsten für starke Worte

Brachylog , 18 11 10 Bytes

,Ḷs₂{¬∈Ẉ}ᵐ

Probieren Sie es online!

Ordentlich und einfach (mit Ausnahme der 2 zusätzlichen Anfangsbytes, die für den endgültigen Konsonantenfall erforderlich sind, z. B. "Sittich").

Ist falsch für starke Worte und wahr für nicht starke Worte.

,Ḷ               % 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, wenn man merkt, dass es so einfach ist wie Arnauld's JS-Antwort .

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

Probieren Sie es online!

Perl 5, 31 Bytes (30 + 1)

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

+1 Byte für -pBefehlszeilenflag. Gibt das Wort aus, wenn es ein starkes Wort ist, oder die leere Zeichenfolge, wenn dies nicht der Fall ist.

Jelly , 11 Bytes

e€ØY;1a2\¬Ȧ

Probieren Sie es 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

Ja, ich weiß, dass ich viel von Jonathan Allan geschlagen wurde, aber ich wollte trotzdem meinen Ansatz teilen: P

-4 Bytes durch Diebstahl eines kleinen Teils von Jonathan Allans Antwort (anstatt einen Konsonanten anzufügen, um den Rand des letzten Buchstabens zu prüfen, fügen Sie einfach 1)
-1 Bytes dank Meilen hinzu

Awk, 39 Bytes

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

druckt nfür Nicht-Strongword, nichts (oder nur eine neue Zeile) für Strongword

Folgen Sie dem Pack und suchen Sie nach zwei aufeinander folgenden Nicht-Vokalen bei der Eingabe in Kleinbuchstaben

testen

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

Richtig und falsch sind vertauscht

Verschönert

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

Prüfung

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

Basierend auf der Antwort von @ Arnauld

Retina , 23 18 Bytes

$
$
1`[^aeiouy]{2}

Probieren Sie es online! Gibt 0 für stark aus, 1 wenn nicht. Fügen Sie 1 Byte hinzu, um gemischte Groß- und Kleinschreibung zu unterstützen. Bearbeiten: 5 Bytes dank @ovs gespeichert.

Java 8, 53 42 Bytes

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

-11 Bytes mit demselben regulären Ausdruck wie in @jrtapsells Kotlin-Antwort .

Probieren Sie es hier aus. ( falsewenn stark, truewenn nicht)

Erläuterung:

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)

Es wird also grundsätzlich geprüft, ob wir zwei benachbarte Konsonanten finden können oder ob der String mit einem Konsonanten endet.

Alte Antwort ( 53 Bytes ):

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

Probieren Sie es hier aus. ( truewenn stark, falsewenn nicht)

Verwendet Regex, um festzustellen, ob der Eingabe-String mit dem Regex 'strong' übereinstimmt. Beachten Sie, dass String#matchesin Java automatisch hinzugefügt wird ^...$, um zu überprüfen, ob der String vollständig mit dem angegebenen regulären Ausdruck übereinstimmt.

Erläuterung":

 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)

Eine Suche anstelle von Übereinstimmungen (wie viele andere Antworten) ist in Java tatsächlich länger:
70 Bytes :

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

Probieren Sie es hier aus. ( falsewenn stark, truewenn nicht)

Ruby , 25 Bytes

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

Probieren Sie es online!

Alle anderen machen es so, warum kann Ruby es nicht?

SOGL V0.12 , 19 18 Bytes

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

Probieren Sie es hier aus!

Erläuterung:

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

Probieren Sie es online!

Verwendet Jonathans Algorithmus und gibt 0für wahr und 1falsch zurück.

Swift 3.1 , 85 Bytes

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

Probieren Sie es hier aus!

Dies leiht Arnauld Regex .

Lua, 41 Bytes

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

Liest von der Standardeingabe

Lua (Loadstring), 37 Bytes

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

Liest aus Funktionsparametern

Die Eingabe erfolgt in Kleinbuchstaben

Es wird festgestellt, ob es eine Zeichenfolge mit einer Länge von 2 oder mehr gibt, die nur aus Nicht-Vokalen (Konsonanten) besteht, oder ob die Zeichenfolge mit einem Nicht-Vokal endet

Gibt true / false zurück

C ++, 195 194 Bytes

-1 Bytes dank Zacharý

Großbuchstaben, Rückgabe true, wenn die Eingabe ein starkes Wort ist, andernfalls false (C ++ hat einfache implizite Umwandlungsregeln für int, 0 => false, andernfalls 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);}

Code zum Testen:

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

Gibt 1 für ein starkes Wort und 0 für ein schwaches Wort zurück. Getestet mit den Worten im Hauptbeitrag.

C (gcc) , 59 Bytes

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

Probieren Sie es online!

PHP, 69 Bytes

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

Gibt 1 zurück, wenn das Wort nicht stark ist.

CJam , 57 Bytes

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

Probieren Sie es online!

Liest die Eingabe, konvertiert in 1s für Konsonanten, 0s für Vokale. Für jeden Konsonanten UND vordefinierte Variable X (vordefiniert auf 1) mit dem Wert des nächsten Zeichens. Ausgang X