Сегодняшняя задача проста: не принимая никакой информации, выведите любую действующую доску судоку.

Если вы не знакомы с судоку, Википедия описывает, как должна выглядеть действующая доска :

Цель состоит в том, чтобы заполнить сетку 9 × 9 цифрами, чтобы каждый столбец, каждая строка и каждая из девяти подсеток 3 × 3, составляющих сетку (также называемые «ящиками», «блоками» или «регионами»), содержали все цифры от 1 до 9.

Теперь вот в чем дело ... Существует 6 670 903 752 021 072 936 960 различных действующих карт судоку . Некоторые из них могут быть очень сложными для сжатия и вывода в меньшем количестве байтов. Другие из них могут быть проще. Часть этой задачи состоит в том, чтобы выяснить, какие платы будут наиболее сжимаемыми и могут быть выведены с наименьшим количеством байтов.

Ваша заявка не обязательно должна каждый раз выводить одну и ту же доску. Но если возможно несколько выходов, вам нужно будет доказать, что каждый возможный выход является допустимой платой.

Вы можете использовать этот скрипт (спасибо Magic Octopus Urn) или любой из этих ответов, чтобы проверить, является ли конкретная сетка допустимым решением. Он выведет a [1]для действительной доски и что-нибудь еще для неверной доски.

Я не слишком разборчив в том, в каком формате вы выводите свой ответ, если он явно двухмерный. Например, вы можете вывести матрицу 9x9, девять матриц 3x3, строку, массив строк, массив из 9-значных целых чисел или девять 9-значных чисел с разделителем. Вывод 81 цифры в одном измерении не допускается. Если вы хотите узнать о конкретном формате вывода, не стесняйтесь спрашивать меня в комментариях.

Как обычно, это код-гольф , поэтому напишите кратчайший ответ, который вы можете придумать на выбранном вами языке!

Pyth, 22 14 12 10 байт

.<LS9%D3 9

Сохранено 2 байта благодаря г-ну Xcoder.

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

.<LS9%D3 9
     %D3 9     Order the range [0, ..., 8] mod 3.
  >            For each, ...
.< S9          ... Rotate the list [1, ..., 9] that many times.

Python 2 , 47 байт

l=range(1,10)
for x in l:print(l*9)[x*8/3:][:9]

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

T-SQL, 96- 89 байт

Нашел один короче, чем тривиальный вывод!

SELECT SUBSTRING('12345678912345678',0+value,9)FROM STRING_SPLIT('1,4,7,2,5,8,3,6,9',',')

Извлекает 9-символьные строки, начиная с разных точек, как определено в таблице в памяти, созданной STRING_SPLIT(которая поддерживается в SQL 2016 и более поздних версиях). Это 0+valueбыл самый короткий способ, которым я мог сделать неявное приведение к целому числу.

Исходный тривиальный вывод (96 байт):

PRINT'726493815
315728946
489651237
852147693
673985124
941362758
194836572
567214389
238579461'

Желе , 7 байт

9Rṙ%3$Þ

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

И немного этого ...
-1 благодаря Джонатану Аллану (думает?)

Python 2 , 53 байта

r=range(9)
for i in r:print[1+(j*10/3+i)%9for j in r]

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

Альтернативы:

Python 2 , 53 байта

i=0;exec"print[1+(i/3+j)%9for j in range(9)];i-=8;"*9

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

Python 2 , 54 байта

for i in range(81):print(i/9*10/3+i)%9+1,'\n'*(i%9>7),

i=0;exec"print[1+(i/3+j)%9for j in range(9)];i+=10;"*9

r=range(9);print[[1+(i*10/3+j)%9for j in r]for i in r]

Python 3 , 58 55 байт

l=*range(10),
for i in b"	":print(l[i:]+l[1:i])

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

• -3 байта благодаря Джо Кингу,

Элементы байтовой строки в итоге дают числа, [1, 4, 7, 2, 5, 8, 3, 6, 9]которые используются для перестановки вращений [0..9]. Объект 0удален, l[1:i]и нет необходимости в нулевом байте, для которого требуется два символа ( \0) для представления в байтовом объекте.

55 байт

_,*l=range(10)
for i in b"	":print(l[i:]+l[:i])

Желе , 9 8 байт

9Rṙ`s3ZẎ

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

9Rṙ`s3ZẎ
9R         Range(9) -> [1,2,3,4,5,6,7,8,9]
   `       Use the same argument twice for the dyad:
  ṙ        Rotate [1..9] each of [1..9] times.
           This gives all cyclic rotations of the list [1..9]
    s3     Split into three lists.
      Z    Zip. This puts the first row of each list of three in it's own list, 
           as well as the the second and third.
       Ẏ   Dump into a single list of nine arrays.

Пакетная, 84 байта

@set s=123456789
@for %%a in (0 3 6 1 4 7 2 5 8)do @call echo %%s:~%%a%%%%s:~,%%a%%

Использует вывод @ Mnemonic. callиспользуется для интерполяции переменной в операцию среза (обычно она принимает только числовые константы).

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

Вывести в виде массива строк.

_=>[...w="147258369"].map(x=>(w+w).substr(x,9))

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

Создает это:

472583691
583691472
691472583
725836914
836914725
914725836
258369147
369147258
147258369

Perl 6 , 40 32 27 байт

-5 байт благодаря nwellnhof

{[^9+1].rotate($+=3.3)xx 9}

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

Блок анонимного кода, который возвращает матрицу 9x9. Сопоставляет каждую строку с различным вращением в диапазоне от 1 до 9.

J , 18 байт

>:(,&|:|."{,)i.3 3

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

Выход

1 2 3 4 5 6 7 8 9
4 5 6 7 8 9 1 2 3
7 8 9 1 2 3 4 5 6
2 3 4 5 6 7 8 9 1
5 6 7 8 9 1 2 3 4
8 9 1 2 3 4 5 6 7
3 4 5 6 7 8 9 1 2
6 7 8 9 1 2 3 4 5
9 1 2 3 4 5 6 7 8

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

>:(,&|:|."{,)i.3 3
             i.3 3  The 2D array X = [0 1 2;3 4 5;6 7 8]
   ,&|:|."{,        3-verb train:
   ,&|:               Transpose and flatten X to get Y = [0 3 6 1 4 7 2 5 8]
           ,          Flatten X to get Z = [0 1 2 3 4 5 6 7 8]
       |."{           Get 2D array whose rows are Z rotated Y times
>:                  Increment

Необычная версия, 23 байта

|.&(>:i.3 3)&.>|:{;~i.3

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

Выход:

┌─────┬─────┬─────┐
│1 2 3│4 5 6│7 8 9│
│4 5 6│7 8 9│1 2 3│
│7 8 9│1 2 3│4 5 6│
├─────┼─────┼─────┤
│2 3 1│5 6 4│8 9 7│
│5 6 4│8 9 7│2 3 1│
│8 9 7│2 3 1│5 6 4│
├─────┼─────┼─────┤
│3 1 2│6 4 5│9 7 8│
│6 4 5│9 7 8│3 1 2│
│9 7 8│3 1 2│6 4 5│
└─────┴─────┴─────┘

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

|.&(>:i.3 3)&.>|:{;~i.3
                    i.3  Array [0 1 2]
                 {;~     Get 2D array of boxed pairs (0 0) to (2 2)
               |:        Transpose
|.&(>:i.3 3)&.>          Change each pair to a Sudoku box:
            &.>            Unbox
    >:i.3 3                2D array X = [1 2 3;4 5 6;7 8 9]
|.&                        Rotate this 2D array over both axes
                             e.g. 1 2|.X gives [6 4 5;9 7 8;3 1 2]
            &.>            Box again so the result looks like the above

05AB1E , 14 12 байт

8ÝΣ3%}ε9Ls._

-2 байт путем создания порта @Mnemonic Pyth ответа «s .

Попробуйте онлайн. (Нижний колонтитул добавлен в pretty-print it. Фактический результат - матрица 9x9; не стесняйтесь снимать нижний колонтитул, чтобы увидеть.)

Объяснение:

8Ý              # List in the range [0, 8]
  Σ  }          # Sort the integers `i` by
   3%           #  `i` modulo-3
      ε         # Map each value to:
       9L       #  List in the range [1, 9]
         s._    #  Rotated towards the left the value amount of times

Оригинальное 14- байтовое решение:

9Lε9LN3*N3÷+._

Попробуйте онлайн. (Нижний колонтитул добавлен в pretty-print it. Фактический результат - матрица 9x9; не стесняйтесь снимать нижний колонтитул, чтобы увидеть.)

Объяснение:

9L                # Create a list of size 9
  ε               # Change each value to:
   9L             #  Create a list in the range [1, 9]
     N3*N3÷+      #  Calculate N*3 + N//3 (where N is the 0-indexed index,
                  #                        and // is integer-division)
            ._    #  Rotate that many times towards the left

Оба ответа приводят к судоку:

123456789
456789123
789123456
234567891
567891234
891234567
345678912
678912345
912345678

Octave & Matlab, 50 48 29 байт

mod((1:9)+['furRaghAt']',9)+1

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

-2 благодаря Джонатону Фреху

-14 благодаря предложению Sanchises Broadcast, которое также указало на несовместимость.

-5, заметив, что вектор может быть записан в Matlab с символьной строкой и транспонированием.

Был интуитивно понятен, теперь не так. Использует широковещательное суммирование для распределения 1: 9 по 9 строкам, распределенных по значениям, определенным символьной строкой

Судоку доски производят:

 5 6 7 8 9 1 2 3 4
 2 3 4 5 6 7 8 9 1
 8 9 1 2 3 4 5 6 7
 3 4 5 6 7 8 9 1 2
 9 1 2 3 4 5 6 7 8
 6 7 8 9 1 2 3 4 5
 7 8 9 1 2 3 4 5 6
 4 5 6 7 8 9 1 2 3
 1 2 3 4 5 6 7 8 9

Haskell , 41 байт

[[x..9]++[1..x-1]|x<-[1,4,7,2,5,8,3,6,9]]

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

Java 10, 82 75 байт

v->{for(int i=81;i-->0;)System.out.print((i/9*10/3+i)%9+1+(i%9<1?" ":""));}

-7 байт, создав порт одного из ответов @TFeld 's Python 2 .

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

Объяснение:

v->{                    // Method with empty unused parameter and no return-type
  for(int i=81;i-->0;)  //  Loop `i` in the range (81, 0]
    System.out.print(   //   Print:
     (i/9               //    (`i` integer-divided by 9,
         *10            //     then multiplied by 10,
         /3             //     then integer-divided by 3,
           +i)          //     and then we add `i`)
             %9         //    Then take modulo-9 on the sum of that above
               +1       //    And finally add 1
    +(i%9<1?            //    Then if `i` modulo-9 is 0:
            " "         //     Append a space delimiter
           :            //    Else:
            ""));}      //     Append nothing more

Выводит следующую судоку (разделенную пробелами вместо новых строк, как показано ниже):

876543219
543219876
219876543
765432198
432198765
198765432
654321987
321987654
987654321

Python - 81 байт

l=list(range(1,10))
for i in range(1,10):print(l);l=l[3+(i%3==0):]+l[:3+(i%3==0)]

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

Мне нравится иметь 81 байт, но после некоторой оптимизации :(

Python 2 - 75 68 59 58 байт

-7 байт благодаря @DLosc

-9 байт благодаря @Mnemonic

-1 байт благодаря @JoKing

l=range(1,10)
for i in l:print l;j=i%3<1;l=l[3+j:]+l[:3+j]

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

Рубин , 34 байта

(a=*1..9).map{|x|p a.rotate x*3.3}

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

R , 54 байта

x=1:9;for(y in(x*3)%%10)print(c(x[-(1:y)],x[(1:y)]))

Выход:

[1] 4 5 6 7 8 9 1 2 3
[1] 7 8 9 1 2 3 4 5 6
[1] 1 2 3 4 5 6 7 8 9
[1] 3 4 5 6 7 8 9 1 2
[1] 6 7 8 9 1 2 3 4 5
[1] 9 1 2 3 4 5 6 7 8
[1] 2 3 4 5 6 7 8 9 1
[1] 5 6 7 8 9 1 2 3 4
[1] 8 9 1 2 3 4 5 6 7

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

Огромное спасибо @Shaggy!

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

t=>[...s='123456789'].map(e=>s.slice(t=e*3.3%9)+s.slice(0,t))

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

MathGolf , 16 11 байт

9{9╒♂ï*3/Ä╫

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

Сохранено 5 байтов благодаря JoKing

Холст , 13 11 байтов

◂ｊ３［«３［Ｔ３［«

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

C (лязг) , 65 байтов

f(i){for(i=0;i<81;)printf("%d%c",(i/9*10/3+i)%9+1,i++%9>7?10:9);}

Функция теперь может быть повторно использована

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

К (нгн / к) , 16 байт

1+9!(<9#!3)+\:!9

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

Первый ответ в ngn / k, сделанный с большой помощью самого человека, @ngn.

Как:

1+9!(<9#!3)+\:!9 // Anonymous fn
              !9 // Range [0..8]
    (     )+\:   // Sum (+) that range with each left (\:) argument
        !3       // Range [0..2]
      9#         // Reshaped (#) to 9 elements: (0 1 2 0 1 2 0 1 2)
     <           // Grade up
  9!             // Modulo 9
1+               // plus 1

Japt, 11 10 байт

9õ ñu3
£éX

Попробуйте или проверьте вывод

объяснение

9õ         :Range [1,9]
   ñ       :Sort by
    u3     :  Mod 3 of each
\n         :Assign to variable U
£          :Map each X
 éX        :  U rotated right by X

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

Ｅ⁹⭆⁹⊕﹪⁺÷×χι³λ⁹

Попробуйте онлайн! Ссылка на подробную версию кода. Использует вывод @ Mnemonic. Объяснение:

Ｅ⁹              Map over 9 rows
  ⭆⁹            Map over 9 columns and join
          ι     Current row
         χ      Predefined variable 10
        ×       Multiply
       ÷   ³    Integer divide by 3
            λ   Current column
      ⁺         Add
     ﹪       ⁹  Modulo 9
    ⊕           Increment
                Implicitly print each row on its own line