Raccolta da una sequenza che costituisce un quadrato perfetto


10

Data la sequenza OEIS A033581 , che è la sequenza infinita, il n 'esimo termine (0-indicizzazione) è dato dalla forma formula chiusa 6 × n 2 .

Il tuo compito è quello di scrivere il codice, che genera tutti i sottoinsiemi dell'insieme di N primi numeri nella sequenza, in modo tale che la somma del sottoinsieme sia un quadrato perfetto.

Regole

  • L'intero Nviene fornito come input.
  • Non è possibile riutilizzare un numero già utilizzato nella somma. (ovvero, ogni numero può apparire in ogni sottoinsieme al massimo una volta)
  • I numeri utilizzati possono essere non consecutivi.
  • Il codice con la dimensione minima vince.

Esempio

La sequenza indicata è {0,6,24,54,96, ..., 15000}

Uno dei sottoinsiemi richiesti sarà {6,24,294}, perché

6+24+294 = 324 = 18^2

È necessario trovare tutti questi insiemi di tutte le lunghezze possibili nell'intervallo indicato.


3
Buon primo post! Puoi prendere in considerazione l'aggiunta di esempi e casi di test. Per riferimento futuro, abbiamo una sandbox in cui puoi
provare le

Ci sta chiedendo di calcolare A033581 dato N? O non lo capisco correttamente?
ATaco,

@ATaco Come per una sequenza (1,9,35,39 ...) 1 + 9 + 39 = 49 un quadrato perfetto (usa 3 numeri), 35 + 1 = 36 un altro quadrato perfetto ma usa 2 numeri. Quindi {1,35} è il set richiesto.
prog_SAHIL

3
@prog_SAHIL Aggiungere questo, e alcuni altri, come esempi al post sarebbe utile :)
Οurous

Risposte:


3

05AB1E , 10 byte

ݨn6*æʒOŲ

Provalo online!

Come?

ݨn6 * æʒOŲ || Programma completo. Chiamerò l'ingresso N.

Ý || Gamma inclusiva basata su 0. Premere [0, N] ∩ ℤ.
 ¨ || Rimuovi l'ultimo elemento.
  n || Quadrato (per quanto riguarda l'elemento).
   6 * || Moltiplicare per 6.
     æ || Powerset.
      ʒ || Filtra-conserva quelli che soddisfano i seguenti requisiti:
       O || --- | La loro somma ...
        Ų || --- | ... è una piazza perfetta?

3

Haskell , 114 104 103 86 byte

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

Grazie a Laikoni e Ørjan Johansen per la maggior parte del golf! :)

Provalo online!

La versione leggermente più leggibile:

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

@Laikoni È molto geniale! Grazie!
Cristian Lupascu,

@Laikoni Right! Grazie!
Cristian Lupascu,


2

Pyth , 12 byte

-2 byte grazie a Mr. Xcoder

fsI@sT2ym*6*

Provalo online!

Altri 2 byte devono essere aggiunti per rimuovere []e [0], ma mi sembrano output validi!


Explanataion

    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

12 byte: fsI@sT2ym*6*.
Mr. Xcoder,

Questo è il golf a quadri che stavo cercando!
Dave,

2

Pulito , 145 ... 97 byte

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@

Provalo online!

Utilizza la funzione di aiuto @per generare la potenza impostata ai ntermini concatenando ogni termine di [[],[6*n^2],...]con ciascun termine in [[],[6*(n-1)*2],...]modo ricorsivo e in ordine inverso.

La funzione parziale fviene quindi composta (dove ->indica la ocomposizione) come:
apply @ -> take the elements where -> the sum -> is a square

Sfortunatamente non è possibile saltare il f=e fornire una funzione parziale letterale , perché le regole di precedenza richiedono che abbiano parentesi quando usato in linea.


1
Bah hai un trucco che la risposta di Haskell dovrebbe rubare ...: P
Ørjan Johansen



1

JavaScript (ES7), 107 byte

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

dimostrazione

Commentate

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

0

Japt , 15 byte

ò_²*6Ãà k_x ¬u1

Provalo


Spiegazione

Generare su array di numeri interi da 0 a input ( ò) e passare ciascuno attraverso una funzione ( _ Ã), ²quadrandolo ( ) e mutiplicando per 6 ( *6). Ottieni tutte le combinazioni di quell'array ( à) e rimuovi quelle che restituiscono verità ( k) quando passano attraverso una funzione ( _) che aggiunge i loro elementi ( x), ottiene la radice quadrata del risultato ( ¬) e le mod che di 1 ( u1)

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.