Dil öğrenme uygulaması olan Duolingo'da bunun için birçok şey var, ancak beni çıldırtan önemli bir konu var. Bana arka arkaya kaç gün geçirdiğimi ve 7 günlük bir izlemiş olduğunuz gibi bir mesajla uygulamayı kullandığımı söylüyor ! Bir kenara tirelemeyi ve sayının hecelenmesi gerekip gerekmediğini belirleyerek, bu, çoğu sayı için işe yarar, ancak 8 günlük bir çizgide olduğunuzu söylediğinde tartışmasız yanlıştır ! İngilizce öğrenmek için kullanmıyorum, ancak bu hala bir dil uygulaması için talihsiz bir davranış.

Belirli bir sayıda öncesinde gerekip gerekmediğini anlarsa komple program veya fonksiyon yazarak Duolingo ekibine yardım edeceğiz bir veya bir . Bir dizi öncesinde bir İngilizce konuşma onun telaffuz bir başlıyorsa ünsüz ya semivowel ses ile ve öncesinde bir onun telaffuz sesli harf sesi ile başlıyorsa. Böylece, bir tarafından gelen tek sayılar telaffuzu sekiz , onbir , on sekiz veya seksen ile başlayan sayılardır .

Muhtemelen Duolingo dev ekibi, uygulamadaki daha fazla kaynak kodu için boş alan kaldığından bu hatayı bıraktı, bu yüzden sıkıştırabilecekleri umuduyla bu kodu mümkün olduğunca kısa tutmanız gerekiyor.

Kodunuz 0 ile 2,147,483,647 arasında bir tamsayı almalı ve aveya çıktısını almalıdır an. Sondaki yeni satır isteğe bağlıdır. Bu zorluğun amaçları doğrultusunda, 1863, onsekiz yüz altmış üç değil, bin sekiz yüz altmış üç olarak okunur .

Test durumları:

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 bayt

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

Bu "an", ilk harfin bir olmadığını 8ve temel 1000'de ele alındığında sayının ilk basamağının ne 11 ne de 18 olduğunu kontrol ederek kaç harfin dilimleyeceğini seçer . son.

Python 2,60 bayt

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

Anonim bir işlev. nYa bir ekler :

• İlk hane 8
• İlk iki hane 11 veya 18'dir ve uzunluk 2 modulo3'tür.

GNU Sed, 32

Skor -Eseçeneği için +1'i içerir .

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

Çevrimiçi deneyin.

• Sadece 1 ila 3 hane kalana kadar her sayının sonundaki 3 hane gruplarını kaldırın
• 8 veya tam olarak 11 veya 18 ile başlayan herhangi bir sayıyı eşleştirin ve an
• Diğer tüm numaraları değiştir a

10 byte tasarruf sağlayan retina yaklaşımı için @ MartinBüttner'e teşekkürler .

Shell + BSD oyunları, 30

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

Giriş STDIN'den okunur.

numberOndalık bir dize kelimelere dönüştürür. O zaman sonucun başlayıp başlamayacağına karar vermek basit bir meseledir e.

Retina , 27 bayt

Bu, DigitalTrauma'nın Retina cevabından çok farklı değil, ancak bunu kendim göndermemde ısrar ettiler.

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

Çevrimiçi deneyin.

İlk regex tüm ilgili sayıları ile andeğiştirir, ikincisi kalan tüm sayıları ile değiştirir a. Bu aynı bayt için çalışır:

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

C ++, 101

Bu benim meydan okumam, bu yüzden rekabetçi bir cevap olması gerekmiyor. Sadece C ++ 'da ne kadar kısa süre alabileceğimi görmek istedim. Dize işlemleri sadece çok ayrıntılı, bu matematik ile yapılır. Bu durumu küçültmenin bir yolu olması gerektiğini düşünüyorum ama tam olarak çözemiyorum.

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 bayt

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

Dize işleme kullanan bir çözüm aslında daha uzun sürecektir.

PostScript, 119 113 karakter

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

Test kodu ile:

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

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

Topluluk wiki, çünkü mevcut çözüm benim orijinalimden çok farklı. Herkese teşekkürler!

Gösteri: http://www.es6fiddle.net/iio40yep/

Cidden, 43 40 bayt

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

Buradaki strateji, girdiyi girişten 10^(3n)daha küçük olan en büyük değere tam olarak bölerek sadece 1, 2 veya 3 en önemli haneye bakmaktır .

Çevrimiçi deneyin

Açıklama:

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

Sed cevabımın direkt çevirisi :

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

Çevrimiçi deneyin.

@Timwi sayesinde bir bayt kurtarıldı.

Perl 6 ,  31   30 bayt

{'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, [ ]yakalamamak için regex'lerde ( )kullanır <[ ]>ve karakter kümeleri için kullanır )

Kullanımı:

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

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

Kod, sayının belirli öneklerle başladığını doğrular. Önek 8her zaman kontrol edilir ( sekiz , seksen bir şey , sekiz yüzlerce ve ), ancak 11ve 18( onbir ve on sekiz ) yalnızca basamak sayısı 3 artı 2'nin katları olduğunda kontrol edilir.

Geçici bir sonuçla başlıyoruz ave bir önek bulunduğunda sonucun yerini alıyoruz an. anchorsearchdizeden bir önek çıkarmamak için kullanılır. Bir eşleşme bulunsa bile, öneklerin geri kalanını doğrulamaya devam ediyoruz - neden 5 bayt israfı  exit? -, ancak orijinal dize ile değiştirilir çünkü aherhangi bir yanlış pozitif almak emin değiliz.

Sonuç yerine yazdırmak yerine işlemsel yığında a-ya da- sonunu döndürmek için anizini kaldırın  =(sonuç uzunluğu: 107 bayt).

Test kodu:

/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 (ikili belirteçlerle), 63 bayt

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

’Değeri 146 (ondalık) ile bayt olan ¥bir 165 ve $bir 3. Tüm diğerleri yazdırılabilir 7-bitlik ASCII karakterleri olmasıdır.

Bu benim PostScript [saf ASCII] sürümümle aynı, ancak bunun toplam uzunluğu azaltmaya yardımcı olduğu ikili simgeleri kullanıyor. 3 nedenden dolayı ayrı olarak gönderiyorum:

• Genel durumda, ASCII kodunu en aza indiren bir uygulama mutlaka ikili sürümü en aza indirenle aynı değildir. Uzun ASCII PostScript kodunun bir kısmı diğerinden daha iyi sıkıştırabilir ve ilgili ikili sürümü daha kısa olabilirdi.
• İkili kod her yerde uygun değildir, bu nedenle daha uzun olsa bile saf bir ASCII yanıtı tercih edilebilir.
• Saf ASCII PostScript cevabının uzunluğunu ikili kodlamalar kullanarak cevap ile karşılaştırmak doğru olmaz.

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

İşte uzun bir tane ama basit bir tane.

Düzenleme: isaacg sayesinde düzeltildi . Karşılaştırmalardan sonra bir miktar boşluk bıraktım. Timwi , Mego , benpop ve Alissa sayesinde birçok bayt kurtarıldı .

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

veya aynı sayıda bayt için.

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 bayt

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

Çevrimiçi deneyin.

Açıklama:

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 bayt

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

Çevrimiçi deneyin!

Ambalajsız ve Nasıl Çalışır?

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

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

İlk önce ingilizce numarasına dönüşelim. Sonra olası bir başlangıç ​​dışındaki her şeyi silin eve ile öneki a. Sonra e(varsa) 'a dönüştürün n. Tek golf hilesi eilk ikamede isteğe bağlı ile eşleşmektir , bu nedenle deseni aşağıdaki satırda tekrar kullanabiliriz.

gösteri

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 bayt

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

Burada dene.

açıklama

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

Açıkçası lambdabiri kadar kısa değil .

05AB1E , 26 bayt

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

Muhtemelen biraz daha golf oynayabilir, ancak çalışıyor.

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

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 bayt

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

Çevrimiçi deneyin!

Stax , 25 bayt

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

Koş ve hata ayıkla

Ambalajsız, ağzı açılmış ve yorumlanmış gibi görünüyor.

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"

Bunu çalıştır

Boşluk , 243 bayt

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

Harfler S(boşluk), T(sekme) ve N(yeni satır) yalnızca vurgulama olarak eklenmiştir.
[..._some_action]sadece açıklama olarak eklendi.

Çevrimiçi deneyin (yalnızca ham alanlar, sekmeler ve yeni satırlarla).
Program bir hata ile bitiyor: Çıkış bulunamadı.

Sahte kodda açıklama:

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 bayt

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

Açıkça 8xx ve 8x'e karşı test yapmak için 4 bayt daha kısa çıktı /=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";}

gösteri

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

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

Çevrimiçi deneyin!

Perl, 71 55 49 bayt

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

Üçlü operatörün bir gün yardım edeceğini biliyordum.

Bunu yıkmama izin ver.

• $_=<> bir sayıyı girdi olarak kabul eder.
• Büyük $_=...blok $_kullanıldıktan sonra değerini belirleyecektir .
  • ...?...:...üçlü operatör. Koşul (birinci argüman) doğruysa, ikinci argümanı döndürür. Aksi takdirde, üçüncü döndürür.
  • /^8/||(/^1[18]/&&length%3==2)sayının 8 ile mi yoksa 11 ile mi (18 ile mi) başladığını 1[18]ve 2 ile 3 arasında bir uzunluğa sahip olup olmadığını kontrol eder.
  • Eğer bu doğruysa, $_ayarlanır an. Aksi takdirde, ayarlanır a.
• Daha sonra $_(veya aveya an) ile birlikte içeriğini yazdırır say.

değişiklikler

• Msh210 sayesinde 16 bayt kaydedildi.
• Parenler kaldırarak ve varsayılanları kullanarak 6 bayt kaydedildi.

Pyth, 29 31

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

Dizeyi ters çevirir, üç bölüme ayırır, tekrar ters çevirir, ardından uygun sonu seçer.