Rotaciones divisibles por 8

PorJosé A. Alonso 22-diciembre-201719-febrero-2018

Las rotaciones de 928160 son 928160, 281609, 816092, 160928, 609281 y 92816 de las que 3 son divisibles por 8 (928160, 160928 y 92816).

Definir la función

   nRotacionesDivisiblesPor8 :: Integer -> Int

1	nRotacionesDivisiblesPor8 :: Integer -> Int

tal que (nRotacionesDivisiblesPor8 x) es el número de rotaciones de x divisibles por 8. Por ejemplo,

   nRotacionesDivisiblesPor8 928160       ==  3
   nRotacionesDivisiblesPor8 43262488612  ==  4
   nRotacionesDivisiblesPor8 (read (take (10^4) (cycle "248")))  ==  6666

nRotacionesDivisiblesPor8 928160 == 3

nRotacionesDivisiblesPor8 43262488612 == 4

nRotacionesDivisiblesPor8 (read (take (10^4) (cycle "248"))) == 6666

Soluciones

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

nRotacionesDivisiblesPor8 :: Integer -> Int
nRotacionesDivisiblesPor8 x =
  length [y | y <- rotaciones x
            , y `mod` 8 == 0]

--    rotaciones 1234  ==  [1234,2341,3412,4123]
rotaciones :: Integer -> [Integer]
rotaciones x = [read ys | ys <- rotacionesLista xs]
  where xs = show x

--    rotacionesLista "abcd"  ==  ["abcd","bcda","cdab","dabc"]
rotacionesLista :: [a] -> [[a]]
rotacionesLista xs =
  [zs ++ ys | k <- [0 .. length xs - 1]
            , let (ys,zs) = splitAt k xs] 

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

nRotacionesDivisiblesPor8b :: Integer -> Int
nRotacionesDivisiblesPor8b x =
  length [y | y <- tresDigitosConsecutivos x
            , y `mod` 8 == 0]

--    tresDigitosConsecutivos 1234  ==  [123,234,341,412]
tresDigitosConsecutivos :: Integer -> [Integer]
tresDigitosConsecutivos x =
  [read (take 3 ys) | ys <- rotacionesLista (show x)]

-- Comparación de eficiencia
-- =========================

--    λ> nRotacionesDivisiblesPor8 (read (take (3*10^3) (cycle "248")))
--    2000
--    (3.59 secs, 4,449,162,144 bytes)
--    λ> nRotacionesDivisiblesPor8b (read (take (3*10^3) (cycle "248")))
--    2000
--    (0.48 secs, 593,670,656 bytes)

-- 1ª definición

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

nRotacionesDivisiblesPor8 :: Integer -> Int

nRotacionesDivisiblesPor8 x =

length [y | y <- rotaciones x

, y `mod` 8 == 0]

-- rotaciones 1234 == [1234,2341,3412,4123]

rotaciones :: Integer -> [Integer]

rotaciones x = [read ys | ys <- rotacionesLista xs]

where xs = show x

-- rotacionesLista "abcd" == ["abcd","bcda","cdab","dabc"]

rotacionesLista :: [a] -> [[a]]

rotacionesLista xs =

[zs ++ ys | k <- [0 .. length xs - 1]

, let (ys,zs) = splitAt k xs]

-- 2ª definición

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

nRotacionesDivisiblesPor8b :: Integer -> Int

nRotacionesDivisiblesPor8b x =

length [y | y <- tresDigitosConsecutivos x

, y `mod` 8 == 0]

-- tresDigitosConsecutivos 1234 == [123,234,341,412]

tresDigitosConsecutivos :: Integer -> [Integer]

tresDigitosConsecutivos x =

[read (take 3 ys) | ys <- rotacionesLista (show x)]

-- Comparación de eficiencia

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

-- λ> nRotacionesDivisiblesPor8 (read (take (3*10^3) (cycle "248")))

-- 2000

-- (3.59 secs, 4,449,162,144 bytes)

-- λ> nRotacionesDivisiblesPor8b (read (take (3*10^3) (cycle "248")))

-- 2000

-- (0.48 secs, 593,670,656 bytes)

10 Comentarios

nRotacionesDivisiblesPor8 :: Integer -> Int
nRotacionesDivisiblesPor8 x =
  sum [1 | n <- rotaciones x, mod n 8 == 0]

rotaciones :: Integer -> [Integer]
rotaciones x = map read $ aux (show x) []
  where aux [] _      = []
        aux (x:xs) ys = (xs ++ ysx) : aux xs ysx
          where ysx = ys ++ [x]

nRotacionesDivisiblesPor8 :: Integer -> Int

nRotacionesDivisiblesPor8 x =

sum [1 | n <- rotaciones x, mod n 8 == 0]

rotaciones :: Integer -> [Integer]

rotaciones x = map read $ aux (show x) []

where aux [] _ = []

aux (x:xs) ys = (xs ++ ysx) : aux xs ysx

where ysx = ys ++ [x]

Responder

nRotacionesDivisiblesPor8 :: Integer -> Int
nRotacionesDivisiblesPor8 x = sum [1 | n<- rotaciones x, n `mod`8 ==0] 

rota :: [a] -> [a]
rota (x:xs) = xs ++ [x]

rotaciones :: Integer -> [Int]
rotaciones x = map read (take (length n) (iterate rota n))
   where n =show x

nRotacionesDivisiblesPor8 :: Integer -> Int

nRotacionesDivisiblesPor8 x = sum [1 | n<- rotaciones x, n `mod`8 ==0]

rota :: [a] -> [a]

rota (x:xs) = xs ++ [x]

rotaciones :: Integer -> [Int]

rotaciones x = map read (take (length n) (iterate rota n))

where n =show x

Responder

nRotacionesDivisiblesPor8 :: Integer -> Int
nRotacionesDivisiblesPor8 n
  | n < 100   = f n + f (nRot (show n))
  | otherwise = sum . map f . map read . aux . show $ n 
  where f x | x `mod` 8 == 0 = 1
            | otherwise      = 0
        aux n = aux2 $ drop (length n - 3) n ++ init n
        aux2 (x:y:z:xs) = (x:y:z:[]) : aux2 (y:z:xs)
        aux2 _          = []
        nRot (x:y) | length (x:y) == 1 = 3
                   | otherwise         = (read y)*10 + read [x]

nRotacionesDivisiblesPor8 :: Integer -> Int

nRotacionesDivisiblesPor8 n

| n < 100 = f n + f (nRot (show n))

| otherwise = sum . map f . map read . aux . show $ n

where f x | x `mod` 8 == 0 = 1

| otherwise = 0

aux n = aux2 $ drop (length n - 3) n ++ init n

aux2 (x:y:z:xs) = (x:y:z:[]) : aux2 (y:z:xs)

aux2 _ = []

nRot (x:y) | length (x:y) == 1 = 3

| otherwise = (read y)*10 + read [x]

Responder

Buenas, considerando como tú que si un número de tres cifras o más es divisible por ocho si sus tres últimas cifras lo son, se me ocurre también esta función:

import Data.List.Split (divvy)

nRotacionesDivisiblesPor8 :: Integer -> Int
nRotacionesDivisiblesPor8 x =
  sum [1 | n <- rotaciones8 x, n `mod` 8 == 0]

-- (rotaciones8 n) calcula las tres últimas cifras
-- de todas las rotaciones de un número de tres o
-- más cifras, y todas las rotaciones en otro caso.
-- Por ejemplo,
--   λ> rotaciones8 3456
--   [345,456,563,634]
rotaciones8 :: Integer -> [Integer]
rotaciones8 = map read . aux . show
  where aux [x]      = [[x]]
        aux [x,y]    = [[x,y],[y,x]]
        aux (x:y:xs) = divvy 3 1 (x:y:xs ++ [x,y])

import Data.List.Split (divvy)

nRotacionesDivisiblesPor8 :: Integer -> Int

nRotacionesDivisiblesPor8 x =

sum [1 | n <- rotaciones8 x, n `mod` 8 == 0]

-- (rotaciones8 n) calcula las tres últimas cifras

-- de todas las rotaciones de un número de tres o

-- más cifras, y todas las rotaciones en otro caso.

-- Por ejemplo,

-- λ> rotaciones8 3456

-- [345,456,563,634]

rotaciones8 :: Integer -> [Integer]

rotaciones8 = map read . aux . show

where aux [x] = [[x]]

aux [x,y] = [[x,y],[y,x]]

aux (x:y:xs) = divvy 3 1 (x:y:xs ++ [x,y])

Responder

angruicam1 dice:

23-diciembre-2017 a las 18:32

La demostración de esta propiedad (y algunas más) la podéis encontrar en el siguiente enlace: Criterios de divisibilidad.

Responder
angruicam1 dice:

26-diciembre-2017 a las 16:20

Podemos modificar de la siguiente forma la función nRotacionesDivisiblesPor8 para trabajar sin argumentos:

Haskell

nRotacionesDivisiblesPor8 :: Integer -> Int nRotacionesDivisiblesPor8 = length . filter (\ x -> x `mod` 8 == 0) . rotaciones8

1
2
3

nRotacionesDivisiblesPor8 :: Integer -> Int
nRotacionesDivisiblesPor8 =
length . filter (\ x -> x `mod` 8 == 0) . rotaciones8

Responder
1. antgongar dice:
  
  26-diciembre-2017 a las 19:29
  
  Se puede seguir eliminando argumentos ya que
  
  Haskell
  
  \x -> x `mod` 8 == 0
  
  1
  
  \x -> x `mod` 8 == 0
  
  es equivalente a
  
  Haskell
  
  (== 0) . (`mod` 8)
  
  1
  
  (== 0) . (`mod` 8)
  
  Responder

nRotacionesDivisiblesPor8 :: Integer -> Int
nRotacionesDivisiblesPor8 n =
  sum [1 | x <- take k (rotaciones n) , x `mod` 8 == 0]
  where k = length (show n)

rotaciones :: Integer -> [Integer]
rotaciones n =
  [n] ++ (rotaciones ((10*(n`mod`10^(-1+k))) + (n`div`10^(-1+k))))
  where k = length (show n)

nRotacionesDivisiblesPor8 :: Integer -> Int

nRotacionesDivisiblesPor8 n =

sum [1 | x <- take k (rotaciones n) , x `mod` 8 == 0]

where k = length (show n)

rotaciones :: Integer -> [Integer]

rotaciones n =

[n] ++ (rotaciones ((10*(n`mod`10^(-1+k))) + (n`div`10^(-1+k))))

where k = length (show n)

Responder

nRotacionesDivisiblesPor8 :: Integer -> Int
nRotacionesDivisiblesPor8 n = length $ filter p (rotaciones n)
  where p x = mod x 8 == 0

rotaciones :: Integer -> [Integer]
rotaciones n = take l $ iterate siguiente n'
  where siguiente m = div m 10
        n' :: Integer
        n' = read $ show (mod n 100) ++ show n
        l = length $ show n

nRotacionesDivisiblesPor8 :: Integer -> Int

nRotacionesDivisiblesPor8 n = length $ filter p (rotaciones n)

where p x = mod x 8 == 0

rotaciones :: Integer -> [Integer]

rotaciones n = take l $ iterate siguiente n'

where siguiente m = div m 10

n' :: Integer

n' = read $ show (mod n 100) ++ show n

l = length $ show n

Responder

import Data.Char (digitToInt)

nRotacionesDivisiblesPor8 :: Integer -> Int
nRotacionesDivisiblesPor8 =
  length
  . filter ((== 0) . (`mod` 8))
  . rotaciones8
  . abs

-- (rotaciones8 n) calcula los números obtenidos al
-- multiplicar por 4 la antepenúltima cifra de cada una
-- de las rotaciones de un número, por 2 la penúltima y
-- sumarlas con la última cifra. Por ejemplo,
--   λ> rotaciones8 3456
--   [25,32,35,34]

rotaciones8 :: Integer -> [Int]
rotaciones8 n
  | n < 10    = [fromEnum n]
  | otherwise =
    zipWith3 (((+).) . flip ((+) . (2*)) . (4*))
    (a:b:ds) (b:ds++[a]) (ds++[a,b])
  where (a:b:ds) = digitos n

-- (digitos n) calcula todas las cifras de un número.
-- Por ejemplo,
--   λ> digitos 3456
--   [3,4,5,6]

digitos :: Integer -> [Int]
digitos = map digitToInt . show

import Data.Char (digitToInt)

nRotacionesDivisiblesPor8 :: Integer -> Int

nRotacionesDivisiblesPor8 =

length

. filter ((== 0) . (`mod` 8))

. rotaciones8

. abs

-- (rotaciones8 n) calcula los números obtenidos al

-- multiplicar por 4 la antepenúltima cifra de cada una

-- de las rotaciones de un número, por 2 la penúltima y

-- sumarlas con la última cifra. Por ejemplo,

-- λ> rotaciones8 3456

-- [25,32,35,34]

rotaciones8 :: Integer -> [Int]

rotaciones8 n

| n < 10 = [fromEnum n]

| otherwise =

zipWith3 (((+).) . flip ((+) . (2*)) . (4*))

(a:b:ds) (b:ds++[a]) (ds++[a,b])

where (a:b:ds) = digitos n

-- (digitos n) calcula todas las cifras de un número.

-- Por ejemplo,

-- λ> digitos 3456

-- [3,4,5,6]

digitos :: Integer -> [Int]

digitos = map digitToInt . show

Responder

Rotaciones divisibles por 8

Soluciones

10 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico

Soluciones

Se puede imprimir o compartir con

10 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico