Número primo de Sheldon

PorJosé A. Alonso 5-junio-20194-junio-2019

En el episodio número 73 de la serie «The Big Bang Theory», Sheldon Cooper enuncia lo siguiente:

«El mejor número es el 73. El 73 es el 21-ésimo número primo. Al invertir sus cifras obtenemos 37, que es el primo número 12. Y al invertir este obtenemos 21, que es el producto de, agarraos fuerte, 7 y 3.»

Se define un número primo de Sheldon como: el n-ésimo número primo p(n) será un primo de Sheldon si cumple que el producto de sus dígitos es n y si, además, el número que se obtiene al invertir sus cifras, rev(p(n)), es el rev(n)-ésimo número primo; es decir, si rev(p(n)) = p(rev(n)).

Definir la función

   esPrimoSheldon :: Int -> Bool

1	esPrimoSheldon :: Int -> Bool

tal que (esPrimoSheldon x) se verifica si x un primo de Sheldon. Por ejemplo,

_ 
   esPrimoSheldon 73  ==  True
   esPrimoSheldon 79  ==  False

esPrimoSheldon 73 == True

esPrimoSheldon 79 == False

Comprobar con QuickCheck que 73 es el único primo de Sheldon.

Referencia: Este ejercicio está basado en la noticia Descubierta una nueva propiedad de los números primos gracias a The Big Bang Theory donde podéis leer más información sobre el tema, entre ello la prueba de que el 73 es el único número primo de Sheldon.

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

Soluciones

[schedule expon=’2019-06-12′ expat=»06:00″]

Las soluciones se pueden escribir en los comentarios hasta el 12 de junio.
El código se debe escribir entre una línea con <pre lang=»haskell»> y otra con </pre>

Pensamiento

El mejor número es el 73. El 73 es el 21-ésimo número primo. Al invertir sus cifras obtenemos 37, que es el primo número 12. Y al invertir este obtenemos 21, que es el producto de, agarraos fuerte, 7 y 3.

Sheldon Cooper

[/schedule]

[schedule on=’2019-06-12′ at=»06:00″]

import Data.Char           (digitToInt)
import Data.List           (elemIndex)
import Data.Maybe          (fromJust)
import Data.Numbers.Primes (isPrime, primes)
import Test.QuickCheck     (Property, (==>), quickCheck)

-- 1ª definición
-- =============

esPrimoSheldon :: Int -> Bool
esPrimoSheldon x =
     n > 0
  && x == primes !! (n - 1)
  && inverso x == primes !! (inverso n - 1)
  where n = productoDigitos x

-- (productoDigitos x) es el producto de los dígitos de x. Por ejemplo, 
--    productoDigitos 73  ==  21
productoDigitos :: Int -> Int
productoDigitos x = product (map digitToInt (show x))

-- (inverso x) es el número obtenido invirtiendo el orden de los dígitos
-- de x. Por ejemplo,
--    inverso 735  ==  537
inverso :: Int -> Int
inverso x = read (reverse (show x))

-- 2ª definición
-- =============

esPrimoSheldon2 :: Int -> Bool
esPrimoSheldon2 x =
     n > 0
  && x == primes !! (n - 1)
  && inverso2 x == primes !! (inverso2 n - 1)
  where n = productoDigitos2 x

-- (productoDigitos2 x) es el producto de los dígitos de x. Por ejemplo, 
--    productoDigitos2 73  ==  21
productoDigitos2 :: Int -> Int
productoDigitos2 = product . map digitToInt . show

-- (inverso2 x) es el número obtenido invirtiendo el orden de los dígitos
-- de x. Por ejemplo,
--    inverso2 735  ==  537
inverso2 :: Int -> Int
inverso2 = read . reverse . show

-- 3ª definición
-- =============

esPrimoSheldon3 :: Int -> Bool
esPrimoSheldon3 n = isPrime n && p1 && p2
  where p  = primes
        i1 = fromJust (elemIndex n p) + 1
        i2 = read (reverse (show i1))
        p1 = i1 == product (map digitToInt (show n))
        p2 = read (reverse (show n)) == p !! (i2 - 1)

-- Propiedad de primo de Sheldon
-- =============================

-- La propiedad es
prop_primoDeShelldon :: Int -> Property
prop_primoDeShelldon x =
  x >= 0 ==> esPrimoSheldon x == (x == 73)

-- La comprobación es
--    λ> quickCheck prop_primoDeShelldon
--    +++ OK, passed 100 tests.

import Data.Char (digitToInt)

import Data.List (elemIndex)

import Data.Maybe (fromJust)

import Data.Numbers.Primes (isPrime, primes)

import Test.QuickCheck (Property, (==>), quickCheck)

-- 1ª definición

-- =============

esPrimoSheldon :: Int -> Bool

esPrimoSheldon x =

n > 0

&& x == primes !! (n - 1)

&& inverso x == primes !! (inverso n - 1)

where n = productoDigitos x

-- (productoDigitos x) es el producto de los dígitos de x. Por ejemplo,

-- productoDigitos 73 == 21

productoDigitos :: Int -> Int

productoDigitos x = product (map digitToInt (show x))

-- (inverso x) es el número obtenido invirtiendo el orden de los dígitos

-- de x. Por ejemplo,

-- inverso 735 == 537

inverso :: Int -> Int

inverso x = read (reverse (show x))

-- 2ª definición

-- =============

esPrimoSheldon2 :: Int -> Bool

esPrimoSheldon2 x =

n > 0

&& x == primes !! (n - 1)

&& inverso2 x == primes !! (inverso2 n - 1)

where n = productoDigitos2 x

-- (productoDigitos2 x) es el producto de los dígitos de x. Por ejemplo,

-- productoDigitos2 73 == 21

productoDigitos2 :: Int -> Int

productoDigitos2 = product . map digitToInt . show

-- (inverso2 x) es el número obtenido invirtiendo el orden de los dígitos

-- de x. Por ejemplo,

-- inverso2 735 == 537

inverso2 :: Int -> Int

inverso2 = read . reverse . show

-- 3ª definición

-- =============

esPrimoSheldon3 :: Int -> Bool

esPrimoSheldon3 n = isPrime n && p1 && p2

where p = primes

i1 = fromJust (elemIndex n p) + 1

i2 = read (reverse (show i1))

p1 = i1 == product (map digitToInt (show n))

p2 = read (reverse (show n)) == p !! (i2 - 1)

-- Propiedad de primo de Sheldon

-- =============================

-- La propiedad es

prop_primoDeShelldon :: Int -> Property

prop_primoDeShelldon x =

x >= 0 ==> esPrimoSheldon x == (x == 73)

-- La comprobación es

-- λ> quickCheck prop_primoDeShelldon

-- +++ OK, passed 100 tests.

[/schedule]

10 Comentarios

posicionPrimo :: Int -> Int
posicionPrimo x | isPrime x = length (takeWhile (/=x) primes) + 1
                | otherwise = -1

invierteCifras :: Int -> Int
invierteCifras x =  read (reverse (show x))

productoDigitos :: Int -> Int
productoDigitos x = product [read [a] | a <- show x]

esPrimoSheldon :: Int -> Bool
esPrimoSheldon x = productoDigitos x == posicionPrimo x
  && invierteCifras ( posicionPrimo x) ==  posicionPrimo (invierteCifras x)

prop_Sheldon :: Int -> Property
prop_Sheldon n = n > 1 ==> if n == 73 then esPrimoSheldon 73 == True else esPrimoSheldon n ==  False

posicionPrimo :: Int -> Int

posicionPrimo x | isPrime x = length (takeWhile (/=x) primes) + 1

| otherwise = -1

invierteCifras :: Int -> Int

invierteCifras x = read (reverse (show x))

productoDigitos :: Int -> Int

productoDigitos x = product [read [a] | a <- show x]

esPrimoSheldon :: Int -> Bool

esPrimoSheldon x = productoDigitos x == posicionPrimo x

&& invierteCifras ( posicionPrimo x) == posicionPrimo (invierteCifras x)

prop_Sheldon :: Int -> Property

prop_Sheldon n = n > 1 ==> if n == 73 then esPrimoSheldon 73 == True else esPrimoSheldon n == False

Responder

esPrimoSheldon :: Int -> Bool
esPrimoSheldon n = isPrime n && isPrime (f n) && t+1 == (f (s+1)) && (length $ nub$ show n) /= 1 && product [read [y] | y <- show n] == t+1
  where f w = (read . reverse . show) w 
        Just t = elemIndex n primes
        Just s = elemIndex (f n) primes

esPrimoSheldon :: Int -> Bool

esPrimoSheldon n = isPrime n && isPrime (f n) && t+1 == (f (s+1)) && (length $ nub$ show n) /= 1 && product [read [y] | y <- show n] == t+1

where f w = (read . reverse . show) w

Just t = elemIndex n primes

Just s = elemIndex (f n) primes

Responder

esPrimoSheldon :: Int -> Bool
esPrimoSheldon n =  p (aux n) == aux (p n)
  where aux :: Int -> Int
        aux  = read.reverse.show
        p n = head [ a  | (a,b) <- zip [1..] primes , n == b]
        
prop_esPrimoSheldon :: Int -> Property
prop_esPrimoSheldon n = isPrime n ==> esPrimoSheldon n && n /=73

esPrimoSheldon :: Int -> Bool

esPrimoSheldon n = p (aux n) == aux (p n)

where aux :: Int -> Int

aux = read.reverse.show

p n = head [ a | (a,b) <- zip [1..] primes , n == b]

prop_esPrimoSheldon :: Int -> Property

prop_esPrimoSheldon n = isPrime n ==> esPrimoSheldon n && n /=73

Responder

Carlos dice:

5-junio-2019 a las 16:57

Proof: https://www.math.dartmouth.edu/~carlp/sheldonresub011119.pdf
Solución óptima:

esPrimoSheldon 73 == True esPrimoSheldon _ == False

1
2

esPrimoSheldon 73 == True
esPrimoSheldon _ == False

Responder

Complicándose un poco más…

import Test.QuickCheck
import Data.List
import Data.Tuple

unDigits base = foldl (\a b -> a * base + b) 0

digitsRev base = unfoldr step
  where
    step 0 = Nothing
    step n = Just $ swap (divMod n base)

primes = sieve [2..] where sieve (p:xs) = p : sieve [x | x <- xs, x `mod` p /= 0]

sheldon (n,p) = isProduct && isMirror
  where
    isProduct = n == product (to10 p)
    isMirror  = rev p == primes !! (rev n - 1)
    rev = unDigits 10 . to10
    to10 = digitsRev 10

esPrimoSheldon :: Int -> Bool
esPrimoSheldon x = x == snd p && sheldon p
  where
    p = head $ dropWhile ((<x).snd) (zip [1..] primes)

prop_Sheldon :: Int -> Property
prop_Sheldon x = (x == 73) === esPrimoSheldon x

main = quickCheck (withMaxSuccess 10000 prop_Sheldon)

import Test.QuickCheck

import Data.List

import Data.Tuple

unDigits base = foldl (\a b -> a * base + b) 0

digitsRev base = unfoldr step

where

step 0 = Nothing

step n = Just $ swap (divMod n base)

primes = sieve [2..] where sieve (p:xs) = p : sieve [x | x <- xs, x `mod` p /= 0]

sheldon (n,p) = isProduct && isMirror

where

isProduct = n == product (to10 p)

isMirror = rev p == primes !! (rev n - 1)

rev = unDigits 10 . to10

to10 = digitsRev 10

esPrimoSheldon :: Int -> Bool

esPrimoSheldon x = x == snd p && sheldon p

where

p = head $ dropWhile ((<x).snd) (zip [1..] primes)

prop_Sheldon :: Int -> Property

prop_Sheldon x = (x == 73) === esPrimoSheldon x

main = quickCheck (withMaxSuccess 10000 prop_Sheldon)

Responder

esPrimoSheldon :: Int -> Bool
esPrimoSheldon n = isPrime n && productoDigitos n && esPrimoInvertido n

esPrimoInvertido :: Int -> Bool
esPrimoInvertido n = isPrime (invertido n) && productoDigitosInvertido n

productoDigitosInvertido :: Int -> Bool
productoDigitosInvertido n = primes !! (y-1) == invertido n
  where y=invertido ( product (digitos n))

invertido :: Int ->Int
invertido n =read(reverse (show n))

productoDigitos :: Int -> Bool
productoDigitos n = primes !! (y-1) == n
  where y =product (digitos n)

digitos :: Int -> [Int]
digitos n = [read [c] |c<- show n]

esPrimoSheldon :: Int -> Bool

esPrimoSheldon n = isPrime n && productoDigitos n && esPrimoInvertido n

esPrimoInvertido :: Int -> Bool

esPrimoInvertido n = isPrime (invertido n) && productoDigitosInvertido n

productoDigitosInvertido :: Int -> Bool

productoDigitosInvertido n = primes !! (y-1) == invertido n

where y=invertido ( product (digitos n))

invertido :: Int ->Int

invertido n =read(reverse (show n))

productoDigitos :: Int -> Bool

productoDigitos n = primes !! (y-1) == n

where y =product (digitos n)

digitos :: Int -> [Int]

digitos n = [read [c] |c<- show n]

Responder

esPrimoSheldon = (==73)

O(1)

*Main> :main
+++ OK, passed 100000 tests (0.304% = 73).

import Test.QuickCheck
import Data.Tuple
import Data.List

unDigits base = foldl (\a b -> a * base + b) 0

digitsRev base = unfoldr step
  where
    step 0 = Nothing
    step n = Just $ swap (divMod n base)

primes = sieve [2..] where sieve (p:xs) = p : sieve [x | x <- xs, x `mod` p /= 0]

index = zip [1..]

sheldon (n,p) = isProduct && isMirror
  where
    isProduct = n == product (r10 p)
    isMirror  = rev p == primes !! (rev n - 1)
    rev = unDigits 10 . r10
    r10 = digitsRev 10

isPrimeSheldon x = x == snd p && sheldon p
  where
    p = head $ dropWhile ((x>).snd) (index primes)

esPrimoSheldon :: Int -> Bool
esPrimoSheldon = (==73)

prop_Sheldon :: Positive Int -> Property
prop_Sheldon (Positive x) = classify (x == 73) "= 73" $
        isPrimeSheldon x === esPrimoSheldon x

main = quickCheck $ withMaxSuccess 100000 prop_Sheldon

import Test.QuickCheck

import Data.Tuple

import Data.List

unDigits base = foldl (\a b -> a * base + b) 0

digitsRev base = unfoldr step

where

step 0 = Nothing

step n = Just $ swap (divMod n base)

primes = sieve [2..] where sieve (p:xs) = p : sieve [x | x <- xs, x `mod` p /= 0]

index = zip [1..]

sheldon (n,p) = isProduct && isMirror

where

isProduct = n == product (r10 p)

isMirror = rev p == primes !! (rev n - 1)

rev = unDigits 10 . r10

r10 = digitsRev 10

isPrimeSheldon x = x == snd p && sheldon p

where

p = head $ dropWhile ((x>).snd) (index primes)

esPrimoSheldon :: Int -> Bool

esPrimoSheldon = (==73)

prop_Sheldon :: Positive Int -> Property

prop_Sheldon (Positive x) = classify (x == 73) "= 73" $

isPrimeSheldon x === esPrimoSheldon x

main = quickCheck $ withMaxSuccess 100000 prop_Sheldon

Responder

antgutmen1 dice:

8-junio-2019 a las 22:19

esPrimoSheldon :: Int -> Bool
esPrimoSheldon x | not(isPrime x) || not(isPrime (inverso x)) = False
|otherwise = posicion x == inverso (posicion (inverso x)) &&
sort (primeFactors (posicion x)) == sort (digitos x)

posicion :: Int -> Int
posicion x | not (isPrime x) = error «no es primo»
| otherwise = head [n | n <- [0..], primes !! n == x] + 1

inverso :: Int -> Int
inverso x = aDigito (reverse (digitos x))
aDigito :: [Int] -> Int
aDigito [] = 0
aDigito (x:xs) = x *10^length(xs) + aDigito xs

digitos :: Int -> [Int]
digitos x = [read [y] | y <- show x]

prop_primoSheldon :: Int -> Property
prop_primoSheldon n = isPrime n && n /= 73 ==> not (esPrimoSheldon n)

Responder

esPrimoSheldon :: Int -> Bool
esPrimoSheldon x = and [isPrime x,p(x) ==product(digit x),  isPrime (rev x),
                        p(rev x)== rev(p x)]
                        

rev :: Int -> Int
rev x = read (reverse (show x))

digit :: Int -> [Int]
digit x = [ read [k] | k<-(show x)]

p :: Int -> Int
p n = length (takeWhile (<=n) primes)

esPrimoSheldon :: Int -> Bool

esPrimoSheldon x = and [isPrime x,p(x) ==product(digit x), isPrime (rev x),

p(rev x)== rev(p x)]

rev :: Int -> Int

rev x = read (reverse (show x))

digit :: Int -> [Int]

digit x = [ read [k] | k<-(show x)]

p :: Int -> Int

p n = length (takeWhile (<=n) primes)

Responder

esPrimoSheldon :: Int -> Bool
esPrimoSheldon x = (isPrime x && product(digitos x)==(posicionPrimo x)) && (isPrime (inverso x) && (posicionPrimo (inverso x) == inverso(posicionPrimo x)))

inverso :: Int -> Int
inverso x = read (concat (map show (reverse(digitos x))))

digitos :: Int -> [Int]
digitos x = [read [y] | y <- show x]

posicionPrimo :: Int -> Int
posicionPrimo x = length $ takeWhile (<= x) primes

prop_Sheldon :: Int -> Property
prop_Sheldon n = n > 1 ==> if n == 73 then esPrimoSheldon 73 == True else esPrimoSheldon n ==  False

esPrimoSheldon :: Int -> Bool

esPrimoSheldon x = (isPrime x && product(digitos x)==(posicionPrimo x)) && (isPrime (inverso x) && (posicionPrimo (inverso x) == inverso(posicionPrimo x)))

inverso :: Int -> Int

inverso x = read (concat (map show (reverse(digitos x))))

digitos :: Int -> [Int]

digitos x = [read [y] | y <- show x]

posicionPrimo :: Int -> Int

posicionPrimo x = length $ takeWhile (<= x) primes

prop_Sheldon :: Int -> Property

prop_Sheldon n = n > 1 ==> if n == 73 then esPrimoSheldon 73 == True else esPrimoSheldon n == False

Responder

Número primo de Sheldon

Soluciones

Pensamiento

10 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico

Soluciones

Pensamiento

Se puede imprimir o compartir con

10 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico