Definiamo come l'elenco di potenze distinte di che si sommano a . Ad esempio, .2 x V ( 35 ) = [ 32 , 2 , 1 $V(x)$$2$$x$$V(35)=[32,2,1]$

Per convenzione, i poteri sono ordinati qui dal più alto al più basso. Ma non influisce sulla logica della sfida, né sulle soluzioni previste.

Compito

Dato un semiprime , sostituisci ogni termine in con un altro elenco di poteri di che si sommano a questo termine, in modo tale che l'unione di tutti i sotto-elenchi risultanti sia una copertura esatta della matrice definita come:V ( N ) 2 $N$$V(N)$$2$$M$

dove e sono i fattori primi di .Q $P$$Q$$N$

Questo è molto più facile da capire con alcuni esempi.

Esempio 1

Per , abbiamo:$N=21$

• $V(N)=[16,4,1]$
• $P=7$ e$V(P)=[4,2,1]$
• $Q=3$ e$V(Q)=[2,1]$
• $M=\pmatrix{8&4&2\\4&2&1}$

Per trasformare in una copertura esatta di , possiamo dividere in 8 + 4 + 4 e 4 in 2 + 2 , mentre 1 rimane invariato. Quindi un possibile output è:M 16 8 + 4 + 4 4 2 + 2 $V(N)$$M$$16$$8+4+4$$4$$2+2$$1$

Un altro output valido è:

Esempio n. 2

Per $N=851$ , abbiamo:

• $V(N)=[512,256,64,16,2,1]$
• $P=37$ e $V(P)=[32,4,1]$
• $Q=23$ e $V(Q)=[16,4,2,1]$
• $M=\pmatrix{512&64&16\\128&16&4\\64&8&2\\32&4&1}$

Un possibile output è:

Regole

• Poiché la fattorizzazione di non è la parte principale della sfida, puoi alternativamente prendere e come input.$N$$P$$Q$
• Quando esistono diverse possibili soluzioni, è possibile restituire solo una di esse o tutte.
• Puoi alternativamente restituire gli esponenti dei poteri (ad esempio invece di ).$[[3,2,2],[1,1],[0]]$$[[8,4,4],[2,2],[1]]$
• L'ordine delle liste secondarie non ha importanza, né l'ordine dei termini in ciascuna lista secondaria.
• Per alcuni semiprimi, non dovrai dividere alcun termine perché è già una copertura perfetta di (vedi A235040 ). Ma devi ancora restituire un elenco di elenchi (singleton) come per .$V(N)$$M$$[[8],[4],[2],[1]]$$N=15$
• Questo è code-golf !

Casi test

 Input | Possible output
-------+-----------------------------------------------------------------------------
 9     | [ [ 4, 2, 2 ], [ 1 ] ]
 15    | [ [ 8 ], [ 4 ], [ 2 ], [ 1 ] ]
 21    | [ [ 8, 4, 4 ], [ 2, 2 ], [ 1 ] ]
 51    | [ [ 32 ], [ 16 ], [ 2 ], [ 1 ] ]
 129   | [ [ 64, 32, 16, 8, 4, 2, 2 ], [ 1 ] ]
 159   | [ [ 64, 32, 32 ], [ 16 ], [ 8 ], [ 4 ], [ 2 ], [ 1 ] ]
 161   | [ [ 64, 32, 16, 16 ], [ 8, 8, 4, 4, 4, 2, 2 ], [ 1 ] ]
 201   | [ [ 128 ], [ 64 ], [ 4, 2, 2 ], [ 1 ] ]
 403   | [ [ 128, 64, 64 ], [ 32, 32, 16, 16, 16, 8, 8 ], [ 8, 4, 4 ], [ 2 ], [ 1 ] ]
 851   | [ [ 512 ], [ 128, 64, 64 ], [ 32, 16, 16 ], [ 8, 4, 4 ], [ 2 ], [ 1 ] ]
 2307  | [ [ 1024, 512, 512 ], [ 256 ], [ 2 ], [ 1 ] ]

K (ngn / k) , 66 63 byte

{(&1,-1_~^(+\*|a)?+\b)_b:b@>b:,/*/:/2#a:{|*/'(&|2\x)#'2}'x,*/x}

Provalo online!

accetta (P; Q) invece di N

algoritmo:

• calcolare A come le somme parziali di V (P * Q)

• moltiplica ogni V (P) per ogni V (Q), ordina i prodotti in ordine decrescente (chiamiamolo R) e calcola le loro somme parziali B

• trova le posizioni di quegli elementi in B che si verificano anche in A; tagliare R subito dopo quelle posizioni

Gelatina , 24 byte

BṚT’2*
Ç€×þ/FṢŒṖ§⁼Ç}ɗƇPḢ

Un collegamento monadico che accetta un elenco di due numeri interi [P, Q]che produce un possibile elenco di elenchi come descritto nella domanda.

Provalo online! (il piè di pagina stampa una rappresentazione di stringa per mostrare l'elenco così com'è)

Oppure guarda la suite di test (prendendo un elenco di N e riordinando i risultati per essere come quelli nella domanda)

Come?

Possiamo sempre dividere gli elementi di dal più basso, avidamente (o c'è un 1 in M o abbiamo avuto un input di 4 , quando M = [ [ 4 ] ] ) per trovare una soluzione.$M$$1$$M$$4$$M=[[4]]$

^{Nota: il codice raccoglie tutte (una!) Tali soluzioni in un elenco e quindi prende il risultato (solo) head - cioè la testa finale è necessaria in quanto le partizioni non sono di tutti i possibili ordini.}

BṚT’2* - Link 1, powers of 2 that sum to N: integer, N    e.g. 105
B      - binary                                                [1,1,0,1,0,0,1]
 Ṛ     - reverse                                               [1,0,0,1,0,1,1]
  T    - truthy indices                                        [1,4,6,7]
   ’   - decrement                                             [0,3,5,6]
    2  - literal two                                           2
     * - exponentiate                                          [1,8,32,64]

Ç€×þ/FṢŒṖ§⁼Ç}ɗƇPḢ - Main Link: list of two integers, [P,Q]
Ç€                - call last Link (1) as a monad for €ach
    /             - reduce with:
   þ              -   table with:
  ×               -     multiplication
     F            - flatten
      Ṣ           - sort
       ŒṖ         - all partitions
              Ƈ   - filter keep if:
             ɗ    -   last three links as a dyad:
         §        -     sum each
            }     -     use right...
               P  -       ...value: product (i.e. P×Q)
           Ç      -       ...do: call last Link (1) as a monad
          ⁼       -     equal? (non-vectorising so "all equal?")
                Ḣ - head

Python 2 , 261 233 232 231 byte

g=lambda n,r=[],i=1:n and g(n/2,[i]*(n&1)+r,i*2)or r
def f(p,q):
 V=[[v]for v in g(p*q)];i=j=0
 for m in sorted(-a*b for a in g(p)for b in g(q)):
	v=V[i]
	while-m<v[j]:v[j:j+1]=[v[j]/2]*2
	i,j=[i+1,i,0,j+1][j+1<len(v)::2]
 return V

Provalo online!

1 byte da Jo King ; e un altro 1 byte a causa di Kevin Cruijssen .

Accetta come input p,q. Persegue l'algoritmo avido.

Gelatina , 41 byte

Œṗl2ĊƑ$Ƈ
PÇIP$ƇṪÇ€Œpµ³ÇIP$ƇṪƊ€ŒpZPṢ⁼FṢ$µƇ

Provalo online!

ÇIP$Ƈ$[P, Q]$

Gelatina , 34 byte

BṚT’2*
PÇŒṗæḟ2⁼ƊƇ€ŒpẎṢ⁼Ṣ}ʋƇÇ€×þ/ẎƊ

Provalo online!

Formato di input: [P, Q](il link TIO sopra non accetta questo, ma un singolo numero, per aiutare con i casi di test).

Formato di output: elenco di tutte le soluzioni (mostrato come rappresentazione a griglia dell'elenco 3D su TIO).

Velocità: tartaruga.

Pyth , 27 byte

$N$

L^2x1jb2;hfqyQsMT./S*M*FyMP

Provalo qui!

Haskell, 281 195 byte

import Data.List
r=reverse.sort
n#0=[]
n#x=[id,(n:)]!!mod x 2$(n*2)#div x 2
m!0=[]
m!x=m!!0:tail m!(x-m!!0)
m%[]=[]
m%n=m!head n:drop(length$m!head n)m%tail n
p&q=r[x*y|x<-1#p,y<-1#q]%r(1#(p*q))