Sortie des positions diagonales de moi au carré

18

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

code-golf  math  matrix 
— sergiol
source
1
La question consiste à demander les indices (indexés 1) des caractères \, / et X dans les images. Pas une mauvaise question en soi, mais manque d'explication.
— Arfie
Si vous êtes prêt à fournir une explication brève et claire de ce que vous voulez, nous allons probablement rouvrir cela, car ce n'est pas un mauvais défi. Pour l'instant, ce n'est pas très clair
— M. Xcoder
J'ai voté pour la réouverture, bien que vous souhaitiez également déplacer les images ascii hors de la zone d'exemples pour éviter toute confusion. Au début, je ne savais pas si je devais aussi les produire (mais je comprends que la sortie souhaitée n'est que la liste des indices)
— Arfie
7
La commande est-elle importante?
— M. Xcoder du
9
FWIW Je pense qu'avoir une commande non pertinente pourrait rendre les golfs plus intéressants ...
— Jonathan Allan

Réponses:

7

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

Afficher l'extrait de code

— Arnauld
source
Belle solution de contournement, en utilisant les signes comme séparateurs. Pourriez-vous utiliser bitwsie &pour enregistrer un octet?
— Shaggy
@Shaggy Non, ça ne marcherait pas. Par exemple: 4%3et 4%5n'ont pas de 1 bit en commun, mais les deux sont différents de zéro.
— Arnauld
Ouais, je l'ai juste testé avec n=5et j'ai remarqué que ça ne marcherait pas.
— Shaggy
k%~-n&&k%-~ndevrait marcher. belle astuce avec le séparateur!
— Titus
@Titus Ce n'est pas vraiment important pour le golf, mais ... oui, cela pourrait être légèrement plus lisible. :-) (mis à jour)
— Arnauld
7

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
— user2390246
source
1
-1 octetd=diag(n<-scan());which(d|d[n:1,])
— Rift
Lorsque vous l'exécutez en tant que programme complet ( source), cela n'imprime rien. Vous devez appeler cat. Voir ce post sur meta .
— JAD
@JarkoDubbeldam Assez juste! J'avais toujours travaillé sur la base qu'il donne une sortie valide sur TIO, jamais vraiment considéré les exigences d'être un "programme complet".
— user2390246
Bien que je ne prévoie pas de revenir en arrière et de modifier toutes mes anciennes réponses pour résoudre ce problème!
— user2390246
C'est un peu vague, car l'environnement de console de R et les extraits de code sont le principal moyen de l'utiliser. N'hésitez pas à partager des informations sur ce fil méta que j'ai lié. Il n'a pas reçu beaucoup de commentaires.
— JAD
5

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.

— Stewie Griffin
source
5

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 .

— Luis Mendo
source
Que signifie «transposer»?
— Erik the Outgolfer
@EriktheOutgolfer Désolé, ma mauvaise. test en double, pas transposé. En outre, j'ai ajouté un exemple élaboré
— Luis Mendo
Incroyable! Cela me prendrait deux boucles si je veux accomplir cela.
— mr5
@LuisMendo Je m'en doutais, car transposer une matrice d'identité n'a aucun sens ... hmm, j'ai réussi à sauvegarder un octet avec votre algorithme.
— Erik the Outgolfer
4

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.
— Steadybox
source
@LuisMendo Merci, Jimi est mon préféré.
— Steadybox
4

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}]&
— J42161217
source
##&@@@Table[{i-#,1-i}+i#,{i,#}]⋃{}&est 5 octets plus court
— Kelly Lowder
Union@@Range[{1,#},#^2,{#+1,#-1}]&
— alephalpha
2

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!

— Ayb4btu
source
vous pouvez réduire le code en vous débarrassant du supplément &. L'extra &n'est là que pour casser la comparaison si la première entrée est fausse MSDN
— Dennis.Verweij
en fait, vous pouvez avoir 92 octets en utilisant Linq Essayez-le en ligne!
— Dennis.Verweij
@ Dennis.Verweij Neat, je ne savais pas combien je pouvais passer à l'en-tête ou au pied de page dans TIO. Je vais jouer avec le mien.
— Ayb4btu
vous devez vous rappeler d'inclure 18 octets pour la référence à linq (en utilisant System.Linq;) ce qui est regrettable, mais comment cela fonctionne: S
— Dennis.Verweij
Ah ok. Mais ce n'est pas nécessaire pour using System;? (Je suppose que l'envelopper namespace System.Linqn'est pas valide?)
— Ayb4btu
2

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

Afficher l'extrait de code

— Marco Lepore
source
Bienvenue chez PPCG :) Une solution similaire à celle sur laquelle je travaillais (seule la mienne est indexée 0). Vous pourriez être en mesure d'économiser quelques octets en utilisant ce qui suit dans votre filterfonction: !(--x%(n+1)&&x%(n-1))et en créant votre tableau comme ceci:[...Array(n*n+1).keys()]
— Shaggy
@Shaggy Merci! J'essaierai d'améliorer la réponse avec votre suggestion dès que je rentrerai du travail!
— Marco Lepore
Je vous en prie. Soit dit en passant: " c'est un peu plus court que de créer une [1...n*n]plage avecArray(n*n).fill().map((x,i)=>i+1) " - [...Array(n*n)].map((_,y)=>y+1)est une façon plus courte de le faire, pour référence future.
— Shaggy
A fait un peu plus avec elle et s'est retrouvé avec cela pour 56 octets:n=>[...Array(n*n+1).keys()].filter(x=>!(--x%-~n&&x%~-n))
— Shaggy
@Shaggy J'ai essayé votre dernière version mais elle produirait un zéro supplémentaire pour f (1) et f (2), mais elle fonctionne avec une plage [1 ... n * n], donc j'ai utilisé la façon dont vous m'avez montré dans le commentaire précédent. Ou peut-être que j'ai tout gâché?
— Marco Lepore
1

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

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

Essayez-le en ligne!

— Xcali
source
«-N» ne devrait-il pas être +3?
— sergiol
1
Non. La ligne de commande supposée est perl -e. La ligne de commande de cet exemple serait perl -ne. C'est une différence de +1.
— Xcali
1

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

— Hirsute
source
0

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.

— Titus
source
0

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.

— Level River St
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.