Pasos ortodiagonales

26

Es un problema común navegar en una matriz 2D. Lo hemos visto muchas veces y lo veremos nuevamente. Entonces, ayúdenos a desarrollarnos en el futuro y desarrollemos las soluciones más cortas para generar los ocho pasos posibles en una matriz 2D.

Reto

Su código debe generar los siguientes 8 pares de -1,0,1 en cualquier orden:

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

Reglas

No hay entrada
El orden de salida no es relevante
La salida es flexible. Los pares de números solo necesitan ser distinguibles
Este es el código de golf , por lo que la respuesta más corta en bytes gana

code-golf kolmogorov-complexity matrix Zarigüeya muerta
fuente

2

@MartinEnder También estaba 99% seguro de eso, pero tampoco encontré ninguno. Así que lo puse en la caja de arena durante unos días, pero nadie comentó sobre duplicados.

Dead Possum

44

Debido a la salida flexible, resulta ser un interesante sabor de complejidad de Kolmogorov para este. Algunos idiomas encontrarán más difícil que hacerlo mejor que simplemente codificar la salida. ¿Debería agregarse esta etiqueta?

ngm

1

@ Adám Sí, usa cualquier cosa mientras pares de números sean distinguibles

Dead Possum

1

@ Adám ¿Pero qué pasa (1 + 0i)?

Dead Possum

8

Este es un duplicado exacto de 8 cuadrados adyacentes , uno de los primeros campos de golf de código que hice.

isaacg

Respuestas:

19

Octava , 24 bytes

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

Pruébalo en línea!

Todavía no he visto este enfoque.

Crea una lista de enteros [0, 1, 2, 3, 5, 6, 7, 8]y la convierte en ternario, devolviendo una matriz de caracteres:

Restar 49(valor ASCII para 1) de todos los caracteres da una matriz numérica:

Stewie Griffin
fuente

9

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

Crea una tabla t (permanente) que contiene (-1,0,1)y realiza una autounión con una WHEREcláusula que excluye la 0,0fila. Mi tabla no ha limpiado la tabla t , debe dejarla usted mismo

Lamentablemente, casi el doble de tiempo que la solución aburrida ( 44 bytes ), ya que SQL permite retornos en cadenas:

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

BradC
fuente

No conozco T-SQL tan bien: ¿puedes usar solo WHERE t.n OR z.n? (Usted puede, en algunos pero no todos los dialectos SQL.)

msh210

@ msh210 Buena idea, lo intenté pero no parece funcionar en MS SQL Server. Me sale el error:An expression of non-boolean type specified in a context where a condition is expected

BradC

1

Puede eliminar los espacios alrededor del *

Razvan Socol

8

Pure Bash (sin utilidades externas), 36

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

Pruébalo en línea!

Bash con Sed, 35

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

Pruébalo en línea!

Trauma digital
fuente

Alternativamente usando cutpor 36 bytes también.

ბიმო

33 bytes para bash + sed (a pesar de lo aburrido que es),echo {-1..1},{-1..1}|sed s/0,0.//

Kritixi Lithos

printf %s\\n {-1..1},{-1..1}|grep 1también es 35.

Neil

7

Python 2 , 33 bytes

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

Pruébalo en línea!

Dennis ahorró 3 5 bytes, wow. ¡Gracias!

Lynn
fuente

7

Jalea , 8 7 6 bytes

3p_2ẸƇ

Pruébalo en línea!

¡Mi primera respuesta de Jelly! Muchas gracias a Dennis por la pieza final del rompecabezas.

Ahora, veamos si puedo explicarlo ... jajaja.

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 gracias a Erik; -1 byte gracias a Mr Xcoder y Dennis

AdmBorkBork
fuente

1

Respuesta alternativa basada en este enfoque:3p3_2ẸƇ

Sr. Xcoder

@ Mr.Xcoder Puede soltar el segundo 3.

Dennis

@ Dennis Oh, de hecho. En este caso, Adm puede actualizar con el 6-byter :)

Sr. Xcoder

7

R , 26 24 bytes

Créditos a @JDoe por guardar dos bytes más con un enfoque directo:

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

Pruébalo en línea!

La respuesta original:

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

Pruébalo en línea!

O para 27 bytes

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

Pruébalo en línea!

O para 34 bytes con factores:

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

Pruébalo en línea!

Esta última solución podría ser la mejor si la salida puede ser de 1 a 3 en lugar de -1 a 1.

Vea la otra respuesta R para soluciones alternativas con expand.grido con cbind.

JayCe
fuente

eh, buen uso del formato de salida flexible!

Giuseppe

2

Este es mejor que el mío por lo inútil que es en última instancia :)

ngm

@Giuseppe Originalmente intenté lo cque no tenía sentido dentro de una matriz, así que paste

cambié al

24 bytes conpaste

J.Doe

1

@ J. ¿Eres genial?

JayCe

6

Japt , 13 12 11 bytes

Guardado un byte gracias a @Shaggy

9ó8_ìJõ é)Å

Pruébalo en línea! Utiliza la -Rbandera para poner cada elemento en su propia línea.

Explicación

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

ETHproducciones
fuente

6

Japt `-Q` , 15 13 bytes

Estoy seguro de que hay un camino más corto, pero me gustó este enfoque.

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

Afeitado dos bytes gracias a Shaggy .

Pruébalo en línea!

Liendre
fuente

6

Haskell , 22 bytes

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

Pruébalo en línea!

Laikoni guardó 1 byte.

xnor
fuente

_:l=mapM(:[1,-1])[0,0]Guarda un byte. (Tomado de la respuesta de Isaac al desafío anterior).

Laikoni

@Laikoni Así que lo consideré y pensé que sería un fragmento (ya que muchas respuestas al viejo desafío eran). Pero combinar esta meta publicación con la regla de que las funciones se pueden definir indirectamente, por lo que parece estar bien. Gracias por la sugerencia.

xnor

5

Perl 6 , 23 bytes

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

Pruébalo en línea!

nwellnhof
fuente

5

05AB1E , 8 7 bytes

2Ý<ãʒĀZ

Pruébalo en línea!

Explicación

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 gracias a Emigna!

Kaldo
fuente

Dang, me ganaste. Tenía el mismo inicio ( 2Ý<ã), pero estaba descubriendo cómo eliminar el elemento central de la lista de pares ... No había pensado en ordenar por valor absoluto y eliminar el primero ... +1 de mí.

Kevin Cruijssen

2

Use ʒĀZpara guardar 1

Emigna

@Emigna Gracias por hacerme entender la diferencia entre la versión regular y la 05AB1IE del comando verificado :-)

Kaldo

5

MATL , 12 bytes

9:q4X-3YA49-

Pruébalo en línea!

Debido a que es el mes MATL, aquí hay un puerto MATL de la respuesta Octave de @ Stewie. La secuencia [0 1 2 3 5 6 7 8] se genera como la diferencia establecida entre [0 ... 8] y 4.

Sanchises
fuente

5

Java 8, 83 42 bytes

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

-41 bytes gracias a @AdmBorkBork mediante codificación rígida.

Pruébalo en línea.

Versión no codificada como referencia ( 83 72 70 68 bytes ):

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

-11 bytes gracias a @ OlivierGrégoire .
-2 bytes creando un puerto de respuesta JavaScript de @ETHproductions (ES6) .

Pruébalo en línea.

Kevin Cruijssen
fuente

Respuesta no hardcoded de 72 bytes: v->{for(int i=9;i-->0;)if(i!=4)System.out.println((i/3-1)+","+(i%3-1));}.

Olivier Grégoire

@ OlivierGrégoire Gracias, agregado (y jugado por 2 bytes más).

Kevin Cruijssen

4

R , 27 bytes

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

Pruébalo en línea!

30 y 35 bytes:

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

ngm
fuente

Un resultado de aspecto funky, me gusta: D Buen trabajo

Dead Possum

expand.grid(-1:1,-1:1)[-5,]es de 27 bytes.

Giuseppe

4

JavaScript (ES6)

Dos métodos alternativos, ambos más largos que el hardcoding.

49 bytes

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

Pruébalo en línea!

51 bytes

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

Pruébalo en línea!

Arnauld
fuente

4

Haskell , 27 bytes

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

Pruébalo en línea!

La salida es [(0,1),(0,-1),(1,0),(1,1),(1,-1),(-1,0),(-1,1),(-1,-1)].

Laikoni
fuente

4

Haskell , 28 27 bytes

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

Pruébalo en línea!

Angs
fuente

4

Casco , 7 6 bytes

Hay muchas maneras diferentes (la parte difícil / costosa se está eliminando [0,0]), ~~7 bytes es lo más corto que pude encontrar~~ gracias a Leo por señalar que usa la conversión decimal ( d) como filtro:

fdπ2ṡ1

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

Explicación

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

ბიმო
fuente

1

Otra alternativa de 7 bytes tπ2↑3İZ.

Laikoni

2

Puede guardar un byte filtrando las listas según su conversión decimal. ¡ Pruébelo en línea!

Leo

3

PowerShell , 41 bytes

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

Pruébalo en línea!

Doble bucle for en el rango 1..-1, con un -not eal final para extraer la 0,0entrada extraña . Cada uno se deja individualmente en la tubería e implícito Write-outputen la finalización del programa nos da nuevas líneas de forma gratuita.

Lamentablemente, solo la salida de cadena básica es dos bytes más corta:

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

Pero eso es aburrido.

AdmBorkBork
fuente

3

Python 2 , 39 bytes

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

Pruébalo en línea!

Dennis
fuente

3

J , 18 16 bytes

echo}.,{;~0 1 _1

Pruébalo en línea!

FrownyFrog
fuente

¿Por qué menos se muestra como guión bajo en TIO?

Dead Possum

Alternativa de 18 bytes: echo }.>,{;~0 1 _1 TIO

Galen Ivanov

@Dead Possum Los números negativos se muestran con un guión bajo en J

Galen Ivanov

1

Sí, 17 :) echo}.>,{;~0 1 _1

Galen Ivanov

2

Es echonecesario?

Cole

3

CJam , 13 bytes

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

Pruébalo en línea!

Explicación

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

Fruta Esolanging
fuente

3

Befunge-93 , 24 bytes

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

Pruébalo en línea!

Siento que a este desafío le faltan respuestas de los lenguajes 2D, incluso si la mayoría no se mueve en diagonal. Esto genera números separados por espacios, cada par separado por pestañas.

Jo King
fuente

3

F # (Mono) , 54 bytes

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

Pruébalo en línea!

44 bytes - gracias a Laikoni:

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

Henrik Hansen
fuente

1

44 bytes al (0,0)ser el primer elemento y llamar Seq.tail: ¡ Pruébelo en línea!

Laikoni

3

Brachylog , 8 bytes

Ċ{ṡᵐ≜}ᶠb

Pruébalo en línea!

Explicación

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

Fatalizar
fuente

3

MATL , 12 bytes

3:qq2Z^[]5Y(

¡Pruébalo en MATL Online!

¡Mi primera respuesta MATL seria! Muchas gracias a Luis Mendo , Sanchises y DJMcMayhem por la ayuda.

Cómo funciona

3: qq2Z ^ [] 5Y (- Programa completo. Salidas a STDOUT.
3: - Rango 3. Empuje [1 2 3] a la pila.
  qq - Disminuir en 2. Rendimientos [-1 0 1].
    2Z ^ - Poder cartesiano de 2.
         5Y (- Reemplace la fila en el índice 5 con ...
       [] - Un vector vacío.

Sr. Xcoder
fuente

3

Perl 5 , 31 bytes

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

Pruébalo en línea!

Dom Hastings
fuente

¿ -1..1Funcionaría en el glob?

msh210

@ msh210 Desafortunadamente no ... Experimenté con él, y funciona en bash, pero no en Perl :(

Dom Hastings

3

Bash , 30 bytes

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

Pruébalo en línea!

Imprime un espacio final en cada línea pero en la última. (Gracias a @Neil : originalmente imprimió un espacio inicial, pero un espacio final es mejor según su comentario)

Dom Hastings
fuente

Supongo que podría imprimir un espacio final en todos menos en la última línea como alternativa.

Neil

2

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 si se permite un separador no estándar:

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

Neil
fuente

2

Pyth, 11 9 bytes

t^+U2_1 2

Pruébalo aquí

Explicación

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

De manera equivalente, podríamos usar t*J+U2_1J, pero eso no es más corto.

fuente