Menu Close

Números somirp

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

4 soluciones de “Números somirp

  1. 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. 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. 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. 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)

Leave a Reply

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