Créer une matrice en damier

26

Prenez un entier positif n en entrée et sortez une matrice de damier n par n composée de 1 et 0 .

Le chiffre en haut à gauche doit toujours être 1 .

Cas de 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

Les formats d'entrée et de sortie sont facultatifs. La sortie de la matrice sous forme de liste de listes est acceptée.

code-golf number matrix Stewie Griffin
la source
Une liste de chaînes est-elle OK?
xnor
Oui, ça va.
Stewie Griffin
1
Connexes .
bécher
2
Vos exemples montrent des espaces entre les nombres sur la même ligne, est-ce nécessaire, pour ressembler davantage à un carré?
BradC
@BradC ce n'est pas obligatoire. La première approche ici est valable.
Stewie Griffin

Réponses:

12

Gelée , 4 octets

52 secondes!

+€ḶḂ

Essayez-le en ligne!

Leaky Nun
la source
7
"52 secondes!" comme si je n'y étais pas habitué ...
Erik the Outgolfer
5
Avez-vous, comme un bip, que vous portez 24/7 pour les nouveaux défis PPCG?
Magic Octopus Urn
@carusocomputing Ceux qui ont une connexion Internet plus rapide sont généralement les plus chanceux qui gagneront.
Erik the Outgolfer
9

MATL , 5 octets

:otYT

Essayez-le sur MATL en ligne!

Explication

Considérez la saisie 4comme exemple.

:    % 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
la source
7

Japt , 6 octets

ÆÇ+X v

Testez-le en ligne! (Utilise le -Qdrapeau pour une visualisation plus facile)

Explication

 Æ   Ç   +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

Une chose intéressante à noter est que ce vn'est pas un "divisible par 2" intégré. Au lieu de cela, c'est un "divisible par X" intégré. Cependant, contrairement à la plupart des langages de golf, les fonctions de Japt n'ont pas d'arité fixe (elles peuvent accepter n'importe quel nombre d'arguments de droite). Lorsque 0 argument de droite est donné, vsuppose que vous vouliez 2, et agit donc exactement comme il a été donné 2au lieu de rien.

ETHproductions
la source
7

V , 16 , 15 octets

Ài10À­ñÙxñÎÀlD

Essayez-le en ligne!

Hexdump:

00000000: c069 3130 1bc0 adf1 d978 f1ce c06c 44    .i10.....x...lD
DJMcMayhem
la source
7

Haskell , 50 41 39 38 octets

Merci à nimi et xnor d'avoir aidé à raser un total de 9 10 octets

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

Alternativement, pour un octet de plus:

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

ou:

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

Probablement sous-optimal, mais une approche claire et simple.

Julian Wolf
la source
concat.repeatest cycle: n!l=take n$cycle l. Si vous allez Pointfree enregistre un octet: (!)=(.cycle).take.
nimi
Charmant! Je savais qu'il y avait une fonction intégrée pour cela, mais je ne me souvenais pas du nom pour ma vie
Julian Wolf
J'allais suggérer f n|r<-take n.cycle=r[r"10",r"01"]ou similaire. mais Haskell semble inférer le mauvais type pour r? Cela fonctionne avec une frappe explicite f n|r<-take n.cycle::[a]->[a]=r[r"10",r"01"].
xnor
1
@JulianWolf Haskell semble avoir du mal à déduire les types polymorphes
xnor
1
@zbw Je pensais que c'était le cas mais l'utilisation NoMonomorphismRestrictionn'a pas aidé. Ni fait Rank2Typesni RankNTypes. Savez-vous ce qui se passe là-bas?
xnor
5

APL (Dyalog) , 8 octets

~2|⍳∘.+⍳

Essayez-le en ligne!

Explication

Appelons l'argument n.

⍳∘.+⍳

Cela crée une 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

Prend ensuite le 2|modulo 2 de la matrice (il vectorise) après quoi ~prend le NON du résultat.

Kritixi Lithos
la source
4

Mathematica, 25 octets

1-Plus~Array~{#,#}~Mod~2&
Martin Ender
la source
4

JavaScript ES6, 55 54 51 46 octets

1 octet enregistré grâce à @Neil

Sauvegardé 2 octets grâce à @Arnauld

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

Essayez-le en ligne!

Cela sort comme un tableau de tableaux. Les plages JavaScript sont assez peu pratiques, mais j'utilise [...Array(n)]ce qui génère un tableau de taillen

Downgoat
la source
C'est encore un octet plus court pour utiliser les paramètres d'index:n=>[...Array(n)].map((_,i,a)=>a.map((_,j)=>(i+j+1)%2))
Neil
@Neil hein, je n'ai jamais pensé utiliser le troisième paramètre dans la carte, merci!
Downgoat
@Arnauld merci! cela m'a inspiré pour économiser 5 octets de plus!
Downgoat
4

Rétine , 33 30 octets

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

Essayez-le en ligne! Explication: Le premier étage convertit l'entrée en unaire à l'aide de 1s (commodément!) Tandis que le deuxième étage transforme la valeur en carré. La troisième étape inverse les bits alternés sur chaque ligne tandis que la dernière étape inverse les bits sur les lignes alternatives. Edit: sauvé 3 octets grâce à @MartinEnder.

Neil
la source
$`1$'est juste $_.
Martin Ender
@MartinEnder Ah, je ne suis pas familier avec $_, merci!
Neil
3

MATL , 7 octets

:t!+2\~

Essayez-le en ligne!

Explication:

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

Remarque: J'ai commencé à résoudre ce problème dans MATL après avoir posté le défi.

Stewie Griffin
la source
Équivalent et plus court::&+o~
Luis Mendo
1
J'apprends encore :-) Je mettrai à jour demain. J'ai aussi aimé votre autre approche :-)
Stewie Griffin
1
C'est ce que j'ai trouvé aussi. Et bon, vous n'utilisez que le jeu d'instructions MATL pur , pas les Yinstructions modifiées embêtantes que @LuisMendo utilise.
Sanchises
@Sanchises Pesky, hein ? :-P
Luis Mendo
3

Brachylog , 15 octets

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

Essayez-le en ligne!

Explication

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
la source
3

Clojure, 36 octets

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

Oui, le bon outil pour le travail.

NikoNyrh
la source
3

05AB1E , 9 7 octets

-2 octets grâce à Emigna

LDÈD_‚è

Essayez-le en ligne!

Explication

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
la source
Vous pouvez couper la »sortie en tant que liste de listes, mais vous pouvez également la supprimer s.
Emigna
@Emigna Yep, merci!
kalsowerus
L'explication est un peu hors de propos.
Erik the Outgolfer
3

Java (OpenJDK 8) , 80 77 octets

-3 octets grâce à 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;}

Essayez-le en ligne!

Oh regardez, une réponse java de longueur semi-raisonnable, avec beaucoup d'opérateurs amusants.

lambda qui prend un entier et renvoie une chaîne. Fonctionne en utilisant le numéro de ligne et le numéro de colonne en utilisant / et% pour déterminer quelle valeur il doit être, mod 2;

Non golfé:

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
la source
Vous pouvez supprimer l'espace pour enregistrer un octet. Le défi indique que le format de sortie est flexible. Oh, et vous pouvez enregistrer deux octets supplémentaires en changeant (i++/j+i%j)%2en i++/j+i%j&1afin que vous n'ayez pas besoin de ces parenthèses. Ce qui rend le total 1 octet plus court que ma solution imbriquée pour boucle ( n->{String r="";for(int i=0,j;i++<n;r+="\n")for(j=0;j<n;r+=j+++i&1);return r;}), donc +1 de ma part. :)
Kevin Cruijssen
@KevinCruijssen Ouais, j'attendais toujours une réponse sur l'espace. Je n'ai pas pensé à & avoir une priorité plus élevée que% et & 1 ==% 2
PunPun1000
2

Fusain, 8 octets

ＵＯＮ10¶01

Essayez-le en ligne! Explication: Cela se traduit approximativement par le code détaillé suivant (malheureusement, le déverbosificateur ajoute actuellement un séparateur inutile):

Oblong(InputNumber(), "10\n01");
Neil
la source
2

Pyth , 9 octets

VQm%+hdN2

Essaye ça!

une autre solution de 9 octets:

mm%+hdk2Q

Essayez!

KarlKastor
la source
2

Mathematica, 23 octets

ToeplitzMatrix@#~Mod~2&
alephalpha
la source
2

R , 38 37 octets

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

Essayez-le en ligne!

-1 octet grâce à Giuseppe

Profite des règles de recyclage de R, d'une part lors de la création de la matrice, et d'autre part lors de l'ajout de 0: (n-1) à cette matrice.

user2390246
la source
Vous pouvez supprimer un octet en vous débarrassant de tet en construisant la matrice avec byrow=T, c'est-à-dire(matrix(1:n,n,n,T)+1:n-1)%%2
Giuseppe
1
outer(1:n,1:n-1,"+")%%2est bien plus court de quelques octets :)
JAD
2

Swi-Prolog, 142 octets.

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

Essayez en ligne - http://swish.swi-prolog.org/p/BuabBPrw.pl

Il génère une liste imbriquée, donc les règles disent:

  • t() est une bascule, elle fait 0 -> 1 et 1 -> 0.
  • r() réussit pour une ligne individuelle, qui est une vérification récursive sur une ligne qu'il s'agit uniquement de uns et de zéros alternatifs.
  • f()vérifie récursivement toutes les lignes, qu'elles sont de la bonne longueur, qu'elles sont des lignes valides avec r()et que chaque ligne commence par un 0/1 différent.
  • c(N,C) indique que C est un damier valide de taille N si le nombre de lignes (listes imbriquées) est N, et que l'aide f réussit.

Cas de test: entrez la description de l'image ici

TessellatingHeckler
la source
2

C, 69 67 63 octets

Merci à @Kevin Cruijssen pour avoir sauvé deux octets et @ceilingcat pour avoir sauvé quatre octets!

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

Essayez-le en ligne!

Steadybox
la source
Vous pouvez supprimer l'espace printf("%d ", car c'est une autre méthode de sortie valide.
Conor O'Brien
@ ConorO'Brien Oui, merci.
Steadybox
Vous pouvez enregistrer deux octets en changeant (j+++i)%2de j+++i&1supprimer ces parenthèses.
Kevin Cruijssen
@ceilingcat Merci!
Steadybox
1

QBIC , 19 octets

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

Explication

[:|         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
la source
1

PHP , 56 octets

Sortie sous forme de chaîne 

for(;$i<$argn**2;)echo++$i%2^$n&1,$i%$argn?"":"
".!++$n;

Essayez-le en ligne!

PHP , 66 octets

Sortie en réseau 2 D 

for(;$i<$argn**2;$i%$argn?:++$n)$r[+$n][]=++$i%2^$n&1;print_r($r);

Essayez-le en ligne!

Jörg Hülsermann
la source
1

CJam , 17 octets

{_[__AAb*<_:!]*<}

Essayez-le en ligne!

Renvoie une liste (le lien TIO a une sortie formatée).

Erik le Outgolfer
la source
hors-
golf
@ Challenger5 Désolé, vous ne pouvez pas surpasser avec la réponse supprimée.
Erik the Outgolfer
1

/// , 87 octets + entrée

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

Essayez-le en ligne!(entrée pour 4)

Entrée unaire en 1s, 95 octets + entrée

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

Essayez-le en ligne!(entrée pour 8)

Comment cela marche-t-il?

  • Vet Dsont au golf \/et //respectivement.

  • /*/k#/et /&1/k#&//&|//séparez l'entrée en l'équivalent de'k#'*len(input())

  • /#k//k#//&k/k&//\/k/k\//déplacer tous les ks vers le /r/S/bloc

  • Sles s sont juste utilisés pour remplir les instances où ks viennent après /s afin qu'ils ne soient pas déplacés ailleurs, et les Ss sont ensuite supprimés

  • #s sont ensuite transformés en r\ns

  • La chaîne de ks est transformée en une 1010...chaîne alternée

  • Les r\ns sont transformés en 1010...\ns

  • Chaque paire 1010...\n1010\nest transformée en1010...\01010...;\n

  • Soit 0;ou 1;sont coupés (car la 01010...chaîne est trop longue de 1)

boboquack
la source
1

Mathematica, 28 octets

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

Fonction pure prenant un entier positif en entrée et renvoyant un tableau 2D. Utilise la fonction périodique cos² (πx / 2) pour générer les 1 et les 0.

Pour un peu plus de plaisir, que diriez-vous de la solution de 32 octets

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

qui utilise les emplacements des zéros triviaux de la fonction zêta de Riemann.

Greg Martin
la source