Dado un número n, genera una lista ordenada de índices basados ​​en 1 que caen en cualquiera de las diagonales de una n*nmatriz cuadrada.

Ejemplo:

Para una entrada de 3:

El cuadrado será:

1 2 3
4 5 6
7 8 9

Ahora seleccionamos todos los índices representados por \, /oX ( #o se rechazan las posiciones no diagonales)

\ # /
# X #
/ # \

El resultado será:

[1,3,5,7,9]

Casos de prueba:

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]

No habrá respuesta aceptada. Quiero saber el código más corto para cada idioma.

Octava , 28 bytes

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

Función anónima que ingresa un número y genera un vector de columna de números.

Pruébalo en línea!

JavaScript (ES6), 48 bytes

Emite una lista de enteros separados por guiones como una cadena.

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

Formateado y comentado

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

Casos de prueba

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 bytes

3 bytes guardados cuando recordé la existencia de la whichfunción ..., 1 byte guardado gracias a @Rift

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

+4 bytes para el argumento ec=Tcuando se llama como un programa completo porsource()

Pruébalo en línea!

Explicación:

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

Jalea , 8 bytes

⁼þ`+Ṛ$ẎT

Pruébalo en línea!

Utiliza el algoritmo de Luis Mendo en su respuesta MATL.

Octava , 41 37 bytes

Por cierto, esto también funciona en MATLAB. Sin funcionalidad furtiva de Octave específica :)

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

Pruébalo en línea!

Explicación:

En lugar de crear una matriz cuadrada y encontrar las dos diagonales, pensé que preferiría calcular las diagonales directamente. ¡Esto fue 17 bytes más corto! =)

@(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

Esto es lo que parece, sin unique:

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

_{Sí, probablemente debería haber cambiado el orden de las diagonales para hacerlo más amigable con los humanos.}

MATL , 6 bytes

XytP+f

Pruébalo en línea!

Explicación

El mismo enfoque que mi respuesta Octave.

Considere la entrada 3como un ejemplo.

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]

La indexación lineal es la columna mayor , basada en 1. Para obtener más información, consulte el fragmento de longitud 12 aquí .

Python 2 , 54 53 bytes

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

Pruébalo en línea!

Octava, 68 54 bytes

¡Gracias a @Stewie Griffin por guardar 14 bytes!

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

Pruébalo en línea!

MATLAB, 68 bytes

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

Explicación:

@(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 bytes

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

Pruébalo en línea!

@KellyLowder lo jugó hasta ..

Mathematica, 37 bytes

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

y @alephalpha tiró la mesa!

Mathematica, 34 bytes

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

Protón , 41 bytes

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

Pruébalo en línea!

MATL , 14 bytes

U:GeGXytPY|*Xz

Pruébalo en línea!

C (gcc) , 65 58 bytes

-7 bytes gracias a Titus!

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

Pruébalo en línea!

C # (.NET Core) , 97 83 bytes

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

Pruébalo en línea!

El cambio aquí se basa en el cambio entre números para encontrar. Los dos turnos que comienzan en 0 son n-1y n+1, por lo tanto n=5, si , los números para n-1sería 0,4,8,12,16,20y para n+1sería 0,6,12,18,24. Combinando estos y dando 1-indexación (en lugar de 0-indexación) da 1,5,7,9,13,17,19,21,25. El desplazamiento desde nse logra utilizando la negación bit a bit (operación de complemento bit a bit), donde ~-n==n-1y -~n==n+1.

Versión antigua

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}]";}

Pruébalo en línea!

Este enfoque utiliza los índices de columna y fila para determinar si los números están en las diagonales. i/nda el índice de la fila y i%nda el índice de la columna.

Devolviendo solo la matriz de números

Si se considera que construir solo la matriz de números cuenta para el costo de bytes, entonces se podría hacer lo siguiente, según la sugerencia de Dennis.Verweij ( using System.Linq;agrega 18 bytes adicionales):

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

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

Pruébalo en línea!

Javascript, 73 63 bytes

versión antigua

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

Guardado 10 bytes gracias a @Shaggy

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

Primera vez jugando al golf! Espero no haberlo estropeado demasiado.

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 bytes

^{( Aquí está la versión inicial ).}

hMf|<%ThQ1<%TtQ1U*

Banco de pruebas.

Pyth , 18 bytes

hMf>1*%ThQ%T|tQ1U*

Banco de pruebas.

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

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

Pruébalo en línea!

Java (OpenJDK 8) , 71 bytes

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

Pruébalo en línea!

La respuesta del puerto de scottinet .

Japt , 16 bytes

Parece que no puede hacerlo mejor que esto, pero estoy seguro de que es posible. Tuve que sacrificar 2 bytes por el requisito innecesario de que usáramos 1 indexación.

²õ f@´XvUÉ ªXvUÄ

Pruébalo

Octava, 32 bytes

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

Pruébalo en línea!

PHP, 56 54 + 1 bytes

+1 byte para -Rbandera

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

imprime números precedidos por guiones. Ejecutar como tubería -nRo probarlo en línea .

requiere PHP 5.6 o posterior para el **operador.
Agregue un byte para PHP anterior: Reemplace ;$z**.5<$n=$argncon $z=$argn;$z<$n*$n.

Ruby, 45 bytes

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

Funciona internamente como cero indexado. comprueba si imódulo n+1o n-1es 0, si es así imprime i+1.