Nous définissons comme la liste des puissances distinctes de qui totalisent . Par exemple, .2 x V ( 35 ) = [ 32 , 2 , 1 $V(x)$$2$$x$$V(35)=[32,2,1]$

Par convention, les pouvoirs sont classés ici du plus élevé au plus bas. Mais cela n'affecte pas la logique du défi, ni les solutions attendues.

Tâche

Étant donné un semi-premier , remplacer chaque terme dans par une autre liste de puissances de qui résument ce terme, de telle sorte que l'union de toutes les sous-listes résultantes soit une couverture exacte de la matrice définie comme:V ( N ) 2 $N$$V(N)$$2$$M$

où et sont les facteurs premiers de .Q $P$$Q$$N$

C'est beaucoup plus facile à comprendre avec quelques exemples.

Exemple 1

Pour , nous avons:$N=21$

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

Pour transformer en une couverture exacte de , nous pouvons diviser en et en , tandis que reste inchangé. Une sortie possible est donc:M 16 8 + 4 + 4 4 2 + 2 $V(N)$$M$$16$$8+4+4$$4$$2+2$$1$

Une autre sortie valide est:

Exemple # 2

Pour , nous avons:$N=851$

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

Une sortie possible est:

Règles

• Parce que la factorisation de n'est pas la partie principale du défi, vous pouvez alternativement prendre et en entrée.$N$$P$$Q$
• Lorsque plusieurs solutions possibles existent, vous pouvez soit renvoyer une seule d'entre elles, soit toutes.
• Vous pouvez alternativement renvoyer les exposants des pouvoirs (par exemple au lieu de ).$[[3,2,2],[1,1],[0]]$$[[8,4,4],[2,2],[1]]$
• L'ordre des sous-listes n'a pas d'importance, pas plus que l'ordre des termes dans chaque sous-liste.
• Pour certains semi-premiers, vous n'aurez pas à diviser un terme car est déjà une couverture parfaite de (voir A235040 ). Mais vous devez toujours renvoyer une liste de listes (singleton) telles que pour .M [ [ 8 ] , [ 4 ] , [ 2 ] , [ 1 ] ] N = $V(N)$$M$$[[8],[4],[2],[1]]$$N=15$
• C'est du code-golf !

Cas de 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 octets

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

Essayez-le en ligne!

accepte (P; Q) au lieu de N

algorithme:

• calculer A comme les sommes partielles de V (P * Q)

• multiplier chaque V (P) par chaque V (Q), trier les produits par ordre décroissant (appelons cela R) et calculer leurs sommes partielles B

• trouver les positions de ces éléments dans B qui se produisent également dans A; couper R juste après ces positions

Gelée , 24 octets

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

Un lien monadique acceptant une liste de deux entiers [P, Q]qui donne une liste possible de listes comme décrit dans la question.

Essayez-le en ligne! (le pied de page imprime une représentation sous forme de chaîne pour afficher la liste telle qu'elle est réellement)

Ou voir la suite de tests (prendre une liste de N et réorganiser les résultats pour être comme ceux de la question)

Comment?

On peut toujours découper les éléments de du plus bas vers le haut, goulûment (soit il y a un 1 dans M soit on a une entrée de 4 , quand M = [ [ 4 ] ] ) afin de trouver une solution.$M$$1$$M$$4$$M=[[4]]$

^{Remarque: le code rassemble toutes (une!) Ces solutions dans une liste et prend ensuite le résultat de la tête (uniquement) - c'est-à-dire que la tête finale est nécessaire car les partitions ne sont pas de tous les ordres possibles.}

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 octets

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

Essayez-le en ligne!

1 octet de Jo King ; et un autre octet dû à Kevin Cruijssen .

Prend en entrée p,q. Poursuit l'algorithme gourmand.

Gelée , 41 octets

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

Essayez-le en ligne!

ÇIP$Ƈ$[P, Q]$

Gelée , 34 octets

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

Essayez-le en ligne!

Format d'entrée: [P, Q](le lien TIO ci-dessus n'accepte pas cela, mais un seul numéro à la place, pour faciliter les cas de test).

Format de sortie: Liste de toutes les solutions (représentée sous forme de représentation de grille de la liste 3D sur TIO).

Vitesse: tortue.

Pyth , 27 octets

$N$

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

Essayez-le ici!

Haskell, 281195 octets

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