Le premier numéro de la fonction dans la R

Je suis en train de créer une fonction pour tester si un nombre entier est un nombre premier, j'ai essayé d'utiliser les éléments suivants:

tpn <- function(prime.num){

    if(prime.num==2){
        print("PRIME")
    } else {

    if(prime.num%%(2:(prime.num-1))!=0){
        print("PRIME")

    } else { 
        print("NOT PRIME")

}}}

Cela ne fonctionne pas, bien que je ne peux pas comprendre pourquoi. Je suis de la vérification pour voir si le nombre donné est divisible par aucun des entiers jusqu'à ce nombre sans résidus. Si elle ne peut pas, alors le nombre est premier.

Une autre solution que j'ai trouvé était:

tpn <- function(pn){

    if(sum(pn/1:pn==pn%/%1:pn)==2)
            print("prime")

}

Cela fonctionne. Bien que, je ne peux pas obtenir ma tête autour de ce qui sum(pn/1:pn == pn%/%1:pn) == 2 est en fait à tester.

Avez-vous essayé de le décomposer en morceaux? Si vous ne les avez, vous verriez que if n'accepte qu'un seul argument, pour une chose (dans votre premier exemple). Dans la seconde, quelques parenthèses pourrait l'aider, alors allez à la page d'aide ?Syntax de voir les opérations qui arrive en premier.
Peut-être un doublon de stackoverflow.com/q/3789968/321622 ou stackoverflow.com/q/3858636/321622

OriginalL'auteur user2952367 | 2013-11-04

primes r

20

Un certain nombre a est divisible par un nombre b si le résultat de la division a /b est égal au résultat de la division entière a %/% b. Tout entier pn peut être divisé en au moins deux numéros: 1 et pn. Les nombres premiers sont ceux qui ne peuvent être divisés par ces deux. Briser le code:
1. pn /1:pn sont les résultats des divisions par 1, 2, ..., pn
2. pn %/% 1:pn sont le résultat de la division entière par 1, 2, ..., pn
3. sum(pn /1:pn == pn %/% 1:pn) sont de ce nombre, combien sont égaux, c'est à dire, le nombre des diviseurs de l'entier de pn. Si ce nombre est 2, vous avez un nombre premier.
Ce qui était incorrect avec votre code: if besoin de tester si quelque chose est TRUE ou FALSE, mais vous avez été en passant un ensemble de vecteur. Aussi, votre logique est erronée. Il doit avoir été:
```
is.prime <- function(num) {
   if (num == 2) {
      TRUE
   } else if (any(num %% 2:(num-1) == 0)) {
      FALSE
   } else { 
      TRUE
   }
}
```
Et une fois que vous avez réglé sur le retour à une logique, vous pouvez rendre votre code beaucoup plus court:
```
is.prime <- function(n) n == 2L || all(n %% 2L:max(2,floor(sqrt(n))) != 0)
```
(qui intègre @Carl commentaire à propos de ne pas vérifier tous les nombres.)

Eh bien, tant pour le tournage de mon commentaire en réponse 🙁 . FWIW, je vais mentionner que les tests de dépistage 2:prime.num-1 est incroyablement gaspillage, vous pouvez vous arrêter à peu près sqrt(prime.num)
Merci beaucoup, vous avez fait cela très clair! si seulement tu pouvais être mon R conférencier 😀
Donc je sais que c'est tard, mais la version courte est dit que 3 n'est pas premier car floor(sqrt(n)) dans ce cas est de 1.
IMO 1 est un nombre premier. Je n'aime pas ce mathmos dire 🙂
Je vous remercie de votre audace

OriginalL'auteur flodel
8

J'ai juste essayé la is.prime exemple de code. Mais avec ce 3 n'est pas premier ;o)

La version améliorée utilise plafond à la place de la parole de l'opération.
```
is.prime <- function(n) n == 2L || all(n %% 2L:ceiling(sqrt(n)) != 0)
```
Meilleur!

OriginalL'auteur Seily
4

Vous pouvez également utiliser le isprime() fonction dans le matlab paquet. Il fonctionne également avec le vecteur arguments:
```
library(matlab)

as.logical(isprime(7))
as.logical(isprime(42))

#> as.logical(isprime(7))
#[1] TRUE
#> as.logical(isprime(42))
#[1] FALSE
```
OriginalL'auteur user2030503

Une expression régulière pour trouver des nombres premiers

is.prime <- function(x) {
  x <- abs(as.integer(x))
  !grepl('^1?$|^(11+?)\+$', strrep('1', x))
}

(-100:100)[is.prime(-100:100)]
# [1]  -97 -89 -83 -79 -73 -71 -67 -61 -59 -53 -47 -43 -41 -37 -31 -29 -23 -19 -17 -13 -11  -7  -5  -3  -2
# [26]   2   3   5   7  11  13  17  19  23  29  31  37  41  43  47  53  59  61  67  71  73  79  83  89  97

http://diswww.mit.edu/bloom-picayune.mit.edu/perl/10138

Ou si vous prenez tous les entiers de 1 à x, le nombre de diviser sans reste devrait être de 2: 1 et x

is.prime <- function(x)
  vapply(x, function(y) sum(y / 1:y == y %/% 1:y), integer(1L)) == 2L

(1:100)[is.prime(1:100)]
# [1]  2  3  5  7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

Je savais que la regex serait plus lent, mais c'est une de mes préférées

is.prime <- function(x)
  vapply(x, function(y) sum(y / 1:y == y %/% 1:y), integer(1L)) == 2L

is.prime_regex <- function(x) {
  x <- abs(as.integer(x))
  !grepl('^1?$|^(11+?)\+$', strrep('1', x))
}

is.prime_Seily  <- function(n)
  vapply(n, function(y)
    y == 2L || all(y %% 2L:ceiling(sqrt(y)) != 0), logical(1L))

is.prime_flodel <- function(n)
  vapply(n, function(y)
    y == 2L || all(y %% 2L:max(2,floor(sqrt(y))) != 0), logical(1L))

x <- 1:1000

library('microbenchmark')
microbenchmark(
  is.prime(x),
  is.prime_regex(x),
  is.prime_Seily(x),
  is.prime_flodel(x),
  unit = 'relative'
)

# Unit: relative
#               expr       min        lq      mean    median        uq        max neval cld
#        is.prime(x)  8.593971  8.606353  8.805690  8.892905  9.724452 21.9886734   100  b 
#  is.prime_regex(x) 84.572928 86.200415 76.413036 86.895956 85.117796 25.7106323   100   c
#  is.prime_Seily(x)  1.000000  1.000000  1.000000  1.000000  1.000000  1.0000000   100 a  
# is.prime_flodel(x)  1.146212  1.147971  1.144839  1.146119  1.163302  0.9085948   100 a

Belle référence. Je suppose que le test doit être sur un grand nombre, pas seulement beaucoup de chiffres. J'ai posté un autre test ici: chat.stackoverflow.com/transcript/message/36663729#36663729 j'ai ajouté un couple d'autres méthodes, la tricherie en utilisant le compilateur paquet et stocker les résultats dans la fonction de l'environnement.
très vrai. l'indice de référence des timings sont très bizarres. au moins dans le vôtre, ils vont dans le même (mauvais) sens, mais dans la regex de référence dans la réponse, min est inférieure à T1 mais T1 est plus grand que la moyenne, mais seulement légèrement inférieure à la médiane, qui est plus élevé que le quartile supérieur et le maxis le plus bas.. aucune idée de ce qui se passe là
Ouais, je suppose min vs max n'est pas significative avec l'unité = 'relatif', qui, apparemment, convertit chaque colonne de façon indépendante. Dans mon test, il est logique que max doit être super élevé, car il fait beaucoup de travail pour la première itération... mais alors min est très faible car il peut se reposer sur ses lauriers / memoised calculs.

OriginalL'auteur rawr

Je vais vous fournir avec 2 facile fonctions. La seconde affiche n-ième nombre premier. EDIT* (faute de frappe)

PrimeNumber <- function(n){
#Eratosthenes 
#Return all prime numbers up to n (based on the sieve of Eratosthenes)
    if (n >= 2) {
      sieve <- seq(2, n)
      primes <- c()

      for (i in seq(2, n)) {
        if (any(sieve == i)) {
          primes <- c(primes, i)
          sieve <- c(sieve[(sieve %% i) != 0], i)
        }
      }
      return(primes)
    } else {
      stop("Input value of n should be at least 2.")
    }
}

testScript <- function(n){
i=3
v=c(2)
while (length(v)<=n-1){

      if (all((i%%v[v<ceiling(sqrt(i))])!=0)){ 
        v=c(v,i)
      }
    i=i+2;
  }
  return(v)
}

OriginalL'auteur MathGainz

Voici une autre méthode pour trouver le premier numéro à l'aide du simple concept

is.prime <- function(n){
 if (n == 2){  # finds the square root of number and assign to var 'i'
  print('number is prime')
 }
 else if (n > 2){
 i <- sqrt(n)   # finds the square root of number and assign to var 'i'
 i <- round(i, digits = 1) # if square root generates decimals, round it to one place
 vec <- c(2:i) #creating vector to load numbers from 2 to 'i'
 d <- n %% (vec) #dividing each number generated by vector by the input number 'n'
 if ( 0 %in% d){ # check to see if any of the result of division is 0
  print('number is not prime') #if any of the result of division is 0, number is not prime
 }
 else{ 
   print('number is prime')
 }
 }
}




is.prime(2)
[1] "number is prime"

is.prime(131) #calling the function with the desired number
[1] "number is prime"

is.prime(237)
[1] "number is not prime"

Je vois beaucoup de question d'Entrevue a demandé de vérifier si un nombre est premier sans l'aide de tous intégré la fonction, de sorte que vous pouvez y aller.

OriginalL'auteur Sugand Anand

C'est le vectorisé version avec naturel-numéro de contrôle:

is.prime <- Vectorize(function(n) ifelse(round(n) == n, 
                                  n == 2L || all(n %% 2L:max(2,floor(sqrt(n))) != 0), NA));

#> is.prime(c(1:10, 1.1))
# [1]  TRUE  TRUE  TRUE FALSE  TRUE FALSE  TRUE FALSE FALSE FALSE    NA

OriginalL'auteur Yuri

    is.primeornot <- function(n)
    {
      count = 0
      for( i in 2:n)
      {

        if(n%%i == 0){count = count+1}

      }
      p = c(n)
      if(count > 1){
        print(paste(n,"is not a prime number"))}
      else{print("prime")}
    }

OriginalL'auteur neeraj Guntupalli

0

Ici est le plus compact de code je pense:
```
is_prime <- function(n){
  ifelse(sum(n %% (1:n) == 0) > 2, FALSE, TRUE)
}
```
Si vous avez besoin de vérifier si chaque élément d'un vecteur de nombres est un nombre premier, vous pouvez le faire:
```
is_prime2 <- Vectorize(FUN = is_prime, vectorize.args = "n")
```
Maintenant is_prime2() travaille avec des vecteurs.

Encore plus compact serait is_prime <- function(n) sum(n %% (1:n) == 0) <= 2 😉

OriginalL'auteur SavedByJESUS

if(prime.num%%(2:(prime.num-1))!=0){

Modifier la présente déclaration:

if(any(prime.num %% (2:(prime.num-1)) == rep(0,d-2))==TRUE){

et tout fonctionnera.

OriginalL'auteur Cat Katherine

0

Premier ou non:
```
prime.or.not<-function(x){ifelse(0%in%(x%%(2:(x-1))),"not prime","prime")}
```
il suffit de taper cette sur la r de la console

OriginalL'auteur A Chatterjee

Vous devez vous connecter pour publier un commentaire.