Перечислите все возможные названия игр Anno

37

В серии видеоигр Anno есть 6 игр, 7 из которых объявлены в начале 2019 года. Их названия всегда содержат год по определенной схеме:

Anno 1602, Anno 1503, Anno 1701, Anno 1404, Anno 2070, Anno 2205, Anno 1800

  • Цифровая сумма всегда 9.
  • Годы четырехзначные.
  • Они содержат как минимум один ноль.

В рамках этих ограничений существует 109 возможных названий:

[1008,1017,1026,1035,1044,1053,1062,1071,1080,1107,1170,1206,1260,1305,1350,1404,1440,1503,1530,1602,1620,1701,1710,1800,2007,2016,2025,2034,2043,2052,2061,2070,2106,2160,2205,2250,2304,2340,2403,2430,2502,2520,2601,2610,2700,3006,3015,3024,3033,3042,3051,3060,3105,3150,3204,3240,3303,3330,3402,3420,3501,3510,3600,4005,4014,4023,4032,4041,4050,4104,4140,4203,4230,4302,4320,4401,4410,4500,5004,5013,5022,5031,5040,5103,5130,5202,5220,5301,5310,5400,6003,6012,6021,6030,6102,6120,6201,6210,6300,7002,7011,7020,7101,7110,7200,8001,8010,8100,9000]

Ваша цель - перечислить их все в любой разумной форме с наименьшим количеством байтов.

code-golf  number  kolmogorov-complexity 
— Laikoni
источник
Насколько гибок формат вывода? Является ли это приемлемо?
— Луис Мендо
1
@ LuisMendo Да, со мной все в порядке.
— Лайкони
Разрешены ли списки цифр ?
— Эрик Outgolfer
1
@aslum Полагаю, вы имеете в виду много пробелов, а не только один, верно? Уценка комментария не позволяет получить хорошее представление об этом. И я предположил бы, что это разрешено, учитывая, что формат Луиса выше разрешен. ;-)
— Эрик Outgolfer
1
@EriktheOutgolfer Я бы сказал «нет» спискам цифр, потому что они больше не похожи на годы.
— Лайкони

Ответы:

20

R , 59 51 байт

Выводит действительные числа в качестве названий списка 201-х годов. Почему 201? Потому что ASCII 0 это 48, а 4 * 48 + 9 это ... да. Сохраненные 6 байт от наложения спектров , ^чтобы Mapи еще 2, используя в 1:9e3качестве диапазона.

"^"=Map;x=sum^utf8ToInt^grep(0,1:9e3,,,T);x[x==201]

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

объяснение

# Create list of sums of ASCII char values of numbers,
# with the original numbers as the names of the list
x <- Map(sum,
  # Create a list from the strings where each element is the string split 
  # into ASCII char values
  Map(utf8ToInt,
      # Find all numbers between 1 and 9e3 that contain a zero
      # Return the matched values as a vector of strings (6th T arg)
      grep(pattern=0,x=1:9000,value=TRUE)
  )
)
# Pick out elements with value 201 (i.e. 4-digits that sum to 9)
# This implicitly only picks out elements with 4 digits, since 3-digit 
# sums to 9 won't have this ASCII sum, letting us use the 1:9e3 range
x[x==201]
— j.doe
источник
3
ах, grepпочему я никогда не вспоминаю, что это приводит к character...
— Джузеппе
9

Желе , 11 байт

9ȷṢ€æ.ẹ9ṫ19

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

Как это работает

9ȷṢ€æ.ẹ9ṫ19  Main link. No arguments.

9ȷ           Set the left argument and the return value to 9000.
  Ṣ€         Sort the digits of each integer in [1, ..., 9000].
    æ.       Perform the dot product of each digit list and the left argument,
             which gets promoted from 9000 to [9000].
             Overflowing digits get summed without multiplying, so we essentially
             map the digit list [a, b, c, d] to (9000a + b + c + d).
      ẹ9     Find all 1-based indices of 9.
             Note that 9000a + b + c + d == 9 iff a == 0 and b + c + d == 9.
        ṫ19  Tail 19; discard the first 18 indices.
— Деннис
источник
7

PowerShell , 50 49 байт

999..1e4-match0|?{([char[]]"$_"-join'+'|iex)-eq9}

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

Создает диапазон от 999до 10000, затем использует встроенный -matchв качестве фильтра для извлечения тех записей, с которыми совпадают регулярные выражения 0. Это оставляет нас с 1000, 1001, 1002, etc.Мы затем Where-Objectпередаем это в предложение, где мы берем текущее число в виде строки "$_", charприводим его как -array, -joinэти символы вместе с +и Invoke- Expression (аналогично eval), чтобы получить их сумму в цифрах . Мы проверяем, является ли это -eqUAL 9, и если это так, он передается по конвейеру. По завершении программы эти числа извлекаются из конвейера и неявно выводятся.

— AdmBorkBork
источник
5

JavaScript (ES6), 78 73 байта

Сохранено 2 байта благодаря @KevinCruijssen

Возвращает разделенную пробелами строку.

f=(n=9e3)=>n>999?f(n-9)+(eval([...n+''].join`+`)&/0/.test(n)?n+' ':''):''

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

Как?

Мы выполняем итерацию в диапазоне [1008..9000] с шагом 9 , игнорируя числа без 0 .

Все эти числа кратны 9 , поэтому сумма их цифр также будет кратна 9 .

0918

Отсюда и тест:

(eval([...n + ''].join`+`) & /0/.test(n)
— Arnauld
источник
Вы можете сохранить байты , изменяющие 1008к 999, так как она не содержит 0 в любом случае, и 999+9 = 1008.
— Кевин Круйссен
Или даже 2 байта, изменив его на f=(n=9e3)=>n<1e3?'':(eval([...n+''].join`+`)<10&/0/.test(n)?[n,,]:'')+f(n-9)(хотя и содержит конечную запятую, хотя f=(n=9e3)=>n<1e3?'':(eval([...n+''].join`+`)<10&/0/.test(n)?n+' ':'')+f(n-9)с разделителем пробела, включая конечный пробел, может выглядеть красивее)
— Кевин Круйссен
@KevinCruijssen Спасибо! Я на самом деле пытаюсь обновить это некоторое время, но у меня есть пропускная способность интернета 500B / s, где я нахожусь сегодня вечером. : /
— Арнаулд
Мне знакомо это чувство ... В последнее время наш интернет дома по какой-то причине дерьмовый. Не может загрузить что-либо более 10 МБ, и иногда приходится несколько раз обновлять видео или страницы с 10+ изображениями, прежде чем он полностью загрузится .. Действительно раздражает когда я работаю из дома по понедельникам / вторникам ..>.> Завтра кто-то приходит, чтобы починить его (и я не
— оставлю
5

JavaScript (Node.js) , 89 байт

[...Array(9e3)].map(_=>i++,i=1e3).filter(a=>(s=[...a+""]).sort()[0]<1&eval(s.join`+`)==9)

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

  • -4 байта благодаря @ETHproductions

JavaScript (Node.js), 129 127 126 124 115 114 111 110 105 97 93 92 90 байт

[...Array(9e3)].map(f=(_,i)=>eval(s=[...(i+=1e3)+""].sort().join`+`)-9|s[0]?0:i).filter(f)

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

объяснение

[...Array(9e3)].map(f=(_,i)=>eval(s=[...(i+=1e3)+""].sort().join`+`)-9|s[0]?0:i).filter(f)
[...Array(9e3)].map(f=(_,i)=>                                                  )           // Create a 9000-length array and loop over it; store the loop body
                                    [...(i+=1e3)+""]                                       // Add 1000 to the index and split it into an array of characters (17 -> ["1", "0", "1", "7"])
                                                    .sort()                                // Sort the array of characters in ascending order by their code points ("0" will always be first) (["1", "0", "1", "7"] -> ["0", "1", "1", "7"])
                                  s=                       .join`+`                        // Join them together with "+" as the separator (["0", "1", "1", "7"] -> "0+0+2+9"); store the result
                             eval(                                 )-9                     // Evaluate and test if it's different than 9
                                                                       s[0]                // Take the first character of the string and implicitly test if it's different than "0"
                                                                      |    ?0              // If either of those tests succeeded, then the number doesn't meet challenge criteria - return a falsey value
                                                                             :i            // Otherwise, return the index
                                                                                .filter(f) // Filter out falsey values by reusing the loop body

Впервые занялся кодовым гольфом на JavaScript. Я не думаю, что мне нужно это говорить, но если я делаю что-то не так, пожалуйста, сообщите мне в комментариях ниже.

  • -3 байта благодаря @Luis felipe De jesus Munoz

  • -6 байт благодаря @Kevin Cruijssen

— Лев
источник
1
[...Array(9e3)]вместо этого Array(9e3).fill()экономит 2 байта
— Луис Фелипе Де Иисус Муньос
1
.map(a=>+a)вместо этого .map(Number)сохраняет еще один байт
— Луис Фелипе Де Иисус Муньос
1
Вы можете удалить пробел в, (_, i)чтобы сохранить байт, и s[0]+s[1]+s[2]+s[3]может быть, eval(s.join`+`)чтобы сохранить дополнительные 4 байта.
— Кевин Круйссен
1
Кроме того, я уверен, что это ||может быть |в вашем ответе.
— Кевин Круйссен
1
Если вы используете .map()только для генерации диапазона и не используете фильтрацию отдельно, вы можете сохранить 8 байтов: попробуйте онлайн!
— ETHproductions
5

Python 2 , 57 байт

n=999
exec"n+=9\nif'0'in`n`>int(`n`,11)%10>8:print n\n"*n

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

2 байта благодаря Денису

Использует execцикл для отсчета nс шагом 9 как 1008, 1017, ..., 9981, 9990, печатая те, которые удовлетворяют условию.

Только кратные 9 могут иметь сумму цифр 9, но кратные 9 в этом диапазоне также могут иметь сумму цифр 18 и 27. Мы исключаем их с условием int(`n`,11)%10>8. Интерпретируя nв базе 11, его сумма цифр равна числу по модулю 10, точно так же как в базе 10 число равно его сумме цифр по модулю 9. Сумма цифр (9, 18, 27) соответствует (9, 8, 7) по модулю 10, так что взяв эти >8работы, чтобы отфильтровать девятки.

Число, содержащее ноль, проверяется со строковым членством. '0'in`n`, Это условие соединяется с другим с цепочечным неравенством, при котором Python 2 обрабатывает строки как числа больше, чем числа.

— XNOR
источник
Мне нравится, как сильно в Python, как кажется, часто бывают чрезвычайно длинные
— автоматически сгенерированные
4

sed и grep (и seq), 72 64 63 байта

seq 9e3|sed s/\\B/+/g|bc|grep -wn 9|sed s/:9//|grep 0|grep ....
— Тор
источник
Некоторые из них не четырехзначные (но я не уверен, что это за финал grep, так что, может быть, я ошибаюсь?)
— Sparhawk
@Sparhawk: последний grep гарантирует, что число будет состоять из 4 цифр
— Thor
@ Тор, да. По какой-то причине я разобрал это как многоточие.
— Sparhawk
4

Haskell , 55 байтов

[i|i<-show<$>[1..5^6],201==sum(fromEnum<$>i),elem '0'i]

Спасибо @Laikoni, смотрите комментарии.

Удобочитаемый:

import Data.Char (digitToInt)

[i | i <- show <$> [1000..9999]
   , sum (digitToInt <$> i) == 9
   , '0' `elem` i
   ]
— MB21
источник
2
Добро пожаловать в PPCG и Haskell в гольф в частности! Вы можете сохранить несколько байтов, опустив (-48+)и сравнив сумму 201вместо 9. Между прочим, это также позволяет использовать 1вместо 1000диапазона.
— Лайкони
Также ваша предыдущая версия без main=printбыла хороша в соответствии с этим консенсусом по Meta .
— Лайкони
9999может быть 5^6вместо.
— Лайкони
1
Ха, всегда есть другой байт для бритья! Спасибо :-)
— MB21
3

R , 82 байта

write((x=t(expand.grid(1:9,0:9,0:9,0:9)))[,colSums(x)==9&!apply(x,2,all)],1,4,,"")

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

Создает матрицу xиз всех возможных четырехзначных чисел, исключая ведущие нули, идущие вниз по столбцам. Тогда фильтры для столбцовых (цифровых) сумм из 9 и содержащих ноль, т. Е. Не allравны нулю. writeпечатает вниз по столбцам, так что мы writeдо stdoutшириной 4и сепаратора "".

Outgolfed Дж. Доу

— Giuseppe
источник
Хороший ответ! Я придумал другой маршрут ...
— J.Doe
3

Japt , 20 18 байт.

-2 байта благодаря @Shaggy и @ETHproductions

A³òL² f_=ì)x ¥9«Z×

A³òL² f_=ì)x ¥9«Z×  Full program
A³òL²               Range [1000, 10000]
      f_            Filter by : 
        =ì)         Convert to array 
           x ¥9     Sum equal to 9?
               «    And 
                Z×  Product not 0

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

— Луис Фелипе Де Иисус Муньос
источник
Это на самом деле 28 байтов . Использование литерального целого числа вместо 22 байтов, но A³ò9000 f_ìx ¥9©ZsøTвозвращает вас обратно до 20.
— Shaggy
1
Вы можете сохранить 1 байт, используя ìвместо sи ¬, что должно быть сделано в фильтре: f_=ì)x ¥9.... Затем вы можете сохранить другой, проверив, равен ли продукт Z нулю с помощью «Z×: Попробуйте онлайн!
— ETHproductions
3

Java 8, 128 117 115 байт

v->{int i=109,r[]=new int[i],n=i;for(;i>0;n++)if((n+"").chars().sum()==201&(n+"").contains("0"))r[--i]=n;return r;}

-11 байт благодаря @nwellnhof .

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

Объяснение:

v->{                              // Method with empty unused parameter & int-array return
  int i=109,                      //  Index-integer, starting at 109
      r[]=new int[i],             //  Result-array of size 109
      n=i;                        //  Number integer, starting at 109
   for(;i>0;                      //  Loop as long as `i` is not 0 yet:
       n++)                       //    After every iteration, increase `n` by 1
     if((n+"").chars().sum()==201 //   If the sum of the unicode values of `n` is 201,
                                  //   this means there are four digits, with digit-sum = 9
        &(n+"").contains("0"))    //   and `n` contains a 0:
       r[--i                      //    Decrease `i` by 1 first
            ]=n;                  //    And put `n` in the array at index `i`
  return r;}                      //  Return the array as result
— Кевин Круйссен
источник
1
Как насчет chars().sum()==201?
— nwellnhof
@nwellnhof А, конечно. Благодарность!
— Кевин Круйссен
3

R 85 байт

(просто соревнуемся за лучшее злоупотребление R квадратными скобками ...: P)

`[`=`for`;i[a<-0:9,j[a,k[a,w[a,if(sum(s<-c(i,j,k,w))==9&any(!s)&i)write(s,1,s='')]]]]

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

— digEmAll
источник
1
Святой для петель, Бэтмен!
— BLT
3

05AB1E , 15 13 12 10 байт

₄4°ŸεW°ö9Q

-2 байта благодаря @Emigna
-3 байта благодаря @Grimy

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

Объяснение:

₄4°Ÿ        # Create a list in the range [1000,10000]
    ʒ       # Filter this list by:
     W      #  Get the smallest digit in the number (without popping the number itself)
      °     #  Take 10 to the power this digit
       ö    #  Convert the number from this base to an integer (in base-10)
        9Q  #  Check if it's equal to 9
  • d=0110d°ö
  • d=11010d°ö
  • d=210010d°ö023452030405
  • d=3100010d°ö0034563004005006
  • d=[4,9]d=2d=3d−10

>0[1000,10000]°ö[1111,9000000009000000009000000009]999Qd=0°ö9

— Кевин Круйссен
источник
1
₄4°Ÿʒ0å}ʒSO9Q, Расщепляющие фильтры обычно короче
— Emigna
@ Emigna Ах, я искал более короткий путь для диапазона, но полностью забыл о 4°. Спасибо. И вы действительно правы, что несколько незакрепленных фильтров (в конце) короче. Также добавлю это в один из моих советов. Спасибо за оба байта!
— Кевин Круйссен
1
И мой другой 13-байтовый (вдохновленный трюком ord sum == 201) есть 4°Lʒ0å}ʒÇOт·-. Оставив это здесь, возможно, кто-то может
— сыграть в
1
₄4°ŸʒD0åôO9Q, Использование одного фильтра обычно короче.
— Grimmy
1
Неважно, вот 10:₄4°ŸʒW°ö9Q
— Мрачный
2

Пип , 18 байт

{0Na&$+a=9}FIm,t*m

Используйте флаг формата -pвывода, например, чтобы получить читаемый вывод. Попробуйте онлайн!

{0Na&$+a=9}FIm,t*m
             m,t*m  Range from 1000 to 10*1000
{         }FI       Filter on this function:
 0Na                 There is at least one 0 in the argument
    &                and
     $+a             The sum of the argument
        =9           equals 9
— DLosc
источник
2

Wolfram Language (Mathematica) , 56 55 байт

Select[9!!~Range~9999,Tr@#==Times@@#+9&@*IntegerDigits]

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

Мы тестируем диапазон от 9! = От 945 до 9999, поскольку между 945 и 999 нет результатов. Возможно, есть более короткий способ также написать число от 9000 до 10007.

Tr@#==Times@@#+9&применяется к {a,b,c,d}тестам if a+b+c+d == a*b*c*d+9, что в конечном итоге эквивалентно условию Anno.

— Миша лавров
источник
Оглядываясь назад, 9 !! не короче 999 или около того, но бьет 1000.
— Миша Лавров
Что такое 9 !! ? В догадках это не связано с факториалами.
— Роберт Фрейзер
@RobertFraser Двойной факториал: 9*7*5*3*1.
— Миша Лавров
2

Рубин , 46 42 41 байт

?9.upto(?9*4){|x|x.sum==201&&x[?0]&&p(x)}

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

Как это работает:

  • Итерация по строкам от 9 до 9999
  • Убедитесь, что сумма значений ASCII равна 201
  • Проверьте, содержит ли строка ноль (без регулярного выражения регулярное выражение будет на 1 байт длиннее)

(Спасибо Лайкони за -2 байта)

— гигабайт
источник
1
9*3может быть просто 9, потому что проверка по 201 уже требует 4-значных чисел.
— Лайкони
2

Октава , 49 байт

6 байтов сохранены с использованием более удобного формата вывода, предложенного J.Doe .

Спасибо @Laikoni за исправление .

y=dec2base(x=1e3:9999,10)'-48;x(sum(y)==9>all(y))

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

— Луис Мендо
источник
Я ничего не знаю об Октаве, но похоже, что вы можете оставить disp...
— J.Doe
@ J.Doe OP подтвердил, что этот формат вывода является приемлемым. Спасибо за предложение!
— Луис Мендо
2

Дротик ,  103 100  96 байт

f()=>List.generate(9001,(i)=>'$i').where((i)=>i.contains('0')&&i.runes.fold(0,(p,e)=>p+e)==201);

  • -3 байта, устанавливая значение в массиве в строку, делая преобразование один раз, а не дважды
  • -4 байта с использованием рун вместо codeUnits

    • Довольно понятно. генерирует список из 9001 (0-9000) ячеек с индексом ячейки в качестве значения, фильтрует ячейки, содержащие 0, а затем ячейку с суммой ASCII, равной 201 (результат, если все символы ASCII суммируются до 9). Эти условия подразумевают, что год состоит из 4 цифр, потому что, используя 2 числа ASCII (и 0), вы не можете достичь 201.

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

    — Elcan
    источник
    Добро пожаловать в PPCG. :)
    — Лайкони
    1
    Благодарность !
    — Некоторое время скрывался
    2

    PHP, 69, 87 байт, 74 байта

    for($i=999;$i<9001;$i++){echo((array_sum(str_split($i))==9&strpos($i,"0")!=0)?$i:" ");} for($i=999;$i++<1e4;)echo!strpos($i,48)|array_sum(str_split($i))-9?" ":$i;

    Обратите внимание, что это ставит пробел для каждого «неудачного» числа, что приводит к некоторому фанки. Это можно изменить на разделение запятыми, но добавим еще 4 символа:?$i.",":""

    Стал больше, потому что я не проверял на 0. Сумасшедший. Сокращено на 13 от Тита!

    — aslum
    источник
    2
    Я действительно не знаю PHP, но этот код гарантирует, что каждый год содержит ноль?
    — Лайкони
    Этот код не проверяет на ноль в числе.
    — krzysiej
    1
    На 13 байт короче:for($i=999;$i++<1e4;)echo!strpos($i,48)|array_sum(str_split($i))-9?" ":$i;
    — Тит
    Вот еще один байт: ?"$i,":""э-э ... теперь наоборот:?"":"$i,"
    — Тит
    На самом деле @Titus, который добавляет пару байтов. Нам не нужны кавычки около $ i, если мы не включаем строку с ней.
    — Проспект
    2

    Scala ( 76 63 61 56 байт)

    for(n<-0 to 9000;t=n+""if t.sum==201&t.min<49)println(t)

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

    • Спасибо Лайкони за предложения
    • Еще два байта сбрасываются после применения комментария Джо Кинга
    — jrook
    источник
    1
    Добро пожаловать в PPCG! У вас есть идея, что нужно добавить в раздел верхнего или нижнего колонтитула, чтобы этот код работал на TIO? Попробуйте онлайн!
    — Лайкони
    @Laikoni, не знал, что смогу запустить Scala в TIO. Починил это. Спасибо за комментарий.
    — Джрук
    1
    Похоже t.sum==201работает вместо t.map(_.asDigit).sum==9.
    — Лайкони
    Вы можете найти наши советы по игре в гольф в Скала интересными. Например, это s"$n"может быть n+""и s"$t "может быть t+" ".
    — Лайкони
    1
    Поскольку вы используете сумму 201 трюк, диапазон не должен начинаться с 999
    — Джо Кинг,
    1

    Japt, 16 байт

    Возвращает массив массивов цифр.

    L²õì l4 k_ת9aZx

    Попробуй это

    объяснение

    L                    :100
 ²                   :Squared
  õ                  :Range [1,L²]
   ì                 :Convert each to a digit array
     l4              :Filter elements of length 4
        k_           :Remove each Z that returns truthy (not 0)
          ×          :  When reduced by multiplication
           ª         :  OR
              Zx     :  When reduced by addition
            9a       :   And subtracted from 9
    — мохнатый
    источник
    1
    ОП постановил, что массивы цифр, к сожалению, недопустимы: o (
    — Sok
    1

    APL (NARS), 45 символов, 90 байтов

    f←{⍵×⍳(0∊x)∧9=+/x←⍎¨⍕⍵}⋄f¨1e3..5e3⋄f¨5e3..9e3

    протестируйте после некоторого форматирования:

    1008  1017  1026  1035  1044  1053  1062  1071  1080  1107  1170  1206  1260  
  1305  1350  1404  1440  1503  1530  1602  1620  1701  1710  1800  2007  2016  
  2025  2034  2043  2052  2061  2070  2106  2160  2205  2250  2304  2340  
  2403  2430  2502  2520  2601  2610  2700  3006  3015  3024  3033  3042  3051  
  3060  3105  3150  3204  3240  3303  3330  3402  3420  3501  3510  3600  
  4005  4014  4023  4032  4041  4050  4104  4140  4203  4230  4302  4320  4401  
  4410  4500 
5004  5013  5022  5031  5040  5103  5130  5202  5220  5301  5310  5400  6003  
  6012  6021  6030  6102  6120  6201  6210  6300  7002  7011  7020  7101  7110  
  7200  8001  8010  8100  9000

    возможная альтернатива

    r←f;i;x
   r←⍬⋄i←1e3⋄→B
A: r←r,i
B: i+←1⋄→A×⍳(0∊x)∧9=+/x←⍎¨⍕i⋄→B×⍳i≤9e3
    — RosLuP
    источник
    1

    Желе , 13 байт

    ȷ4µṢÄm3Ḍ)ẹ9ṫ4

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

    Как?

    ȷ4µṢÄm3Ḍ)ẹ9ṫ4 - Link: no arguments
ȷ4            - literal 10^4 = 10000
  µ     )     - for each in range (1,2,3,...,10000): e.g. 3042       or  5211
   Ṣ          -   sort (given an integer makes digits)    [0,2,3,4]      [1,1,2,5]
    Ä         -   cumulative addition                     [0,2,5,9]      [1,2,4,9]
     m3       -   modulo 3 slice (1st,4th,7th...)         [0,9]          [1,9]
       Ḍ      -   convert from decimal digits             9              19
         ẹ9   - 1-based indices equal to nine             [9,99,999,1008,1017,...,8100,9000]
           ṫ4 - tail from the 4th index                   [1008,1017,...,8100,9000]
    — Джонатан Аллан
    источник
    Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
    Licensed under cc by-sa 3.0 with attribution required.