Entrée: Vous recevrez une chaîne contenant un seul mot anglais. Toutes les lettres seront en minuscules et il n'y aura pas de caractères non alphabétiques dans la chaîne.

Sortie: Vous retournerez un entier de 1 à 7 représentant le nombre de syllabes que vous pensez être dans le mot.

Notation: votre programme sera exécuté par rapport à tous les mots trouvés dans ce référentiel . Si vous obtenez des Nmots corrects et que votre programme est Mvolumineux, alors votre score est N-(M*10). Le score le plus élevé l'emporte.

Pour générer mon nombre syllabe, je ce que ma liste de mots et ce à compter les syllabes.

Ruby, 8618 correct (91,1%), 53 octets, 8618 - 10 * 53 = score 8088

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

Il s'agit d'une fonction Ruby anonyme qui utilise des expressions rationnelles pour compter les syllabes.

La fonction ajoute une syllabe pour chaque instance de:

• Une série de non- evoyelles, suivie de zéro de plus es
• Un equi ne fait pas partie d'un suivi edou ely, à l'exception du suivi tedou deds
• Une fuite le

Une analyse

L'idée de base est de compter les séries de voyelles, mais ce n'est pas très précis en soi (il [aeiouy]+est correct à 74%). La raison principale en est le silencee , qui modifie le son de voyelle précédent sans être prononcé lui-même. Par exemple, le mot slatea deux voyelles mais une seule syllabe.

Pour y faire face, nous retirons ela première partie de l'expression rationnelle et la traitons séparément. Détecter les es silencieux est difficile, mais j'ai trouvé deux cas où ils se produisent souvent:

• Dans le cadre d'un suivi ed(sauf s'il s'agit d'un tedou dedcomme settledou saddled),
• Dans le cadre d'une fuite evy(par exemple lovely)

Ces cas sont spécifiquement exclus de ce qui serait autrement e..

La raison de l' .entrée e(?!d$|ly).est de consommer le caractère suivant s'il y a une voyelle double (par exemple eaou ee), et de sorte qu'à ela fin du mot ne soit pas compté. Cependant, une fuite le est généralement prononcée, de sorte qu'elle est ajoutée à nouveau.

Enfin, les voyelles sont comptées comme une syllabe. Bien que cela ne soit pas toujours le cas (par exemple curious), il est souvent difficile de déterminer s'il existe plusieurs syllabes. Prenez le iade celestialet spatial, à titre d'exemple.

Programme de test

Je ne connais pas vraiment Ruby, donc je ne sais pas à quel point il peut être joué au golf. J'ai réussi à rassembler un programme de test en consultant beaucoup de SO cependant:

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

Ma réponse rapide et sale: comptez les séries de voyelles consécutives, mais supprimez tout e final en premier.

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

Après avoir supprimé les e, cela remplace les voyelles par xet tous les autres caractères par un espace. Le résultat est joint à nouveau dans une chaîne, puis divisé en espaces blancs. Idéalement, les espaces au début et à la fin sont ignorés (par exemple, " x xx ".split()donne ["x","xx"]). La longueur de la liste résultante est donc le nombre de groupes de voyelles.

La réponse originale de 83 octets ci-dessous était plus précise car elle ne supprimait qu'un seul e à la fin. Le plus récent a donc des problèmes pour des mots comme bee; mais le code raccourci l'emporte sur cet effet.

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

Programme de test:

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

Évidemment, c'était trop sale et pas assez rapide pour battre la réponse Ruby du Sp3000. ; ^)

Perl, 8145 - 3 * 30 = 7845

Utilisation des listes d'avant les commits récents.

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

Python, 5370-10 * 19 = 5180

Ce programme suppose simplement que des mots plus longs signifient plus de syllabes.

lambda x:len(x)/6+1

Le programme de testeur que j'utilise est:

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