Eingabe: Ihnen wird eine Zeichenfolge übergeben, die ein einzelnes englisches Wort enthält. Alle Buchstaben werden in Kleinbuchstaben geschrieben und die Zeichenfolge enthält keine nicht-alphabetischen Zeichen.

Ausgabe: Sie geben eine Ganzzahl von 1 bis 7 zurück, die angibt, wie viele Silben das Wort enthält.

Bewertung: Ihr Programm wird mit allen Wörtern in diesem Repository ausgeführt . Wenn Sie die Nrichtigen Wörter finden und Ihr Programm Mbyteslang ist, ist Ihre PunktzahlN-(M*10) . Die höchste Punktzahl gewinnt.

Um meine Silbenzählung zu generieren, habe ich diese als meine Wortliste verwendet und dies, um die Silben zu zählen.

Ruby, 8618 korrekt (91,1%), 53 Byte, 8618 - 10 * 53 = 8088 Punkte

->s{s.scan(/[aiouy]+e*|e(?!d$|ly).|[td]ed|le$/).size}

Dies ist eine anonyme Ruby-Funktion, die reguläre Ausdrücke verwendet, um Silben zu zählen.

Die Funktion fügt eine Silbe für jede Instanz von:

• Eine Folge von Nicht- eVokalen, gefolgt von null oder mehr es
• Ein ewas ist nicht Teil eines Trailings edoder ist ely, mit Ausnahme von Trailing tedoder deds
• Ein schleppendes le

Analyse

Die Grundidee ist, Vokalläufe zu zählen, aber das ist an sich nicht sehr genau ([aeiouy]+ 74% richtig). Der Hauptgrund dafür liegt in der Stillee , die den vorherigen Vokalton verändert, ohne selbst ausgesprochen zu werden. Zum Beispiel hat das Wort slatezwei Vokale, aber nur eine Silbe.

Um damit umzugehen, nehmen wir e den ersten Teil des regulären Ausdrucks heraus und behandeln ihn separat. Das Erkennen stiller es ist schwierig, aber ich habe zwei Fälle gefunden, in denen sie häufig auftreten:

• Als Teil eines Trailings ed(es sei denn, es ist einted oder dedwie settledoder saddled),
• Im Rahmen eines Trailings evy (zB lovely)

Diese Fälle sind im Übrigen ausdrücklich ausgeschlossen e..

Der Grund für das .In e(?!d$|ly).ist, das nächste Zeichen zu verbrauchen, wenn es einen Doppelvokal gibt (z. B. eaoder ee), und damit eam Ende des Wortes nicht gezählt werden. Allerdings ein Nachlaufle ist Regel ausgesprochen, so dass wieder in hinzugefügt wird.

Schließlich werden Vokalläufe als eine Silbe gezählt. Dies ist möglicherweise nicht immer der Fall (z. B. curious), es ist jedoch oft schwierig herauszufinden, ob mehrere Silben vorhanden sind. Nehmen Sie das iavoncelestial und spatial, als Beispiel.

Testprogramm

Ich kenne Ruby nicht wirklich, also bin ich mir nicht sicher, wie gut es golfen kann. Es ist mir gelungen, ein Testprogramm zusammenzustellen, indem ich viel SO konsultiert habe:

cases = 0
correct = 0

s = "->s{s.scan(/[aiouy]+e*|e(?!d$|ly).|[td]ed|le$/).size}"

f = eval s

for i in 1 ... 8
    filepath = i.to_s + "-syllable-words.txt"
    file = File.open(filepath)

    while (line = file.gets)
        word = line.strip
        cases += 1
        if f.call(word) == i
            correct += 1
        end
    end
end

p "Correct: #{correct}/#{cases}, Length: #{s.length}, Score: #{correct - s.length*10}"

Python3, 7935-10 * 71 = 7225

Meine schnelle und schmutzige Antwort: Zähle die Läufe aufeinanderfolgender Vokale, aber entferne zuerst alle abschließenden Es.

lambda w:len(''.join(" x"[c in"aeiouy"]for c in w.rstrip('e')).split())

Nach dem Entfernen der e werden die Vokale durch xund alle anderen Zeichen durch ein Leerzeichen ersetzt. Das Ergebnis wird wieder zu einer Zeichenfolge zusammengefasst und dann in Leerzeichen aufgeteilt. Praktischerweise wird das Leerzeichen am Anfang und Ende ignoriert (zB " x xx ".split()gibt ["x","xx"]). Die Länge der resultierenden Liste ist daher die Anzahl der Vokalgruppen.

Die ursprüngliche 83-Byte-Antwort unten war genauer, da nur ein einzelnes e am Ende entfernt wurde. Das neuere hat also Probleme für Wörter wie bee; aber der verkürzte Code überwiegt diesen Effekt.

lambda w:len(''.join(" x"[c in"aeiouy"]for c in(w[:-1]if'e'==w[-1]else w)).split())

Testprogramm:

syll = lambda w:len(''.join(c if c in"aeiouy"else' 'for c in w.rstrip('e')).split())

overallCorrect = overallTotal = 0
for i in range(1, 7):
    with open("%s-syllable-words.txt" % i) as f:
        words = f.read().split()
    correct = sum(syll(word) == i for word in words)
    total = len(words)
    print("%s: %s correct out of %s (%.2f%%)" % (i, correct, total, 100*correct/total))
    overallCorrect += correct
    overallTotal += total

print()
print("%s correct out of %s (%.2f%%)" % (overallCorrect, overallTotal, 100*overallCorrect/overallTotal))

Offensichtlich war dies zu schmutzig und nicht schnell genug, um die Ruby-Antwort von Sp3000 zu übertreffen. ; ^)

Perl, 8145-3 * 30 = 7845

Verwenden der Listen vor den letzten Commits.

#!perl -lp
$_=s/(?!e[ds]?$)[aeiouy]+//g

Python, 5370-10 * 19 = 5180

Dieses Programm geht einfach davon aus, dass längere Wörter mehr Silben bedeuten.

lambda x:len(x)/6+1

Das Testerprogramm, das ich benutze, ist:

correct = 0
y = lambda x:len(x)/6+1
for i in xrange(1,8):
    f = file(str(i)+"-syllable-words.txt")
    lines = f.read().split("\n")
    f.close()
    correct += len([1 for line in lines if y(line)==i])
print correct