Immaginiamo di avere un insieme finito di numeri interi positivi. Questo set può essere rappresentato come una linea di punti in cui ogni numero intero presente nel set viene riempito come una scantron o una scheda perforata . Ad esempio il set {1,3,4,6}potrebbe essere rappresentato come:

*.**.*

*rappresenta un membro del nostro set e .rappresenta un numero intero che non è un membro del set.

Questi insiemi hanno "fattori". Liberamente x è un fattore di y se y può essere costruito da copie di x. Più rigorosamente la nostra definizione di fattore è la seguente:

• x è un fattore di y se e solo se y è l'unione di un numero di insiemi disgiunti , che sono tutti x con un offset.

Vorremmo chiamare *.*un fattore di *.**.*perché è chiaramente costituito da due copie di *.*fine put a fine.

*.**.*
------
*.*...
...*.*

I fattori non devono essere end-to-end, diciamo anche che *.*è un fattore di*.*.*.*

*.*.*.*
-------
*.*....
....*.*

I fattori possono anche sovrapporsi. Questo significa che *.*è anche un fattore di****

****
----
*.*.
.*.*

Tuttavia, un numero non può essere coperto da un fattore più di una volta. Ad esempio non*.* è un fattore di .*.*.*

Ecco un esempio più complicato:

 *..*.**..***.*.*

Questo ha *..*.*come fattore. Puoi vedere quello sotto dove ho allineato i tre casi di *..*.*.

*..*.**..***.*.*
----------------
*..*.*..........
......*..*.*....
..........*..*.*

Compito

Dato un set da qualsiasi rappresentazione ragionevole emetta tutti gli insiemi che sono fattori dell'input.

Puoi indicizzare per qualsiasi valore (ovvero puoi selezionare un numero più piccolo che può essere presente nell'input). Si può anche supporre che il set di input contenga sempre quel valore più piccolo.

Questa è una domanda di code-golf, quindi dovresti mirare a farlo nel minor numero di byte possibile.

Casi test

Questi casi di test sono stati fatti a mano, potrebbero esserci un errore o due su quelli più grandi

*                -> *
*.*.*            -> *, *.*.*
*.*.*.*          -> *, *.*, *...*, *.*.*.*
******           -> *, **, *..*, ***, *.*.*, ******
*..*.**..***.*.* -> *, *..*.*, *.....*...*, *..*.**..***.*.*
*...*****.**.**  -> *, *...**.**, *.....*, *...*****.**.**

Mathematica, 71 68 byte

#&@@@Cases[(s=Subsets)@s@#,x_/;Sort[Join@@x]==#&&Equal@@(#&@@@x-x)]&

Input come {1,3,5,7}(ordinato) e output come {{1, 3, 5, 7}, {1, 3}, {1, 5}, {1}}. La funzione genererà un sacco di messaggi.

Questo è O (2 ^{2 No} ) (dove N è la lunghezza dell'ingresso e o = p = e = 1 ...). Genera tutti i sottoinsiemi di sottoinsiemi, quindi seleziona quelli che determinano l'invio dell'input quando vengono uniti (garantendo che stiamo prendendo in considerazione solo le partizioni) e in cui tutti gli elementi sono uguali se sottraggiamo il valore più piccolo di ciascun sottoinsieme.

Gelatina , 12 byte

;÷@DỊȦ
ÆDçÐf

Uso input e output 1e 0anziché *e ..

Provalo online!

Come funziona

ÆDçÐf   Main link. Argument: n (integer with decimal digits 1 and 0)

ÆD      Compute all divisors of n.
  çÐf   Filter; call the helper link with left argument d and right argument n for
        all divisors d of n. Return the array of d's for which the helper link
        returns a truthy value.


;÷@DỊȦ  Helper link. Left argument: d. Right argument: n

 ÷@     Divide n by d.
;       Concatenate, yielding [d, n÷d].
   D    Decimal; convert both integers in the pair to base 10.
    Ị   Insignificant; map 1 and 0 to 1, all other positive integers to 0.
     Ȧ  All; return 1 iff the result contains no zeroes.