언어 학습 앱인 Duolingo에는 많은 것들이 있지만 나를 미치게하는 주요한 문제가 있습니다. 그것은 당신이 7 일 연속으로 당신 과 같은 메시지와 함께 응용 프로그램을 사용한 몇 일 연속 나에게 알려줍니다 ! 하이픈 넣기 및 숫자 철자 여부를 따로 설정하면 대부분의 숫자에서 잘 작동하지만 8 일 연속 행진 이라고 말할 때 틀림없이 잘못되었습니다 ! 나는 영어를 배우기 위해 그것을 사용하지 않고 있지만 이것은 여전히 ​​언어 앱의 불행한 행동입니다.

당신은 주어진 숫자가 선행되어야하는지 여부를 파악 완전한 프로그램이나 기능을 작성하여 듀오 링고 팀을 도울거야 또는 을 . 다수의 앞에는 음성 영어의 발음이로 시작하는 경우 자음 또는 반모음 소리 에 의해, 그리고 앞에 의 발음이 모음 소리와 함께 시작합니다. 따라서 발음 앞에 오는 숫자 는 발음이 8 , 11 , 18 또는 80으로 시작 하는 숫자 입니다.

아마도 Duolingo dev 팀은이 버그를 남겼습니다. 앱에서 더 많은 소스 코드를위한 공간이 부족했기 때문에 가능한 한 짧게 코드를 짜야합니다.

코드는 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"첫 번째 문자가 아닌지 여부 8와 기본 1000에서 고려할 때 숫자의 첫 번째 숫자가 11 또는 18이 아닌지 여부를 확인 하여 끝에서 분리 할 문자 수를 선택합니다 . 결과 부울은 슬라이스 할 문자 수입니다. 끝.

파이썬 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 세드, 32

점수는 -Esed 옵션에 +1을 포함 합니다.

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

온라인으로 사용해보십시오.

• 1 ~ 3 자리 만 남을 때까지 각 숫자의 끝에서 3 자리 그룹을 제거합니다.
• 8 또는 정확히 11 또는 18로 시작하는 숫자를 일치시키고 an
• 다른 모든 숫자를 a

10 바이트를 절약 한 그의 망막 접근 방식에 대한 @ MartinBüttner에게 감사 합니다.

셸 + bsd 게임, 30

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

STDIN에서 입력을 읽습니다.

number10 진수 문자열을 단어로 변환합니다. 결과가로 시작되는지 여부를 결정하는 것은 간단한 문제입니다 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";}

수학, 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'

현재 솔루션이 원래 솔루션과 너무 다르기 때문에 커뮤니티 위키. 모두 감사합니다!

데모 : 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 덕분에 1 바이트가 절약되었습니다.

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

포스트 스크립트, 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 (2 진 토큰 포함), 63 바이트

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

(가) ’값 146 (10 진수)와 바이트, ¥165을이고 $3. 다른 모든 인쇄 7 비트 ASCII 문자되어있다.

이것은 PostScript [pure ASCII] 버전과 동일하지만 전체 길이를 줄이는 데 도움이되는 이진 토큰을 사용합니다. 세 가지 이유로 별도로 게시합니다.

• 일반적으로 ASCII 코드를 최소화하는 구현이 이진 버전을 최소화하는 구현과 반드시 ​​같을 필요는 없습니다. 더 긴 ASCII PostScript 코드는 다른 것보다 압축률이 높고 해당 바이너리 버전이 더 짧습니다.
• 이진 코드는 모든 곳에 적합하지 않으므로 더 긴 경우에도 순수한 ASCII 응답이 선호 될 수 있습니다.
• 순수 ASCII PostScript 답변의 길이와 이진 인코딩을 사용하는 답변의 길이를 비교하는 것은 불공평합니다.

파이썬 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

자바 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"

apt , 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

티 스크립트 , 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

파이썬 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"

쿼드 , 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";}

다음 /=10과 같이 다른 루프 를 갖는 것보다 8xx 및 8x에 대해 명시 적으로 테스트하는 것이 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

펄 5 -p , 26 바이트

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

온라인으로 사용해보십시오!

펄, 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 바이트를 절약했습니다.
• Parens를 제거하고 기본값을 사용하여 6 바이트를 절약했습니다.

피스, 29 31

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

문자열을 뒤집어 세 부분으로 나누고 다시 뒤집은 다음 적절한 결말을 선택합니다.