Dado um número n, produz uma lista ordenada de índices baseados em 1 que caem em qualquer uma das diagonais de uma n*nmatriz quadrada.

Exemplo:

Para uma entrada de 3:

O quadrado deve ser:

1 2 3
4 5 6
7 8 9

Agora, selecionamos todos os índices representados por \, /ou X( #ou as posições não diagonais são rejeitadas)

\ # /
# X #
/ # \

A saída deve ser:

[1,3,5,7,9]

Casos de teste:

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]

Não haverá resposta aceita. Quero saber o código mais curto para cada idioma.

Oitava , 28 bytes

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

Função anônima que insere um número e gera um vetor de coluna de números.

Experimente online!

JavaScript (ES6), 48 bytes

Produz uma lista separada por traços de números inteiros como uma sequência.

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

Formatado e 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 teste

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 salvos quando me lembrei da existência da whichfunção ..., 1 byte salvo graças ao @Rift

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

+4 bytes para o argumento ec=Tquando chamado como um programa completo porsource()

Experimente online!

Explicação:

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

Gelatina , 8 bytes

⁼þ`+Ṛ$ẎT

Experimente online!

Usa o algoritmo de Luis Mendo em sua resposta MATL.

Oitava , 41 37 bytes

A propósito, isso também funciona no MATLAB. Nenhuma funcionalidade específica oculta do Octave :)

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

Experimente online!

Explicação:

Em vez de criar uma matriz quadrada e encontrar as duas diagonais, imaginei que, em vez disso, calculasse as diagonais diretamente. Isso foi 17 bytes mais curto! =)

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

É assim que parece, sem unique:

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

_{Sim, eu provavelmente deveria ter mudado a ordem das diagonais para torná-la mais amigável ao ser humano.}

MATL , 6 bytes

XytP+f

Experimente online!

Explicação

A mesma abordagem da minha resposta do Oitava.

Considere a entrada 3como um exemplo.

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]

A indexação linear é baseada na coluna principal , 1. Para mais informações, consulte o fragmento length-12 aqui .

Python 2 , 54 53 bytes

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

Experimente online!

Oitava, 68 54 bytes

Obrigado a Stewie Griffin por salvar 14 bytes!

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

Experimente online!

MATLAB, 68 bytes

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

Explicação:

@(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,#}]&

Experimente online!

@KellyLowder jogou para baixo para ..

Mathematica, 37 bytes

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

e @alephalpha jogou fora a mesa!

Mathematica, 34 bytes

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

Proton , 41 bytes

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

Experimente online!

MATL , 14 bytes

U:GeGXytPY|*Xz

Experimente online!

C (gcc) , 65 58 bytes

-7 bytes graças a Titus!

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

Experimente online!

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

Experimente online!

A alteração aqui é baseada no deslocamento entre os números a serem encontrados. Os dois turnos que começam em 0 são n-1e n+1, portanto n=5, se os números para n-1seriam 0,4,8,12,16,20e para n+1seriam 0,6,12,18,24. Combiná-los e fornecer indexação 1 (em vez de indexação 0) fornece 1,5,7,9,13,17,19,21,25. O deslocamento de né obtido usando negação bit a bit (operação de complemento bit a bit), onde ~-n==n-1e -~n==n+1.

Versão antiga

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

Experimente online!

Essa abordagem usa os índices de coluna e linha para determinar se os números estão nas diagonais. i/nfornece o índice da linha e i%no índice da coluna.

Retornando apenas a matriz numérica

Se a construção de apenas a matriz numérica for considerada como contando para o custo de bytes, o seguinte poderá ser feito, com base na sugestão de Dennis.Verweij ( using System.Linq;adiciona 18 bytes extras):

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

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

Experimente online!

Javascript, 73 63 bytes

versão antiga

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

Guardado 10 bytes graças a @Shaggy

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

Golfe pela primeira vez! espero que eu não tenha estragado muito.

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

Pitão , 20 18 bytes

^{( Aqui está a versão inicial .)}

hMf|<%ThQ1<%TtQ1U*

Suíte de teste.

Pitão , 18 bytes

hMf>1*%ThQ%T|tQ1U*

Suíte de teste.

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

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

Experimente online!

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);}

Experimente online!

Porto da resposta do escoteiro .

Japt , 16 bytes

Não consigo fazer melhor que isso, mas tenho certeza de que é possível. Tivemos que sacrificar 2 bytes pelo requisito desnecessário de usar a indexação 1.

²õ f@´XvUÉ ªXvUÄ

Teste-o

Oitava, 32 bytes

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

Experimente online!

PHP, 56 54 + 1 bytes

+1 byte para -Rsinalizador

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

imprime números precedidos por traços. Execute como pipe -nRou experimente online .

requer PHP 5.6 ou posterior para o **operador.
Adicione um byte para o PHP antigo: Substitua ;$z**.5<$n=$argnpor $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 zero indexado. verifica se o imódulo n+1ou n-1é 0, se assim for i+1.