Gradini ortogonali

26

È un problema comune navigare in una matrice 2D. L'abbiamo visto molte volte e ci rivedremo. Aiutiamoci in futuro e sviluppiamo le soluzioni più brevi per generare tutti gli otto passaggi possibili in una matrice 2D.

Sfida

Il tuo codice deve generare le seguenti 8 coppie di -1,0,1 in qualsiasi ordine:

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

Regole

Non ci sono input.
L'ordine di uscita non è rilevante
L'output è flessibile. Le coppie di numeri devono solo essere distinguibili
Questo è code-golf , quindi vince la risposta più breve in byte

code-golf kolmogorov-complexity matrix

— Dead Possum
fonte

2

@MartinEnder Ne ero sicuro al 99%, ma non ne ho trovato neanche uno. Quindi l'ho messo nella sandbox per alcuni giorni, ma nessuno ha commentato il duplicato.

— Dead Possum

4

A causa dell'output flessibile, a questo si rivela un interessante sapore di complessità di Kolmogorov. Alcune lingue troveranno più difficile che fare meglio della semplice codifica dell'output. Questo tag dovrebbe essere aggiunto?

— ngm

1

@Adám Sì, usa qualsiasi cosa mentre le coppie di numeri sono distinguibili

— Dead Possum

1

@ Adám Ma che dire (1 + 0i)?

— Dead Possum

8

Questo è un duplicato esatto di 8 quadrati adiacenti , uno dei primi campi da golf che abbia mai fatto.

— isaacg,

Risposte:

19

Ottava , 24 byte

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

Provalo online!

Non ho ancora visto questo approccio.

Crea un elenco di numeri interi [0, 1, 2, 3, 5, 6, 7, 8]e lo converte in ternario, restituendo una matrice di caratteri:

Sottraendo 49(valore ASCII per 1) da tutti i caratteri si ottiene un array numerico:

— Stewie Griffin
fonte

9

T-SQL, 80 78 byte

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

Crea una tabella (permanente) t contenente (-1,0,1), ed esegue un self-join con una WHEREclausola che esclude la 0,0riga. La tabella t non è stata ripulita dal mio codice, è necessario rilasciarlo da soli.

Purtroppo quasi il doppio della soluzione noiosa ( 44 byte ), poiché SQL consente di restituire stringhe:

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

— BradC
fonte

Non conosco T-SQL così bene: puoi usare solo WHERE t.n OR z.n? (È possibile in alcuni ma non in tutti i dialetti SQL.)

— msh210,

@ msh210 Buona idea, l'ho provato ma non sembra funzionare su MS SQL Server. Ottengo l'errore:An expression of non-boolean type specified in a context where a condition is expected

— BradC,

1

Puoi rimuovere gli spazi attorno al *

— Razvan Socol l'

8

Pure Bash (senza utility esterne), 36

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

Provalo online!

Bash with Sed, 35

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

Provalo online!

— Trauma digitale
fonte

In alternativa, utilizza anche cutper 36 byte.

— ბიმო

33 byte per bash + sed (nonostante quanto sia noioso),echo {-1..1},{-1..1}|sed s/0,0.//

— Kritixi Lithos

printf %s\\n {-1..1},{-1..1}|grep 1è anche 35.

— Neil

7

Python 2 , 33 byte

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

Provalo online!

Dennis ha salvato 3 5 byte, wow. Grazie!

— Lynn
fonte

7

Gelatina , 8 7 6 byte

3p_2ẸƇ

Provalo online!

La mia prima risposta in assoluto Jelly! Mille grazie a Dennis per l'ultimo pezzo del puzzle.

Ora, vediamo se posso spiegarlo ... lol.

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

— AdmBorkBork
fonte

1

Modifica la risposta in base a questo approccio:3p3_2ẸƇ

— Mr. Xcoder

@ Mr.Xcoder Puoi rilasciare il secondo 3.

— Dennis,

@Dennis Oh, davvero. In questo caso, Adm può aggiornare con il 6-byte :)

— Mr. Xcoder

7

R , 26 24 byte

Crediti a @JDoe per il salvataggio di altri due byte con un approccio diretto:

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

Provalo online!

La risposta originale:

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

Provalo online!

O per 27 byte

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

Provalo online!

O per 34 byte con fattori:

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

Provalo online!

Quest'ultima soluzione potrebbe essere la più golfosa se l'output potrebbe essere compreso tra 1 e 3 anziché tra -1 e 1.

Vedi l'altra risposta R per soluzioni alternative con expand.grido con cbind.

— Jayce
fonte

eh, buon uso del formato di output flessibile!

— Giuseppe,

2

Questo è migliore del mio a causa di quanto alla fine sia inutile :)

— ngm

@Giuseppe Inizialmente ho provato cche non aveva senso all'interno di una matrice, quindi sono passato al pasteformato di output originale ...

— JayCe

24 byte conpaste

— J.Doe,

1

@ J.Doe rock!

— JayCe,

6

Japt , 13 12 11 byte

Salvataggio di un byte grazie a @Shaggy

9ó8_ìJõ é)Å

Provalo online! Usa la -Rbandiera per mettere ogni oggetto sulla propria riga.

Spiegazione

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
fonte

6

Japt `-Q` , 15 13 byte

Sono sicuro che c'è un modo più breve, ma mi è piaciuto questo approccio.

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

Rasato di due byte grazie a Shaggy .

Provalo online!

— lendine
fonte

6

Haskell , 22 byte

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

Provalo online!

Laikoni ha salvato 1 byte.

— XNOR
fonte

_:l=mapM(:[1,-1])[0,0]salva un byte. (Tratto dalla risposta di isaacg alla sfida precedente).

— Laikoni,

@Laikoni Quindi l'avevo considerato e pensato che l'avrebbe reso un frammento (come molte risposte alla vecchia sfida erano). Ma combinando questo meta post con la regola che le funzioni possono essere definite indirettamente, quindi questo sembra essere OK. Grazie per il suggerimento

— xnor

5

Perl 6 , 23 byte

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

Provalo online!

— nwellnhof
fonte

5

05AB1E , 8 7 byte

2Ý<ãʒĀZ

Provalo online!

Spiegazione

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

— Kaldo
fonte

Dang, mi hai battuto. Aveva lo stesso inizio ( 2Ý<ã), ma stava scoprendo come rimuovere l'elemento centrale dell'elenco di coppie .. Non avevo pensato all'ordinamento per valore assoluto e alla rimozione del primo .. +1 da me.

— Kevin Cruijssen,

2

Usa ʒĀZper salvare 1

— Emigna

@Emigna Grazie per avermi fatto capire la differenza tra la versione normale e la versione 05AB1IE del comando verificato :-)

— Kaldo,

5

MATL , 12 byte

9:q4X-3YA49-

Provalo online!

Perché è il mese MATL, ecco una porta MATL della risposta Octave di @ Stewie. La sequenza [0 1 2 3 5 6 7 8] viene generata come differenza impostata tra [0 ... 8] e 4.

— Sanchises
fonte

5

Java 8, 83 42 byte

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

-41 byte grazie a @AdmBorkBork tramite hard-coding ..

Provalo online.

Versione non codificata come riferimento ( 83 72 70 68 byte ):

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

-11 byte grazie a @ OlivierGrégoire .
-2 byte creando una porta della risposta JavaScript (ES6) di @ETHproductions .

Provalo online.

— Kevin Cruijssen
fonte

Risposta non hardcoded in 72 byte: v->{for(int i=9;i-->0;)if(i!=4)System.out.println((i/3-1)+","+(i%3-1));}.

— Olivier Grégoire

@ OlivierGrégoire Grazie, aggiunto (e giocato da altri 2 byte).

— Kevin Cruijssen,

4

R , 27 byte

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

Provalo online!

30 e 35 byte:

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

— ngm
fonte

Qualche uscita dall'aspetto funky, mi piace: D Ottimo lavoro

— Dead Possum

expand.grid(-1:1,-1:1)[-5,]è di 27 byte.

— Giuseppe,

4

JavaScript (ES6)

Due metodi alternativi, entrambi più lunghi rispetto all'hardcoding.

49 byte

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

Provalo online!

51 byte

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

Provalo online!

— Arnauld
fonte

4

Haskell , 27 byte

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

Provalo online!

L'output è [(0,1),(0,-1),(1,0),(1,1),(1,-1),(-1,0),(-1,1),(-1,-1)].

— Laikoni
fonte

4

Haskell , 28 27 byte

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

Provalo online!

— Angs
fonte

4

Buccia , 7 6 byte

Ci sono molti modi diversi (la parte difficile / costosa si sta liberando [0,0]), ~~7 byte è il più breve che ho potuto inventare~~ grazie a Leo per aver sottolineato come utilizzare la conversione decimale ( d) come filtro:

fdπ2ṡ1

Provalo online!

Spiegazione

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 byte

tπ2ṙ1ṡ1

Provalo online!

Spiegazione

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

— ბიმო
fonte

1

Un'altra alternativa a 7 byte tπ2↑3İZ.

— Laikoni

2

Puoi salvare un byte filtrando gli elenchi in base alla loro conversione decimale Provalo online!

— Leone,

3

PowerShell , 41 byte

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

Provalo online!

Doppio per loop su tutta la gamma 1..-1, con un -not equals alla fine per estrarre l' 0,0ingresso estraneo . Ognuno di essi viene lasciato individualmente in cantiere e implicito Write-outputal completamento del programma ci dà nuove linee gratis.

Purtroppo, solo l'output della stringa barebone è più breve di due byte:

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

Ma è noioso.

— AdmBorkBork
fonte

3

Python 2 , 39 byte

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

Provalo online!

— Dennis
fonte

3

J , 18 16 byte

echo}.,{;~0 1 _1

Provalo online!

— FrownyFrog
fonte

Perché meno viene visualizzato come carattere di sottolineatura in TIO?

— Dead Possum

Alternativa a 18 byte: echo }.>,{;~0 1 _1 TIO

— Galen Ivanov

@Dead Possum I numeri negativi vengono visualizzati con un trattino basso in J

— Galen Ivanov

1

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

— Galen Ivanov,

2

È echonecessario?

— Cole

3

CJam , 13 byte

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

Provalo online!

Spiegazione

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
fonte

3

Befunge-93 , 24 byte

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

Provalo online!

Sento che a questa sfida mancano le risposte dai linguaggi 2D, anche se la maggior parte non si muove in diagonale. Questo genera numeri separati da spazi, ogni coppia separata da tabulazioni.

— Jo King
fonte

3

F # (Mono) , 54 byte

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

Provalo online!

44 byte - grazie a Laikoni:

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

— Henrik Hansen
fonte

1

44 byte essendo (0,0)il primo elemento e chiamando Seq.tail: provalo online!

— Laikoni,

3

Brachylog , 8 byte

Ċ{ṡᵐ≜}ᶠb

Provalo online!

Spiegazione

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

— Fatalize
fonte

3

MATL , 12 byte

3:qq2Z^[]5Y(

Provalo su MATL Online!

La mia prima risposta MATL mai seria! Grazie mille a Luis Mendo , Sanchises e DJMcMayhem per l'aiuto.

Come funziona

3: qq2Z ^ [] 5Y (- Programma completo. Emette su STDOUT.
3: - Range 3. Spingere [1 2 3] nella pila.
  qq - Decremento di 2. Rendimento [-1 0 1].
    2Z ^ - Potenza cartesiana di 2.
         5Y (- Sostituisci la riga all'indice 5 con ...
       [] - Un vettore vuoto.

— Mr. Xcoder
fonte

3

Perl 5 , 31 byte

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

Provalo online!

— Dom Hastings
fonte

Funzionerebbe -1..1nel mondo?

— msh210,

@ msh210 Sfortunatamente no ... l' ho provato , e funziona bash, ma non in Perl :(

— Dom Hastings,

3

Bash , 30 byte

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

Provalo online!

Stampa uno spazio finale su ogni riga tranne l'ultima. (Grazie a @Neil - questo originariamente stampava uno spazio iniziale, ma uno spazio finale è migliore secondo il loro commento)

— Dom Hastings
fonte

Suppongo che tu possa stampare uno spazio finale su tutti tranne l'ultima riga in alternativa.

— Neil,

2

Lotto, 77 byte

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

63 byte se è consentito un separatore non standard:

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

— Neil
fonte

2

Pyth, 11 9 byte

t^+U2_1 2

Spiegazione

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

Equivalentemente, potremmo usare t*J+U2_1J, ma non è più breve.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.

Licensed under cc by-sa 3.0 with attribution required.