É um problema comum navegar em uma matriz 2D. Já vimos isso muitas vezes e veremos novamente. Então, vamos nos ajudar no futuro e desenvolver as soluções mais curtas para gerar todas as oito etapas possíveis em uma matriz 2D.

Desafio

Seu código deve gerar os seguintes 8 pares de -1,0,1 em qualquer ordem:

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

Regras

1. Não há entrada.
2. A ordem de saída não é relevante
3. A saída é flexível. Pares de números só precisam ser distinguíveis
4. Isso é código-golfe , então a resposta mais curta em bytes ganha

Oitava , 24 bytes

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

Experimente online!

Ainda não vi essa abordagem.

Cria uma lista de números inteiros [0, 1, 2, 3, 5, 6, 7, 8]e a converte em ternário, retornando uma matriz de caracteres:

00
01
02
10
12
20
21
22

Subtrair 49(valor ASCII para 1) de todos os caracteres fornece uma matriz numérica:

-1  -1
-1   0
-1   1
 0  -1
 0   1
 1  -1
 1   0
 1   1

T-SQL, 80 78 bytes

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

Cria uma tabela (permanente) t contendo (-1,0,1)e executa uma auto-junção com uma WHEREcláusula que exclui a 0,0linha. A tabela t não é limpa pelo meu código, você deve descartá-la.

Infelizmente, quase o dobro da solução chata ( 44 bytes ), pois o SQL permite retornos em strings:

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

Pure Bash (sem utilitários externos), 36

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

Experimente online!

Festança com Sed, 35

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

Experimente online!

Python 2 , 33 bytes

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

Experimente online!

Dennis salvou 3 5 bytes, uau. Obrigado!

Gelatina , 8 7 6 bytes

3p_2ẸƇ

Experimente online!

Minha primeira resposta Jelly! Muito obrigado a Dennis pela peça final do quebra-cabeça.

Agora, vamos ver se consigo explicar ... rs.

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 byte graças a Erik; -1 byte graças ao Sr. Xcoder e Dennis

R , 26 bytes 24

Créditos ao @JDoe por salvar mais dois bytes com uma abordagem direta:

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

Experimente online!

O asnwer original:

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

Experimente online!

Ou por 27 bytes

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

Experimente online!

Ou para 34 bytes com fatores:

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

Experimente online!

Essa última solução pode ser a mais golfista se a saída puder ser de 1 a 3 em vez de -1 a 1.

Veja a outra resposta R para soluções alternativas com expand.gridou com cbind.

Japonês , 13 12 11 bytes

Guardou um byte graças a @Shaggy

9ó8_ìJõ é)Å

Experimente online! Usa -Rsinalizador para colocar cada item em sua própria linha.

Explicação

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

Japonês -Q , 15 13 bytes

Tenho certeza de que há uma maneira mais curta, mas gostei dessa abordagem.

##ü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.

Raspou dois bytes graças a Shaggy .

Experimente online!

Haskell , 22 bytes

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

Experimente online!

Laikoni salvou 1 byte.

Perl 6 , 23 bytes

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

Experimente online!

05AB1E , 8 7 bytes

2Ý<ãʒĀZ

Experimente online!

Explicação

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 byte graças a Emigna!

MATL , 12 bytes

9:q4X-3YA49-

Experimente online!

Como é o mês do MATL, aqui está uma porta MATL da resposta de @ Stewie Octave. A sequência [0 1 2 3 5 6 7 8] é gerada como a diferença definida entre [0 ... 8] e 4.

Java 8, 83 42 bytes

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

-41 bytes graças a @AdmBorkBork por codificação ..

Experimente online.

Versão não codificada como referência ( 83 72 70 68 bytes ):

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

-11 bytes graças a @ OlivierGrégoire .
-2 bytes criando uma porta da resposta JavaScript (ES6) do @ETHproductions .

Experimente online.

R , 27 bytes

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

Experimente online!

30 e 35 bytes:

cbind(-1:1,rep(-1:1,e=3))[-5,]
expand.grid(rep(list(-1:1),2))[-5,]

JavaScript (ES6)

Dois métodos alternativos, ambos mais longos que codificados.

49 bytes

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

Experimente online!

51 bytes

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

Experimente online!

Haskell , 27 bytes

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

Experimente online!

A saída é [(0,1),(0,-1),(1,0),(1,1),(1,-1),(-1,0),(-1,1),(-1,-1)].

Haskell , 28 27 bytes

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

Experimente online!

Casca , 7 6 bytes

Existem várias maneiras diferentes (a parte complicada / cara está se livrando [0,0]), 7 bytes é o mais curto que consegui encontrar, graças ao Leo por apontar para usar a conversão decimal ( d) como um filtro:

fdπ2ṡ1

Experimente online!

Explicação

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

Alternativa, 7 bytes

tπ2ṙ1ṡ1

Experimente online!

Explicação

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 bytes

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

Experimente online!

Laço duplo para o intervalo 1..-1, com um -not equals no final para retirar a 0,0entrada estranha . Cada um deles é deixado individualmente no pipeline e, implícito Write-outputna conclusão do programa, oferece novas linhas gratuitamente.

Infelizmente, apenas a saída da string de barebones é dois bytes mais curta:

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

Mas isso é chato.

Python 2 , 39 bytes

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

Experimente online!

J , 18 16 bytes

echo}.,{;~0 1 _1

Experimente online!

CJam , 13 bytes

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

Experimente online!

Explicação

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 bytes

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

Experimente online!

Sinto que esse desafio está faltando respostas das linguagens 2D, mesmo que a maioria não se mova na diagonal. Isso gera números separados por espaço, cada par separado por tabulações.

F # (Mono) , 54 bytes

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

Experimente online!

44 bytes - graças a Laikoni:

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

Braquilog , 8 bytes

Ċ{ṡᵐ≜}ᶠb

Experimente online!

Explicação

Ċ           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 bytes

3:qq2Z^[]5Y(

Experimente no MATL Online!

Minha primeira resposta séria ao MATL! Muito obrigado a Luis Mendo , Sanchises e DJMcMayhem pela ajuda.

Como funciona

3: qq2Z ^ [] 5Y (- Programa completo. Saídas para STDOUT.
3: - Faixa 3. Pressione [1 2 3] para a pilha.
  qq - Decrementa em 2. Rende [-1 0 1].
    2Z ^ - Potência cartesiana de 2.
         5Y (- Substitua a linha no índice 5 por ...
       [] - um vetor vazio.

Perl 5 , 31 bytes

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

Experimente online!

Bash , 30 bytes

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

Experimente online!

Imprime um espaço à direita em cada linha, exceto a última. (Graças a @Neil - isso originalmente imprimiu um espaço à esquerda, mas um espaço à direita é melhor conforme o comentário)

Lote, 77 bytes

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

63 bytes se um separador fora do padrão for permitido:

@for %%x in (-1/-1 -1/0 -1/1 0/-1 0/1 1/-1 1/0 1/1)do @echo %%x

Pitão, 11 9 bytes

t^+U2_1 2

Experimente aqui

Explicação

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

Equivalentemente, poderíamos usar t*J+U2_1J, mas isso não é mais curto.