在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. 这是代码高尔夫球，因此最短答案以字节为单位

八度，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

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'

Pure Bash（无外部实用程序），36

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

在线尝试！

Bed与Sed，35岁

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

在线尝试！

Python 2，33个字节

i=9;exec"print-i%3-1,i/5;i-=2;"*8

在线尝试！

丹尼斯节省了3个 5字节，哇。谢谢！

果冻，8 7 6个字节

3p_2ẸƇ

在线尝试！

我的第一个果冻答案！非常感谢Dennis的难题的最后一部分。

现在，让我们看看我能否解释一下……大声笑。

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个字节，感谢Erik；-1个字节，感谢Xcoder先生和Dennis

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。

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).

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.

多亏Shaggy削减了两个字节。

在线尝试！

Haskell，22个字节

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

在线尝试！

Laikoni保存了1个字节。

Perl 6、23个字节

{(1,-1,0 X 1,-1,0)[^8]}

在线尝试！

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！

MATL，12字节

9:q4X-3YA49-

在线尝试！

因为是MATL月，所以这里是@Stewie的Octave答案的MATL端口。序列[0 1 2 3 5 6 7 8]生成为[0 ... 8]和4之间的设置差。

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）answer的端口。

在线尝试。

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,]

JavaScript（ES6）

两种替代方法，均比硬编码长。

49个字节

_=>[...'11202200'].map((n,i,a)=>[~-n,~-a[i+3&7]])

在线尝试！

51字节

f=(n=1679887e3)=>n?[n%4-1,~-(n/4%4)]+' '+f(n>>4):''

在线尝试！

Haskell，27个字节

tail$(,)<$>t<*>t
t=[0,1,-1]

在线尝试！

输出为[(0,1),(0,-1),(1,0),(1,1),(1,-1),(-1,0),(-1,1),(-1,-1)]。

Haskell，28 27字节

tail.mapM id$[0,1,-1]<$"ao"

在线尝试！

稻壳，7 6个字节

有很多不同的方式（摆脱了棘手/代价高昂的部分[0,0]），由于Leo指出使用十进制转换（）作为过滤器，我可以使用的最短字节数为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]]

PowerShell，41个字节

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

在线尝试！

该范围内的Double-for循环1..-1，末尾有-not e限定符以拉出无关紧要的0,0条目。它们每个都单独留在管道中，并且Write-output在程序完成时隐式提供给我们免费的换行符。

可悲的是，仅准系统字符串输出要短两个字节：

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

但这很无聊。

Python 2，39个字节

n=6;exec'n+=~(n==2);print n/3,n%3-1;'*8

在线尝试！

J，18 16字节

echo}.,{;~0 1 _1

在线尝试！

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]]"

Befunge-93，24个字节

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

在线尝试！

我觉得这个挑战缺少2D语言的答案，即使大多数语言不是沿对角线移动。这将输出以空格分隔的数字，每对数字之间用制表符分隔。

F＃（单声道），54字节

let f=Seq.where((<>)(0,0))(Seq.allPairs[-1..1][-1..1])

在线尝试！

44字节-感谢Laikoni：

let f=Seq.tail(Seq.allPairs[0;-1;1][0;-1;1])

Brachylog，8个字节

Ċ{ṡᵐ≜}ᶠb

在线尝试！

说明

Ċ           Couple: take a list of two elements [A,B]
 {   }ᶠ     Find all…
    ≜         …possible values of…
  ṡᵐ          …signs of A and B
       b    Behead: remove the first one which is [0,0]

MATL，12字节

3:qq2Z^[]5Y(

在MATL在线上尝试一下！

我的第一个认真的MATL回答！非常感谢Luis Mendo，Sanchises和DJMcMayhem的帮助。

怎么运行的

3：qq2Z ^ [] 5Y（–完整程序。输出到STDOUT。
3：–范围3.将[1 2 3]推入堆栈。
  qq –减少2。收益为[-1 0 1]。
    2Z ^ – 2的笛卡尔幂。
         5Y（–将索引5的行替换为...
       [] –空向量。

Perl 5，31个字节

map/1/&&say,<{-1,0,1},{-1,0,1}>

在线尝试！

Bash，30个字节

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

在线尝试！

在每行（最后一行）上打印尾随空格。（感谢@Neil-最初打印了前导空格，但根据他们的评论，尾随空格更好）

批次，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

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，但这并不短。