Menu Close

Números somirp

José A. Alonso,

Un número omirp es un número primo que forma un primo distinto al invertir el orden de sus dígitos.

Definir las funciones

  esOmirp            :: Integer -> Bool
  omirps             :: [Integer]
  nOmirpsIntermedios :: Int -> Int

tales que

  • (esOmirp n) se verifica si n es un número omirp. Por ejemplo,
     esOmirp 13      ==  True
     esOmirp 11      ==  False
     esOmirp 112207  ==  True
  • omirps es la lista de los números omirps. Por ejemplo,
     take 15 omirps  ==  [13,17,31,37,71,73,79,97,107,113]
     omirps !! 2000  ==  112207
  • (nOmirpsIntermedios n) es la cantidad de números omirps entre el n-ésimo número omirp y el obtenido al invertir el orden de sus dígitos. Por ejemplo,
     nOmirpsIntermedios 2000  ==  4750

Nota: Este ejercicio ha sido propuesto por Ángel Ruiz Campos.

Soluciones

import Data.Numbers.Primes (isPrime,primes)
 
esOmirp :: Integer -> Bool
esOmirp n = n /= rn && isPrime rn
  where rn = read . reverse . show $ n
 
omirps :: [Integer]
omirps = filter esOmirp primes
 
nOmirpsIntermedios :: Int -> Int
nOmirpsIntermedios n =
  length
  . filter esOmirp
  . takeWhile (< rx)
  . dropWhile (<= x) $ primes
  where x  = omirps !! n
        rx = read . reverse . show $ x
Inicial
, , , , , , , , ,

4 soluciones de “Números somirp”

  1. Responder
    jaibengue 
    import Data.Numbers.Primes (isPrime, primes)
import Data.List (elemIndex)
import Data.Maybe (fromJust)
 
esOmirp :: Integer -> Bool
esOmirp n = (isPrime n && isPrime m) && (m/=n)
  where m = (read.reverse.show) n
 
omirps :: [Integer]
omirps = filter aux primes
  where aux n = isPrime m && (m/=n)
          where m = (read.reverse.show) n
 
nOmirpsIntermedios :: Int -> Int
nOmirpsIntermedios n = (fromJust $ elemIndex m omirps) - (n+1)
  where m = (read.reverse.show) (omirps !! n)
  2. Responder
    alerodrod5 
     
import Data.Numbers.Primes
import Data.List (elemIndex)
import Data.Maybe (fromJust)
 
esOmirp :: Integer -> Bool
esOmirp x = isPrime x && isPrime y && x/=y
  where y = (read.reverse.show) x
omirps:: [Integer]
omirps = filter (esOmirp) primes
nOmirpsIntermedios :: Int -> Int
nOmirpsIntermedios x = (fromJust $ elemIndex y omirps) - (x+1)
  where y = (read.reverse.show) (omirps !! x)
  3. Responder
    carbremor 
    import Data.Numbers.Primes
 
esOmirp :: Integer -> Bool
esOmirp n | isPrime n && (read . reverse . show) n == n               = False
          | isPrime n &&  isPrime ((read . reverse . show) n) == True = True
          | otherwise                                                 = False
 
 
omirps :: [Integer]
omirps = [n | n <- [13..],  esOmirp n]
 
nOmirpsIntermedios :: Int -> Int
nOmirpsIntermedios n = length [x | x <- [a..b], esOmirp x]  -2
  where
    a = omirps !! n
    b = (read . reverse . show) (omirps !! n)
  4. Responder
    Chema Cortés

    <

    pre lang=”haskell”>
    import Data.Numbers.Primes

    esOmirp :: Integer -> Bool
    esOmirp n = n /= inv && isPrime inv
    where
    inv = (read . reverse . show) n

    omirps :: [Integer]
    omirps = filter esOmirp primes

    nOmirpsIntermedios :: Int -> Int
    nOmirpsIntermedios n = abs (n – length (takeWhile (<inv) omirps)) – 1
    where
    inv = (read . reverse . show) (omirps!!n)

Escribe tu solución

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.