Ортодиагональные шаги

26

Это общая проблема для навигации в 2D матрице. Мы видели это много раз и увидим снова. Итак, давайте поможем нам в будущем и разработаем кратчайшие решения для генерации всех восьми возможных шагов в 2D-матрице.

Вызов

Ваш код должен вывести следующие 8 пар -1,0,1 в любом порядке: 

(0,1)
(0,-1)
(1,0)
(-1,0)
(1,1)
(1,-1)
(-1,1)
(-1,-1)

правила

  1. Там нет ввода.
  2. Порядок вывода не актуален
  3. Выход гибкий. Пары чисел просто должны быть различимы
  4. Это код-гольф , поэтому выигрывает самый короткий ответ в байтах
code-golf kolmogorov-complexity matrix Мертвый Опоссум
источник
2
@MartinEnder В этом я тоже был уверен на 99%, но ничего не нашел. Так что я положил его в песочницу на несколько дней, но никто не прокомментировал дубликат.
Мертвый Опоссум
4
Из-за гибкого вывода этот интересный колмогоровский привкус оказался интересным. Некоторым языкам будет сложнее, чем делать лучше, чем просто жестко кодировать вывод. Должен ли этот тег быть добавлен?
НГМ
1
@ Adám Да, используйте что-нибудь, пока различимы пары чисел
Мертвый Поссум
1
@ Adám А как же (1 + 0i)?
Мертвый опоссум
8
Это точная копия 8 смежных квадратов , одного из первых кодовых гольфов, которые я когда-либо делал.
Исаак

Ответы:

19

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

dec2base([0:3,5:8],3)-49

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

Я еще не видел этот подход.

Создает список целых чисел [0, 1, 2, 3, 5, 6, 7, 8]и преобразует его в троичный, возвращая массив символов:

00
01
02
10
12
20
21
22

Вычитание 49(ASCII-значение для 1) из всех символов дает числовой массив:

-1  -1
-1   0
-1   1
 0  -1
 0   1
 1  -1
 1   0
 1   1
Стьюи Гриффин
источник
9

T-SQL, 80 78 байт

SELECT-1n INTO t;INSERT t VALUES(0),(1)SELECT*FROM t,t z WHERE t.n<>0OR z.n<>0

Создает (постоянную) таблицу t, содержащую (-1,0,1), и выполняет самостоятельное соединение с WHEREпредложением, которое исключает 0,0строку. Таблица t не очищена моим кодом, вы должны удалить ее самостоятельно.

К сожалению, почти вдвое длиннее скучного решения ( 44 байта ), поскольку SQL допускает возврат в виде строк:

PRINT'0,1
0,-1
1,0
-1,0
1,1
1,-1
-1,1
-1,-1'
BradC
источник
Я не очень хорошо знаю T-SQL: можете ли вы просто использовать WHERE t.n OR z.n? (Вы можете на некоторых, но не на всех диалектах SQL.)
msh210
@ msh210 Хорошая идея, я попробовал, но, похоже, не работает на MS SQL Server. Я получаю ошибку:An expression of non-boolean type specified in a context where a condition is expected
BradC
1
Вы можете удалить пробелы вокруг *
Разван Соколь
8

Pure Bash (без внешних утилит), 36

a=({0,-1,1},{0,-1,1})
echo ${a[@]:1}

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

Баш с седом, 35

printf %s\\n {-1..1},{-1..1}|sed 5d

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

Цифровая травма
источник
В качестве альтернативы можно использовать и cut36 байтов.
ბიმო
33 байта для bash + sed (несмотря на то, как это скучно),echo {-1..1},{-1..1}|sed s/0,0.//
Kritixi Lithos
printf %s\\n {-1..1},{-1..1}|grep 1также 35.
Нейл
7

Желе , 8 7 6 байт

3p_2ẸƇ

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

Мой первый ответ желе! Большое спасибо Деннису за последний кусок головоломки.

Теперь посмотрим, смогу ли я это объяснить ... смеется.

3p_2ẸƇ   Main program, takes no input.
3p       Product with Range 3, yields [[1,1], [1,2], [1,3], [2,1], [2,2], ...]
  _2     Decrement twice, vectorizes, yields [[-1,-1], [-1,0], [-1,1], [0,-1], ...]
    ẸƇ   Comb, removes those that contain only falsey values, the [0,0]
         Implicit output

-1 байт благодаря Эрику; -1 байт благодаря мистеру Xcoder и Деннису

AdmBorkBork
источник
1
Альтернативный ответ, основанный на таком подходе:3p3_2ẸƇ
Мистер Xcoder
@ Mr.Xcoder Вы можете оставить второй 3.
Денис
@ Деннис Да, действительно. В этом случае Adm может обновить с 6-байтовым :)
Мистер Xcoder
7

R , 26 24 байта

Кредиты @JDoe для сохранения еще двух байтов с прямым подходом:

paste(-1:1,-3:5%/%3)[-5]

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

Оригинальный ответ:

outer(-1:1,-1:1,paste)[-5]

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

Или для 27 байтов

sapply(-1:1,paste,-1:1)[-5]

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

Или для 34 байтов с коэффициентами:

(gl(3,3,,-1:1):gl(3,1,9,-1:1))[-5]

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

Это последнее решение может быть самым удачным, если результат будет от 1 до 3, а не от -1 до 1.

Смотрите другой ответ R для альтернативных решений с expand.gridили с cbind.

Jayce
источник
Да, приятно использовать гибкий формат вывода!
Джузеппе
2
Этот лучше моего, потому что в конечном итоге он бесполезен :)
НГМ,
@Giuseppe Первоначально я пытался, cчто не имеет смысла внутри матрицы, поэтому я переключился на pasteи исходный формат вывода ...
JayCe
24 байта сpaste
J.Doe
1
@ Дж. Ты молодец!
JayCe
6

Japt , 13 12 11 байт

Сохраненный байт благодаря @Shaggy

9ó8_ìJõ é)Å

Попробуйте онлайн! Использует -Rфлаг для размещения каждого элемента в отдельной строке.

объяснение

9ó8_ìJõ é)Å
9ó8             Create the range [9, 9+8). [9, 10, ..., 16]
   _            Map each item in this range through this function:
     Jõ é)        Generate the range [-1...1] and rotate to get [1, -1, 0].
    ì             Convert the item to an array of base-3 digits,
                  mapping [0,1,2] to [1,-1,0]. [[-1, 1, 1], [-1, 1,-1], [-1, 1, 0],
                                                [-1,-1, 1], [-1,-1,-1], [-1,-1, 0],
                                                [-1, 0, 1], [-1, 0,-1]]
          Å       Remove the first item (gets rid of the leading -1).
ETHproductions
источник
6

Japt -Q , 15 13 байт

Я уверен, что есть более короткий путь, но мне понравился этот подход.

##ü80ì3 mÉ ò
##ü80        // Take 14425280
     ì3      // and turn it into an array of base-3 numbers.
        mÉ   // Subtract one from each digit
           ò // and then split them pairwise.

Срезал два байта благодаря Шегги .

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

гнида
источник
6

Haskell , 22 байта

_:l=mapM(:[1,-1])[0,0]

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

Лайкони спас 1 байт.

XNOR
источник
_:l=mapM(:[1,-1])[0,0]сохраняет байт. (Взято из ответа Исаака на предыдущий вызов).
Лайкони
@ Laikoni Итак, я обдумал это и подумал, что это сделает его фрагментом (как много ответов на старый вызов). Но объединяя этот мета-пост с правилом, что функции могут быть определены косвенно, так что, похоже, все в порядке. Спасибо за предложение.
xnor
5

05AB1E , 8 7 байт

2Ý<ãʒĀZ

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

объяснение

2Ý<     # Range of 2 decremented, yields [-1, 0, 1]
   ã    # Cartesian product of the list with itself
    ʒ   # Filter by ...
     ĀZ # Maximum of the truthified values, yields 0 only if both values are 0.

-1 байт благодаря Emigna!

Kaldo
источник
Черт, ты меня побил. Был такой же start ( 2Ý<ã), но выяснял, как убрать средний элемент списка пар .. Я не думал о сортировке по абсолютному значению и убрал первое .. +1 из меня.
Кевин Круйссен
2
Используйте, ʒĀZчтобы сохранить 1
Эминья
@Emigna Спасибо за то, что помогли мне понять разницу между обычной версией и версией 05AB1IE укороченной команды :-)
Kaldo
5

MATL , 12 байт

9:q4X-3YA49-

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

Поскольку это месяц MATL, вот порт MATL ответа @ Stewie's Octave. Последовательность [0 1 2 3 5 6 7 8] генерируется как разность установок между [0 ... 8] и 4.

Sanchises
источник
5

Java 8, 83 42 байта

v->"1,1 1,0 1,-1 0,1 0,-1 -1,1 -1,0 -1,-1"

-41 байт благодаря @AdmBorkBork с помощью жесткого кодирования ..

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

Не жестко запрограммированная версия для справки ( 83 72 70 68 байт ):

v->{for(int i=9;i-->1;)System.out.println(~i%3+1+","+(~(i/3)%3+1));}

-11 байт благодаря @ OlivierGrégoire .
-2 байта, создающие порт ответа @ETHproductions на JavaScript (ES6) .

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

Кевин Круйссен
источник
Non-зашиты ответ в 72 байт: v->{for(int i=9;i-->0;)if(i!=4)System.out.println((i/3-1)+","+(i%3-1));}.
Оливье Грегуар
@ OlivierGrégoire Спасибо, добавил (и добавил еще 2 байта).
Кевин Круйссен
4

R , 27 байт

expand.grid(-1:1,-1:1)[-5,]

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

30 и 35 байтов:

cbind(-1:1,rep(-1:1,e=3))[-5,]
expand.grid(rep(list(-1:1),2))[-5,]
НГМ
источник
Какой-то прикольный выходной, мне это нравится: D Хорошая работа
Мертвый Опоссум
expand.grid(-1:1,-1:1)[-5,]составляет 27 байтов.
Джузеппе
4

Шелуха , 7 6 байт

Есть много разных способов (избавление от хитрой / дорогостоящей части [0,0]), 7 байтов - самый короткий, который я смог найти, благодаря Лео за указание использовать десятичное преобразование ( d) в качестве фильтра:

fdπ2ṡ1

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

объяснение

fdπ2ṡ1  -- constant function (expects no arguments)
    ṡ1  -- symmetric range [-n..n]: [-1,0,1]
  π2    -- cartesian power of 2: [[-1,-1],[-1,0],[0,-1],[-1,1],[0,0],[1,-1],[0,1],[1,0],[1,1]]
f       -- filter only elements that are truthy when
 d      -- | decimal conversion (interpret as polynomial and evaluate at x=10)
        -- : [[-1,-1],[-1,0],[0,-1],[-1,1],[1,-1],[0,1],[1,0],[1,1]]

Альтернатива, 7 байт

tπ2ṙ1ṡ1

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

объяснение

tπ2ṙ1ṡ1  -- constant function (expects no arguments)
     ṡ1  -- symmetric range [-n..n]: [-1,0,1]
   ṙ1    -- rotate by 1: [0,1,-1]
 π2      -- cartesian power of 2: [[0,0],[0,1],[1,0],[0,-1],[1,1],[-1,0],[1,-1],[-1,1],[-1,-1]]
t        -- tail: [[0,1],[1,0],[0,-1],[1,1],[-1,0],[1,-1],[-1,1],[-1,-1]]
ბიმო
источник
1
Еще одна 7-байтовая альтернатива tπ2↑3İZ.
Лайкони
2
Вы можете сохранить один байт, отфильтровав списки на основе их десятичного преобразования. Попробуйте онлайн!
Лев
3

PowerShell , 41 байт

(1..-1|%{$i=$_;1..-1|%{"$i,$_"}})-ne'0,0'

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

Дважды цикл по диапазону 1..-1, с -nOt eQuals в конце концов , чтобы вытащить посторонний 0,0элемент. Каждый из них по отдельности остается в конвейере и неявно Write-outputпри завершении программы дает нам новые строки бесплатно.

К сожалению, только вывод строки barebones на два байта короче:

'1,1
1,0
1,-1
0,1
0,-1
-1,1
-1,0
-1,-1'

Но это скучно.

AdmBorkBork
источник
3

J , 18 16 байт

echo}.,{;~0 1 _1

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

FrownyFrog
источник
Почему минус отображается как подчеркивание в TIO?
Мертвый опоссум
Альтернатива 18 байт: echo }.>,{;~0 1 _1 TIO
Гален Иванов
@Dead Possum Отрицательные числа отображаются с подчеркиванием в J
Гален Иванов
1
Да, 17 :) echo}.>,{;~0 1 _1
Гален Иванов
2
Является ли это echoнеобходимо?
Коул
3

CJam , 13 байтов

3,:(2m*{2b},`

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

объяснение

3,    e# Range [0,3):       [0 1 2]
:(    e# Decrement each:    [-1 0 1]
2m*   e# Cartesian square:  [[-1 -1] [-1 0] [-1 1] [0 -1] [0 0] [0 1] [1 -1] [1 0] [1 1]]
{     e# Filter by
 2b   e#   conversion to binary:
},    e#                    [[-1 -1] [-1 0] [-1 1] [0 -1] [0 1] [1 -1] [1 0] [1 1]]
`     e# Stringify:         "[[-1 -1] [-1 0] [-1 1] [0 -1] [0 1] [1 -1] [1 0] [1 1]]"
Esolanging Fruit
источник
3

Befunge-93 , 24 байта

11#v91090~9~19~<
9.._@#,

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

Я чувствую, что в этой задаче отсутствуют ответы из 2D-языков, даже если большинство из них не двигаются по диагонали. Это выводит разделенные пробелами числа, каждая пара которых разделена табуляцией.

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

MATL , 12 байт

3:qq2Z^[]5Y(

Попробуйте это в MATL Online!

Мой первый серьезный ответ на MATL! Большое спасибо Луису Мендо , Sanchises и DJMcMayhem за помощь.

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

3: qq2Z ^ [] 5Y (- Полная программа. Вывод на STDOUT.
3: - Диапазон 3. Нажмите [1 2 3] на стопку.
  qq - Уменьшение на 2. Выход [-1 0 1].
    2Z ^ - декартова степень 2.
         5Y (- заменить строку с индексом 5 на ...
       [] - пустой вектор.
Мистер Xcoder
источник
3

Баш , 30 байт

echo "
"{-1..1},{-1..1}|grep 1

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

Печатает завершающий пробел в каждой строке, кроме последней. (Благодаря @Neil - изначально печатался начальный пробел, но завершающий пробел лучше по их комментарию)

Дом Гастингс
источник
Я полагаю, что вы можете напечатать конечный пробел на всех, кроме последней строки, в качестве альтернативы.
Нил
2

Пакетный, 77 байт

@for %%x in (-1 0 1)do @for %%y in (-1 0 1)do @if not %%x%%y==00 echo %%x %%y

63 байта, если разрешен нестандартный разделитель:

@for %%x in (-1/-1 -1/0 -1/1 0/-1 0/1 1/-1 1/0 1/1)do @echo %%x
Нил
источник
2

Pyth, 11 9 байт

t^+U2_1 2

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

объяснение

t^+U2_1 2
  +U2_1     [0, 1, -1]
 ^      2   Product with itself.
t           Exclude the first.

Эквивалентно, мы могли бы использовать t*J+U2_1J, но это не короче.


источник