Você deve escrever um programa muito pequeno com 100 caracteres. Seu programa deve distinguir entre substantivos franceses masculinos e femininos. O resultado deve ser unse for masculino e unese for feminino. Frequentemente, existem certas regras estatísticas que você pode seguir (por exemplo, se terminar em um "e", é mais provável que feminino do que masculino).

Entrada :

Uma palavra francesa; pode consistir em letras minúsculas e traços, incluindo letras minúsculas com acentos.

Exemplo de entrada: ami

Saída :

unse a palavra é masculina e unese a palavra é feminina.

Exemplo de saída: un

Você não precisa acertar todas as palavras; seu objetivo é ser o mais preciso possível.

Pontuação : sua resposta deve ter até 100 caracteres. Declarações como printou console.logou alertque não contam como parte dos seus bytes totais. Você também pode escrever uma função ou método que execute essa tarefa; nesse caso, os primeiros bytes (por exemplo f=x=>) que fazem parte da declaração da função não contam para o total. Sua pontuação total é o número de respostas incorretas. Os laços são quebrados pelo tamanho do código.

Substantivos para testar:

un ami
un café
un chapeau
un concert
un crayon
un garage
un garçon
un lit
un livre
un mari
un musée
un oncle
un ordinateur
un pantalon
un piano
un pique-nique
un portable
un père
un sandwich
un saxophone
un stade
un stylo
un théâtre
un téléphone
un voisin
une botte
une boum
une chaise
une chaussette
une chemise
une clarinette
une copine
une femme
une fille
une glace
une heure
une lampe
une maison
une montagne
une personne
une piscine
une pizza
une radio
une raquette
une salade
une souris
une sœur
une table
une télé
une voiture

CJam, 0 incorreto, 32 29 bytes

Esse código usa alguns caracteres ímpares (alguns deles não imprimíveis), mas todos estão bem dentro do intervalo ASCII estendido. Então, novamente, estou contando cada caractere como um único byte.

"un"'el2b"zPB:  ":i+:%2/*

Devido aos caracteres não imprimíveis, tenho certeza de que o Stack Exchange engole um pouco, portanto, convém copiar o código do contador de caracteres (ele mostra bytes com a codificação UTF-8, que é subótima para esse desafio; também, o link não ' parece funcionar no Firefox, mas funciona no Chrome).

Teste aqui.

Depois de mais algumas discussões no chat, descobrimos que o golfe regex não nos traria muito mais longe. Então, seguindo uma sugestão minha (brincando), começamos a manipular os códigos de caracteres das palavras com determinadas funções, de modo que todas as palavras de um grupo produzissem um número com alguma propriedade que fosse fácil de verificar. E tivemos mais sorte do que esperávamos! Aqui está o que o código faz com as palavras:

• Converta implicitamente os caracteres da palavra em seus pontos de código.
• Interprete-os como dígitos na base 2 (sim, os dígitos serão muito maiores que 0 ou 1, mas o CJam pode lidar com isso).
• Repetidamente levar o modulo resultado ... os seguintes números: [133, 122, 80, 66, 58, 26, 20, 14, 9, 4]. Essa sequência de números é codificada como os pontos de código de uma sequência (é aqui que entram os caracteres estranhos e não imprimíveis).
• Como que por mágica, todos os 25 substantivos masculinos produzem 0ou 1, e todos os 25 substantivos femininos produzem 2ou 3com este procedimento. Portanto, se dividirmos isso por 2(divisão inteira), obteremos zeros para substantivos masculinos e um para substantivos femininos.

Para finalizar, empurramos "un"a pilha, empurramos uma única e. Em seguida, lemos a palavra de entrada de STDIN e executamos o cálculo acima e, finalmente, multiplicamos epelo resultado.

Nunca dobrei o módulo em nenhuma lista antes e sinto que nunca mais voltarei ...

Muito obrigado ao xnor e ao Sp3000 por oferecer idéias e ajudar na busca pela cadeia divisória.

Ruby, 0 incorreto, 63 56 53 52 51 50 bytes

Todos os caracteres estão em ASCII estendido , especificamente ISO 8859-1 , então estou contando cada caractere como um único byte.

f=->s{s[/la|tt|i.e|[égdzœu]..$|^b|^f|so|^ta/]?'une':'un'}

Parece que seu conjunto de testes foi um pouco curto demais. Eu criei o regex com o jogador de regex de Peter Norvig .

Você pode chamar a função acima como f["ami"]. Você pode usar este equipamento de teste para verificar todos os casos de teste:

puts "ami café chapeau concert crayon garage garçon lit livre mari musée 
      oncle ordinateur pantalon piano pique-nique portable père sandwich 
      saxophone stade stylo théâtre téléphone voisin botte boum chaise 
      chaussette chemise clarinette copine femme fille glace heure lampe 
      maison montagne personne piscine pizza radio raquette salade souris 
      sœur table télé voiture".split.map{|s|f[s]+" "+s}

Teste-o no campo de codificação.

Edit: Usando o segundo script de Peter Norvig, encontrei um regex diferente, que na verdade era um byte mais longo, mas que eu poderia encurtar dois bytes à mão.

Edit: O Sp3000 definiu o regex golfista que ele escreveu para o meu recente desafio do regex e encontrou um regex de 36 35 34 bytes para eu usar. Obrigado por isso!

CJam, 0 erros ( 36 32 29 28 bytes)

{"un"oEb72^"+ÕåWïº"583b2b='e*o}:F;

Esta é uma função nomeada, então estou contando apenas o código interno. Além disso, oé uma declaração de impressão, portanto, não contribui para a contagem de bytes.

Experimente os casos de teste no intérprete CJam .

Como funciona

"un"o       " Print 'un'.                                                  ";
Eb          " Consider the input a base 14 number.                        ";
72^         " XOR the result with 72.                                     ";
"+ÕåWïº"    " Push that string.                                           ";
583b2b      " Convert from base 583 to base 2.                            ";
=           " Retrieve the corresponding element (0 or 1) from the array. ";
'e*o        " Print 'e' that many times.                                  ";

Apenas uma função de hash e uma pesquisa de tabela.