Dada a sequência OEIS A033581 , que é a sequência infinita, o n '° termo (0-indexação) é dada pela fórmula fechado forma 6 × N ² .

Sua tarefa é escrever o código, que gera todos os subconjuntos do conjunto de N primeiros números na sequência, de forma que a soma do subconjunto seja um quadrado perfeito.

Regras

• O número inteiro Né dado como entrada.
• Você não pode reutilizar um número já usado na soma. (ou seja, cada número pode aparecer em cada subconjunto no máximo uma vez)
• Os números usados ​​podem ser não consecutivos.
• O código com o menor tamanho vence.

Exemplo

A sequência fornecida é {0,6,24,54,96, ..., 15000}

Um dos subconjuntos necessários será {6,24.294}, porque

6+24+294 = 324 = 18^2

Você precisa encontrar todos esses conjuntos de todos os comprimentos possíveis no intervalo especificado.

05AB1E , 10 bytes

ݨn6*æʒOŲ

Experimente online!

Como?

ݨn6 * æʒOŲ || Programa completo. Vou chamar a entrada N.

Ý || Intervalo inclusivo baseado em 0. Pressione [0, N] ∩ ℤ.
 ¨ || Remova o último elemento.
  n || Quadrado (elemento a elemento).
   6 * || Multiplique por 6.
     æ || Conjunto de força.
      ʒ || Mantenha os filtros satisfeitos com o seguinte:
       O || --- | A soma deles ...
        Ų || --- | ... É um quadrado perfeito?

Haskell , 114 104 103 86 bytes

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

Obrigado a Laikoni e Ørjan Johansen pela maior parte do golfe! :)

Experimente online!

A versão um pouco mais legível:

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

Pitão , 12 bytes

-2 bytes graças ao Sr. Xcoder

fsI@sT2ym*6*

Experimente online!

Mais 2 bytes precisam ser adicionados para remover []e [0], mas parecem saída válida para mim!

Explicação

    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

Limpo , 145 ... 97 bytes

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@

Experimente online!

Usa a função auxiliar @para gerar a energia definida em ntermos concatenando cada termo de [[],[6*n^2],...]com cada termo de forma [[],[6*(n-1)*2],...]recursiva e na ordem inversa.

A função parcial fé então composta (onde ->denota ocomposição) como:
apply @ -> take the elements where -> the sum -> is a square

Infelizmente, não é possível pular o f=e fornecer uma literal de função parcial , porque as regras de precedência exigem que ele tenha colchetes quando usado em linha.

Gelatina , 12 bytes

Ḷ²6׌PSƲ$Ðf

Experimente online!

Saída é uma lista de subconjuntos, incluindo 0s e o subconjunto vazio.

Wolfram Language (Mathematica) , 49 bytes

Abordagem de força bruta

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

Experimente online!

JavaScript (ES7), 107 bytes

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

Demo

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

Comentado

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

Japonês , 15 bytes

ò_²*6Ãà k_x ¬u1

Tente

Explicação

Gere na matriz de números inteiros de 0 a input ( ò) e passe cada um por uma função ( _ Ã), ao quadrado ( ²) e mutiplicando por 6 ( *6). Obtenha todas as combinações desse array ( à) e remova aquelas que retornam verdade ( k) quando passadas por uma função ( _) que adiciona seus elementos ( x), obtém a raiz quadrada do resultado ( ¬) e mods que por 1 ( u1)