Um número esfênico é um número que é o produto de exatamente três números primos distintos. Os primeiros números esfênicos são 30, 42, 66, 70, 78, 102, 105, 110, 114. Esta é a sequência A007304 no OEIS.

Sua tarefa:

Escreva um programa ou função para determinar se um número inteiro inserido é um número esfênico.

Entrada:

Um número inteiro entre 0 e 10 ^ 9, que pode ou não ser um número esfênico.

Saída:

Um valor de verdade / falso indicando se a entrada é um número esfênico.

Exemplos:

30  -> true
121 -> false
231 -> true
154 -> true
4   -> false
402 -> true
79  -> false
0   -> false
60  -> false
64  -> false
8   -> false
210 -> false

Pontuação:

Este é o código-golfe , o código mais curto em bytes vence.

Braquilog , 6 3 bytes

ḋ≠Ṫ

Experimente online!

Explicação

ḋ        The prime factorization of the Input…
 ≠       …is a list of distinct elements…
  Ṫ      …and there are 3 elements

bash, 43 bytes

factor $1|awk '{print $2-$3&&$3-$4&&NF==4}'

Experimente online!

Entrada via argumento de linha de comando, saídas 0ou 1para stdout.

Bastante auto-explicativo; analisa a saída de factorpara verificar se o primeiro e o segundo fatores são diferentes, o segundo e o terceiro são diferentes (eles estão na ordem de classificação, portanto, isso é suficiente) e existem quatro campos (o número de entrada e os três fatores).

MATL , 7 bytes

_YF7BX=

Experimente online! Ou verifique todos os casos de teste .

Explicação

_YF   % Implicit input. Nonzero exponents of prime-factor decomposition
7     % Push 7
B     % Convert to binary: gives [1 1 1] 
X=    % Is equal? Implicit display

C, 88 78 126 58 77 73 + 4 ( lm) = 77 bytes

l,j;a(i){for(l=1,j=0;l++<i;fmod(1.*i/l,l)?i%l?:(i/=l,j++):(j=9));l=i==1&&j==3;}

Ungolfed comentou explicação:

look, div; //K&R style variable declaration. Useful. Mmm.

a ( num ) { // K&R style function and argument definitions.

  for (
    look = 1, div = 0; // initiate the loop variables.
    look++ < num;) // do this for every number less than the argument:

      if (fmod(1.0 * num / look, look))
      // if num/look can't be divided by look:

        if( !(num % look) ) // if num can divide look
          num /= look, div++; // divide num by look, increment dividers
      else div = 9;
      // if num/look can still divide look
      // then the number's dividers aren't unique.
      // increment dividers number by a lot to return false.

  // l=j==3;
  // if the function has no return statement, most CPUs return the value
  // in the register that holds the last assignment. This is equivalent to this:
  return (div == 3);
  // this function return true if the unique divider count is 3
}

Experimente online!

CJam , 11 bytes

rimFz1=7Yb=

Experimente online! Ou verifique todos os casos de teste .

Explicação

Com base na minha resposta MATL.

ri    e# Read integer
mF    e# Factorization with exponents. Gives a list of [factor exponent] lists
z     e# Zip into a list of factors and a list of exponents
1=    e# Get second element: list of exponents
7     e# Push 7
Yb    e# Convert to binary: gives list [1 1 1]
=     e# Are the two lists equal? Implicitly display

Gelatina , 8 bytes

ÆEḟ0⁼7B¤

Experimente online!

Usa o algoritmo de Luis Mendo.

Explicação:

ÆEḟ0⁼7B¤
ÆE       Prime factor exponents
  ḟ0     Remove every 0
    ⁼7B¤ Equal to 7 in base 2?

Casca , 6 bytes

≡ḋ3Ẋ≠p

Experimente online!

Retorna 1 para números esfênicos e 0 caso contrário.

Explicação

≡ḋ3Ẋ≠p    Example input: 30
     p    Prime factors: [2,3,5]
   Ẋ≠     List of absolute differences: [1,2]
≡         Is it congruent to...       ?
 ḋ3           the binary digits of 3: [1,1]

Na última passagem, congruência entre duas listas significa ter o mesmo comprimento e a mesma distribuição de valores de verdade / falsidade. Nesse caso, estamos verificando se nosso resultado é composto por dois valores verdadeiros (ou seja, diferentes de zero).

Mathematica, 31 bytes

SquareFreeQ@#&&PrimeOmega@#==3&

Gelatina , 6 bytes

ÆE²S=3

Experimente online!

Como funciona

ÆE²S=3  Main link. Argument: n

ÆE      Compute the exponents of n's prime factorization.
  ²     Take their squares.
   S    Take the sum.
    =3  Test the result for equality with 3.

05AB1E , 7 5 bytes

ÓnO3Q

Experimente online!

Usa o algoritmo de Dennis.

Na verdade , 7 bytes

w♂N13α=

Experimente online!

Explicação:

w♂N13α=
w       Push [prime, exponent] factor pairs
 ♂N     Map "take last element"
   1    Push 1
    3   Push 3
     α  Repeat
      = Equal?

Haskell , 59 bytes

f x=7==sum[6*0^(mod(div x a)a+mod x a)+0^mod x a|a<-[2..x]]

Experimente online!

J , 15 bytes

7&(=2#.~:@q:)~*

Experimente online!

Explicação

7&(=2#.~:@q:)~*  Input: integer n
              *  Sign(n)
7&(         )~   Execute this Sign(n) times on n
                 If Sign(n) = 0, this returns 0
          q:       Prime factors of n
       ~:@         Nub sieve of prime factors
    2#.            Convert from base 2
   =               Test if equal to 7

Dyalog APL, 26 bytes

⎕CY'dfns'
((≢,∪)≡3,⊢)3pco⎕

Experimente online!

Ruby, 81 49 46 bytes

Inclui 6 bytes para opções de linha de comando -rprime.

->n{n.prime_division.map(&:last)==[1]*3}

Experimente online!

Python 3 , 54 53 bytes

lambda n:sum(1>>n%k|7>>k*k%n*3for k in range(2,n))==6

Graças a @xnor por jogar fora um byte!

Experimente online!

C, 91 102 bytes, corrigidos (novamente), jogados e testados em tempo real:

<strike>s(c){p,f,d;for(p=2,f=d=0;p<c&&!d;){if(c%p==0){c/=p;++f;if(c%p==0)d=1;}++p;}c==p&&f==2&&!d;}</strike>
s(c){int p,f,d;for(p=2,f=d=0;p<c&&!d;){if(c%p==0){c/=p;++f;if(c%p==0)d=1;}++p;}return c==p&&f==2&&!d;}

/ * Isso também funciona em 93 bytes, mas como eu esqueci as regras padrão que restringem o tipo int padrão em variáveis ​​dinâmicas e sobre o fato de não permitir valores implícitos de retorno sem atribuições, não vou aceitar:

p,f,d;s(c){for(p=2,f=d=0;p<c&&!d;){if(c%p==0){c/=p;++f;if(c%p==0)d=1;}++p;}p=c==p&&f==2&&!d;}

(Quem disse que eu sabia alguma coisa sobre C? ;-)

Aqui está o quadro de teste com o script shell nos comentários:

/* betseg's program for sphenic numbers from 
*/
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <math.h> /* compile with -lm */

/* l,j;a(i){for(l=1,j=0;l<i;i%++l?:(i/=l,j++));l=i==1&&j==3;} */
#if defined GOLFED
l,j;a(i){for(l=1,j=0;l++<i;fmod((float)i/l,l)?i%l?:(i/=l,j++):(j=9));l=i==1&&j==3;}
#else 
int looker, jcount;
int a( intval ) {
  for( looker = 1, jcount = 0; 
    looker++ < intval; 
    /* Watch odd intvals and even lookers, as well. */
    fmod( (float)intval/looker, looker )  
      ? intval % looker /* remainder? */
        ? 0 /* dummy value */
        : ( inval /= looker, jcount++ /* reduce the parameter, count factors */ ) 
      : ( jcount = 9 /* kill the count */ ) 
  )
    /* empty loop */;
  looker = intval == 1 && jcount == 3; /* reusue looker for implicit return value */
}
#endif

/* for (( i=0; $i < 100; i = $i + 1 )) ; do echo -n at $i; ./sphenic $i ; done */

Peguei emprestada a resposta anterior da betseg para chegar à minha versão.

Esta é a minha versão do algoritmo da betseg, que joguei para chegar à minha solução:

/* betseg's repaired program for sphenic numbers
*/
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

int sphenic( int candidate )
{
  int probe, found, dups;
  for( probe = 2, found = dups = 0; probe < candidate && !dups; /* empty update */ ) 
  { 
    int remainder = candidate % probe;
    if ( remainder == 0 ) 
    {
      candidate /= probe;
      ++found;
      if ( ( candidate % probe ) == 0 )
        dups = 1;
    }
    ++probe;
  } 
  return ( candidate == probe ) && ( found == 2 ) && !dups;
}

int main( int argc, char * argv[] ) { /* Make it command-line callable: */
  int parameter;
  if ( ( argc > 1 ) 
       && ( ( parameter = (int) strtoul( argv[ 1 ], NULL, 0 ) ) < ULONG_MAX ) ) {
    puts( sphenic( parameter ) ? "true" : "false" );
  }
  return EXIT_SUCCESS; 
}

/* for (( i=0; $i < 100; i = $i + 1 )) ; do echo -n at $i; ./sphenic $i ; done */

Pitão, 9 bytes

&{IPQq3lP

Experimente aqui.

Javascript (ES6), 87 bytes

n=>(a=(p=i=>i>n?[]:n%i?p(i+1):[i,...p(i,n/=i)])(2)).length==3&&a.every((n,i)=>n^a[i+1])

Exemplo de trecho de código:

f=
n=>(a=(p=i=>i>n?[]:n%i?p(i+1):[i,...p(i,n/=i)])(2)).length==3&&a.every((n,i)=>n^a[i+1])

for(k=0;k<10;k++){
  v=[30,121,231,154,4,402,79,0,60,64][k]
  console.log(`f(${v}) = ${f(v)}`)
}

Python 2 , 135 121 bytes

• Muito tempo, pois inclui todos os procedimentos: verificação primária, fatores de obtenção primária e verificação da condição do número da esfera.

lambda x:(lambda t:len(t)>2and t[0]*t[1]*t[2]==x)([i for i in range(2,x)if x%i<1and i>1and all(i%j for j in range(2,i))])

Experimente online!

Python 2 , 59 bytes

lambda x:6==sum(5*(x/a%a+x%a<1)+(x%a<1)for a in range(2,x))

Experimente online!

J, 23 bytes

0:`((~.-:]*.3=#)@q:)@.*

Experimente online!

Manipular 8 e 0 basicamente arruinou este ...

q: fornece todos os fatores primos, mas não lida com 0. o resto diz apenas "os fatores únicos devem ser iguais aos fatores" e "o número deles deve ser 3"

Japonês , 14 bytes

k
k@è¥X ÉÃl ¥3

Experimente online!

Mathematica, 44 bytes

Plus@@Last/@#==Length@#==3&@FactorInteger@#&

Experimente online!

VB.NET (.NET 4.5), 104 bytes

Function A(n)
For i=2To n
If n Mod i=0Then
A+=1
n\=i
End If
If n Mod i=0Then A=4
Next
A=A=3
End Function

Estou usando o recurso de VB, onde o nome da função também é uma variável. No final da execução, como não há declaração de retorno, ela passará o valor da 'função'.

O último A=A=3pode ser pensado return (A == 3)em idiomas baseados em C.

Começa com 2 e puxa os primários iterativamente. Como estou começando com os primos menores, ele não pode ser dividido por um número composto.

Tentará uma segunda vez dividir pelo mesmo primo. Se estiver (por exemplo, como 60 é dividido duas vezes por 2), ele definirá a contagem de números primos para 4 (acima do máximo permitido para um número esfênico).

Experimente Online!

Dyalog APL, 51 49 48 46 45 43 bytes

1∊((w=×/)∧⊢≡∪)¨(⊢∘.,∘.,⍨){⍵/⍨2=≢∪⍵∨⍳⍵}¨⍳w←⎕

Experimente online! (modificado para ser executado no TryAPL)

Eu queria enviar um que não confie no namespace dfns, mesmo que seja longo .

J, 15 14 19 bytes

Tentativa anterior: 3&(=#@~.@q:)~*

Versão Atual: (*/*3=#)@~:@q: ::0:

Como funciona:

(*/*3=#)@~:@q: ::0:  Input: integer n
               ::0:  n=0 creates domain error in q:, error catch returns 0
            q:       Prime factors of n
         ~:@         Nub sieve of prime factors 1 for first occurrence 0 for second
(*/*3=#)@            Number of prime factors is equal to 3, times the product across the nub sieve (product is 0 if there is a repeated factor or number of factors is not 3)

Isso passa para os casos 0, 8 e 60 que a versão anterior não.

Mathematica, 66 57 bytes

Length@#1==3&&And@@EqualTo[1]/@#2&@@(FactorInteger@#)&

Define uma função anônima.

é Transpor .

Explicação

FactorIntegerfornece uma lista de pares de fatores e seus expoentes. Por exemplo FactorInteger[2250]=={{2,1},{3,2},{5,3}}. Isso é transposto para facilitar o uso e alimentado à função Length@#1==3&&And@@EqualTo[1]/@#2&. A primeira parte, Length@#1==3verifica se há três fatores únicos, enquanto a segunda And@@EqualTo[1]/@#2verifica se todos os expoentes são 1.

PHP, 66 bytes:

for($p=($n=$a=$argn)**3;--$n;)$a%$n?:$p/=$n+!++$c;echo$c==7&$p==1;

Execute como pipe -nRou experimente on-line .

Loop infinito para 0; insira $n&&antes--$n de corrigir.

demolir

for($p=($n=$a=$argn)**3;    # $p = argument**3
    --$n;)                  # loop $n from argument-1
    $a%$n?:                     # if $n divides argument
        $p/=$n                      # then divide $p by $n
        +!++$c;                     # and increment divisor count
echo$c==7&$p==1;            # if divisor count is 7 and $p is 1, argument is sphenic

exemplo
argumento = 30:
factores primos são 2, 3e 5
outros divisores são 1, 2 * 3 = 6, 2 * 5 = 10e 3 * 5 = 15
seu produto: 1*2*3*5*6*10*15é 27000==30**3

Python 99 bytes

def s(n):a,k=2,0;exec('k+=1-bool(n%a)\nwhile not n%a:n/=a;k+=10**9\na+=1\n'*n);return k==3*10**9+3

Primeira submissão. Perdoe-me se fiz algo errado. Meio bobo, conta o número de fatores de ne, em seguida, o número de vezesn é divisível por cada um (adicionando 10 ** 9).

Tenho certeza de que existem algumas maneiras fáceis de cortar ~ 10 a 20 caracteres, mas não o fiz.

Além disso, isso é intratàvelmente lento em 10 ** 9. Poderia ser resolvido alterando '...a+=1\n'*npara '...a+=1\n'*n**.5, pois só precisamos ir para a raiz quadrada de n.