Duolingo, приложение для изучения языка, предлагает много вещей, но есть одна серьезная проблема, которая сводит меня с ума. Он говорит мне, сколько дней подряд я использовал приложение с сообщением, как будто Вы на 7-дневной полосе! Если оставить в стороне переносы и указывать, нужно ли указывать число, это прекрасно работает для большинства чисел, но, безусловно, неправильно, когда говорится, что вы на 8-дневной полосе! Я не использую его для изучения английского языка, но это все еще неудачное поведение для языкового приложения.

Вы собираетесь помочь команде Duolingo, написав полную программу или функцию, которая выясняет, следует ли заданному числу предшествовать a или an . Ряд предшествует , если его произношение в разговорном английском языке начинается с согласным или полугласным звуком и предшествует , если его произношение начинается с гласным звуком. Таким образом, единственные числа, которым предшествует, - это те, чье произношение начинается с восьми , одиннадцати , восемнадцати или восьмидесяти .

Предположительно, команда разработчиков Duolingo оставила эту ошибку, потому что ей не хватило места для большего количества исходного кода в приложении, поэтому вам нужно сделать этот код как можно короче, в надежде, что он сможет его сжать.

Ваш код должен принимать целое число от 0 до 2 147 483 647 и выводить aили an. Завершающий перевод строки не является обязательным. Для целей этого испытания 1863 читается как тысяча восемьсот шестьдесят три , а не восемнадцатьсот шестьдесят три .

Тестовые случаи:

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 байта

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

Это выбирает, сколько букв нужно вырезать с конца "an", проверяя, не является ли первая буква буквой 8A, и что первая цифра числа при рассмотрении в базе 1000 не равна ни 11, ни 18. Полученное логическое число - это количество символов, которое нужно вырезать из конец.

Python 2, 60 байт

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

Анонимная функция. Добавляет, nесли либо:

• Первая цифра 8
• Первые две цифры 11 или 18, а длина 2 по модулю 3.

GNU Sed, 32

Оценка включает +1 за -Eопцию sed.

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

Попробуйте онлайн.

• Удалите группы из 3 цифр в конце каждого номера, пока не останется от 1 до 3 цифр.
• Подберите любое число, начинающееся с 8 или ровно с 11 или 18, и измените на an
• Изменить все остальные номера на a

Спасибо @ MartinBüttner за его подход к сетчатке, который сэкономил 10 байт.

Shell + bsd-игры, 30

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

Ввод читать из STDIN.

numberпреобразует десятичную строку в слова Тогда легко решить, начинается ли результат e.

Сетчатка , 27 байт

Это не очень отличается от ответа Retina на DigitalTrauma, но они настояли, чтобы я отправил это сам.

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

Попробуйте онлайн.

Первое регулярное выражение заменяет все соответствующие числа на an, а второе заменяет все оставшиеся числа на a. Это работает для тех же байтов:

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

С ++, 101

Это моя задача, так что это не должно быть конкурентным ответом. Просто хотел посмотреть, насколько коротким я смог получить его в C ++. Строковые операции слишком многословны, так что это делается с помощью математики. Я чувствую, что должен быть способ уменьшить это состояние, но я не могу понять это.

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 байта

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

Решение, использующее обработку строк, на самом деле будет длиннее.

PostScript, 119 113 символов

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

С тестовым кодом:

/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 байт

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

Сообщество вики, потому что текущее решение настолько отличается от моего оригинала. Всем спасибо!

Демо: http://www.es6fiddle.net/iio40yep/

Серьезно, 43 40 байт

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

Стратегия здесь состоит в том, чтобы смотреть только на 1, 2 или 3 наиболее значимых цифры, целочисленным делением ввода на наибольшее значение 10^(3n), которое меньше, чем ввод.

Попробуйте онлайн

Объяснение:

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

Сетчатка , 34

Прямой перевод моего ответа sed :

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

Попробуйте онлайн.

Один байт сохранен благодаря @Timwi.

Perl 6 ,  31   30 байт

{'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 использует [ ]регулярные выражения для захвата ( )и использует <[ ]>наборы символов)

Использование:

# 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 байт

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

Код проверяет, начинается ли номер с определенных префиксов. Приставка 8всегда проверяется ( восемь , восемьдесят с чем-то , восемь-сотни-и ), но 11и 18( одиннадцать и восемнадцать ) проверяются только тогда , когда количество цифр кратна 3 плюс 2.

Мы начнем с предварительного результата, aи когда префикс будет найден, результат будет заменен на an. anchorsearchиспользуется, чтобы избежать извлечения префикса из строки. Даже если совпадение найдено, мы продолжаем проверять остальные префиксы - зачем тратить 5 байтов на  exit? -, но поскольку исходная строка заменяется на aмы, мы уверены, что не получим никаких ложных срабатываний.

Чтобы вернуть a-или- anрезультат в стеке операндов, а не печатать его, удалите завершающий символ  =(итоговая длина: 107 байт).

Тестовый код:

/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 (с двоичными токенами), 63 байта

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

Это ’байты со значением 146 (десятичное), ¥165 и $3. 3. Все остальные - 7-битные ASCII-символы для печати.

Это то же самое, что и моя версия PostScript [чистый ASCII], но использует двоичные токены, где это помогает уменьшить общую длину. Я публикую это отдельно по 3 причинам:

• В общем случае реализация, которая минимизирует код ASCII, не обязательно совпадает с реализацией, минимизирующей двоичную версию. Некоторый более длинный фрагмент кода PostScript ASCII может сжиматься лучше, чем другой, и соответствующая ему двоичная версия будет короче.
• Двоичный код не подходит везде, поэтому может быть предпочтительнее чистый ответ ASCII, даже если он дольше.
• Было бы несправедливо сравнивать длину чистого ответа ASCII PostScript с ответом, использующим двоичные кодировки.

Python 3, 110 93 91 76 74 70 65 64 байта

Вот длинный, но простой.

Изменить: Исправлено с помощью isaacg . Сохранено несколько пробелов после сравнений. Многие байты сохраняются благодаря Timwi , Mego , benpop и Алисса .

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

или для того же количества байтов.

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 байта

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

Попробуйте онлайн.

Объяснение:

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 байтов

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

Попробуйте онлайн!

Распаковано и как это работает

'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 байта

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

Сначала мы конвертируем в английский номер. Затем удалите все, кроме возможного инициала eи префикса с a. Затем преобразовать e(если есть) в n. Единственный трюк в гольфе - это соответствие необязательности eв первой замене, поэтому мы можем повторно использовать схему в следующей строке.

демонстрация

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 байт

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

Попробуй это здесь.

объяснение

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

Очевидно, не такой короткий, как lambdaтот.

05AB1E , 26 байт

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

Возможно, можно играть в гольф немного больше, но это работает.

Попробуйте онлайн или проверьте все контрольные примеры .

Объяснение:

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 байта

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

Попробуйте онлайн!

Stax , 25 байт

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

Запустите и отладьте его

Распакованный, размазанный и прокомментированный, это выглядит так.

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"

Запустите этот

Пробел , 243 байта

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

Буквы S(пробел), T(табуляция) и N(новая строка) добавляются только как подсветка.
[..._some_action]добавлено только для пояснения.

Попробуйте онлайн (только с необработанными пробелами, вкладками и новыми строками).
Программа останавливается с ошибкой: выход не найден.

Объяснение в псевдокоде:

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 байт

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

Оказалось, что на 4 байта короче для явного тестирования на 8хх и 8х, чем на другой /=10цикл, например:

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

демонстрация

#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 байт

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

Попробуйте онлайн!

Perl, 71 55 49 байт

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

Я знал, что троичный оператор поможет однажды ...

Позвольте мне сломать это.

• $_=<> принимает число в качестве ввода.
• Большой $_=...блок установит значение $_после его использования.
  • ...?...:...является троичным оператором. Если условие (первый аргумент) истинно, оно возвращает второй аргумент. В противном случае возвращается третье.
  • /^8/||(/^1[18]/&&length%3==2)проверяет, начинается ли число с 8 или начинается с 11 или 18 ( 1[18]принимает либо), и имеет длину 3 из 2.
  • Если это правда, $_устанавливается на an. В противном случае он установлен на a.
• Затем он печатает содержимое $_(или aили an) с помощью say.

изменения

• Сохранено 16 байт благодаря msh210.
• Сохранено 6 байтов путем удаления паренов и использования значений по умолчанию.

Пиф, 29 31

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

Переворачивает строку, разбивает ее на части по три, снова переворачивает, затем выбирает подходящее окончание.