È un numero sfenico?


29

Un numero sfenico è un numero che è il prodotto di esattamente tre numeri primi distinti. I primi pochi numeri sfenici sono 30, 42, 66, 70, 78, 102, 105, 110, 114. Questa è la sequenza A007304 nell'OEIS.

Il tuo compito:

Scrivi un programma o una funzione per determinare se un numero intero immesso è un numero sferico.

Ingresso:

Un numero intero compreso tra 0 e 10 ^ 9, che può essere o meno un numero sferico.

Produzione:

Un valore di verità / falsità che indica se l'input è un numero sferico.

Esempi:

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

punteggio:

Questo è , vince il codice più corto in byte.


È 60un numero sferico? 2 × 2 × 3 × 5
Erik the Outgolfer,

1
@EriktheOutgolfer non è il prodotto di 3 numeri primi distinti, ma è il prodotto di 3 numeri primi distinti e 1 duplicato.
Rɪᴋᴇʀ

1
@Riker Non sono proprio sicuro se "3 numeri primi distinti" significa "3 numeri primi che sono tutti distinti" o "una volta unificati dovrebbero rimanere 3 numeri primi". EDIT: Oh capisco, 60non è un numero sferico. (in attesa di chiarimenti sul PO)
Erik the Outgolfer,

@EriktheOutgolfer Secondo la definizione di numeri sfenici, 60 non è uno di questi. Non so comunque se 60 sia valido per questa sfida.
Wheat Wizard,

@WheatWizard, 60 non è un numero sferico (ad es. Output / return falsy).
Gryphon - Ripristina Monica il

Risposte:


7

Brachylog , 6 3 byte

ḋ≠Ṫ

Provalo online!

Spiegazione

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

2
E poi c'è l'unica lingua che ha un incorporato come .
Erik the Outgolfer,

E anche il builtin .
Zacharý,

1
@ Zacharý non è comunque un predicato incorporato; è una variabile incorporata: un elenco di 3 elementi variabili. È una variabile preconcetta abbastanza utile in molte sfide diverse.
Fatalizza il

Congratulazioni per la risposta più breve.
Gryphon - Ripristina Monica il

11

bash, 43 byte

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

Provalo online!

Input tramite argomento della riga di comando, output 0o 1stdout.

Abbastanza autoesplicativo; analizza l'output di factorper verificare che il primo e il secondo fattore siano diversi, il secondo e il terzo siano diversi (sono in ordine, quindi questo è sufficiente) e ci sono quattro campi (il numero di input e i tre fattori).


11

MATL , 7 byte

_YF7BX=

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

_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

@Suever ci stavo pensando, ma poi falsare l'uscita diventa più brutto (o vuoto con errore o un array con alcuni zeri). Non sono sicuro che dovrei ...
Luis Mendo,

4
X=è l'edificio più triste che abbia mai visto.
Erik the Outgolfer,

9

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

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;}

Spiegazione commentata da ungolf:

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
}

Provalo online!


1
Considera i*1.0/linvece che il cast fluttuare. (E poiché l, jessendo globali, vengono inizializzati su 0 gratuitamente, non è necessario farlo se la funzione viene chiamata una sola volta. Non sei sicuro di quale sia la regola.)
Mat


5

CJam , 11 byte

rimFz1=7Yb=

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

Basato sulla mia risposta 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


4

Buccia , 6 byte

≡ḋ3Ẋ≠p

Provalo online!

Restituisce 1 per i numeri sferici e 0 in caso contrario.

Spiegazione

≡ḋ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]

Nell'ultimo passaggio, la congruenza tra due elenchi significa avere la stessa lunghezza e la stessa distribuzione di valori di verità / falsità. In questo caso stiamo verificando che il nostro risultato sia composto da due valori di verità (cioè diversi da zero).


4

Mathematica, 31 byte

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

Dal momento che stai già testando la squarefree-ness, PrimeNufarà altrettanto bene PrimeOmega, ed è più breve.
Mark S.

4

Gelatina , 6 byte

ÆE²S=3

Provalo online!

Come funziona

Æ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.




2

J , 15 byte

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

Provalo online!

Spiegazione

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

Ottimo uso di ~: e #. Un'alternativa potrebbe essere (7 & (= #. @ ~: @Q:) ~ *) che trovo un po 'più facile da leggere, ma non è più breve.
bob


2

Rubino, 81 49 46 byte

Include 6 byte per le opzioni della riga di comando -rprime.

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

Provalo online!


2

Python 3 , 54 53 byte

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

Grazie a @xnor per giocare a golf a 1 byte!

Provalo online!


Puoi controllare squarefreeness k*k%npiuttosto chen%k**2
xnor

Bene, ho solo bisogno di un fallimento. Grazie!
Dennis,

2

C, 91 102 byte, corretto (di nuovo), golfato e testato per davvero questa volta:

<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;}

/ * Funziona anche in 93 byte, ma dal momento che ho dimenticato le regole standard che escludono il tipo int predefinito sulle variabili dinamiche e il fatto di non consentire valori di ritorno impliciti senza assegnazioni, non ho intenzione di prenderlo:

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;}

(Chi ha detto che sapevo qualcosa di C? ;-)

Ecco il frame di test con script shell nei commenti:

/* 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 */

Ho preso in prestito la risposta precedente di betseg per arrivare alla mia versione.

Questa è la mia versione dell'algoritmo di betseg, che ho giocato a golf per arrivare alla mia soluzione:

/* 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 */

Risponde alla domanda, ora?
Joel Rees,

Sì, lo fa. Inserire questo link per la risposta di betseg: [betseg's answer](https://codegolf.stackexchange.com/a/135203/65836). Puoi anche fare clic su modifica sulla sua risposta per suggerire una modifica, se lo desideri, che includa la spiegazione - nessuna promessa sul fatto che sarà approvata o meno.
Stephen,

Sono qui ora e ho corretto il mio programma, ora è a 87 byte; ma anche il tuo programma sembra buono.
Betseg,

@betseg Interessante che tu abbia usato questa virgola mobile questa volta. Oh, e grazie per avermi permesso di prendere in prestito il tuo algoritmo. ;-)
Joel Rees,

@JoelRees ho aggiunto una spiegazione alla mia risposta, anche la tua risposta ha un problema, penso? non sembra funzionare correttamente: provalo online
betseg


1

Javascript (ES6), 87 byte

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])

Esempio di frammento di codice:

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)}`)
}


1

Python 2 , 135 121 byte

  • Abbastanza a lungo poiché questo include tutte le procedure: primo controllo, ottenere fattori primi e controllare la condizione del numero di sfera.
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))])

Provalo online!



1

J, 23 byte

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

Provalo online!

Gestire 8 e 0 ha praticamente rovinato questo ...

q: ti dà tutti i fattori primi, ma non gestisce 0. il resto dice semplicemente "i fattori unici dovrebbero essere uguali ai fattori" e "il numero di questi dovrebbe essere 3"


Questo non riesce per input60
Conor O'Brien,

@ConorO'Brien grazie. Vedi la mia modifica - la correzione di 60 mi ha aiutato , ma mi sono reso conto che anche io non gestivo correttamente 0 e gestivo che più che raddoppia i byte
Giona

L'ultima è stata la mia idea originale, e questo fallisce 8.
Conor O'Brien,

Ho (6=]#@,~.)@q:una possibile soluzione
Conor O'Brien,

@ ConorO'Brien ah buon punto su 8. il tuo fallirà per 0, però.
Giona,

1

Japt , 14 byte

k
k@è¥X ÉÃl ¥3

Provalo online!


@Oliver Ciò comporterebbe il passaggio a una funzione Number.k(), che non avrebbe alcun effetto e verificherebbe solo se l'input ha 3 fattori primi, non 3 fattori primi distinti . Ciò significherebbe 8(con tre fattori primi :)2, 2, 2 passerebbe nonostante non si trovasse in A007304
Justin Mariner,

Ah, hai ragione. Stavo solo esaminando i casi di test.
Oliver,

@Oliver Sì, mi ha davvero colpito quando ho lavorato su questa soluzione. Ho appena aggiunto 8ai casi di test per quel motivo.
Justin Mariner,


1

VB.NET (.NET 4.5), 104 byte

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

Sto usando la funzione di VB in cui il nome della funzione è anche una variabile. Alla fine dell'esecuzione, poiché non esiste un'istruzione return, passerà invece il valore della "funzione".

L'ultimo A=A=3può essere pensatoreturn (A == 3) in linguaggi basati su C.

Inizia da 2 e toglie i numeri primi in modo iterativo. Dal momento che sto iniziando con i numeri più piccoli, non può essere diviso per un numero composto.

Proverà una seconda volta a dividere per lo stesso numero primo. Se lo è (come il modo in cui 60 viene diviso due volte per 2), imposterà il conteggio dei numeri primi su 4 (al di sopra del massimo consentito per un numero sferico).

Provalo online!


1

Dyalog APL, 51 49 48 46 45 43 byte

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

Provalo online! (modificato in modo che possa essere eseguito su TryAPL)

Volevo inviarne uno che non si basasse sullo spazio dei nomi dei DNS, anche se è lungo .


1

J, 15 14 19 byte

Tentativo precedente: 3&(=#@~.@q:)~*

Versione corrente: (*/*3=#)@~:@q: ::0:

Come funziona:

(*/*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)

Questo vale per i casi 0, 8 e 60 che la versione precedente non aveva.


1
perché non 3 = # ~ .q: per 7 caratteri? Da una sessione J 3 = # ~ .q: 30 ==> 1 e 3 = # ~ .q: 20 ==> 0
Richard Donovan,

Richard, il tuo suggerimento fornisce un falso positivo per n = 60 e crea un errore di dominio per n = 0, ma anche la mia versione precedente non è riuscita per n = 60. Il tuo commento mi ha spinto a cercare una soluzione corretta!
bob,

0

Mathematica, 66 57 byte

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

Definisce una funzione anonima.

è Transpose .

Spiegazione

FactorIntegerfornisce un elenco di coppie di fattori e dei loro esponenti. Es FactorInteger[2250]=={{2,1},{3,2},{5,3}}. Questo è trasposto per facilità d'uso e alimentato alla funzione Length@#1==3&&And@@EqualTo[1]/@#2&. La prima parte Length@#1==3verifica che vi siano 3 fattori univoci, mentre la seconda And@@EqualTo[1]/@#2verifica che tutti gli esponenti siano 1.


0

PHP, 66 byte:

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

Esegui come pipe -nRo provalo online .

Ciclo infinito per 0; inserire $n&&prima --$ndi risolvere.

abbattersi

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

Esempio
argomento = 30:
fattori primi sono 2, 3e 5
altri sono divisori 1, 2 * 3 = 62 * 5 = 10e 3 * 5 = 15
loro prodotto: 1*2*3*5*6*10*15è 27000==30**3


0

Python 99 byte

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

Prima presentazione. Perdonami se ho fatto qualcosa di sbagliato. Un po 'sciocco, conta il numero di fattori ne quindi il numero di volten è divisibile per ciascuno (aggiungendo 10 ** 9).

Sono abbastanza sicuro che ci sono alcuni modi semplici per tagliare ~ 10-20 caratteri, ma non l'ho fatto.

Anche questo è intrattabilmente lento a 10 ** 9. Potrebbe essere fatto bene cambiando '...a+=1\n'*nin '...a+=1\n'*n**.5, dato che dobbiamo solo andare alla radice quadrata di n.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.