Вывести доску судоку

25

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

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

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

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

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

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

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

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

DJMcMayhem
источник
Можем ли мы вывести три матрицы 3х9? Каждая строка каждой подматрицы представляет строку на доске судоку. Как этого
dylnan
2
Связанный, но не дуп . Кроме того, если вы разрешаете гибкий вывод, я не уверен, что применяется колмогоровская сложность , поскольку это обычно для фиксированных выводов, таких как точные ascii art.
BradC

Ответы:

13

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.

источник
11: m.<S9d%D3 9.
г-н Xcoder
Крест , что из, 10: .<LS9%D3 9.
г-н Xcoder
Могли бы хотеть обновить ссылку ( TiO )
БРИКа
8

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'
BradC
источник
5

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])
dylnan
источник
55 байтов
Джо Кинг,
@JoKing Умный, спасибо
Дилнан
4

Желе , 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.
dylnan
источник
4

Пакетная, 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используется для интерполяции переменной в операцию среза (обычно она принимает только числовые константы).

Нил
источник
4

Perl 6 , 40 32 27 байт

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

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

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

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

Джо Кинг
источник
4

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
фонтанчик для питья
источник
4

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

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
Poptimist
источник
Здравствуйте и добро пожаловать в PPCG; хороший первый пост.
Джонатан Фрех
48 байтов .
Джонатан Фрех
Конечно, s можно определить в самой матрице. Должно быть, я неправильно подсчитал байты.
Поптимист
Теперь это Octave, больше не совместимый с MATLAB. Если хотите, вы можете использовать маленький значок цепочки в верхней части ссылки Джонатана, чтобы скопировать и вставить форматирование PPCG по умолчанию.
Санчиз
Если хотите, вы можете уменьшить это до 34 байтов с добавлением трансляции: попробуйте онлайн!
Санчиз
3

Haskell , 41 байт

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

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

Кертис Бехтель
источник
Это недействительно Каждый квадрат содержит несколько одинаковых номеров. Вместо этого вы можете сделать что-то вроде этого (43 байта)
Джо Кинг,
Благодарность! Я принял ваше предложение
Кертис Бектел
@RushabhMehta Я сделал. Это было 43 байта, но я удалил, s=так как это не нужно
Кертис Бехтел
3

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

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]

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

Дон Тысяча
источник
2
81 байт Идеальный результат! : D
DJMcMayhem
@DJMcMayhem Я подумывал об укорочении, r=range(1,10)но не смог испортить красоту
Дон Тысяча
68 байт ;)
DLosc
@DLosc Ох, умное повторное использованиеl
Дон Тысяча
Если вы не возражаете против Python 2, вы можете вынуть скобки из печати и удалить упаковку списка.
2

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

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

DobromirM
источник
1

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

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

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

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

Logern
источник
Вместо того, чтобы печатать байт NUL для разделения ваших цифр, вы можете использовать символ табуляции с тем же количеством байтов.
Джонатан Фрех,
«Ваше представление не обязательно должно выводить одну и ту же плату каждый раз. Но если возможно несколько выходов, вам нужно будет доказать, что каждый возможный вывод является действительной платой». Это не говорит о необходимости нескольких выходов. @ceilingcat
Logern
1
@Logern Правило, о котором идет речь, состоит в том, что представления функций должны быть многоразовыми . Хорошо, если она f(); f()выводит одну и ту же плату дважды, но не, если второй вызов не работает вообще.
Андерс Касеорг,
63 байта
Джо Кинг,
61 байт, включая предложения от @JoKingf(i){for(i=81;i--;)printf("%d%c",(i/9*10/3+i)%9+1,i%9?9:10);}
floorcat
1

К (нгн / к) , 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
Ж. Салле
источник
0

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

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

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

E⁹              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
Нил
источник