Блок цифр

18

Выведите / распечатайте этот блок текста:

1234567890
2468013579
3691470258
4815926037
5049382716
6172839405
7306295184
8520741963
9753108642
0987654321

Приемлемые форматы включают в себя:

  • Конечные символы новой строки / пробелы
  • Список строк
  • Список списков персонажей
  • Список списков целых чисел

Однако список целых чисел недопустим, поскольку последняя строка не является целым числом.

Это код-гольф . Кратчайший ответ в байтах побеждает. Применяются стандартные лазейки .

code-golf math kolmogorov-complexity Дрянная Монахиня
источник

Ответы:

20

Mathematica, 33 байта

Mod[1##,11]~Mod~10&~Array~{10,10}

Попробуйте онлайн! (Используя математику.)

Ячейка с индексом на основе 1 (x,y)имеет значение((x*y) % 11) % 10

Мартин Эндер
источник
11

Python 2 , 48 46 байт

n=10
while n:print('00987654321'*n)[n::n];n-=1

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

mdahmoune
источник
6
Добро пожаловать в PPCG и потрясающий первый ответ! Мы надеемся, что вы
остаетесь и вносите
@ETHproductions спасибо :)))
mdahmoune
5

МАТЛ , 12 11 байт

Сохранил байт благодаря Луису. Я постоянно забываю, что &это ярлык для дублирования и транспонирования.

10:&*11\10\

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

Используя алгоритм @ Martin: x*y % 11 % 10

Объяснение:

10            % Pust 10 to the stack. Stack: 1
  :           % 1-based range. Stack: [1 2 3 ... 10]
   &          % Duplicate range. Stack: [1 2 3 ... 10],[1 2 3 ... 10]
              % Transpose last range. Stack [1 2 3 ... 10],[1;2;3 ...10]
    *         % Multiply with broadcasting. Stack: [1 2 3 ...;2 4 6...] (10-by-10 array)
     11       % Push 11 to the stack. Stack [1 2 3 ...;2 4 6 ...], 11
       \      % Modulus. 
        10    % Push 10 to the stack.
          \   % Modulus
              % Implicit display

Тот же счет:

10t:&*11\w\
Стьюи Гриффин
источник
Вы можете сохранить замену байта t!*на&*
Луис Мендо
1
@LuisMendo двойные обратные косые черты, если у вас есть обратная косая черта в конце фрагмента кода в комментариях.
Мартин Эндер
@MartinEnder Спасибо! Я никогда не помню, как это работает, поэтому я пошел простым путем :-)
Луис Мендо
@ LuisMendo да, это немного запутанно с сообщениями и комментариями, использующими другой синтаксис.
Мартин Эндер
Спасибо @LuisMendo! Это не в документах, не так ли?
Стьюи Гриффин
2

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

Число байтов предполагает кодировку ISO 8859-1.


10$*
1
,1$`
,1+
$_¶
(?<=(¶?.+)+)1
$#1$*
1{10}1?

,(1*)
$.1

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

объяснение

Еще одна реализация алгоритма ...% 11% 10 . Забавная часть работы с регулярным выражением состоит в том, что мы можем позаботиться об обоих вычислениях по модулю одновременно.


10$*

Инициализируйте строку до десяти 1с.

1
,1$`

Замените каждый из них запятой, единицей и префиксом перед ним. Это дает ,1,11,...,1111111111, то есть одинарный диапазон.

,1+
$_¶

Теперь замените каждый из элементов диапазона всей строкой, за которой следует перевод строки. Это дает нам сетку унарных чисел 10х10, обозначающую текущий столбец.

(?<=(¶?.+)+)1
$#1$*

Сопоставьте каждый 1и определите, в каком ряду он находится, повторяя одно и то же число раз. Замените на 1то, что много 1с. Это умножает значения в каждой строке на 1-й индекс строки.

1{10}1?

Теперь давайте сделаем мод 11, мод 10 за один шаг. Чтобы сделать мод 11 , мы обычно просто удаляем все 1{11}из строки, оставленной с остатками. А потом мы удалим 1{10}после этого. Но если мы просто удалим десять 1с плюс другое, если это возможно, жадность движка регулярных выражений будет делать для нас мод 11 как можно дольше, а если нет, то он попробует хотя бы мод 10 .

,(1*)
$.1

Наконец, мы просто конвертируем каждое число в десятичное, заменяя его длиной.

Мартин Эндер
источник
2

05AB1E , 14 байтов

11GTLN*11%T%})

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

Использует алгоритм Мартина, как обычно.

Эрик Outgolfer
источник
О, есть алгоритм для этого шаблона. Это объясняет, почему я на 30 байт выше среднего ответа.
Волшебная Урна Осьминога
2

Haskell, 43 байта

l=[1..10]
f=[[x*i`mod`11`mod`10|i<-l]|x<-l]
Сиракуза
источник
2

Javascript (ES6), 70 64 56 байт

_=>[...1e9+''].map((_,a,b)=>b.map((_,c)=>-~a*++c%1‌​1%10))

Сохранено 4 байта благодаря Shaggy и 8 байтов благодаря Arnauld.

Люк
источник
1
66 байт: _=>[...a=Array(10)].map((_,x)=>[...a].map((_,y)=>(x+1)*++y%11%10)). Вы экономите мне 4 байта, я
Shaggy
Большое спасибо. Вы также исправили ошибку, поэтому я побрил еще 2 байта вашего решения ;-)
Люк
1
Вы можете сохранить 5 байтов, используя третий параметр обратного вызова в первом map()и еще 3 байта, используя 1e9+''вместо Array(10). Это приводит к _=>[...1e9+''].map((_,x,a)=>a.map((_,y)=>-~x*++y%11%10)).
Arnauld
@Arnauld: Спасибо за 1e9трюк. Я этого не знал. Я действительно думал об использовании третьего аргумента, но по какой-то причине я не использовал его.
Люк
Я недавно составил список подобных трюков здесь .
Арно
2

Джапт , 16 12 11 байт

Оказывается, это был мой 200 (неотвеченный) ответ здесь :)

Похоже, это та же самая формула, которую заметил Мартин .

Aõ
£®*X%B%A

Протестируйте это ( -Rпометьте только для визуализации)

  • 4 байта сохранены благодаря тому, что Люк указал, что возвращение массива массивов допустимо.

объяснение

Aõ    :Generate an array of integers from 1 to 10, inclusive.
£     :Map over each element in the array, returning...
®     :Another map of the same array, which...
*X    :Multiplies the current element of the inner function by the current element of the outer function...
%B    :Modulus 11...
%A    :Modulus 10.
      :Implicit output of resulting 2D array
мохнатый
источник
Обыграй меня ... Вы можете бросить последние два символа и вместо этого использовать -Rфлаг
Лука
1
Еще лучше, бросьте последние четыре символа. Кажется, это разрешено ...
Люк
Да, похоже, ты прав, спасибо, @Luke :)
Лохматый
1

Java 8, 84 байта

o->{String r="";for(int x=0,y;++x<11;r+="\n")for(y=0;++y<11;r+=x*y%11%10);return r;}

Использует тот же алгоритм, что и ответ @MartinEnder 's Mathematica : 1-индексированный x*y%11%10.

Объяснение:

Попробуй это здесь.

o->{                     // Unused Object parameter and String return-type
  String r="";           //  Result-String
  for(int x=0,y;++x<11;  //  Loop (1) from 1 to 11 (exclusive)
      r+="\n")           //    And append a new-line after every iteration
    for(y=0;++y<11;      //   Inner loop (2) from 1 to 11 (exclusive)
      r+=x*y%11%10       //    And append the result-String with `x*y%11%10`
    );                   //   End of inner loop (2)
                         //  End of loop (1) (implicit / single-line body)
  return r;              //  Return result-String
}                        // End of method
Кевин Круйссен
источник
1

Python 2 , 58 52 байта

-6 байт благодаря offcialaimm.

Использует алгоритм Мартина, который я не понимаю, как он придумал его так быстро. о0

r=range(1,11)
print[[x*y%11%10for y in r]for x in r]

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

totallyhuman
источник
1
Сокращения r=range(1,11)сохраняют 6 байтов
officialaimm
2
Одной из причин, по которой я так быстро нашел формулу, является мой вопрос по математике и комментарии Орла .
Мартин Эндер
1

Pyth, 13 байт

mme%*kd11STST

Попробуй здесь

-1 спасибо КарлКастор .

Давай дууууууупе!

Эрик Outgolfer
источник
Сохраните один байт, если вы используете eвместо% T
KarlKastor
@KarlKastor ... и я помнил это ._.
Эрик Outgolfer
1

Древесный уголь , 30 29 19 байт

Ｆχ«ＦχＩ﹪﹪×⁺¹ι⁺¹κ¹¹χ⸿

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

Использует формулу Мартина .

  • Благодаря Нилу удалось сэкономить 10 байтов, еще раз доказав, что мне еще предстоит многому научиться ...
Чарли
источник
Вам не нужен трейлинг » s, и хотя вы можете использовать ωвместо этого, ””вы можете сохранить целую кучу байтов, используя, ⸿как это становится Ｆχ«ＦχＩ﹪﹪×⁺¹ι⁺¹κ¹¹χ⸿. (До того, как я узнал об этом, ⸿я бы предложил, Ｊ⁰ιчто бы сэкономило несколько байтов.)
Нил
@Neil Это ⸿обратный оператор, что он делает в конце вашего кода без аргументов? Это задокументировано?
Чарли
1
Нет, ⮌является оператором Reverse, ⸿является move cursor to start of next lineсимволом (как, но может быть в отдельной строке).
Нил
0

QBIC , 17 байт

[|?[|?a*b%11%z';

Это, конечно, использует метод Мартина. Это переводится как этот код QBasic .

объяснение

[|               FOR A = 1 to 10 ([ starts a FOR loop, | delimits the list of arguments; 
                 a FOR loop with 0 args loops from 1 to 10 by default with increment 1.
  ?              PRINT a newline
   [|            Start a second FOR loop from 1-10, iterator b
     ?           PRINT
      a*b%11%z   the result of Martin's formula.
              '; and suppress newlines/tabs/spaces
steenbergh
источник
0

C #, 81 байт

_=>{var r="";for(int x=0,y;++x<11;r+="\n")for(y=0;++y<11;r+=x*y%11%10);return r;}

Тот же алгоритм, что и у большинства других ответов, и, по сути, порт C # @Kevins Java-ответа.

TheLethalCoder
источник
0

GolfScript , 37 24 байта

10,{){\)*11%10%}+10,%}%`

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

-13 благодаря умному трюку, предложенному Мартином Эндером .

Эрик Outgolfer
источник
если вы превратите его в полную программу ( {-> ;, }-> `), вы можете по крайней мере отбросить первую [.
Мартин Эндер
Однако гораздо короче использовать простой вложенный цикл вместо техники zip:{){\)*11%10%}+10,/n}10,/
Мартин Эндер,
@MartinEnder Хмм ... кажется, ты злоупотребляешь /. ;)
Эрик Outgolfer
@MartinEnder О, я вижу, что ты сделал ... ты использовал int blk + -> {int space contents-of-blk}.
Эрик Outgolfer
@MartinEnder хорошо, я реализовал твой +трюк ... хотя я немного изменил твой код
Эрик Outgolfer
0

PHP , 54 байта

for(;9>=$y++||9>=$x+=$y=print"
";)echo($x+1)*$y%11%10;

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

PHP , 56 байт

for(;$x++<=9;print"
")for($y=0;$y++<=9;)echo$x*$y%11%10;

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

Йорг Хюльсерманн
источник
1
Вы можете бросить скобки ().
Кристоф
-2 байта:for(;<0>$y++||10>$x+=$y=print"\n";)echo($x+1)*$y%11%10;
Тит
... илиfor($x=1;11>++$y||11>$x+=$y=print"\n";)echo$x*$y%11%10;
Тит
0

TECO, 45 байт

1un@i/
/10<@i/01234567890/jl10<qnc0a^t>jtl%n>

(Довольно) прямолинейная реализация ответа Рода на Python.

1un           !initialize register n to 1!
@i/<nl>/      !insert a newline!
10<           !loop for 10 rows!
@i/01234567890/  !insert the mysterious string of digits!
j             !move point to start of buffer!
l             !move forward past the newline!
10<           !loop for 10 digits on a line!
qnc           !move point forward by n characters!
0a^t          !print the character at point!
>             !end inner loop!
j             !move point to start of buffer!
t             !print (empty) line!
l             !move to start of digit string!
%n            !increment register n (for next line)!
>             !end outer loop!

Использование вставок, определяемых <ESC>, и управляющего символа для команды ^ T спасло бы еще три пять байтов за счет читабельности.

Использование формулы Мартина mod-11 / mod-10 фактически увеличивает его на 43 байта, используя элементы управления для ^ A и ^ T, главным образом потому, что у TECO нет оператора мод.

0ur10<%run10<qn-10"g-11%n'qn\r0a^Tqr%n>^a
^A>

Мод 11 выполняется постоянно, увеличивая число в qn на -11 всякий раз, когда оно превышает 10. qn\r0a^T Последовательность вставляет число в буфере редактирования в виде десятичных цифр, переворачивает последнюю последнюю цифру, извлекает ее из буфера и печатает ее, по сути дела мод-10.

Я ожидал, что это будет короче. Ну что ж.

JoeT
источник