O Duolingo, o aplicativo de aprendizado de idiomas, tem muitas coisas a seu favor, mas há uma questão importante que me deixa louca. Ele me diz quantos dias seguidos eu usei o aplicativo com uma mensagem como Você está em uma sequência de 7 dias! Deixando de lado a hifenização e se o número deve ser digitado, isso funciona bem para a maioria dos números, mas é indiscutivelmente errado quando diz que você está em uma sequência de 8 dias! Não estou usando para aprender inglês, mas esse ainda é um comportamento infeliz para um aplicativo de idioma.

Você ajudará a equipe do Duolingo escrevendo um programa ou função completa que calcula se um determinado número deve ser precedido por um ou um . Um número é precedido por a se sua pronúncia no inglês falado começar com um som consoante ou semivogal e precedido por um se sua pronúncia começar com um som com vogal. Assim, os únicos números precedidos por um são aqueles cuja pronúncia começa com oito , onze , dezoito ou oitenta .

Presumivelmente, a equipe de desenvolvedores do Duolingo deixou esse bug porque ficou sem espaço para obter mais código-fonte no aplicativo, então você precisa torná-lo o mais curto possível, na esperança de que eles possam extraí-lo.

Seu código deve levar um número inteiro de 0 a 2.147.483.647 e gerar aou an. Uma nova linha à direita é opcional. Para os propósitos deste desafio, 1863 é lido como mil oitocentos e sessenta e três , e não mil e oitocentos e sessenta e três .

Casos de teste:

0 → a
8 → an
11 → an
18 → an
84 → an
110 → a
843 → an
1111 → a
1863 → a
8192 → an
11000 → an
18000 → an
110000 → a
180000 → a
1141592 → a
1897932 → a
11234567 → an
18675309 → an

Pitão, 23 bytes

<>n\8hz}hjsz^T3,hT18"an

Isso seleciona quantas letras devem ser cortadas no final "an", verificando se a primeira letra não é um 8e se o primeiro dígito do número, quando considerado na base 1000, não é 11 nem 18. O booleano resultante é o número de caracteres para fatiar o fim.

Python 2, 60 bytes

lambda n:'a'+'n'[:`n`[0]=='8'or`n`[:2]in len(`n`)%3/2*'118']

Uma função anônima. Adiciona um nse:

• O primeiro dígito é 8
• Os dois primeiros dígitos são 11 ou 18 e o comprimento é 2 módulos 3.

GNU Sed, 32

A pontuação inclui +1 para a -Eopção sed.

s/^8.*|^1[18](...)*$/an/
t
ca
:

Experimente online.

• Remova grupos de 3 dígitos do final de cada número até restar apenas 1 a 3 dígitos
• Combine qualquer número que comece com 8 ou exatamente 11 ou 18 e mude para an
• Mude todos os outros números para a

Obrigado a @ MartinBüttner por sua abordagem de retina que salvou 10 bytes.

Shell + bsd-games, 30

number -l|sed '/^e/{can
q};ca'

Entrada lida de STDIN.

numberconverte uma string decimal em palavras. É então uma questão simples decidir se o resultado começa ou não e.

Retina , 27 bytes

Isso não é muito diferente da resposta Retina da DigitalTrauma, mas eles insistiram que eu publicasse isso pessoalmente.

^8.*|^1[18](...)*$
an
\d+
a

Experimente online.

O primeiro regex substitui todos os números relevantes por ane o segundo substitui todos os números restantes por a. Isso funciona para os mesmos bytes:

^8.*|^1[18](...)*$
n
^\d*
a

C ++, 101

Esse é o meu desafio, portanto, não é uma resposta competitiva. Só queria ver o quão curto eu poderia obtê-lo em C ++. As operações de string são muito detalhadas, portanto, isso é feito com matemática. Sinto que deve haver uma maneira de diminuir essa condição, mas não consigo entender direito.

const char*f(int i){int n=0,d=0;for(;i;(!(d++%3)&(i==18|i==11))|i==8?n=1:0,i/=10);return n?"an":"a";}

Mathematica, 53 bytes

If[#~IntegerName~"Words"~StringStartsQ~"e","an","a"]&

Uma solução usando processamento de string acabaria sendo mais longa.

PostScript, 119 113 caracteres

10 string cvs dup 0 get 56 eq exch dup length 3 mod 2 eq{0 2 getinterval dup(11)eq exch(18)eq or or}{pop}ifelse

Com código de teste:

/An
{
    10 string cvs dup 0 get 56 eq exch dup length 3 mod 2 eq{0 2 getinterval dup(11)eq exch(18)eq or or}{pop}ifelse
} def

/ShouldBeFalse [ 0 110 1111 1863 110000 180000 1141592 1897932 ] def
/ShouldBeTrue [ 8 11 18 84 843 8192 11000 18000 11234567 18675309 ] def

() = (ShouldBeFalse) = ShouldBeFalse {An =} forall
() = (ShouldBeTrue)  = ShouldBeTrue  {An =} forall

JavaScript (ES6) 70 61 46 38 bytes

n=>/^8|^1[18](...)*$/.test(n)?'an':'a'

Wiki da comunidade porque a solução atual é muito diferente da minha original. Obrigado a todos!

Demo: http://www.es6fiddle.net/iio40yep/

Sério, 43 40 bytes

9⌐9τk,;;$l3@\3*╤@\(íub)$#p'8=)XkΣ'n*'a+

A estratégia aqui é examinar apenas os 1, 2 ou 3 dígitos mais significativos, dividindo por inteiro a entrada pelo maior valor 10^(3n)que é menor que a entrada.

Experimente online

Explicação:

9⌐9τk,;;$l3@\3*╤@\(íub)$#p'8=)XkΣ'n*'a+
9⌐9τk                                    push [11, 18]
     ,;;                                 push 3 copies of input (n)
        $l                               get length of n as string (effectively floor(log(n,10)))
          3@\3*╤                         get largest 10^(3n) less than the length
                @\                       get most significant digits of n (x)
                  (í                     bring list from back, push the index of x in the list or -1 if not in list
                    ub)                  increment by 1, convert to boolean, shove to bottom
                       $#p               push first digit from n (as string)
                          '8=            push 1 if "8" else 0
                             )X          shove to bottom of stack, discard remaining digits
                               kΣ'n*     push sum of stack, push a string containing that many "n"s
                                    'a+  push "a", concatenate

Retina , 34

Tradução direta da minha resposta sed :

+`(.)...$
$1
^8.*|^1[18]$
an
\d+
a

Experimente online.

Um byte economizado graças a @Timwi.

Perl 6 ,  31   30 bytes

{'a'~'n'x?/^8|^1<[18]>[...]*$/} # 31 bytes

{<a an>[?/^8|^1<[18]>[...]*$/]} # 31 bytes

{<a an>[?/^8|^[11|18][...]*$/]} # 31 bytes

{'a'~'n'x?/^8|^1[1|8][...]*$/} # 30 bytes

{<a an>[?/^8|^1[1|8][...]*$/]} # 30 bytes

(O Perl 6 usa [ ]em expressões regulares para não captura ( )e usa <[ ]>para conjuntos de caracteres)

Uso:

# store it in a lexical code variable for ease of use
my &code = {...}

my @a  = <0 110 1111 1863 110000 180000 1141592 1897932>;
my @an = <8 11 18 843 8192 11000 18000 11234567 18675309>;

say @a.map: &code;
say @an.map: &code;

(a a a a a a a a)
(an an an an an an an an an)

PostScript, 109 bytes

(a)exch 10 string cvs dup[exch length 3 mod 2 eq{(11)(18)}if(8)]{anchorsearch{pop pop(an)exch}if}forall pop =

O código verifica se o número começa com determinados prefixos. O prefixo 8é sempre verificado ( oito , oitenta e poucos , oito centenas e ), mas 11e 18( onze e dezoito ) são verificados apenas quando o número de dígitos é um múltiplo de 3 mais 2.

Começamos com um resultado provisório de ae quando um prefixo é encontrado, o resultado é substituído por an. anchorsearché usado para evitar extrair um prefixo da string. Mesmo que seja encontrada uma correspondência, continuamos verificando o restante dos prefixos - por que desperdiçar 5 bytes para o  exit? -, mas como a string original é substituída por, atemos certeza de que não obtemos nenhum falso positivo.

Para retornar o resultado a- ou - anna pilha de operandos em vez de imprimi-lo, remova o final  =(comprimento resultante: 107 bytes).

Código do teste:

/DO {
    ... the code above ...
} def

(Should be "a"s:)  = {0 110 1111 1863 110000 180000 1141592 1897932}     { DO } forall
(Should be "an"s:) = {8 11 18 84 843 8192 11000 18000 11234567 18675309} { DO } forall
flush

PostScript (com tokens binários), 63 bytes

(a)’>10’¥’1’8[’>’b3’j2’={(11)(18)}if(8)]{’${’u’u(an)’>}if}’I’u=

O ’são bytes com o valor 146 (decimal), ¥é um 165 e $é um 3. Todos os outros são imprimíveis caracteres ASCII de 7 bits.

É o mesmo que minha versão PostScript [ASCII pura], mas usa tokens binários, onde isso ajuda a reduzir o comprimento total. Coloco separadamente por 3 razões:

• No caso geral, uma implementação que minimiza o código ASCII não é necessariamente a mesma que minimiza a versão binária. Alguma parte mais longa do código ASCII PostScript pode compactar melhor que outra e sua versão binária correspondente é mais curta.
• O código binário não é adequado em todos os lugares; portanto, uma resposta ASCII pura pode ser preferida mesmo que mais longa.
• Não seria justo comparar o comprimento de uma resposta ASCII PostScript pura com uma usando codificações binárias.

Python 3, 110 93 91 76 74 70 65 64 bytes

Aqui é longo, mas simples.

Edit: Corrigido com agradecimentos a isaacg . Economizou algum espaço em branco após as comparações. Muitos bytes salvos graças a Timwi , Mego , benpop e Alissa .

n=input();print("a"+"n"*(len(n)%3>1and n[:2]in"118"or"8"==n[0]))

ou para o mesmo número de bytes.

n=input();print("a"+"n"[:len(n)%3>1and n[:2]in"118"or"8"==n[0]])

Ungolfed:

def a():
    n=input()
    if "8"==n[:1]:
        a = "n"
    elif len(n)%3 == 2 and (n[:2] in ["11", "18"]):
        a = "n"
    else:
        a = ""
    return "a"+a

Java 10, 102 bytes

n->{var N=n+"";return(n>9&&"118".contains(N.substring(0,2))&N.length()%3>1)|N.charAt(0)==56?"an":"a";}

Experimente online.

Explicação:

n->{                  // Method with integer parameter and String return-type
  var N=n+"";         //  Input integer as String
  return(n>9&&        //  If the input has at least two digits,
    "118".contains(N.substring(0,2))
                      //  and the first two digits are "11" or "18",
    &N.length()%3>1)  //  and the length modulo-3 is 2
   |N.charAt(0)==56?  //  Or if the first digit is an '8':
     "an"             //   Return "an"
   :                  //  Else:
     "a";}            //   Return "a"

Japonês , 28 27 bytes

'a+'npUì v ¥8ª[B18]d¥UìA³ v

Experimente online!

Descompactado e como funciona

'a+'npUì v ==8||[B18]d==UìAp3  v

'a+'np  "a" + "n".repeat(...)
Uì v ==8    First digit in decimal == 8
||          or...
[B18]d      [11,18].some(...)
==UìAp3  v  == First digit in base 10**3

GNU sed -r+ BSD number, 34 bytes

s/(e?).*/number &/e
s//a\1/
y/e/n/

Primeiro, convertemos para o número em inglês. Exclua tudo, exceto uma possível inicial e, e prefixe com a. Em seguida, converta o e(se presente) para n. O único truque de golfe é combinar o opcional ena primeira substituição, para que possamos reutilizar o padrão na linha a seguir.

Demo

for i in 0 8 11 18 84 110 843 1111 1863 8192 \
    11000 18000 110000 180000 1141592 1897932 11234567 18675309
do printf "%'10d → %s\n" $i $(./66841.sed <<<$i)
done

         0 → a
         8 → an
        11 → an
        18 → an
        84 → an
       110 → a
       843 → an
     1,111 → a
     1,863 → a
     8,192 → an
    11,000 → an
    18,000 → an
   110,000 → a
   180,000 → a
 1,141,592 → a
 1,897,932 → a
11,234,567 → an
18,675,309 → an

TeaScript , 35 bytes

[18,11,8,80]I(+xh(x.n%3¶3©?'an':'a'

Experimente aqui.

Explicação

               xh(x.n%3¶3           get the relevant digits from the input
                                    xh compiles to x.head which returns the
                                    first n chars of x (implicit input)
                                    ¶ ('\xb6') compiles to ||
              +                     cast the result to an integer since
                                    .includes does a strict comparison
                         ©          ('\xa9') compiles to ))
[18,11,8,80]                        array of the special cases
            I(                      I( is an alias for .includes( which
                                    returns true if the array contains the
                                    argument
                          ?'an':'a' finally, return 'an' if the array
                                    contains the number, 'a' otherwise

Python 2.7, 66

s=`input()`
print['a','an'][s[:1]=='8'or s[:2]in len(s)%3/2*'118']

Obviamente, não tão curto quanto lambdaesse.

05AB1E , 26 bytes

g3%ô¬D11Qs18Q+I1£8Q+>„ans∍

Provavelmente pode ser jogado um pouco mais, mas está funcionando.

Experimente online ou verifique todos os casos de teste .

Explicação:

g3%                  # Length of the input, modulo-3
                     #  11234567 → 8 → 2
                     #  110000 → 6 → 0
   ô                 # Split the input into chunks of that size
                     #  11234567 and 2 → ['11', '23', '45', '67']
                     #  110000 and 0 → ['110000']
    ¬                # Take the Head (first element)
                     #  ['11', '23', '45', '67'] → '11'
                     #  ['110000'] → '110000'
     D11Q            # Does it equal 11?
                     #  '11' and 11 → 1
                     #  '110000' and 11 → 0
     s18Q            # Or does it equal 18?
                     #  '11' and 18 → 0
                     #  '110000' and 18 → 0
         +           # Add them together (if it was either 11 or 18, this becomes 1)
                     #  1 and 0 → 1
                     #  0 and 0 → 0
I1£                  # Get the first character of the input
                     #  11234567 → '1'
                     #  110000 → '1'
   8Q                # Does it equal 8?
                     #  '1' and 8 → 0
          +          # Add them together
                     #  1 and 0 → 1
                     #  0 and 0 → 0
           >         # Increase it by 1
                     #  1 → 2
                     #  0 → 1
            „ans∍    # Push "an", and shorten it to a size equal to the result above
                     #  "an" and 2 → "an"
                     #  "an" and 1 → "a"

QuadS , 32 bytes

'a',⍵
^8.*|^1[18](...)*$
⊃⍵L/'n'

Experimente online!

Stax , 25 bytes

â-x▬♪°∞▄'δL|÷æ╪║>₧4¢ÿ·7åR

Execute e depure

Descompactado, não jogado e comentado, parece com isso.

Vk|Eh       get the first "digit" after converting to base 1000
AJ|Eh       get the first "digit" after converting to base 100
c20>9*^/    if the result is greater than 20, divide it by 10 again
"AMj"!#     is the result one of [8, 11, 18]?
^           increment by 1
.an(        keep that many characters of the string "an"

Execute este

Espaço em branco , 243 bytes

[S S S T    T   S S S S T   N
_Push_97_a][T   N
S S _Print_as_character][S S S T    N
_Push_1][S N
S _Duplicate_1][S N
S _Duplicate_1][T   N
T   T   _Read_STDIN_as_integer][T   T   T   _Retrieve_input][N
S S S T N
_Create_Label_LOOP][S N
T   _Swap_top_two][S S S T  N
_Push_1][T  S S S _Add][S N
T   _Swap_top_two][S N
S _Duplicate][S S S T   T   S S T   S S N
_Push_100][T    S S T   _Subtract][N
T   T   T   N
_If_negative_jump_to_Label_TWO_DIGITS][S S S T  S ST    S N
_Push_10][T S T S _Integer_division][N
S N
S T N
_Jump_to_Label_LOOP][N
S S T   N
_Create_Label_TWO_DIGITS][S N
S _Duplicate][S S S T   S S S N
_Push_8][T  S S T   _Subtract][N
T   S S S N
_If_zero_jump_to_Label_PRINT_n][S N
S _Duplicate][S S S T   S T T   N
_Push_11][T S S T   _Subtract][N
T   S S N
_If_0_jump_to_Label_2_MOD_3][S N
S _Duplicate][S S S T   S S T   S N
_Push_18][T S S T   _Subtract][N
T   S S N
_If_0_jump_to_Label_2_MOD_3][S S S T    S ST    S N
_Push_10][T S T S _Integer_division][S N
S _Duplicate][N
T   S N
_If_0_jump_to_Label_EXIT][N
S N
T   N
_Jump_to_Label_TWO_DIGITS][N
S S S N
_Create_Label_2_MOD_3][S N
T   _Swap_top_two][S S S T  T   N
_Push_3][T  S T T   _Modulo][S S S T    S M
_Push_2][T  S S T   _Subtract][N
T   T   N
_If_negative_jump_to_Label_EXIT][N
S S S S N
_Create_Label_PRINT_n][S S S T  T   S T T   T   S N
_Push_110_n][T  N
S S _Print_as_character][N
S S N
_Create_Label_EXIT]

Letras S(espaço), T(tabulação) e N(nova linha) adicionadas apenas como destaque.
[..._some_action]adicionado apenas como explicação.

Experimente online (apenas com espaços brutos, guias e novas linhas).
O programa para com um erro: Nenhuma saída encontrada.

Explicação em pseudo-código:

Print "a"
Integer input = STDIN as integer
Integer counter = 1
Start LOOP:
  counter = counter + 1
  If(input < 100)
    Jump to function TWO_DIGITS
  input = input integer-divided by 10
  Go to next iteration of LOOP

function TWO_DIGITS:
  If(input == 8)
    Jump to function PRINT_n
  If(input == 11 or input == 18)
    Jump to function 2_MOD_3
  input = input integer-divided by 10
  If(input == 0)
    Exit program
  Recursive call to TWO_DIGITS

function 2_MOD_3:
  If(counter modulo-3 != 2)
    Exit program
  Jump to function PRINT_n

function PRINT_n:
  Print "n"
  Exit program

C ++, 80 bytes

[](int i){for(;i>999;i/=1e3);return i-11&&i-18&&i/100-8&&i/10-8&&i-8?"a":"an";}

Ficou 4 bytes mais curto para testar explicitamente contra 8xx e 8x do que ter outro /=10loop, como este:

[](int i){for(;i>999;i/=1e3);for(i==11|i==18?i=8:0;i>9;i/=10);return i-8?"a":"an";}

Demo

#include <locale>
#include <cstdio>
int main(int argc, char**argv)
{
    auto const f =
        [](int i){for(;i>999;i/=1e3);return i-11&&i-18&&i/100-8&&i/10-8&&i-8?"a":"an";}
    ;

    std::locale::global(std::locale{""});
    for (int i = 1;  i < argc;  ++i) {
        auto const n = std::stoi(argv[i]);
        printf("%'10d → %s\n", n, f(n));
    }
}

         0 → a
         8 → an
        11 → an
        18 → an
        84 → an
       110 → a
       843 → an
     1,111 → a
     1,863 → a
     8,192 → an
    11,000 → an
    18,000 → an
   110,000 → a
   180,000 → a
 1,141,592 → a
 1,897,932 → a
11,234,567 → an
18,675,309 → an

Perl 5 -p , 26 bytes

$_=a.n x/^8|^1[18](...)*$/

Experimente online!

Perl, 71 55 49 bytes

$_=<>;$_=/^8/||/^1[18]/&&length%3==1?'an':'a';say

Eu sabia que o operador ternário ajudaria um dia ...

Deixe-me explicar isso.

• $_=<> aceita um número como entrada.
• O grande $_=...bloco definirá o valor de $_após ser usado.
  • ...?...:...é o operador ternário. Se a condição (primeiro argumento) for verdadeira, ela retornará o segundo argumento. Caso contrário, ele retornará o terceiro.
  • /^8/||(/^1[18]/&&length%3==2)verifica se o número começa com 8 ou começa com 11 ou 18 ( 1[18]aceita um) e tem um comprimento mod 3 de 2.
  • Se isso for verdade, $_está definido como an. Caso contrário, está definido como a.
• Em seguida, imprime o conteúdo de $_(um aou an) com say.

Alterar

• Economizou 16 bytes graças ao msh210.
• Economizou 6 bytes removendo parênteses e usando padrões.

Pyth, 29 31

?:_ec_z3"(^18$|^11$|^8)"0"an"\a

Inverte a string, divide-a em seções de três, inverte-a novamente e escolhe o final apropriado.