Duolingo, l'app per l'apprendimento delle lingue, ha molte cose da fare, ma c'è un grosso problema che mi fa impazzire. Mi dice da quanti giorni consecutivi ho usato l'app con un messaggio come Sei in serie da 7 giorni! Mettere da parte la sillabazione e se il numero debba essere precisato, questo funziona bene per la maggior parte dei numeri, ma è indiscutibilmente sbagliato quando dice che sei in una sequenza di 8 giorni! Non lo sto usando per imparare l'inglese ma questo è ancora un comportamento sfortunato per un'app di lingua.

Aiuterai il team di Duolingo scrivendo un programma o una funzione completa che determina se un determinato numero deve essere preceduto da un o un . Un numero è preceduto da un se la sua pronuncia nell'inglese parlato inizia con un suono di consonante o semivowel e preceduto da un se la sua pronuncia inizia con un suono di vocale. Quindi gli unici numeri preceduti da un sono quelli la cui pronuncia inizia con otto , undici , diciotto o ottanta .

Presumibilmente il team di sviluppatori di Duolingo ha lasciato questo bug perché ha esaurito lo spazio per più codice sorgente nell'app, quindi è necessario rendere questo codice il più breve possibile nella speranza che possano comprimerlo.

Il codice deve richiedere un numero intero compreso tra 0 e 2.147.483.647 e output ao an. Una nuova riga finale è facoltativa. Ai fini di questa sfida, il 1863 viene letto come milleduecentosessantatre , non settecentosessantatre .

Casi test:

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 byte

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

Questo seleziona il numero di lettere da tagliare alla fine "an"controllando se la prima lettera non è una 8e che la prima cifra del numero se considerata nella base 1000 non è né 11 né 18. Il valore booleano risultante è il numero di caratteri da tagliare di fine.

Python 2, 60 byte

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

Una funzione anonima. Aggiunge un nif se:

• La prima cifra è 8
• Le prime due cifre sono 11 o 18 e la lunghezza è 2 modulo 3.

GNU Sed, 32

Il punteggio include +1 per l' -Eopzione di sed.

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

Provalo online.

• Rimuovere i gruppi di 3 cifre dalla fine di ogni numero fino a quando rimangono solo da 1 a 3 cifre
• Abbina qualsiasi numero che inizia con 8 o esattamente 11 o 18 e cambia in an
• Cambia tutti gli altri numeri in a

Grazie a @ MartinBüttner per il suo approccio alla retina che ha permesso di risparmiare 10 byte.

Shell + bsd-games, 30

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

Ingresso letto da STDIN.

numberconverte una stringa decimale in parole. È quindi semplice decidere se iniziare o meno il risultato e.

Retina , 27 byte

Questo non è molto diverso dalla risposta Retina di DigitalTrauma, ma hanno insistito sul fatto che io stesso lo pubblicassi.

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

Provalo online.

Il primo regex sostituisce tutti i numeri rilevanti con ane il secondo sostituisce tutti i numeri rimanenti con a. Funziona con gli stessi byte:

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

C ++, 101

Questa è la mia sfida, quindi non è una risposta competitiva. Volevo solo vedere quanto potevo ottenerlo in C ++. Le operazioni sulle stringhe sono troppo dettagliate, quindi questo viene fatto con la matematica. Sento che ci deve essere un modo per ridurre quella condizione, ma non riesco a capirlo.

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 byte

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

Una soluzione che utilizza l'elaborazione di stringhe finirebbe per essere più lunga.

PostScript, 119 113 caratteri

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 il codice di prova:

/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 byte

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

Wiki della comunità perché la soluzione attuale è così diversa dalla mia originale. Grazie a tutti!

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

Scherzi a parte, 43 40 byte

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

La strategia qui è guardare solo le 1, 2 o 3 cifre più significative, dividendo l'intero input per il valore più grande 10^(3n)che è inferiore all'input.

Provalo online

Spiegazione:

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

Traduzione diretta della mia risposta sed :

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

Provalo online.

Un byte salvato grazie a @Timwi.

Perl 6 ,  31   30 byte

{'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 usa [ ]nelle regex per non catturare ( )e usa <[ ]>per i set di caratteri)

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 byte

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

Il codice verifica se il numero inizia con determinati prefissi. Il prefisso 8viene sempre controllato ( otto , ottanta-qualcosa , ottocento-e ), ma 11e 18( undici e diciotto ) vengono controllati solo quando il numero di cifre è un multiplo di 3 più 2.

Iniziamo con un risultato provvisorio di ae quando viene trovato un prefisso, il risultato viene sostituito con an. anchorsearchviene utilizzato per evitare di estrarre un prefisso dalla stringa. Anche se viene trovata una corrispondenza, continuiamo a verificare il resto dei prefissi: perché sprecare 5 byte per il  exit? -, ma poiché la stringa originale viene sostituita con asiamo sicuri di non ottenere falsi positivi.

Per restituire il risultato a-o-- ansullo stack dell'operando anziché stamparlo, rimuovere il finale  =(lunghezza risultante: 107 byte).

Codice di prova:

/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 token binari), 63 byte

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

La ’sono byte con il valore 146 (decimale), ¥è un 165 ed $è un 3. Tutti gli altri sono stampabili caratteri ASCII 7-bit.

Questo è lo stesso della mia versione PostScript [puro ASCII], ma utilizza token binari in cui ciò aiuta a ridurre la lunghezza totale. Lo pubblico separatamente per 3 motivi:

• Nel caso generale, un'implementazione che minimizza il codice ASCII non è necessariamente la stessa di quella che minimizza la versione binaria. Un pezzo più lungo di codice PostScript ASCII potrebbe comprimersi meglio di un altro e la sua versione binaria corrispondente sarebbe più corta.
• Il codice binario non è adatto ovunque, quindi una risposta ASCII pura può essere preferita anche se più a lungo.
• Non sarebbe corretto confrontare la lunghezza di una risposta PostScript ASCII pura con una che utilizza codifiche binarie.

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

Eccone uno lungo, ma semplice.

Modifica: corretto con grazie a isaacg . Salvati alcuni spazi bianchi dopo i confronti. Molti byte salvati grazie a Timwi , Mego , Benpop e Alissa .

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

o per lo stesso numero di byte.

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 byte

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

Provalo online.

Spiegazione:

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 byte

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

Provalo online!

Disimballato e come funziona

'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 byte

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

Per prima cosa convertiamo in numero inglese. Quindi elimina tutto tranne un'eventuale iniziale ee aggiungi il prefisso a. Quindi convertire e(se presente) in n. L'unico trucco per il golf è quello di abbinare il facoltativo enella prima sostituzione, quindi possiamo riutilizzare il modello nella riga seguente.

dimostrazione

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 byte

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

Provalo qui.

Spiegazione

               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']

Ovviamente non è basso come lambdaquello.

05AB1E , 26 byte

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

Probabilmente si può giocare a golf un po 'di più, ma funziona.

Provalo online o verifica tutti i casi di test .

Spiegazione:

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 byte

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

Provalo online!

Stax , 25 byte

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

Esegui ed esegui il debug

Disimballato, non golfato e commentato, sembra così.

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"

Esegui questo

Spazio bianco , 243 byte

[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]

Lettere S(spazio), T(scheda) e N(nuova riga) aggiunti solo come evidenziazione.
[..._some_action]aggiunto solo come spiegazione.

Provalo online (solo con spazi non elaborati, schede e nuove righe).
Il programma si interrompe con un errore: nessuna uscita trovata.

Spiegazione in pseudo-codice:

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 byte

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

Si è rivelato 4 byte più corto per testare esplicitamente 8xx e 8x piuttosto che avere un altro /=10loop, come questo:

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

dimostrazione

#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 byte

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

Provalo online!

Perl, 71 55 49 byte

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

Sapevo che l'operatore ternario avrebbe aiutato un giorno ...

Lasciami scomporre.

• $_=<> accetta un numero come input.
• Il grande $_=...blocco imposterà il valore di $_dopo che è stato utilizzato.
  • ...?...:...è l'operatore ternario. Se la condizione (primo argomento) è vera, restituisce il secondo argomento. Altrimenti, restituisce il terzo.
  • /^8/||(/^1[18]/&&length%3==2)controlla se il numero inizia con 8 o inizia con 11 o 18 ( 1[18]accetta uno dei due) e ha una lunghezza mod 3 di 2.
  • Se questo è vero, $_è impostato su an. Altrimenti, è impostato su a.
• Quindi stampa il contenuto di $_(o ao an) con say.

I cambiamenti

• Risparmiato 16 byte grazie a msh210.
• 6 byte salvati rimuovendo le parentesi e usando i valori predefiniti.

Pyth, 29 31

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

Inverte la stringa, la divide in sezioni di tre, la inverte di nuovo, quindi sceglie la desinenza appropriata.