In questa sfida abbiamo imparato un modo per codificare ogni numero intero positivo usando alberi dei fattori.

Ecco come funziona:

• La stringa vuota ha valore 1.

• (S)dove si Strova qualsiasi espressione con un valore di S viene valutata come S primo.

• ABdove Ae Bsono espressioni arbirary con valori di A e B ha rispettivamente valore A * B .

Ad esempio, se volessimo rappresentare 7, lo faremmo

  7 -> (4) -> (2*2) -> ((1)(1)) -> (()())

Risulta che possiamo rappresentare ogni numero intero usando questo metodo. In effetti alcuni numeri possiamo rappresentare in più modi. Poiché la moltiplicazione è commutativa, 10 è entrambe le cose

((()))()

e

()((()))

Allo stesso tempo, alcuni numeri possono essere rappresentati solo in 1 modo. Prendi 8 per esempio. 8 può essere rappresentato solo come

()()()

E poiché tutti i nostri atomi sono uguali, non possiamo usare la commutabilità per riorganizzarli.

Quindi ora la domanda è "Quali numeri possono essere rappresentati solo in 1 modo?". La prima osservazione è quella che ho appena iniziato a fare lì. Sembra che i poteri perfetti abbiano alcune proprietà speciali. Sotto ulteriori indagini possiamo trovare 36, che è 6 ² è un potere perfetto ma ha molteplici rappresentazioni.

(())()(())()
(())()()(())
()(())()(())
()(())(())()
()()(())(())

E questo ha senso perché 6 è già riordinabile, quindi anche qualsiasi numero che facciamo su 6 deve essere riorganizzabile.

Quindi ora abbiamo una regola:

• Un numero ha una rappresentazione unica se è un potere perfetto di un numero con una rappresentazione unica.

Questa regola può aiutarci a ridurre la determinazione se un numero composto è univoco per determinare se un numero primo è univoco. Ora che abbiamo quella regola, vogliamo capire cosa rende unico un numero primo . Questo è in realtà abbastanza evidente. Se prendiamo un numero univoco e lo racchiudiamo tra parentesi, il risultato deve essere univoco e, in caso contrario, se n ha rappresentazioni multiple, l' n- prime deve avere rappresentazioni multiple. Questo produce la seconda regola:

• L' n primo è unico se e solo se n è unico.

Entrambe queste regole sono ricorsive, quindi avremo bisogno di un caso base. Qual è il numero univoco più piccolo? Si potrebbe essere tentati di dire 2 perché è giusto (), ma 1, la stringa vuota, è ancora più piccola ed è unica.

• 1 è unico.

Con queste tre regole possiamo determinare se un numero ha un albero dei fattori univoco.

Compito

Potresti averlo visto arrivare, ma il tuo compito è prendere un numero intero positivo e determinare se è univoco. È necessario scrivere un programma o una funzione che esegue questo calcolo. Dovresti generare uno di due possibili valori, quali sono questi valori dipende da te, ma uno dovrebbe rappresentare "sì", essendo output quando l'input è univoco e uno dovrebbe rappresentare "no" in output altrimenti.

Le risposte dovrebbero essere classificate in byte con meno byte migliori.

Casi test

Ecco i primi numeri univoci della coppia:

1
2
3
4
5
7
8
9
11
16
17
19
23
25
27
31

Casi di prova suggeriti

5381 -> Unique

Sembra che OEIS A214577 sia in qualche modo correlato, quindi se hai bisogno di più casi di prova prova lì, ma non so che sono gli stessi, quindi usa a tuo rischio.

Buccia , 11 10 byte

Salvato un byte grazie a Zgarb!

Ωεo?oṗ←¬Ep

Restituisce 1per unico, 0altrimenti

Provalo online! O restituendo i primi 50

Spiegazione:

Ωε              Until the result is small (either 1 or 0), we repeat the following
         p     Get the prime factors
  o?           If ...
        E      they are all equal:
    ȯṗ←           Get the index of the first one into the primes
               Else:
       ¬          Not the list (since non-empty lists are truthy, this returns 0)

Gelatina , 10 byte

^{Dopo un sacco di armeggiare!}

ÆET0ṪḊ?µl¿

Un collegamento monadico che prende un numero intero positivo e ritorna 1se è unico o 0no.

Provalo online!

Come?

ÆET0ṪḊ?µl¿ - Link: number, n     e.g. 11          or 13            or 20
         ¿ - while:
        l  - ...condition: (left) logarithm with base (right)
           -               note: x log 0 and x log 1 both yield None, which is falsey
       µ   - ...do the monadic chain: (first pass shown)
ÆE         -   prime exponent array   [0,0,0,0,1]    [0,0,0,0,0,1]    [2,0,1]
  T        -   truthy indexes         [5]            [6]              [1,3]
      ?    -   if:
     Ḋ     -   ...condition: dequeue (i.e. if length > 1)
   0       -   ...then: literal zero   -              -               0
    Ṫ      -   ...else: tail           5              6               -
           - end result                1              0               0

Aspetta, logaritmo, cosa ?!

Vediamo alcuni esempi del loop.

Se n=31( 31 ¹ , l'undicesimo primo):

log test # |  left, x |  right, b |  x log b
-----------+----------+-----------+----------
         1 |       31 |        31 |    1.000 -> continue
         2 |       11 |        31 |    0.698 -> continue
         3 |        5 |        11 |    0.671 -> continue
         4 |        3 |         5 |    0.683 -> continue
         5 |        2 |         3 |    0.631 -> continue
         6 |        1 |         2 |    0.000 -> stop, yielding left = 1

Se n=625( 5 ⁴ ):

log test # |  left, x |  right, b |  x log b
-----------+----------+-----------+----------
         1 |      625 |       625 |    1.000 -> continue
         2 |        3 |       625 |    0.171 -> continue
         3 |        2 |         3 |    0.631 -> continue
         4 |        1 |         2 |    0.000 -> stop, yielding left = 1

Se n=225( 5 ² × 3 ² ):

log test # |  left, x |  right, b |  x log b
-----------+----------+-----------+----------
         1 |      225 |       225 |    1.000 -> continue
         2 |     *  0 |       225 |-inf+nanj -> continue
         3 |     ** 0 |         0 |     None -> stop, yielding left = 0

*The dequeued list was not empty
**Tailing an empty list in Jelly yields 0

APL (Dyalog) , 42 byte

⎕CY'dfns'
{1≥⍵:1⋄1=≢∪r←3pco⍵:∇1+¯1pco⊃r⋄0}

L'uso ⎕CY'dfns'con dfnses non è molto fattibile su tio.

Gelatina , 11 byte

ÆfẋE$ḢÆCµl¿

Provalo online!

-2 grazie a un trucco molto geniale di Jonathan Allan .

Utilizzando l'algoritmo HP di H.PWiz.

Pari / GP , 49 byte

f(n)=d=factor(n);n<2||(#d~<2&&f(primepi(d[1,1])))

Provalo online!