Duolingo, la aplicación de aprendizaje de idiomas, tiene muchas cosas a su favor, pero hay un problema importante que me vuelve loco. Me dice cuántos días seguidos he usado la aplicación con un mensaje como ¡Estás en una racha de 7 días! Dejando a un lado la separación silábica y si el número se debe deletrear, esto funciona bien para la mayoría de los números, ¡pero es indiscutiblemente incorrecto cuando dice que estás en una racha de 8 días! No lo estoy usando para aprender inglés, pero este sigue siendo un comportamiento desafortunado para una aplicación de idiomas.

Ayudará al equipo de Duolingo escribiendo un programa completo o una función que determine si un número dado debe estar precedido por a o an . Un número está precedido por un si su pronunciación en inglés hablado comienza con un sonido de consonante o semivowel , y está precedido por un si su pronunciación comienza con un sonido de vocal. Por lo tanto, los únicos números precedidos por un son aquellos cuya pronunciación comienza con ocho , once , dieciocho u ochenta .

Presumiblemente, el equipo de desarrollo de Duolingo dejó este error porque se quedaron sin espacio para más código fuente en la aplicación, por lo que debe hacer que este código sea lo más breve posible con la esperanza de que puedan introducirlo.

Su código debe tomar un número entero de 0 a 2,147,483,647 y generar ao an. Una nueva línea final es opcional. Para los propósitos de este desafío, 1863 se lee como mil ochocientos sesenta y tres , no mil ochocientos sesenta y tres .

Casos de prueba:

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

Pyth, 23 bytes

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

Esto selecciona cuántas letras se cortarán al final "an"al verificar si la primera letra no es un 8y que el primer dígito del número cuando se considera en la base 1000 no es ni 11 ni 18. El booleano resultante es el número de caracteres para cortar el fin.

Python 2, 60 bytes

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

Una función anónima. Agrega un nif si:

• El primer dígito es 8
• Los primeros dos dígitos son 11 o 18, y la longitud es 2 módulo 3.

GNU Sed, 32

La puntuación incluye +1 para la -Eopción de sed.

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

Pruébalo en línea.

• Elimine grupos de 3 dígitos del final de cada número hasta que solo queden de 1 a 3 dígitos
• Haga coincidir cualquier número que comience con 8 o exactamente 11 o 18 y cambie a an
• Cambia todos los otros números a a

Gracias a @ MartinBüttner por su enfoque de retina que ahorró 10 bytes.

Juegos de Shell + bsd, 30

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

Entrada leída desde STDIN.

numberConvierte una cadena decimal en palabras. Entonces es una cuestión simple decidir si el resultado comienza o no e.

Retina , 27 bytes

Esto no es muy diferente de la respuesta Retina de DigitalTrauma, pero insistieron en que publique esto yo mismo.

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

Pruébalo en línea.

La primera expresión regular reemplaza todos los números relevantes con an, y la segunda reemplaza todos los números restantes con a. Esto funciona para los mismos bytes:

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

C ++, 101

Este es mi desafío, por lo que no pretende ser una respuesta competitiva. Solo quería ver qué tan corto podría obtenerlo en C ++. Las operaciones de cadena son demasiado detalladas, por lo que esto se hace con las matemáticas. Siento que debe haber una forma de reducir esa condición, pero no puedo entenderlo.

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"]&

Una solución que utiliza el procesamiento de cadenas en realidad terminaría siendo más larga.

PostScript, 119113 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

Con código de prueba:

/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 de la comunidad porque la solución actual es muy diferente a la original. ¡Gracias a todos!

Demostración: http://www.es6fiddle.net/iio40yep/

En serio, 43 40 bytes

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

La estrategia aquí es mirar solo los 1, 2 o 3 dígitos más significativos, dividiendo la entrada por el valor más grande 10^(3n)que sea menor que la entrada.

Pruébalo en línea

Explicación:

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

Traducción directa de mi respuesta sed :

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

Pruébalo en línea.

Un byte guardado gracias 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

(Perl 6 se usa [ ]en expresiones regulares para no capturar ( )y <[ ]>para juegos 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 =

El código verifica si el número comienza con ciertos prefijos. El prefijo 8siempre se verifica ( ocho , ochenta y algo , ocho cientos y ), pero 11y 18( once y dieciocho ) se verifican solo cuando el número de dígitos es un múltiplo de 3 más 2.

Comenzamos con un resultado tentativo de ay cuando se encuentra un prefijo, el resultado se reemplaza por an. anchorsearchse usa para evitar extraer un prefijo de la cadena. Incluso si se encuentra una coincidencia, continuamos verificando el resto de los prefijos: ¿por qué desperdiciar 5 bytes para el  exit? -, pero debido a que la cadena original se reemplaza por aestamos seguros de no obtener ningún falso positivo.

Para devolver el resultado a-o-- anen la pila de operandos en lugar de imprimirlo, elimine el final  =(longitud resultante: 107 bytes).

Código de prueba:

/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 (con tokens binarios), 63 bytes

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

El ’son bytes con el valor 146 (decimal), ¥es un 165 y $es un 3. Todos los demás son imprimibles caracteres ASCII de 7 bits.

Esto es lo mismo que mi versión PostScript [ASCII puro], pero usa tokens binarios donde esto ayuda a reducir la longitud total. Lo publico por separado por 3 razones:

• En el caso general, una implementación que minimiza el código ASCII no es necesariamente la misma que minimiza la versión binaria. Una pieza más larga de código ASCII PostScript podría comprimirse mejor que otra y su versión binaria correspondiente sería más corta.
• El código binario no es adecuado en todas partes, por lo que puede preferirse una respuesta ASCII pura incluso si es más larga.
• No sería justo comparar la longitud de una respuesta PostScript ASCII pura con una que use codificaciones binarias.

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

Aquí hay uno largo, pero simple.

Editar: corregido con gracias a Isaac . Guarde algunos espacios en blanco después de las comparaciones. Muchos bytes guardados gracias a Timwi , Mego , Benpop y Alissa .

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

o para el mismo número de bytes.

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

Sin golf:

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";}

Pruébalo en línea.

Explicación:

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"

Japt , 28 27 bytes

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

Pruébalo en línea!

Desempaquetado y cómo 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/

Primero lo convertimos al número en inglés. Luego borre todo excepto una posible inicial ey prefije con a. Luego convierta el e(si está presente) an . El único truco de golf es hacer coincidir lo opcional een la primera sustitución, para que podamos reutilizar el patrón en la siguiente línea.

Manifestación

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'

Pruébalo aquí

Explicación

               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 no tan corto como el lambda.

05AB1E , 26 bytes

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

Probablemente se pueda jugar un poco más, pero está funcionando.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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'

Pruébalo en línea!

Stax , 25 bytes

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

Ejecutar y depurarlo

Desempaquetado, sin golf y comentado, se ve así.

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"

Ejecute este

Espacio en blanco , 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]

Se agregaron letras S(espacio), T(tabulación) y N(nueva línea) solo como resaltado.
[..._some_action]agregado solo como explicación.

Pruébelo en línea (solo con espacios en bruto, pestañas y nuevas líneas).
El programa se detiene con un error: no se encontró ninguna salida.

Explicación en pseudocó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 79 bytes

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

Resultó 4 bytes más corto para probar explícitamente contra 8xx y 8x que para tener otro /=10ciclo, 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";}

Manifestación

#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](...)*$/

Pruébalo en línea!

Perl, 71 55 49 bytes

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

Sabía que el operador ternario ayudaría algún día ...

Déjame analizar esto.

• $_=<> acepta un número como entrada.
• El $_=...bloque grande establecerá el valor de $_después de que se use.
  • ...?...:...es el operador ternario. Si la condición (primer argumento) es verdadera, devuelve el segundo argumento. De lo contrario, devuelve el tercero.
  • /^8/||(/^1[18]/&&length%3==2)comprueba si el número comienza con 8 o comienza con 11 o 18 ( 1[18]acepta cualquiera) y tiene una longitud mod 3 de 2.
  • Si eso es cierto, $_se establece en an. De lo contrario, se establece en a.
• Luego imprime el contenido de $_(ya sea ao an) con say.

Cambios

• Guardado 16 bytes gracias a msh210.
• Guardado 6 bytes eliminando parens y utilizando valores predeterminados.

Pyth, 29 31

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

Invierte la cadena, la divide en secciones de tres, la invierte nuevamente, luego elige el final apropiado.