Escreva um programa ou função que tenha uma string (ou o equivalente do seu idioma), determine se a string é uma palavra ou não e emita um valor verdadeiro ou falso.

(Isso não é uma duplicata de Isso é mesmo uma palavra? As palavras incorretas são geradas de uma maneira muito diferente que eu acredito que faz deste um desafio completamente diferente)

As palavras serão todas minúsculas, entre 5 e 10 caracteres, e não terão apóstrofos.

As palavras corretas são um subconjunto selecionado aleatoriamente da lista de palavras em inglês do SCOWL (tamanho 50).

As palavras incorretas são geradas por dois métodos: troca e substituição.

As palavras "trocadas" são geradas usando um shuffle Fisher-Yates modificado nas letras das palavras (reais) selecionadas aleatoriamente. Em vez de trocar as letras todas as vezes, uma carta pode ou não ser trocada (a probabilidade varia, portanto, algumas palavras serão mais realistas que outras). Se a nova palavra corresponder a uma palavra existente, o resultado será descartado e gerará outra palavra.

As palavras de "substituição" são geradas usando um método semelhante, mas em vez de trocar a letra por outra letra, cada letra tem a chance de ser substituída por outra letra aleatória.

Cada método é usado para gerar 50% das palavras falsas.

Pontuação

Sua função deve ter menos de 150 bytes . A pontuação é determinada da seguinte forma:

percentage of answers correct + ((150 - length of program) / 10) 

Regras

Como isso lida com um grande número de casos de teste (cada lista de palavras tem 1000 palavras), um programa de teste automatizado é adequado. O testador automatizado não conta para a duração do programa; no entanto, deve ser publicado para que outros possam testá-lo.

• Sem brechas.
• Não há embutidos relacionados a ortografia / dicionário.

Recursos

Lista de palavras: http://pastebin.com/Leb6rUvt

Lista de não palavras (atualizada) : http://pastebin.com/rEyWdV7S

Outros recursos (lista de palavras SCOWL e o código usado para gerar as palavras aleatórias): https://www.dropbox.com/sh/46k13ekm0zvm19z/AAAFL25Z8ogLvXWTDmRwVdiGa?dl=0

PHP, 64,9 (50%, 1 byte)

Bem, não tenho muita certeza se essa é uma resposta aceitável, mas aqui vai:

1

Execute assim:

echo '1' | php -- word

Obviamente, para uma lista igualmente grande de palavras corretas e incorretas, isso resulta em 50% de falsos positivos e 0% em falsos negativos, portanto, 50% de corretas. Como o programa tem 1 byte, você recebe o bônus de comprimento máximo possível (não obstante, respostas com comprimento zero).

CJam, 78,6 (78,5%, 149 bytes)

l2b0"(1»\]ÁûKëá*ßð%äp`Ï_5ÚY÷:Ä$î ëQXV)­JKÆ¿-(ivHì?{'à\ßÐiCæz°P0ãª/îÏèÄ)WCÅH±Ø^2Ô¥?
î'jJ#OAõ~×cA$[8,ô#~¬#7>"255b2b+=

Corresponde 696 palavras reais e não corresponde a 874 não-palavras, dando 1570/2000 = 0.785. Testado no intérprete on-line no Chrome - não tenho certeza se o link permanente funcionará no Firefox. Caso contrário, a sequência, que contém os imprimíveis, pode ser obtida por

[24 40 5 49 25 187 92 93 193 251 158 131 75 235 131 225 42 129 223 240 14 37 228 112 96 207 95 53 218 89 247 58 3 196 3 36 1 238 143 32 235 139 81 15 88 86 41 20 173 74 75 198 191 45 40 105 118 72 236 63 123 39 224 15 15 92 223 208 16 147 105 140 67 16 230 122 176 80 26 48 133 227 148 144 170 47 238 207 232 136 24 196 41 87 132 67 197 72 177 216 94 24 50 212 165 63 10 238 39 106 74 35 79 65 245 126 215 136 6 99 65 36 91 56 44 143 155 150 244 35 126 172 35 55 62]:c

O programa apenas faz o hash da entrada e executa uma pesquisa com base em 1077 possíveis buckets. Eu tentei jogar golfe com regex, mas as não-palavras estavam muito próximas das palavras reais para serem úteis.

Experimente online! | Conjunto de testes (cole a lista completa de palavras para contar o número de correspondências)

Mathematica, 69,35 (69,35%, 150 bytes)

StringContainsQ[" "|##&@@"seaeiislaanreuaooesrtnlneimdiuuosnlrlggtwtwnsdjexexavsvnuvtxsgokcmairlzlzeyatgpnlfiyhtcdxrvmuqtqtmsfohnk"~StringPartition~2]

Explicação

A função verificará se a palavra contém certos pares de letras que raramente ocorrem em palavras reais. TrueNesse caso, a função retornará , indicando que a palavra provavelmente não é uma palavra real. Por exemplo, o par "ii"ocorre 21 vezes na lista de não palavras, enquanto não ocorre na lista de palavras.

Taxa correta

Words:      85.4%  
Not words:  53.3%

CSharp, 69,85 (57,45%, 26 bytes)

"hoeiaunrt".Contains(s[1])

Verifico se a segunda letra da palavra está na lista de segundas letras mais populares em inglês ( deste site ).

Teste automatizado:

static void Main(string[] args)
{
string[] good = System.IO.File.ReadAllLines( @"PATH_GOOD.txt");
string[] bad = System.IO.File.ReadAllLines(@"PATH_BAD.txt");

int counter_good = 0;
int counter_bad = 0;

foreach (string s in good)
{
    if ("hoeiaunrt".Contains(s[1])) counter_good++;
}

foreach (string s in bad)
{
    if (!("hoeiaunrt".Contains(s[1]))) counter_bad++;
}

Console.WriteLine(counter_good);
Console.WriteLine(counter_bad);

Console.ReadLine();
}

Resultado:

828
321

Cálculo:

(828+321)/20 + 124/10 = 57.45 + 12.4 = 69.85

ES6, 76 (67,4%, 64 bytes)

Uma resposta mais séria desta vez. Este é um algoritmo bastante simples. Retorna um valor verdadeiro quando o segundo caractere de uma palavra é um dos aeinoru. Não produz uma taxa de sucesso significativamente melhor do que apenas 1, mas ainda é muito curto.

w=>/^[^qxy][aehil-prux]/.test(w)>/[^aeiouy]{3}|[fiopq]$/.test(w)

Teste aqui.

• +2,7 adicionando uma regex para encontrar palavras com 3 ou mais consoantes consecutivas e defini-las como "não-palavra"
• +0,1 substituindo &!por>
• +1,95 excluindo os primeiros caracteres mais incomuns qxy , adicionando segundos caracteres mais comuns (comuns) para compensar falsos negativos, eliminando a vírgula redundante na regex
• +0,05 excluindo palavras que terminam com os caracteres finais improváveis fiopq