En este desafío , aprendimos una forma de codificar cada número entero positivo utilizando árboles de factores.

Así es como funciona:

• La cadena vacía tiene un valor de 1.

• (S)donde Ses cualquier expresión con un valor de S se evalúa a la S th prima.

• ABdonde Ay Bson expresiones arbirary con valores de A y B tiene respectivamente el valor A * B .

Por ejemplo, si quisiéramos representar 7 haríamos

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

Resulta que podemos representar cada número entero usando este método. De hecho, algunos números los podemos representar de múltiples maneras. Como la multiplicación es conmutativa, 10 es ambos

((()))()

y

()((()))

Al mismo tiempo, algunos números solo se pueden representar de 1 manera. Tome 8 por ejemplo. 8 solo se puede representar como

()()()

Y dado que todos nuestros átomos son iguales, no podemos usar la comunividad para reorganizarlos.

Entonces, la pregunta es "¿Qué números solo se pueden representar de una manera?". La primera observación es una que acabo de comenzar a hacer allí. Parece que los poderes perfectos tienen algunas propiedades especiales. Bajo investigación adicional podemos encontrar 36, que es 6 ² es una potencia perfecta pero tiene múltiples representaciones.

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

Y esto tiene sentido porque 6 ya se puede reorganizar, por lo que cualquier número que hagamos de 6 también debe reorganizarse.

Entonces ahora tenemos una regla:

• Un número tiene una representación única si es una potencia perfecta de un número con una representación única.

Esa regla puede ayudarnos a reducir la determinación de si un número compuesto es único para determinar si un número primo es único. Ahora que tenemos esa regla, queremos descubrir qué hace que un número primo sea único. Esto es realmente bastante evidente. Si tomamos un número único y se envuelve entre paréntesis, el resultado debe ser único, y, en la otra dirección, si n tiene múltiples representaciones del n º primordial debe tener múltiples representaciones. Esto produce la segunda regla:

• El n º primordial es única si y sólo si n es único.

Ambas reglas son recursivas, por lo que vamos a necesitar un caso base. ¿Cuál es el número único más pequeño? Uno podría verse tentado a decir 2 porque es justo (), pero 1, la cadena vacía, es aún más pequeña y es única.

• 1 es único.

Con estas tres reglas podemos determinar si un número tiene un árbol de factores único.

Tarea

Es posible que lo hayas visto venir, pero tu tarea es tomar un número entero positivo y determinar si es único. Debería escribir un programa o función que haga este cálculo. Debe generar uno de los dos valores posibles, lo que estos valores dependen de usted, pero uno debe representar "sí", emitiéndose cuando la entrada es única y uno debería representar "no" siendo emitido de otra manera.

Sus respuestas deben puntuarse en bytes, con menos bytes siendo mejores.

Casos de prueba

Aquí están los primeros números únicos:

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

Casos de prueba sugeridos

5381 -> Unique

Parece que OEIS A214577 está relacionado de alguna manera, por lo que si necesita más casos de prueba, intente allí, pero no sé si son iguales, así que úselo bajo su propio riesgo.

Casco , 11 10 bytes

¡Salvado un byte gracias a Zgarb!

Ωεo?oṗ←¬Ep

Devoluciones 1por únicas, de lo 0contrario

Pruébalo en línea! O devolviendo los primeros 50

Explicación:

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

Jalea , 10 bytes

^{¡Después de MUCHO juguetear!}

ÆET0ṪḊ?µl¿

Un enlace monádico que toma un número entero positivo y regresa 1si es único o 0no.

Pruébalo en línea!

¿Cómo?

Æ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

Espera, logaritmo, ¿qué?

Veamos algunos ejemplos del ciclo.

Si n=31( 31 ¹ , el undécimo 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

Si 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

Si 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 bytes

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

Usar ⎕CY'dfns'con dfnses no es muy factible en tio.

Jalea , 11 bytes

ÆfẋE$ḢÆCµl¿

Pruébalo en línea!

-2 gracias a un truco muy genial de Jonathan Allan .

Usando el algoritmo Husk de H.PWiz.

Pari / GP , 49 bytes

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

Pruébalo en línea!