introduction

XOR est une porte logique numérique qui implémente un ou exclusif. La plupart du temps, cela apparaît comme ^. Les quatre résultats possibles en binaire:

0 ^ 0 = 0
0 ^ 1 = 1
1 ^ 0 = 1
1 ^ 1 = 0

Cela peut également être considéré comme l'addition modulo 2 en binaire. En décimal, nous devons convertir la décimale en binaire, 35 = 100011et pour 25 = 11001calculer la valeur XOR, nous les plaçons les uns sur les autres:

100011
 11001 ^
--------
111010  = 58 in decimal

La tâche : Lorsque la valeur entière N est supérieure à 1, affichez une table XOR de taille N + 1. Par exemple, N = 5:

 0 1 2 3 4 5
 1 0 3 2 5 4
 2 3 0 1 6 7
 3 2 1 0 7 6
 4 5 6 7 0 1
 5 4 7 6 1 0

Vous pouvez voir qu'il y a un espace devant chaque nombre, car le montant le plus élevé du tableau a une longueur 1. Cependant, si nous prenons N = 9, nous obtenons la grille suivante:

  0  1  2  3  4  5  6  7  8  9
  1  0  3  2  5  4  7  6  9  8
  2  3  0  1  6  7  4  5 10 11
  3  2  1  0  7  6  5  4 11 10
  4  5  6  7  0  1  2  3 12 13
  5  4  7  6  1  0  3  2 13 12
  6  7  4  5  2  3  0  1 14 15
  7  6  5  4  3  2  1  0 15 14
  8  9 10 11 12 13 14 15  0  1
  9  8 11 10 13 12 15 14  1  0

La valeur la plus élevée a une longueur 2, donc la valeur est alignée à droite sur la longueur 3 (longueur la plus élevée + 1).

Règles:

• Le premier espace n'est pas obligatoire, uniquement s'il est utilisé (ou non) de manière cohérente
• Vous devez générer un tableau sous la forme indiquée ci-dessus.
• Le remplissage entre les colonnes doit être aussi petit que possible
• C'est du code-golf , donc la soumission avec le moins d'octets gagne!

MATL , 10 octets

0i2$:tXgZ~

Le compilateur (et en particulier ce programme) semble maintenant fonctionner dans Octave, bien qu'il ait encore besoin d'être amélioré. Vous pouvez utiliser provisoirement ce commit GitHub .

Edit (30 mars 16) : Essayez-le en ligne!

Exemple

>> matl 0i2$:tXgZ~
> 9
0  1  2  3  4  5  6  7  8  9
1  0  3  2  5  4  7  6  9  8
2  3  0  1  6  7  4  5 10 11
3  2  1  0  7  6  5  4 11 10
4  5  6  7  0  1  2  3 12 13
5  4  7  6  1  0  3  2 13 12
6  7  4  5  2  3  0  1 14 15
7  6  5  4  3  2  1  0 15 14
8  9 10 11 12 13 14 15  0  1
9  8 11 10 13 12 15 14  1  0

Explication

0i2$:       % vector 0, 1, 2, ... up to input number
t           % duplicate
Xg          % nd-grid
Z~          % bitxor

Utilitaires Bash + BSD, 45

eval echo \$[{0..$1}^{0..$1}]|rs -jg1 $[$1+1]

J'attends depuis longtemps pour trouver une utilisation rs. Cela semble être une bonne chose. rspeut devoir être installé sur des systèmes Linux. Mais il fonctionne immédiatement sur OS X.

• $1se développe en N, et se echo \$[{0..$1}^{0..$1}]développe ainsi enecho $[{0..N}^{0..N}]
• Ceci est ensuite evaléd:
• L'expansion de l'accolade s'étend jusqu'à $[0^0] $[0^1] $[0^2] ... $[0^N] ... $[N^N]
• Ceci est une série d'extensions arithmétiques xor qui s'étendent à une seule ligne de termes
• rs(remodeler) remodèle cette ligne en N + 1 lignes. -jjustifie à droite et -g1donne une largeur de gouttière de 1. Cela garantit que la table de sortie finale a une largeur minimale entre les colonnes.

J'ai testé jusqu'à N = 1000, ce qui a pris 3,8 secondes. Un grand N est théoriquement possible, bien que bash manquera de mémoire à un moment donné avec l'utilisation de la mémoire (N + 1) ² de l'extension d'accolade.

C, 114 128 152

Edit Comptage d'espace simplifié, inspiré par le travail de Khaled A Khunaifer

Fonction AC conforme aux spécifications.

T(n){int i=0,j,x=1,d=0;while(x<=n)x+=x,++d;for(;i<=n;i++)for(j=0;j<=n;j++)printf("%*d%c",d*3/10+1,i^j,j<n?32:10);}

Essayez-le insérer n comme entrée, par défaut 9

Moins golfé

T(n)
{
   int i=0, j, x=1,d=0;
   while(x<=n) x+=x,++d; // count the digits
   // each binary digit is approximately 0.3 decimal digit
   // this approximation is accurate enough for the task
   for(;i<=n;i++)
     for(j=0;j<=n;j++)
       printf("%*d%c",d*3/10+1,
              i^j,
              j < n ? 32:10); // space between columns, newline at end
}

JavaScript (ES6) 120 122

Modifier 2 octets de thx ETHproductions enregistrés

Une fonction anonyme. Remarque: le nombre dans le tableau est limité à 7 chiffres, ce qui est plus que raisonnable compte tenu de la taille globale d'un tableau permettant de plus grands nombres

Maintenant, je devrais trouver un moyen plus court d'obtenir la taille maximale des colonnes, en évitant les logarithmes

n=>(a=Array(n+1).fill(-~Math.log10(2<<Math.log2(n)))).map((m,i)=>a.map((z,j)=>`       ${i^j}`.slice(~m)).join``).join`
`

Tester

f=n=>(a=Array(n+1).fill(-~Math.log10(2<<Math.log2(n)))).map((m,i)=>a.map((z,j)=>`       ${i^j}`.slice(~m)).join``).join`\n`

function update() {
  var v=+I.value
  O.textContent = f(v)
}  

update()

N: <input id=I type=number value=9 oninput='update()'>
<pre id=O></pre>

C, 149 octets

int i=0,j,n,k=2;char b[256];scanf("%d",&n);while((k*=2)<=n);k^=k-1;while(i++<=n&&putchar(10))for(j=0;j<=n;j++)printf(" %*d",sprintf(b,"%d",k),i-1^j);
---------

Détaillé

#include <stdio.h>

int main()
{
    int i=0, j, n, k=2;
    char b[256] = { 0 };

    scanf("%d", &n);

    // find max xor value in the table
    while((k*=2)<=n); k^=k-1;

    printf("> %d ~ %d", k, sprintf(b,"%d",k));

    while(i++ <= n && putchar(10))
    {
        for(j = 0; j <= n;j++)
        {
            printf(" %*d", sprintf(b,"%d",k), (i-1)^j);
        }
    }

    return 0;
}

C, 103 octets

Y(n){int i,j=n++;char*f="%2u";while(j/=8)++f[1];for(;j<n;++j,puts(""))for(i=0;i<n;++i)printf(f,i^j);}

Gelée, non compétitive

7 octets Cette réponse n'est pas concurrente, car elle utilise des fonctionnalités postérieures au défi.

0r©^'®G

Essayez-le en ligne!

Comment ça fonctionne

0r©^'®G  Main link. Input: n (integer)

0r       Range; yield [0, ..., n].
  ©      Save the range in the register.

     ®   Yield the range from the register.
   ^'    XOR each integer in the left argument with each integer in the right one.
      G  Grid; separate rows by newlines, columns by spaces, with a fixed width for
         all columns. Since the entries are numeric, align columns to the right.

R, 38 octets

Habituellement, R nécessite beaucoup d'octets juste pour formater la sortie. Dans ce cas, c'est tout le contraire. outerqui se réfère généralement au produit extérieur de deux tableaux, peut, lorsqu'il est fourni, une fonction effectuer cela à travers les marges des vecteurs. Dans ce cas, nous appliquons la fonction XOR au niveau du bit bitwXor.

names(x)=x=1:scan();outer(x,x,bitwXor)

CJam, 29 27 octets

ri:X),_ff{^s2X2b,#s,)Se[}N*

Testez-le ici.

Explication

ri      e# Read input and convert to integer.
:X      e# Store in X.
),      e# Get range [0 1 ... X].
_ff{    e# Nested map over all repeated pairs from that range...
  ^     e#   XOR.
  s     e#   Convert to string.
  2     e#   Push 2.
  X2b,  e#   Get the length of the base-2 representation of X. This is the same as getting
        e#   getting the base-2 integer logarithm and incrementing it.
  #     e#   Raise 2 to that power. This rounds X up to the next power of 2.
  s,    e#   Convert to string and get length to determine column width.
  )     e#   Increment for additional padding.
  Se[   e#   Pad string of current cell from the left with spaces.
}
N*      e# Join with linefeeds.

MathCAD, 187 octets

MathCAD gère facilement les tableaux intégrés - mais n'a absolument aucun Xor au niveau du bit, ni décimal en convertisseurs binaire ou binaire en décimal. Les fonctions for parcourent les valeurs possibles. Les positions i, a2, Xa et Xb tiennent. La boucle while se convertit activement en binaire, et lors de la conversion en binaire effectue également la fonction xor (la petite croix avec le cercle qui l'entoure). Il stocke le nombre binaire dans un nombre de base 10 composé de 0 et de 1. Celui-ci est ensuite converti avant d'être stocké dans la matrice M via la fonction de sommation.

Cela peut facilement être joué au golf (ne serait-ce qu'en changeant les espaces réservés pour les plus courts), mais j'ai pensé que je le publierais et voir si quelqu'un pouvait jouer au golf sur le convertisseur binaire en décimal plus que toute autre chose.

k4, 50 octets

{-1@" "/:'(-|//#:''x)$x:$2/:''~x=/:\:x:0b\:'!1+x;}

Par exemple:

  {-1@" "/:'(-|//#:''x)$x:$2/:''~x=/:\:x:0b\:'!1+x;}9
 0  1  2  3  4  5  6  7  8  9
 1  0  3  2  5  4  7  6  9  8
 2  3  0  1  6  7  4  5 10 11
 3  2  1  0  7  6  5  4 11 10
 4  5  6  7  0  1  2  3 12 13
 5  4  7  6  1  0  3  2 13 12
 6  7  4  5  2  3  0  1 14 15
 7  6  5  4  3  2  1  0 15 14
 8  9 10 11 12 13 14 15  0  1
 9  8 11 10 13 12 15 14  1  0

Python 3, 133 131 octets

import math
n=int(input())
r,p=range(n+1),print
for y in r:[p(end='%%%dd '%len(str(2**int(math.log2(n)+1)-1))%(x^y))for x in r];p()

Mathematica, 108 octets

StringRiffle[Thread[Map[ToString,a=Array[BitXor,{#,#}+1,0],{2}]~StringPadLeft~IntegerLength@Max@a],"
"," "]&

Ignorez l'erreur, c'est simplement Threadne pas savoir ce qu'elle fait.

Emacs Lisp, 193 octets

(defun x(n)(set'a 0)(set'n(1+ n))(while(< a n)(set'b 0)(while(< b n)(princ(format(format"%%%ss "(ceiling(log(expt 2(ceiling(log n 2)))10)))(logxor a b)))(set'b(1+ b)))(set'a(1+ a))(message"")))

Non golfé:

(defun x(n)
  (set'a 0)
  (set'n(1+ n))
  (while(< a n)
    (set'b 0)
    (while(< b n)
      (princ
        (format
          ;; some format string magic to get the length of the longest
          ;; possible string as a format string
          (format "%%%ss " (ceiling(log(expt 2(ceiling(log n 2)))10)))
          (logxor a b)))
      (set'b(1+ b)))
    (set'a(1+ a))
    ;; new line
    (message"")))

La sortie est envoyée au *Message*tampon, ce qui serait le stdoutcas si elle xdevait être utilisée dans un script.

(x 9)
 0  1  2  3  4  5  6  7  8  9 
 1  0  3  2  5  4  7  6  9  8 
 2  3  0  1  6  7  4  5 10 11 
 3  2  1  0  7  6  5  4 11 10 
 4  5  6  7  0  1  2  3 12 13 
 5  4  7  6  1  0  3  2 13 12 
 6  7  4  5  2  3  0  1 14 15 
 7  6  5  4  3  2  1  0 15 14 
 8  9 10 11 12 13 14 15  0  1 
 9  8 11 10 13 12 15 14  1  0

Python 2, 114 octets

Il a fallu un peu de recherche pour trouver un moyen de faire du rembourrage à largeur variable .format()(certains, pas beaucoup) et de le régler correctement, mais je pense que j'ai tout pour le moment. Pourrait utiliser plus de golf dans ce calcul de largeur.

N=input()+1
for i in range(N):print''.join(' {n:>{w}}'.format(w=len(`2**(len(bin(N))-2)`),n=i^r)for r in range(N))

Caché ObjectScript , 127 octets

x(n)s w=$L(2**$bitfind($factor(n),1,100,-1))+1 f i=0:1:n { w $j(i,w) } f i=1:1:n { w !,$j(i,w) f j=1:1:n { w $j($zb(i,j,6),w) } }

Détaillé:

x(n)
 set w=$Length(2**$bitfind($factor(n),1,100,-1))+1
 for i=0:1:n {
     write $justify(i,w)
 }
 for i=1:1:n {
     write !,$justify(i,w)
     for j=1:1:n {
         write $justify($zboolean(i,j,6),w)
     }

 }

Pyke, 8 octets (non concurrent)

hD]UA.&P

Explication:

         - auto-add eval_or_not_input() to the stack
h        - increment the input
 D]      - Create a list containing [inp+1, inp+1]
   U     - Create a 2d range 
    A.^  - Deeply apply the XOR function to the range
       P - print it out prettily

Essayez-le ici

Python 2, 77 octets

n=input()+1
t=range(n)
for i in t: print "%3d"*n % tuple([x^i for x in t])

J , 10 octets

XOR/~@,~i.

Essayez-le en ligne!

Excel VBA, 95 octets

Fonction de fenêtre immédiate VBE anonyme qui prend les entrées de la plage [A1]et les sorties vers la console.

For y=0To[A1]:For x=0To[A1]:z=x Xor y:?Spc([Len(2^-Int(-Log(A1,2)))]-Len(z))Str(z);:Next:?:Next

Petit de base , 499 octets

Un script qui prend l'entrée de l' TextWindowobjet et la renvoie au même

a=TextWindow.Read()
For y=0To a
For x=0To a
n=x
b()
z1=z
n=y
b()
l=Math.Max(Array.GetItemCount(z),Array.GetItemCount(z1))
o=0
For i=1To l
If z1[i]<>z[i]And(z[i]=1Or z1[i]=1)Then
z2=1
Else 
z2=0
EndIf
o=o+z2*Math.Power(2,i-1)
EndFor
TextWindow.Write(Text.GetSubText("      ",1,Text.GetLength(Math.Power(2,Math.Ceiling(Math.Log(a)/Math.Log(2))))-Text.GetLength(o))+o+" ")
EndFor
TextWindow.WriteLine("")
EndFor
Sub b
z=0
c=0  
While n>0
c=c+1
z[c]=Math.Remainder(n,2)
n=Math.Floor(n/2)
EndWhile
EndSub

Essayez-le sur SmallBasic.com Utilise Silverlight et doit donc être exécuté dans IE ou Edge

Sélectionnez la console noire, puis saisissez un entier et appuyez sur Enter.

Perl 5 -n , 62 octets

for$i(0..$_){printf+(" %".(0|log).d)x($_+1).$/,map$_^$i,0..$_}

Essayez-le en ligne!