Вы на 8-дневной полосе!

82

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
code-golf number Люк
источник
31
Это одобрено Дуолинго? Если нет, попросите их заплатить нам за улучшение языка на сайте изучения языка.
Arc676
10
Является ли 1100 (ая) тысяча сто или (а) одну тысячи сто ?
user3819867
11
Бильбо не согласится с некоторыми вашими тестами. :)
Мартин Эндер
9
@Zaibis: «один» здесь произносится как «вун», который имеет согласный звук. Таким образом, « тысяча один стодневный подряд».
El'endia Starman
31
Они, вероятно, оставили эту ошибку, потому что они думали, что никто не достигнет 8-дневной полосы.
PNDA

Ответы:

14

Pyth, 23 байта

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

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

isaacg
источник
3
Очень креативно. Также страшно.
Hellreaver
29

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.
XNOR
источник
Я знаю, что это очень старый вопрос, но я думаю, что `` n> = '8' `` сохраняет три байта.
Линн
@ Линн Разве это не испортит девятки хотя?
xnor
О Конечно! Я был одурачен тестовым набором :)
Линн
12

GNU Sed, 32

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

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

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

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

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

Цифровая травма
источник
11

Shell + bsd-игры, 30

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

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

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

Цифровая травма
источник
2
+1 за использование bsd-игр, я даже не думал, что они когда-нибудь будут полезны :)
ASCIIThenANSI
@ASCIIThenANSI Да, bsd-игры полезны здесь и там :)
Digital Trauma
9

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

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

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

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

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

^8.*|^1[18](...)*$
n
^\d*
a
Мартин Эндер
источник
1
+1 это почти такой же уровень злоупотребления регулярным выражением, как и тестирование на примитивность :)
кошка
1
И хорошо, что Duolingo на самом деле написан на Retina, так что интегрировать его должно быть легко. Или подождите, на каком языке это было?
перестал поворачиваться против часовой стрелки с
1
@ceasedtoturncounterclockwis Мне говорят, что на самом деле он написан на гексагонии, но они написали транспортер Retina-to-Hexagony, так что это не должно быть проблемой.
Мартин Эндер
6

С ++, 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";}
Люк
источник
4

Mathematica, 53 байта

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

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

LegionMammal978
источник
3

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
jdaw1
источник
3

JavaScript (ES6) 70 61 46 38 байт

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

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

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

Скотт Кэй
источник
1
это имеет смысл. Спасибо за объяснение.
Даниэль Ф
1
@Pavlo Очень приятно, я забыл об одиночных выражениях после обнаружения evalуловки! Я знал, что должно быть и лучшее регулярное выражение, но я не мог придумать ничего более короткого. Спасибо!
Скотт
1
@Pavlo Sweet, обновляется снова! Многому учусь, большое спасибо :)
Скотт
2
Urgh! Забыл побрить 2 байта! Вот последний: n=>/^8|^(?=1[18])..(\d{3})*$/.test(n)?'an':'a'( es6fiddle.net/iiehl1ex ). Это 46 байтов в длину.
Исмаэль Мигель
2
@ScottKaye Код очень прост: он проверяет, начинается ли он с 8, начинается ли он 1[18]и имеет ли длина чисел 2 * (3n). По сути, это весь ваш код, но внутри регулярного выражения.
Исмаэль Мигель
2

Серьезно, 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
Мего
источник
2

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)
Брэд Гилберт b2gills
источник
2

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
провисает
источник
2

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 с ответом, использующим двоичные кодировки.
провисает
источник
1

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
Sherlock9
источник
Это неверно на входе 843«восемьсот сорок три», что должно быть an.
Исаак
@isaacg Вы не только правы, но и значительно упрощаете мой код. Спасибо! Оказывается, я смотрел только на восемь, восемь тысяч, восемь миллионов, игнорируя такие случаи, как восемьдесят восемьсот.
Sherlock9
Почему (-~len(n)%3)<1вместо len(n)%3==2?
Тимви
Может (n[:2]=="11"or n[:2]=="18")быть сокращено до "118".contains(n[:2])?
Тимви
Или даже n[:2]in"118"?
Тимви
1

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"
Кевин Круйссен
источник
1

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
фонтанчик для питья
источник
Вы можете заменить 1e3наA³
Оливер
1

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
Тоби Спейт
источник
0

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
Дом Гастингс
источник
0

Python 2.7, 66

s=`input()`
print['a','an'][s[:1]=='8'or s[:2]in len(s)%3/2*'118']

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

janrn
источник
0

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"
Кевин Круйссен
источник
0

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"

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

рекурсивный
источник
0

Пробел , 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
Кевин Круйссен
источник
0

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
Тоби Спейт
источник
Я не слишком хорошо знаю C ++, но может i/=1000быть i/=1e3, и все могут &&стать &?
Кевин Круйссен
Это действительно работает: попробуйте онлайн.
Кевин Круйссен
1
@Kevin - у меня однажды был 1e3; Я изменил его во время отладки и забыл изменить его обратно. Не &&может быть все &, потому что вычитание дает целые числа, а не логические значения - например 19-11, 8 и 19-181; видите, что 8 && 1это правда, но 8 & 1это ложь. Мы могли бы использовать , &но мы должны были бы изменить , -чтобы !=и добавить скобки.
Тоби Спейт
Ах, конечно .. &действительно не работает здесь, мой плохой. Кстати, почему бы вам не добавить TIO-ссылку в ответ?
Кевин Круйссен
-1

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 байтов путем удаления паренов и использования значений по умолчанию.
ASCIIThenANSI
источник
$_=<>;$_=(/^8/)||/^1[18]/&&length($_)%3==1?'an':'a';sayсохраняет несколько байтов. (Хотя число, которое нужно сравнить с ним, зависит от того, какой у вас символ новой строки, но это не меняет счетчик байтов.)
msh210
@ msh210 Похоже, что это всего 55 байтов, то есть это экономит 16 байтов. Я добавлю это. Спасибо!
ASCIIThenANSI
Пожалуйста. О, и вы можете бросить первые парены (я полагаю. Я не проверял). Я думаю , вы могли бы также изменить length($_)к length(или , по крайней мере , падение скобки) , но это не работает для меня по какой - то причине.
msh210
@ msh210 Да, вы можете бросить парены и ($_)получить $_=<>;$_=/^8/||/^1[18]/&&length%3==1?'an':'a';say, что составляет всего 49 байтов.
ASCIIThenANSI
Вы можете сохранить несколько байт, используя -pвместо $_=<>и say, y///cвместо того length, и опуская кавычки aи an: perl -pe'$_=/^8/||/^1[18]/&&y///c%3==2?an:a'(34 байт + 1 для -p). Обратите внимание , что вход не может заканчиваться символом новой строки: echo -n 11 | perl -pe'...'. Это также исправляет ошибку: length%3==2анализируется как length(%3)==2, а не как length($_)%3==2, поэтому всегда возвращает false.
ThisSuitIsBlackNot
-1

Пиф, 29 31

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

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

лось
источник
5
Это неправильно на входе 111- это даетan
isaacg
Вы правы. Исправлена.
Лось