Compte tenu de la séquence OEIS A033581 , qui est la séquence infinie, la n ième terme (0-indexation) est donnée par la formule de la forme fermée 6 × n ² .

Votre tâche consiste à écrire du code, qui génère tous les sous-ensembles de l'ensemble des N premiers nombres de la séquence, de sorte que la somme du sous-ensemble soit un carré parfait.

Règles

• L'entier Nest donné en entrée.
• Vous ne pouvez pas réutiliser un nombre déjà utilisé dans la somme. (c'est-à-dire que chaque numéro peut apparaître au plus une fois dans chaque sous-ensemble)
• Les nombres utilisés peuvent être non consécutifs.
• Le code avec la plus petite taille gagne.

Exemple

La séquence donnée est {0,6,24,54,96, ..., 15000}

L'un des sous-ensembles requis sera {6,24,294}, car

6+24+294 = 324 = 18^2

Vous devez trouver tous ces ensembles de toutes les longueurs possibles dans la plage donnée.

05AB1E , 10 octets

ݨn6*æʒOŲ

Essayez-le en ligne!

Comment?

ݨn6 * æʒOŲ || Programme complet. J'appellerai l'entrée N.

Ý || Plage inclusive basée sur 0. Appuyez sur [0, N] ∩ ℤ.
 ¨ || Supprimez le dernier élément.
  n || Carré (par élément).
   6 * || Multipliez par 6.
     æ || Powerset.
      ʒ || Filtrez-gardez ceux qui satisfont aux critères suivants:
       O || --- | Leur somme ...
        Ų || --- | ... est un carré parfait?

Haskell , 114104103 86 octets

f n=[x|x<-concat<$>mapM(\x->[[],[x*x*6]])[0..n-1],sum x==[y^2|y<-[0..],y^2>=sum x]!!0]

Merci à Laikoni et Ørjan Johansen pour la majeure partie du golf! :)

Essayez-le en ligne!

La version légèrement plus lisible:

--  OEIS A033581
ns=map((*6).(^2))[0..]

-- returns all subsets of a list (including the empty subset)
subsets :: [a] -> [[a]]
subsets[]=[[]]
subsets(x:y)=subsets y++map(x:)(subsets y)

-- returns True if the element is present in a sorted list
t#(x:xs)|t>x=t#xs|1<2=t==x

-- the function that returns the square subsets
f :: Int -> [[Int]]
f n = filter (\l->sum l#(map(^2)[0..])) $ subsets (take n ns)

Pyth , 12 octets

-2 octets grâce à M. Xcoder

fsI@sT2ym*6*

Essayez-le en ligne!

2 octets supplémentaires doivent être ajoutés pour supprimer []et [0], mais ils me semblent être une sortie valide!

Explication

    fsI@sT2ym*6*
    f                  filter
           y           the listified powerset of
            m*6*ddQ    the listified sequence {0,6,24,...,$input-th result}
        sT             where the sum of the sub-list
     sI@  2            is invariant over int parsing after square rooting

Nettoyer , 145 ... 97 octets

import StdEnv
@n=[[]:[[6*i^2:b]\\i<-[0..n-1],b<- @i]]
f=filter((\e=or[i^2==e\\i<-[0..e]])o sum)o@

Essayez-le en ligne!

Utilise la fonction d'assistance @pour générer la puissance définie en ntermes en concaténant chaque terme de [[],[6*n^2],...]avec chaque terme de [[],[6*(n-1)*2],...]récursivement et dans l'ordre inverse.

La fonction partielle fest alors composée (où ->dénote la ocomposition) comme:
apply @ -> take the elements where -> the sum -> is a square

Malheureusement, il n'est pas possible d'ignorer le f=et de fournir un littéral de fonction partiel , car les règles de priorité nécessitent qu'il ait des crochets lorsqu'il est utilisé en ligne.

Gelée , 12 octets

Ḷ²6׌PSƲ$Ðf

Essayez-le en ligne!

La sortie est une liste de sous-ensembles, y compris 0s et le sous-ensemble vide.

Wolfram Language (Mathematica) , 49 octets

Approche par force brute

Select[Subsets[6Range[#]^2],Sqrt@Tr@#~Mod~1==0&]&

Essayez-le en ligne!

JavaScript (ES7), 107 octets

n=>[...Array(n)].reduce((a,_,x)=>[...a,...a.map(y=>[6*x*x,...y])],[[]]).filter(a=>eval(a.join`+`)**.5%1==0)

Démo

let f =

n=>[...Array(n)].reduce((a,_,x)=>[...a,...a.map(y=>[6*x*x,...y])],[[]]).filter(a=>eval(a.join`+`)**.5%1==0)

console.log(f(6).map(a => JSON.stringify(a)).join('\n'))
console.log(f(10).map(a => JSON.stringify(a)).join('\n'))

Commenté

n =>                      // n = input
  [...Array(n)]           // generate a n-entry array
  .reduce((a, _, x) =>    // for each entry at index x:
    [                     //   update the main array a[] by:
      ...a,               //     concatenating the previous values with
      ...a.map(           //     new values built from the original ones
        y =>              //     where in each subarray y:
          [ 6 * x * x,    //       we insert a new element 6x² before
            ...y       ]  //       the original elements
      )                   //     end of map()
    ],                    //   end of array update
    [[]]                  //   start with an array containing an empty array
  )                       // end of reduce()
  .filter(a =>            // filter the results by keeping only elements for which:
    eval(a.join`+`) ** .5 //   the square root of the sum
    % 1 == 0              //   gives an integer
  )                       // end of filter()

Japt , 15 octets

ò_²*6Ãà k_x ¬u1

Essayez-le

Explication

Générez sur un tableau d'entiers de 0 à input ( ò) et passez chacun par une fonction ( _ Ã), ²mettez-la au carré ( ) et multipliez-la par 6 ( *6). Obtenez toutes les combinaisons de ce tableau ( à) et supprimez celles qui retournent truey ( k) lorsqu'elles sont passées par une fonction ( _) qui ajoute leurs éléments ( x), obtient la racine carrée du résultat ( ¬) et modifie cela par 1 ( u1)