Écrivez un programme ou une fonction qui prend deux entrées:

1. Un message écrit
2. Le dictionnaire de la langue anglaise, tel qu'il apparaît dans ce fichier Github (contenant environ 60000 mots)

et renvoie le nombre d'erreurs d'orthographe dans le message (voir ci-dessous pour la définition et les cas de test).

Vous pouvez recevoir le dictionnaire en tant que paramètre de votre fonction, en tant que fichier prédéfini que votre programme s'attend à trouver, en tant que données codées en dur dans votre code ou de toute autre manière sensée.

Votre code doit lui-même ressembler à un message texte, avec un nombre minimal d'erreurs d'orthographe. Ainsi, vous calculerez le score de votre code en le nourrissant en entrée.

Le gagnant est le code qui a le score le plus bas (le score minimal possible est 0). S'il y a plusieurs réponses avec le même score, le gagnant est déterminé par la taille du code (en caractères). Si deux réponses sont toujours à égalité, le gagnant est le premier.

Si nécessaire, vous pouvez supposer que le message d'entrée est ASCII (octets 32 ... 126) avec des sauts de ligne codés de manière conventionnelle (1 octet "10" ou 2 octets "13 10") et non vide. Cependant, si votre code contient des caractères non ASCII, il doit également prendre en charge la saisie non ASCII (afin qu'il puisse calculer son propre score).

Les personnages sont subdivisés dans les classes suivantes:

• Lettres a ... z et A ... Z
• Espace (défini ici comme le caractère espace ou le caractère de nouvelle ligne)
• Ponctuation . , ; : ! ?
  • Fin de phrase . ! ?
• Ordures (tout le reste)

Un mot est défini comme une séquence de lettres, qui est maximale (c'est-à-dire ni précédée ni suivie d'une lettre).

Une phrase est définie comme une séquence maximale de caractères qui ne se terminent pas par une phrase.

Un caractère est une faute d'orthographe s'il enfreint l'une des règles d'orthographe:

1. Une lettre doit appartenir à un mot du dictionnaire (ou, en d'autres termes: chaque mot de longueur N qui n'apparaît pas dans le dictionnaire compte comme N fautes d'orthographe)
2. Le premier caractère d'une phrase, en ignorant les caractères blancs initiaux, doit être une lettre majuscule
3. Toutes les lettres doivent être en minuscules, sauf celles spécifiées par la règle précédente
4. Un caractère de ponctuation n'est autorisé qu'après une lettre ou une poubelle
5. Un caractère de nouvelle ligne n'est autorisé qu'après un caractère de fin de phrase
6. Les caractères d'espacement ne sont pas autorisés au début du message et après les caractères d'espacement
7. Il ne devrait pas y avoir de déchets (ou, en d'autres termes: chaque caractère de déchets compte est une faute d'orthographe)

De plus, la dernière phrase doit être soit vide soit composée d'un seul caractère de nouvelle ligne (c'est-à-dire que le message doit se terminer par un caractère de fin de phrase et une nouvelle ligne facultative - appelons-la règle 8).

Cas de test (sous chaque caractère se trouve une règle qu'il viole; après =>est la réponse requise):

Here is my 1st test case!!
           711           4                => 4

main(){puts("Hello World!");}
2   777    883     3     77 78            => 12

  This message starts with two spaces
66                                   8    => 3

What ? No apostrophe's??
     4              71 4                  => 4

  Extra   whitespace   is   BAD!
66      661111111111 66   66333           => 21

Several
lines?
Must be used only to separate sentences.
                                          => 1 (first linebreak is en error: rule 5)

"Come here," he said.
73         7                              => 3 (sentence starts with '"', not 'C')

Perl 6 , 134 fautes d'orthographe

my token punctuation {<[.,;:!?]>}
my \text = slurp; my \mistakes=[]; for split /\.|\!|\?/, text { for .trim.match: :g, /<:letter>+/ -> \word { (append mistakes, .comb when none words slurp pi given lc word) or (push mistakes, $_ if ((.from or word.from) xor m/<[a..z]>/) for word.match: :g, /./) }}
append mistakes, comb / <after \s | <punctuation>> <punctuation> | <!before <punctuation> | <:letter> | \s> . | <!after \.|\!|\?> \n | [<before ^> | <after \s>] \s /, text; say mistakes.Numeric

Avec un espace supplémentaire pour la lisibilité:

my token punctuation {<[.,;:!?]>}
my \text = slurp;
my \mistakes=[];
for split /\.|\!|\?/, text {
    for .trim.match: :g, /<:letter>+/ -> \word {
        (append mistakes, .comb when none words slurp pi given lc word)
        or
        (push mistakes, $_ if ((.from or word.from) xor m/<[a..z]>/) for word.match: :g, /./)
    }
}
append mistakes, comb /
  <after \s | <punctuation>> <punctuation>
  | <!before <punctuation> | <:letter> | \s> .
  | <!after \.|\!|\?> \n
  | [<before ^> | <after \s>] \s
/, text;
say mistakes.Numeric

Remarques:

• Attend le dictionnaire dans un fichier appelé 3.14159265358979dans le répertoire de travail actuel.
• La seule partie inspirée est la ligne
  append mistakes, .comb when none words slurp pi given lc word,
  le reste est plutôt mauvais. Mais peut-être qu'elle peut au moins servir de référence pour de meilleures solutions ... :)