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

  1. No hay entrada
  2. El orden de salida no es relevante
  3. La salida es flexible. Los pares de números solo necesitan ser distinguibles
  4. 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:

00
01
02
10
12
20
21
22

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

-1  -1
-1   0
-1   1
 0  -1
 0   1
 1  -1
 1   0
 1   1
— 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
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

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

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

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

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

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.

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.