Nesse desafio , aprendemos uma maneira de codificar todo número inteiro positivo usando árvores fatoriais.

Aqui está como funciona:

• A cadeia vazia tem o valor 1.

• (S)onde Sé qualquer expressão com um valor de S é avaliada como a S ª prime.

• ABonde Ae Bsão expressões arbirary com valores de A e B , respectivamente, têm valor A * B .

Por exemplo, se quiséssemos representar 7, faríamos

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

Acontece que podemos representar todos os números inteiros usando esse método. De fato, alguns números podemos representar de várias maneiras. Como a multiplicação é comutativa, 10 são ambos

((()))()

e

()((()))

Ao mesmo tempo, alguns números podem ser representados apenas de uma maneira. Tome 8 por exemplo. 8 só pode ser representado como

()()()

E como todos os nossos átomos são os mesmos, não podemos usar a comutatividade para reorganizá-los.

Então agora a pergunta é "Quais números só podem ser representados de uma maneira?". A primeira observação é aquela que eu comecei a fazer lá atrás. Parece que poderes perfeitos têm algumas propriedades especiais. Sob investigação adicional, podemos encontrar 36, que é 6 ^2, é uma potência perfeita, mas tem múltiplas representações.

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

E isso faz sentido, porque 6 já é reorganizável; portanto, qualquer número que fizermos de 6 também deve ser reorganizável.

Então agora temos uma regra:

• Um número tem uma representação única se for a potência perfeita de um número com uma representação exclusiva.

Essa regra pode nos ajudar a reduzir a determinação se um número composto é exclusivo para determinar se um número primo é único. Agora que temos essa regra, queremos descobrir o que torna um número primo único. Isso é realmente muito evidente. Se tomarmos um número único e envolvê-la em parênteses, o resultado deve ser único, e, indo para o outro lado, se n tem múltiplas representações do n º nobre deve ter múltiplas representações. Isso produz a segunda regra:

• O n º principal é único, se e somente se n é único.

Como essas regras são recursivas, precisamos de um caso básico. Qual é o menor número único? Pode-se ficar tentado a dizer 2 porque é apenas (), mas 1, a sequência vazia, é ainda menor e é única.

• 1 é único.

Com essas três regras, podemos determinar se um número tem uma árvore de fatores exclusiva.

Tarefa

Você já deve ter percebido isso, mas sua tarefa é pegar um número inteiro positivo e determinar se é único. Você deve escrever um programa ou função que faça esse cálculo. Você deve emitir um dos dois valores possíveis, quais são esses valores, mas um deve representar "yes", sendo exibido quando a entrada for exclusiva e um deve representar "no", caso contrário.

Suas respostas devem ser pontuadas em bytes, com menos bytes sendo melhores.

Casos de teste

Aqui estão os primeiros números únicos:

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

Casos de teste sugeridos

5381 -> Unique

Parece que o OEIS A214577 está de alguma forma relacionado, portanto, se você precisar de mais casos de teste, tente lá, mas eu não sei que eles são os mesmos, portanto, use por seu próprio risco.

Casca , 11 10 bytes

Guardado um byte graças ao Zgarb!

Ωεo?oṗ←¬Ep

Retorna 1para exclusivo, 0caso contrário

Experimente online! Ou retornando os primeiros 50

Explicação:

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

^{Depois de muita brincadeira!}

ÆET0ṪḊ?µl¿

Um link monádico que pega um número inteiro positivo e retorna 1se é exclusivo ou 0não.

Experimente online!

Quão?

Æ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

Espere, logaritmo, o que ?!

Vamos analisar alguns exemplos do loop.

Se n=31( 31 ¹ , o décimo primeiro 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 bytes

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

Usar ⎕CY'dfns'com dfnses não é muito viável.

Gelatina , 11 bytes

ÆfẋE$ḢÆCµl¿

Experimente online!

-2 graças a um truque muito genial de Jonathan Allan .

Usando o algoritmo Husk de H.PWiz.

Pari / GP , 49 bytes

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

Experimente online!