Estás en una racha de 8 días!

82

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
Luke
fuente
31
¿Está avalado por Duolingo? De lo contrario, debe hacer que nos paguen por mejorar el idioma en un sitio de aprendizaje de idiomas.
Arc676
10
¿ 1100 (a) mil cien o (a) mil ciento cien ?
user3819867
11
Bilbo no estaría de acuerdo con algunos de sus casos de prueba. :)
Martin Ender
99
@Zaibis: "uno" aquí se pronuncia como "wun", que tiene un sonido consonante. Por lo tanto, " una racha de mil cien días".
El'endia Starman
31
Probablemente dejaron este error porque pensaron que nadie alcanzaría una racha de 8 días.
PNDA

Respuestas:

14

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.

isaacg
fuente
3
Muy creativo. Además, aterrador.
Hellreaver
29

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.
xnor
fuente
Sé que esta es una pregunta muy antigua, pero creo que `` n> = '8' '`ahorra tres bytes.
Lynn
@ Lynn ¿No será eso un desastre nueve?
xnor
¡Oh por supuesto! Fui engañado por el conjunto de pruebas :)
Lynn
12

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.

Trauma digital
fuente
11

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.

Trauma digital
fuente
2
+1 por usar bsd-games, en realidad no pensé que alguna vez serían útiles :)
ASCIIThenANSI
@ASCIIThenANSI sí, los juegos bsd son útiles aquí y allá :)
Digital Trauma
9

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
Martin Ender
fuente
1
+1 este es casi el mismo nivel de abuso de expresiones regulares que las pruebas de primalidad :)
cat
1
Y lo bueno es que Duolingo en realidad está escrito en Retina, por lo que debería ser muy fácil integrar esto. O espera, ¿qué idioma era?
dejó de girar en contra del reloj el
1
@ceasedtoturncounterclockwis Me han dicho que en realidad está escrito en Hexagony, pero escribieron un transpilador Retina-to-Hexagony, por lo que esto no debería ser un problema.
Martin Ender
6

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";}
Luke
fuente
4

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.

LegionMammal978
fuente
3

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
jdaw1
fuente
3

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/

Scott Kaye
fuente
1
eso tiene sentido. Gracias por la explicación.
Daniel F
1
@Pavlo Muy bien, ¡olvidé las expresiones individuales después de descubrir el evaltruco! Sabía que también tenía que haber una mejor expresión regular, pero no podía entender nada que fuera más corto. ¡Gracias!
Scott
1
@Pavlo Sweet, actualizado de nuevo! Aprendiendo mucho, muchas gracias :)
Scott
2
URGH! Olvidé afeitarme 2 bytes! Aquí está el último: n=>/^8|^(?=1[18])..(\d{3})*$/.test(n)?'an':'a'( es6fiddle.net/iiehl1ex ). Tiene 46 bytes de longitud.
Ismael Miguel
2
@ScottKaye El código es muy simple: comprueba si comienza con 8, si comienza con 1[18]y si la longitud de los números es 2 * (3n). Básicamente, es todo su código, pero dentro de una expresión regular.
Ismael Miguel
2

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
Mego
fuente
2

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)
Brad Gilbert b2gills
fuente
2

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
se hunde
fuente
2

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.
se hunde
fuente
1

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
Sherlock9
fuente
Esto es incorrecto en la entrada 843, "ochocientos cuarenta y tres", que debería ser an.
isaacg
@isaacg No solo tienes razón, sino que esto simplifica enormemente mi código. ¡Gracias! Resulta que solo miraba ocho, ocho mil, ocho millones, mientras ignoraba casos como ochenta y ochocientos.
Sherlock9
¿Por qué en (-~len(n)%3)<1lugar de len(n)%3==2?
Timwi
¿Podría (n[:2]=="11"or n[:2]=="18")ser acortado a "118".contains(n[:2])?
Timwi
O incluso n[:2]in"118"?
Timwi
1

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"
Kevin Cruijssen
fuente
1

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
Bubbler
fuente
Puede reemplazar 1e3con
Oliver
1

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
Toby Speight
fuente
0

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
Dom Hastings
fuente
0

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.

janrn
fuente
0

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"
Kevin Cruijssen
fuente
0

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

recursivo
fuente
0

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
Kevin Cruijssen
fuente
0

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
Toby Speight
fuente
No conozco demasiado bien C ++, pero ¿puede i/=1000serlo i/=1e3y todo puede &&llegar a ser &?
Kevin Cruijssen
De hecho, parece funcionar: Pruébelo en línea.
Kevin Cruijssen
1
@Kevin: en un momento tuve 1e3 allí; Lo cambié durante la depuración y olvidé volver a cambiarlo. No &&puede ser todo &, porque la resta produce enteros y no booleanos, por ejemplo, 19-11es 8 y 19-18es 1; ve que eso 8 && 1es cierto, pero 8 & 1es falso. Podríamos usar &, pero tendríamos que cambiar -a !=y también añadir entre paréntesis.
Toby Speight
Ah, por supuesto ... de &hecho no funciona aquí, mi mal. Por cierto, ¿por qué no agrega un enlace TIO a su respuesta también?
Kevin Cruijssen
-1

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.
ASCIIThenANSI
fuente
$_=<>;$_=(/^8/)||/^1[18]/&&length($_)%3==1?'an':'a';sayGuarda algunos bytes. (Aunque el número de comparar a ella depende de lo que su carácter de nueva línea es, pero eso no cambia el número de bytes.)
msh210
@ msh210 Parece que solo son 55 bytes, lo que significa que ahorra 16 bytes. Agregaré eso. ¡Gracias!
ASCIIThenANSI
De nada. Ah, y puedes dejar los primeros parens (supongo. No he probado). Creo que también podría cambiar length($_)a length(o al menos descartar a los padres), pero eso no funciona para mí por alguna razón.
msh210
@ msh210 Sí, puede soltar los parens y ($_)obtener $_=<>;$_=/^8/||/^1[18]/&&length%3==1?'an':'a';say, que son solo 49 bytes.
ASCIIThenANSI
Puede guardar algunos bytes usando en -plugar de $_=<>y say, en y///clugar de length, y soltando las comillas ay an: perl -pe'$_=/^8/||/^1[18]/&&y///c%3==2?an:a'(34 bytes + 1 para -p). Tenga en cuenta que de entrada no puede terminar en una línea: echo -n 11 | perl -pe'...'. Esto también corrige un error: length%3==2se analiza como length(%3)==2, no como length($_)%3==2, por lo que siempre devuelve falso.
ThisSuitIsBlackNot
-1

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.

Alce
fuente
55
Esto está mal en la entrada 111- daan
isaacg
Tienes razón. Fijo.
Alces