Ist es ein starkes Wort?


33

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 , Bytes die Antwort mit dem geringsten gewinnt!



1
Ist das leere Wort ""eine mögliche Eingabe?
Silvio Mayolo

@SilvioMayolo Ist es nicht.
Text

@LyricLy Wenn die Eingabe "Akademie" ist, sollte die Ausgabe falsch sein, so wie ich das Problem verstehe. Weil 'm' ein Konsonant ist.
Wahrheitssuche

1
Eine "Banane" ist voller Hass
jstnthms

Antworten:


18

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


Warum +0aber? Es scheint gut zu funktionieren, ohne es
Matheus Avellar

1
@MatheusAvellar Ohne +0würde es falsche Positive auf Wörtern zurückgeben, die mit einem Konsonanten enden.
Arnauld

Ich sehe, ohne das es keine 2 aufeinander folgenden Nicht-Vokale finden kann, wenn es der letzte Buchstabe des Wortes ist. Clever!
Matheus Avellar

Sie sollten in der Lage sein, die !(zwei unterschiedliche Werte)
LarsW

@ LarsW Danke! Ich habe diese Regel nicht bemerkt.
Arnauld

10

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.


7

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 ).


hmm, konsistente Werte ...
Erik the Outgolfer

Was meinst du?
Jonathan Allan

die hackige Sache in Ihrem Code ... sonst hätten Sie e€ØY;1w11oder etwas getan
Erik the Outgolfer

Warum elf? String-Wörter schienen in keiner Weise an die Zahl elf gebunden zu sein
hyiltiz

@hyiltiz Wenn die Dyade ein linkes Argument hat, das eine Zahl ist, wird es implizit in eine dezimale Liste von Ziffern konvertiert, sodass die Elf wird [1,1].
Jonathan Allan

5

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

Vielleicht fehlt mir etwas, aber das scheint immer 1 zurückzugeben? Es gibt 1 sowohl für die von mir getesteten Wahrheitsfälle als auch für die Falsey-Testfälle zurück.
Sundar - Reinstate Monica

(Oh, ich habe gerade gemerkt, wie alt diese Antwort (und Frage) ist. Ich denke, etwas in der Sprache hat sich in der Zwischenzeit geändert?)
Sundar - Wiedereinsetzung von Monica

@sundar Ja schöner Fang! Es scheint, dass ich die Split-Funktion irgendwann gebrochen habe. Ich werde das so schnell wie möglich beheben.
Adnan

5

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.


Kannst du hier nicht auch $ in der Regex verwenden, anstatt ein Leerzeichen einzufügen?
Charlie

@Charlie Ich bin mir nicht sicher, wie du das verwenden willst. Möchtest du $das näher erläutern?
Giuseppe

Ich mag diese Lösung sehr. Ich denke, die Logik ist klarer (und Bytes die gleichen) paste0(s,0), aber das ist nur streiten. Ich denke, @Charlie verweist auf so etwas: grep("[^aeiouy]([^aeiouy]|$)",s)
user5957401

3

Dyalog APL, 20 Bytes

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

Probieren Sie es online!


3
Ich glaube nicht, dass du brauchst ⎕←.
Zacharý

@ Zacharý Früher habe ich es nicht gesagt, aber später wurde mir (von Dennis, glaube ich) gesagt, dass ein Programm nicht davon ausgehen sollte, dass es in einer REPL ausgeführt wird.
Oberon,

Über welche Sprache hat er dir das erzählt? War es für Dyalog APL? Ich weiß, dass diese Richtlinie definitiv für Python / JavaScript / etc gilt.
Zacharý,

3

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.


2

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!


Ich habe Angst , booleans ist nicht die Antwort: s->{int w=0,p=w,l;for(char c:s){l="aeiouy".indexOf(c)>>31;w|=p&l;p=l;}return w+p>=0;}.
Jakob

1
Oder Sie können dies sogar tun:s->{int w=0,p=w,l;for(char c:s)w|=p&(p=l="aeiouy".indexOf(c)>>31);return w+p>=0;}
Jakob

Schöne Antwort, aber mit dieser Herausforderung ist ein einfacher Regex-Abgleich tatsächlich ein bisschen kürzer. Trotzdem +1 von mir.
Kevin Cruijssen

1
@ KevinCruijssen Mein Regex ist schrecklich, konnte es nicht zum Laufen bringen: D. Ich werde so tun, als ob ich originell sein wollte
Roberto Graham

@RobertoGraham " Ich werde so tun, als ob ich originell sein wollte " Nun, das ist es auf jeden Fall . :) Und ich war auch bei Regex ziemlich schlecht, aber nach einigen anderen Antworten hier auf PPCG mit Regex gewöhne ich mich mehr daran. Und ich hatte bereits [a-z&&[^aeiouy]] in einer früheren Antwort herausgefunden, wie ich Konsonanten zuordnen kann . ;)
Kevin Cruijssen

2

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.


Kürzere komprimierte Saite . Die Komprimierung der Saiten ist immer noch viel zu langsam, ich muss noch etwas daran arbeiten
Leo

@Leo Ich denke das ist leider ein NP Problem.
Erik der Outgolfer

2

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


@ KevinCruijssen In der Tat verwendet Pyth ISO-8859-1. Deshalb bin ich nicht überzeugt.
Mr. Xcoder

1
@KevinCruijssen Downgoat des userscript sagt mir , es ist 13 Bytes: 13 ISO-8859-1 bytes, 13 chars. Ich denke, das sollte in Ordnung sein
Mr. Xcoder

@ KevinCruijssen Sollte jetzt behoben werden.
Mr. Xcoder

@ KevinCruijssen Ich sehe keinen Unterschied. Welchen Code siehst du in meiner Antwort und welchen Code siehst du in meinem Testlink?
Mr. Xcoder


2

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

1

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!


Sparen Sie 6 Bytes, indem Sie das Gleiche tun wie Arnauld
L3viathan

Müssen Sie das Lambda nicht irgendetwas zuordnen? ief=lambda s...
OldBunny2800

@ OldBunny2800 nur dann, wenn Sie die Referenz in Ihrem Code verwenden (es ist akzeptabel, eine unbenannte Funktion zu erstellen, auf die zur Wiederverwendung mit Kopf- oder Fußzeilencode zugegriffen werden kann - hier mit f=\in einer Kopfzeile).
Jonathan Allan

Ich denke, dass Sie in der Lage sein könnten, Ihre Musterzeichenfolge '[^aeiouy]([^aeiouy]|$)'(24 Bytes) durch "[^aeiouy]("*2+")|$)"(21 Bytes) zu ersetzen , um 3 Bytes zu sparen, da die leere Gruppe ()das Suchverhalten ( TIO ) nicht ändert .
Jonathan Frech

@ JonathanFrech Es kann noch besser werden
Mr. Xcoder

1

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.


"Zwei unterschiedliche und konsistente Werte"
L3viathan

@ L3viathan Leere Zeichenfolgen sind falsch und nicht leere Zeichenfolgen sind wahr. Dies ist gültig.
Text

@ L3viathan Perls Wahrheitsregeln sind solchen Herausforderungen eigentlich sehr förderlich. Es ist nicht das erste Mal, dass ich genau diese Tatsache ausnütze.
Silvio Mayolo

Bei Zeilenumbrüchen kann dies auf gekürzt werden $_=$/if/[^aeiouy]{2}/.
Nwellnhof

1

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


Sie können ein Byte speichern, indem Sie entweder a2\oder Ȧ2Ƥanstelle vonṡ2Ȧ€
Meilen den

@JonathanAllan facepalm Ich stellte sicher , bewusst zu verwenden , ØCum sicherzustellen , Yyals Konsonant gezählt wurde , weil ich irgendwie nach hinten fiel. Vielen Dank!
HyperNeutrino

1

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

1

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


1

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.


18 Bytes durch Anhängen eines Konsonanten an das Ende.
Ovs

1

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)



0

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



0

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


0

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

1
Sie können das Leerzeichen zwischen returnund entfernen !.
Zacharý

0

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.



0

PHP, 69 Bytes

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

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


Willkommen bei PPCG! Ich glaube, Sie können Leerzeichen entfernen, um einige Bytes zu entfernen, insbesondere /", str-> /",strund [1]))) return->, [1])))returnaber ich kenne PHP nicht so gut, daher kann ich nicht sicher sein.
Stephen

Ja, gute Idee! Es ist auch möglich, Bytes zu reduzieren, indem angenommen wird, dass die Eingabe immer in Großbuchstaben erfolgt.
Matias Villanueva

Oh, und wenn es sich bei dem Regex um eine Standard-Regex-Engine handelt, können Sie das nicht tun [B-Z]?
Stephen

@Stephen [B-Z]enthält Vokale. [^AEIOUY]funktioniert aber.
LyricLy

Ich kenne PHP auch nicht, aber Sie könnten wahrscheinlich mehr Bytes einsparen, indem Sie das Ergebnis der Regex-Übereinstimmung direkt zurückgeben, anstatt es in eine ifAnweisung zu schreiben .
LyricLy

0

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

Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.