Étant donné un nombre n, produire une liste ordonnée d'indices basés sur 1 tombant sur l'une des diagonales d'une n*nmatrice carrée.

Exemple:

Pour une entrée de 3:

Le carré doit être:

1 2 3
4 5 6
7 8 9

Maintenant, nous sélectionnons tous les indices représentés par \, /ou X( #ou les positions non diagonales sont rejetées)

\ # /
# X #
/ # \

La sortie doit être:

[1,3,5,7,9]

Cas de test:

1=>[1]
2=>[1,2,3,4]
3=>[1,3,5,7,9]
4=>[1,4,6,7,10,11,13,16]
5=>[1,5,7,9,13,17,19,21,25]

Il n'y aura pas de réponse acceptée. Je veux connaître le code le plus court pour chaque langue.

Octave , 28 octets

@(n)find((I=eye(n))+flip(I))

Fonction anonyme qui entre un nombre et sort un vecteur colonne de nombres.

Essayez-le en ligne!

JavaScript (ES6), 48 octets

Génère une liste d'entiers séparés par des tirets sous forme de chaîne.

f=(n,k=n*n)=>--k?f(n,k)+(k%~-n&&k%-~n?'':~k):'1'

Formaté et commenté

f = (n, k = n * n) => // given n and starting with k = n²
  --k ?               // decrement k; if it does not equal zero:
    f(n, k) + (       //   return the result of a recursive call followed by:
      k % ~-n &&      //     if both k % (n - 1) and
      k % -~n ?       //             k % (n + 1) are non-zero:
        ''            //       an empty string
      :               //     else:
        ~k            //       -(k + 1) (instantly coerced to a string)
    )                 //   end of iteration
  :                   // else:
    '1'               //   return '1' and stop recursion

Cas de test

f=(n,k=n*n)=>--k?f(n,k)+(k%~-n&&k%-~n?'':~k):'1'

;[1,2,3,4,5].forEach(n => console.log(n, '->', f(n)))

R , 38 35 34 38 octets

3 octets enregistrés quand je me souviens de l'existence de la whichfonction ..., 1 octet enregistré grâce à @Rift

d=diag(n<-scan());which(d|d[n:1,])

+4 octets pour l'argument ec=Tlorsqu'il est appelé en tant que programme complet parsource()

Essayez-le en ligne!

Explication:

n<-scan()            # take input
d=diag(n);           # create an identity matrix (ones on diagonal, zeros elsewhere)
d|d[n:1,]            # coerce d to logical and combine (OR) with a flipped version
which([d|d[n:1,]])   # Find indices for T values in the logical expression above

Gelée , 8 octets

⁼þ`+Ṛ$ẎT

Essayez-le en ligne!

Utilise l'algorithme de Luis Mendo sur sa réponse MATL.

Octave , 41 37 octets

Cela fonctionne également dans MATLAB. Aucune fonctionnalité spécifique à Octave sournoise :)

@(x)unique([x:x-1:x^2-1;1:x+1:x*x+1])

Essayez-le en ligne!

Explication:

Au lieu de créer une matrice carrée et de trouver les deux diagonales, j'ai pensé plutôt calculer directement les diagonales. C'était 17 octets de moins! =)

@(x)                                   % Anonymous function that takes 'x' as input
    unique(...                   ...)  % unique gives the unique elements, sorted
           [x:x-1:x^2-1                % The anti-diagonal (is that the correct word?)
                       ;               % New row
                        1:x+1:x*x+1])  % The regular diagonal

Voilà à quoi ça ressemble, sans unique:

ans =    
    6   11   16   21   26   31
    1    8   15   22   29   36

_{Oui, j'aurais probablement dû inverser l'ordre des diagonales pour le rendre plus convivial.}

MATL , 6 octets

XytP+f

Essayez-le en ligne!

Explication

Même approche que ma réponse Octave.

Considérez l'entrée 3comme exemple.

Xy   % Implicit input. Identity matrix of that size
     % STACK: [1 0 0;
               0 1 0;
               0 0 1]
t    % Duplicate
     % STACK: [1 0 0
               0 1 0
               0 0 1],
              [1 0 0
               0 1 0
               0 0 1]
P    % Flip vertically
     % STACK: [1 0 0
               0 1 0
               0 0 1],
              [0 0 1
               0 1 0
               1 0 0]
+    % Add
     % STACK: [1 0 1
               0 2 0
               1 0 1]
f    % Linear indices of nonzero entries. Implicit display  
     % STACK:[1; 3; 5; 7; 9]

L'indexation linéaire est basée sur une colonne , basée sur 1. Pour plus d'informations, voir l'extrait de longueur 12 ici .

Python 2 , 54 53 octets

lambda n:[i+1for i in range(n*n)if i%-~n<1or i%~-n<1]

Essayez-le en ligne!

Octave, 68 54 octets

Merci à @Stewie Griffin pour avoir économisé 14 octets!

@(x)unique([diag(m=reshape(1:x^2,x,x)),diag(flip(m))])

Essayez-le en ligne!

MATLAB, 68 octets

x=input('');m=reshape([1:x*x],x,x);unique([diag(m) diag(flipud(m))])

Explication:

@(x)                               % Anonymous function
m=reshape([1:x*x],x,x);            % Create a vector from 1 to x^2 and
                                   % reshape it into an x*x matrix.
diag(m)                            % Find the values on the diagonal.
diag(flip(m))                      % Flip the matrix upside down and
                                   % find the values on the diagonal.
unique([])                         % Place the values from both diagonals
                                   % into a vector and remove duplicates.

Mathematica, 42 octets

Union@Flatten@Table[{i,#+1-i}+i#-#,{i,#}]&

Essayez-le en ligne!

@KellyLowder l'a joué jusqu'à ..

Mathematica, 37 octets

##&@@@Table[{i-#,1-i}+i#,{i,#}]⋃{}&

et @alephalpha a jeté la table!

Mathematica, 34 octets

Union@@Range[{1,#},#^2,{#+1,#-1}]&

Proton , 41 octets

n=>[i+1for i:0..n*n if!(i%-~n)or!(i%~-n)]

Essayez-le en ligne!

MATL , 14 octets

U:GeGXytPY|*Xz

Essayez-le en ligne!

C (gcc) , 65 58 octets

-7 octets grâce à Titus!

f(n,i){for(i=0;i<n*n;i++)i%-~n&&i%~-n||printf("%d ",i+1);}

Essayez-le en ligne!

C # (.NET Core) , 97 83 octets

f=>{var s="[";for(int i=0;i<n*n-1;)s+=i%-~n<1|i++%~-n<1?i+",":"";return s+n*n+"]";}

Essayez-le en ligne!

Le changement ici est basé sur le décalage entre les nombres à rechercher. Les deux quarts de travail à partir de 0 sont n-1et n+1, donc si n=5, les chiffres pour n-1serait 0,4,8,12,16,20et pour n+1seraient 0,6,12,18,24. La combinaison de ces éléments et l'indexation 1 (au lieu de l'indexation 0) donne 1,5,7,9,13,17,19,21,25. Le décalage par rapport à nest obtenu en utilisant la négation au niveau du bit (opération de complément au niveau du bit), où ~-n==n-1et-~n==n+1 .

Ancienne version

f=>{var s="[";for(int i=0;i<n*n-1;i++)s+=(i/n!=i%n&&n-1-i/n!=i%n?"":i+1+",");return s+$"{n*n}]";}

Essayez-le en ligne!

Cette approche utilise les indices de colonne et de ligne pour déterminer si les nombres sont sur les diagonales. i/ndonne l'index de ligne et i%nl'index de colonne.

Retourner uniquement le tableau de nombres

Si la construction uniquement du tableau de nombres est réputée compter pour le coût en octets, alors ce qui suit pourrait être fait, sur la base de la suggestion de Dennis.Verweij ( using System.Linq;ajoute 18 octets supplémentaires):

C # (.NET Core) , 66 + 18 = 84 octets

x=>Enumerable.Range(1,x*x).Where(v=>~-v%~-x<1|~-v%-~x<1).ToArray()

Essayez-le en ligne!

Javascript, 73 63 octets

ancienne version

n=>[...Array(y=n*n).keys(),y].filter(x=>(--x/n|0)==x%n||(x/n|0)==n-x%n-1)

10 octets enregistrés grâce à @Shaggy

n=>[...Array(n*n)].map((_,y)=>y+1).filter(x=>!(--x%-~n&&x%~-n))

Golf pour la première fois! j'espère que je ne me suis pas trop trompé.

let f=n=>[...Array(n*n)].map((_,y)=>y+1).filter(x=>!(--x%-~n&&x%~-n));
[1,2,3,4,5].forEach(n=>console.log(f(n)))

Pyth , 20 18 octets

^{( Voici la version initiale .)}

hMf|<%ThQ1<%TtQ1U*

Suite de tests.

Pyth , 18 octets

hMf>1*%ThQ%T|tQ1U*

Suite de tests.

Perl 5 , 56 + 1 (-n) = 57 octets

!(($_+1+$_/$,)%$,&&$_%($,+1))&&say++$_ for 0..($,=$_)**2

Essayez-le en ligne!

Java (OpenJDK 8) , 71 octets

n->{for(int i=0;i<n*n;i++)if(i%-~n<1||i%~-n<1)System.out.println(i+1);}

Essayez-le en ligne!

Port de scottinet's answer .

Japt , 16 octets

Je n'arrive pas à faire mieux que ça mais je suis sûr que c'est possible. J'ai dû sacrifier 2 octets pour l'exigence inutile d'utiliser 1-indexation.

²õ f@´XvUÉ ªXvUÄ

Essaye-le

Octave, 32 octets

@(n)find((m=abs(--n:-2:-n))==m')

Essayez-le en ligne!

PHP, 56 54 + 1 octets

+1 octet pour le -Rdrapeau

for(;$z**.5<$n=$argn;$z++)$z%-~$n&&$z%~-$n||print~+$z;

imprime les nombres précédés de tirets. Exécuter en tant que pipe avec -nRou l' essayer en ligne .

nécessite PHP 5.6 ou version ultérieure pour l' **opérateur.
Ajoutez un octet pour les anciens PHP: remplacez ;$z**.5<$n=$argnpar $z=$argn;$z<$n*$n.

Rubis, 45 octets

->n{(n*n).times{|i|i%-~n>0&&i%~-n>0||p(i+1)}}

Fonctionne en interne comme indexé zéro. vérifie si imodulo n+1ou n-1vaut 0, si c'est le cas, imprime i+1.