语言学习应用程序Duolingo有很多功能要做，但是有一个主要问题使我发疯。它告诉我我已经连续几天使用该应用程序，并显示一条消息，例如“ 您正在连续7天出现连败！”。撇开连字符和是否应拼写数字，这对大多数数字都适用，但是当您说自己连续8天出现错误时，这无疑是错误的！我没有用它来学习英语，但这对于语言应用程序来说仍然是不幸的行为。

您将通过编写一个完整的程序或函数来帮助Duolingo团队，该程序或函数可以确定给定数字前应带有a还是a。一个数字前面有一个，如果它的英语口语发音与开始辅音或半元音的声音，并且在前面的，如果它的发音以元音开头。因此，唯一以a开头的数字是那些以八，十一，十八或八十开头的发音。

大概Duolingo开发团队留了这个bug的原因是因为他们用光了空间，无法在应用程序中使用更多的源代码，因此您需要使此代码尽可能短，以希望他们可以将其压缩。

您的代码必须采用0到2,147,483,647之间的整数，并输出a或an。尾随换行符是可选的。出于此挑战的目的，1863年被理解为1836.3，而不是163。

测试用例：

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"通过检查第一个字母是否不是an 8以及在基数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选择。

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字节

这与DigitalTrauma的Retina回答没有太大不同，但他们坚持要我自己张贴此内容。

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

在线尝试。

第一个正则表达式用替换所有相关的数字an，第二个正则表达式用替换所有剩余的数字a。这适用于相同的字节：

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

C ++，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，119113个字符

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'

社区Wiki，因为当前的解决方案与我的原始解决方案有很大不同。感谢大家！

演示：http：//www.es6fiddle.net/iio40yep/

严重的是43 40字节

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

这里的策略是通过将输入整数除以10^(3n)小于输入的最大值，仅查看1、2或3个最高有效数字。

在线尝试

说明：

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总是检查前缀（八，八十年代，八百和），但是仅当数字的位数是3加2的倍数时才检查11和18（十一和十八）。

我们从暂定结果开始，a当找到前缀时，结果将替换为an。anchorsearch用于避免从字符串中提取前缀。即使找到匹配项，我们也会继续验证其余的前缀-为什么要为5浪费字节 exit？–，但是由于原始字符串已被替换，因此a我们确保不会产生任何误报。

要在操作数堆栈上返回a-or- 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.其他所有可打印的7位ASCII字符。

这与我的PostScript [pure ASCII]版本相同，但是使用二进制标记来帮助减少总长度。我将其单独发布有3个原因：

• 在一般情况下，最小化ASCII码的实现不一定与最小化二进制版本的实现相同。更长的ASCII PostScript代码片段可能比另一个更好地压缩，其对应的二进制版本也更短。
• 二进制代码不适用于任何地方，因此，即使更长，也可能首选纯ASCII答案。
• 将纯ASCII PostScript答案的长度与使用二进制编码的答案进行比较是不公平的。

Python 3，110 93 91 76 74 70 65 64字节

这是很长的，但是很简单。

编辑：借助isaacg进行了更正。比较后保存了一些空格。感谢Timwi，Mego，benpop和Alissa，节省了很多字节。

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

取消高尔夫：

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

事实证明，针对8xx和8x进行显式测试的时间要比具有另一个/=10循环的时间短4个字节，如下所示：

[](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，26 -p个字节

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

在线尝试！

Perl，71 55 49字节

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

我知道三元运算符会帮助一天。

让我分解一下。

• $_=<> 接受数字作为输入。
• 大$_=...模块将设置的值，$_它的使用之后。
  • ...?...:...是三元运算符。如果条件（第一个参数）为true，则返回第二个参数。否则，它返回第三个。
  • /^8/||(/^1[18]/&&length%3==2)检查数字是否以8开头或以11或18开头（1[18]接受任意一个）并且长度模3为2。
  • 如果是这样，$_请将设置为an。否则，将其设置为a。
• 然后使用来打印$_（a或an）的内容say。

变化

• 多亏了msh210，节省了16个字节。
• 通过删除括号并使用默认值节省了6个字节。

佩斯，29 31

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

反转字符串，将其分成三部分，再次反转，然后选择适当的结尾。