Crea una matrice a scacchiera

26

Prendi un intero positivo n come input e genera una matrice a scacchiera n-by-n composta da 1 e 0 .

La cifra in alto a sinistra dovrebbe essere sempre 1 .

Casi test:

n = 1
1

n = 2
1 0
0 1

n = 3
1 0 1
0 1 0
1 0 1

n = 4
1 0 1 0
0 1 0 1
1 0 1 0
0 1 0 1

I formati di input e output sono opzionali. L'output della matrice come elenco di elenchi è accettato.

code-golf  number  matrix 
— Stewie Griffin
fonte
Un elenco di stringhe è OK?
— xnor
Sì, va bene.
— Stewie Griffin,
1
— bicchiere
2
I tuoi esempi mostrano spazi tra i numeri sulla stessa riga, è necessario, in modo da sembrare più un quadrato?
— BradC,
@BradC non è richiesto. Il primo approccio qui è valido.
— Stewie Griffin,

Risposte:

9

MATL , 5 byte

:otYT

Provalo su MATL online!

Spiegazione

Considera l'input 4come esempio.

:    % Implicit input, n. Push range [1 2 ... n]
     %   STACK: [1 2 3 4]
o    % Parity, element-wise
     %   STACK: [1 0 1 0]
t    % Duplicate
     %   STACK: [1 0 1 0], [1 0 1 0]
YT   % Toeplitz matrix with two inputs. Implicit display
     %   STACK: [1 0 1 0;
     %           0 1 0 1;
     %           1 0 1 0;
     5           0 1 0 1]
— Luis Mendo
fonte
7

Japt , 6 byte

ÆÇ+X v

Provalo online! (Utilizza -Qflag per una visualizzazione più semplice)

Spiegazione

 Æ   Ç   +X v
UoX{UoZ{Z+X v}}  // Ungolfed
                 // Implicit: U = input number
UoX{          }  // Create the range [0...U), and map each item X to
    UoZ{     }   //   create the range [0...U), and map each item Z to
        Z+X      //     Z + X
            v    //     is divisible by 2.
                 // Implicit: output result of last expression

Una cosa interessante da notare è che nonv è un built-in "divisibile per 2". Invece, è un "divisibile per X" incorporato. Tuttavia, a differenza della maggior parte delle lingue del golf, le funzioni di Japt non hanno un'arità fissa (possono accettare qualsiasi numero di argomenti giusti). Quando vengono forniti 0 argomenti giusti, si assume che tu lo voglia , e quindi agisce esattamente come è stato dato invece di niente.v22

— ETHproductions
fonte
7

Haskell , 50 41 39 38 byte

Grazie a nimi e xnor per l'aiuto nella rasatura di un totale di 9 10 byte

f n=r[r"10",r"01"]where r=take n.cycle

In alternativa, per un byte in più:

(!)=(.cycle).take
f n=n![n!"10",n!"01"]

o:

r=flip take.cycle
f n=r[r"10"n,r"01"n]n

Probabilmente un approccio non ottimale, ma pulito e diretto.

— Julian Wolf
fonte
concat.repeatè cycle: n!l=take n$cycle l. Se si va pointfree Conserva più un byte: (!)=(.cycle).take.
— nimi,
Bello! Sapevo che c'era un builtin per questo, ma non riuscivo a ricordare il nome della mia vita
— Julian Wolf,
Stavo per suggerire f n|r<-take n.cycle=r[r"10",r"01"]o simili. ma Haskell sembra dedurre il tipo sbagliato per r? Funziona con la digitazione esplicita f n|r<-take n.cycle::[a]->[a]=r[r"10",r"01"].
— xnor
1
@JulianWolf Haskell sembra avere difficoltà a dedurre i tipi polimorfici
— xnor
1
@zbw Ho pensato che fosse così, ma l'utilizzo NoMonomorphismRestrictionnon ha aiutato. Nemmeno Rank2Typeso RankNTypes. Sai cosa sta succedendo lì?
— xnor
5

APL (Dyalog) , 8 byte

~2|⍳∘.+⍳

Provalo online!

Spiegazione

Chiamiamo l'argomento n.

⍳∘.+⍳

Questo crea una matrice

1+1 1+2 1+2 .. 1+n
2+1 2+2 2+3 .. 2+n
...
n+1 n+2 n+3 .. n+n

Quindi 2|prende il modulo 2 della matrice (vettorializza) dopodiché ~prende il NOT del risultato.

— Kritixi Lithos
fonte
4

JavaScript ES6, 55 54 51 46 byte

Salvato 1 byte grazie a @Neil

Salvato 2 byte grazie a @Arnauld

n=>[...Array(n)].map((_,i,a)=>a.map(_=>++i&1))

Provalo online!

Questo produce una matrice di array. Le gamme JavaScript sono piuttosto complesse ma io uso [...Array(n)]che genera una matrice di dimensionin

— Downgoat
fonte
Utilizzare i parametri dell'indice è ancora un byte più breve:n=>[...Array(n)].map((_,i,a)=>a.map((_,j)=>(i+j+1)%2))
— Neil,
@Neil eh, non avrei mai pensato di usare il terzo parametro nella mappa, grazie!
— Downgoat,
@Arnauld grazie! che mi ha ispirato a salvare altri 5 byte!
— Downgoat,
4

Retina , 33 30 byte

.+
$*
1
$_¶
11
10
T`10`01`¶.+¶

Provalo online! Spiegazione: Il primo stadio converte l'ingresso in unario usando 1s (convenientemente!) Mentre il secondo stadio trasforma il valore in un quadrato. Il terzo stadio inverte bit alternati su ogni riga mentre l'ultimo stadio inverte bit su righe alternate. Modifica: salvato 3 byte grazie a @MartinEnder.

— Neil
fonte
$`1$'è giusto $_.
— Martin Ender,
@MartinEnder Ah, non ho familiarità con $_, grazie!
— Neil,
3

MATL , 7 byte

:t!+2\~

Provalo online!

Spiegazione:

         % Implicit input (n)
:        % Range from 1-n, [1,2,3]
 t       % Duplicate, [1,2,3], [1,2,3]
  !      % Transpose, [1,2,3], [1;2;3]
   +     % Add        [2,3,4; 3,4,5; 4,5,6]
    2    % Push 2     [2,3,4; 3,4,5; 4,5,6], 2
     \   % Modulus    [0,1,0; 1,0,1; 0,1,0]
      ~  % Negate     [1,0,1; 0,1,0; 1,0,1]

Nota: ho iniziato a risolverlo in MATL dopo aver pubblicato la sfida.

— Stewie Griffin
fonte
Equivalente e più breve::&+o~
— Luis Mendo,
1
Ancora imparando :-) Aggiornerò domani. Mi è piaciuto anche il tuo altro approccio :-)
— Stewie Griffin,
1
Questo è anche quello che mi è venuto in mente. Ehi, usi solo il puro set di istruzioni MATL, non quelle fastidiose Yistruzioni usate da @LuisMendo.
— Sanchises,
@Sanchises Pesky, eh ? :-P
— Luis Mendo,
3

Brachylog , 15 byte

^₂⟦₁%₂ᵐ;?ḍ₎pᵐ.\

Provalo online!

Spiegazione

Example Input: 4

^₂               Square:                            16
  ⟦₁             1-indexed Range:                   [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]
    %₂ᵐ          Map Mod 2:                         [1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0]
       ;?ḍ₎      Input-Chotomize:                   [[1,0,1,0],[0,1,0,1],[1,0,1,0],[0,1,0,1]]
           pᵐ.   Map permute such that..
             .\  ..the output is its own transpose: [[1,0,1,0],[0,1,0,1],[1,0,1,0],[0,1,0,1]]
— Fatalize
fonte
3

Clojure, 36 byte

#(take %(partition % 1(cycle[1 0])))

Sì, lo strumento giusto per il lavoro.

— NikoNyrh
fonte
3

05AB1E , 9 7 byte

-2 byte grazie a Emigna

LDÈD_‚è

Provalo online!

Spiegazione

LDÈD_‚sè» Argument n
LD        Push list [1 .. n], duplicate
  ÈD      Map is_uneven, duplicate
    _     Negate boolean (0 -> 1, 1 -> 0)
     ‚    List of top two elements of stack
      è   For each i in [1 .. n], get element at i in above created list
          In 05AB1E the element at index 2 in [0, 1] is 0 again
— kalsowerus
fonte
È possibile tagliare »come output dell'elenco di elenchi è ok e si può anche rimuovere s.
— Emigna,
@Emigna Sì, grazie!
— Kalsowerus,
La spiegazione è un po 'irrilevante.
— Erik the Outgolfer,
3

Java (OpenJDK 8) , 80 77 byte

-3 byte grazie a Kevin Cruijssen

j->{String s="1";for(int i=1;i<j*j;s+=i++/j+i%j&1)s+=1>i%j?"\n":"";return s;}

Provalo online!

Oh guarda, una risposta java di lunghezza semi ragionevole, con molti operatori divertenti.

lambda che prende un int e restituisce una stringa. Funziona usando il numero di riga e il numero di colonna usando / e% per determinare quale valore dovrebbe essere, mod 2;

Ungolfed:

j->{
    String s="1";
    for(int i=1; i<j*j; s+= i++/j + i%j&1 )
        s+= 1>i%j ? "\n" : "";
    return s;
}
— PunPun1000
fonte
È possibile rimuovere lo spazio per salvare un byte. La sfida afferma che il formato di output è flessibile. Oh, e puoi salvare altri due byte cambiando (i++/j+i%j)%2in i++/j+i%j&1così non avrai bisogno di quelle parentesi. Il che rende il totale di 1 byte più breve della mia soluzione for-loop nidificata ( n->{String r="";for(int i=0,j;i++<n;r+="\n")for(j=0;j<n;r+=j+++i&1);return r;}), quindi +1 da parte mia. :)
— Kevin Cruijssen il
@KevinCruijssen Sì, stavo ancora aspettando una risposta nello spazio. Non ci ho pensato e ho una precedenza superiore a% e & 1 ==% 2
— PunPun1000
2

Carbone, 8 byte

ＵＯＮ10¶01

Provalo online! Spiegazione: Ciò si traduce approssimativamente nel seguente codice dettagliato (sfortunatamente il deverbosificatore sta attualmente aggiungendo un separatore non necessario):

Oblong(InputNumber(), "10\n01");
— Neil
fonte
2

R , 38 37 byte

n=scan();(matrix(1:n,n,n,T)+1:n-1)%%2

Provalo online!

-1 byte grazie a Giuseppe

Sfrutta le regole di riciclaggio di R, in primo luogo durante la creazione della matrice, e in secondo luogo quando si aggiunge 0: (n-1) a quella matrice.

— user2390246
fonte
Puoi rilasciare un byte eliminando il te invece costruendo la matrice con byrow=T, ad esempio,(matrix(1:n,n,n,T)+1:n-1)%%2
— Giuseppe
1
outer(1:n,1:n-1,"+")%%2è piuttosto breve di alcuni byte :)
— JAD,
2

Swi-Prolog, 142 byte.

t(0,1).
t(1,0).
r([],_).
r([H|T],H):-t(H,I),r(T,I).
f([],_,_).
f([H|T],N,B):-length(H,N),r(H,B),t(B,D),f(T,N,D).
c(N,C):-length(C,N),f(C,N,1).

Prova online - http://swish.swi-prolog.org/p/BuabBPrw.pl

Emette un elenco nidificato, quindi le regole dicono:

  • t() è un interruttore, rende 0 -> 1 e 1 -> 0.
  • r() riesce per una singola riga, che è un controllo ricorsivo in basso di una riga che è solo alternato e zero.
  • f()controlla ricorsivamente tutte le righe, che sono della giusta lunghezza, con cui sono valide r()e che ogni riga inizia con uno 0/1 diverso.
  • c(N,C) dice che C è una scacchiera valida di dimensione N se il numero di righe (elenchi nidificati) è N e l'helper f ha esito positivo.

Casi test: inserisci qui la descrizione dell'immagine

— TessellatingHeckler
fonte
2

C, 69 67 63 byte

Grazie a @Kevin Cruijssen per aver salvato due byte e @ceilingcat per aver salvato quattro byte!

i,j;f(n){for(i=n;i--;puts(""))for(j=n;j;)printf("%d",j--+i&1);}

Provalo online!

— Steadybox
fonte
È possibile rimuovere lo spazio in printf("%d ", poiché questo è un altro metodo valido di output.
— Conor O'Brien,
@ ConorO'Brien Sì, grazie.
— Steadybox,
È possibile salvare due byte cambiando (j+++i)%2in j+++i&1per rimuovere quelle parentesi.
— Kevin Cruijssen,
@ceilingcat Grazie!
— Steadybox
1

QBIC , 19 byte

[:|?[b|?(a+c+1)%2';

Spiegazione

[:|         FOR a = 1 to b (b is read from cmd line)
?           PRINT - linsert a linebreak in the output
[b|         FOR c = 1 to b
?(a+c+1)%2  PRINT a=c=1 modulo 2 (giving us the 1's and 0's
';            PRINT is followed b a literal semi-colon, suppressing newlines and 
              tabs. Printing numbers in QBasic adds one space automatically.
— steenbergh
fonte
1

/// , 87 byte + input

/V/\\\///D/VV//*/k#D#k/k#D&k/k&DVk/k\D/SD/#/r
DSkk/10DSk/1D&/V#rV#0r;VV0;VVV1;V\D/r/S/&[unary input in asterisks]

Provalo online! (input per 4)

Input unario in 1s, 95 byte + input

/V/\\\///D/VV//&1/k#&D&|D/#k/k#D&k/k&DVk/k\D/SD/#/r
DSkk/10DSk/1D&/V#rV#0r;VV0;VVV1;V\D/r/S/&&[unary input in ones]|

Provalo online! (input per 8)

Come funziona?

  • Ve Dsono a golf \/e //rispettivamente.

  • /*/k#/e /&1/k#&//&|//separare l'input nell'equivalente di'k#'*len(input())

  • /#k//k#//&k/k&//\/k/k\//sposta tutte le ks nel /r/S/blocco

  • Sgli s sono usati solo per riempire istanze dove kvengono dopo /s in modo che non vengano spostati altrove e gli Ss vengono quindi rimossi

  • #s vengono quindi trasformati in r\ns

  • La stringa di ks viene trasformata in una 1010...stringa alternata

  • Le r\ns si trasformano in 1010...\ns

  • Ogni coppia di 1010...\n1010\nviene trasformata in1010...\01010...;\n

  • Sia 0;o 1;siano rifilata (perché la 01010...stringa è troppo lungo da 1)

— boboquack
fonte
1

Mathematica, 28 byte

Cos[+##/2Pi]^2&~Array~{#,#}&

Funzione pura che accetta un intero positivo come input e restituisce un array 2D. Utilizza la funzione periodica cos² (πx / 2) per generare 1 e 0 secondi.

Per un po 'più di divertimento, che ne dici della soluzione a 32 byte

Sign@Zeta[1-+##]^2&~Array~{#,#}&

che utilizza le posizioni dei banali zeri della funzione zeta di Riemann.

— Greg Martin
fonte
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.