Convierte la lista de enteros en un int (como concat) en haskell

Question

Más o menos lo que dice el título. Tengo una lista de enteros como esta: [1,2,3]. Quiero cambiar esto al Entero 123. Mi primer pensamiento fue concat pero eso no funciona porque es del tipo incorrecto, he intentado varias cosas, pero por lo general acabo devolviendo la misma lista. Cualquier ayuda muy apreciada.

También tengo encontré una forma de imprimir lo correcto (putStr) excepto que quiero que el tipo sea Integer y putStr no lo hace.

Answer 1

Puede utilizar foldl combinar todos los elementos de una lista:

fromDigits = foldl addDigit 0 
    where addDigit num d = 10*num + d 

La función addDigit es llamado por foldl añadir los dígitos, uno tras otro, comenzando desde el extremo izquierdo.

*Main> fromDigits [1,2,3] 
123 

Editar:
foldl paseos a través de la lista de izquierda a derecha, la adición de los elementos de acumular un cierto valor.

El segundo argumento de foldl, 0 en este caso, es el valor inicial del proceso. En el primer paso, ese valor inicial se combina con 1, el primer elemento de la lista, llamando al addDigit 0 1. Esto resulta en 10 * 0 + 1 = 1. En el siguiente paso, este 1 se combina con el segundo elemento de la lista, por addDigit 1 2, dando 10 * 1 + 2 = 12. Entonces esto se combina con el tercer elemento de la lista , por addDigit 12 3, resultando en 10 * 12 + 3 = 123.

Entonces, multiplicar inútilmente por cero es solo el primer paso, en los siguientes pasos la multiplicación es realmente necesaria para agregar los nuevos dígitos "hasta el final" del Número acumulado.

Answer 2

Se podría concat las representaciones de cadena de los números, y luego read de vuelta, así:

joiner :: [Integer] -> Integer 
joiner = read . concatMap show 

Answer 3

Uso read y también intToDigit:

joinInt :: [Int] -> Int 
joinInt l = read $ map intToDigit l 

tiene la ventaja (o desventaja) de vomitar en números de varios dígitos.

Answer 4

En cuanto a cómo imprimir el número, en lugar de

putStr n 

sólo trato

putStr (show n) 

El razonamiento es que sólo puede putStr cadenas de impresión. Por lo tanto, debe convertir el número en una cadena antes de pasarlo.

Es posible que también desee probar la función print de Prelude. Este puede imprimir cualquier cosa que sea "visible" (cualquier instancia de la clase Show), no solo cadenas. Pero tenga en cuenta que print n corresponde (aproximadamente) a putStrLn (show n), no a putStr (show n).

Answer 5

Otra idea sería decir: el último dígito cuenta para 1, el penúltimo cuenta para 10, el dígito anterior cuenta para 100, etcétera. Por lo tanto, para convertir una lista de dígitos en un número, debe invertirlo (para comenzar desde atrás), multiplicar los dígitos junto con las potencias correspondientes de diez y sumar el resultado.

Para invertir una lista, utilice reverse, para obtener las potencias de diez que puede utilizar iterate (*10) 1 (probarlo en GHCi o abrazos!), Para multiplicar los dígitos correspondientes de dos listas utilizar zipWith (*) y añadir todo junto, utilice sum - ¡realmente ayuda conocer algunas funciones de la biblioteca! Poner los trozos juntos, se obtiene

fromDigits xs = sum (zipWith (*) (reverse xs) (iterate (*10) 1)) 

Ejemplo de evaluación:

fromDigits [1,2,3,4] 
    ==> sum (zipWith (*) (reverse [1,2,3,4]) [1,10,100,1000, ....] 
    ==> sum (zipWith (*) [4,3,2,1] [1,10,100,1000, ....]) 
    ==> sum [4 * 1, 3 * 10, 2 * 100, 1 * 1000] 
    ==> 4 + 30 + 200 + 1000 
    ==> 1234 

Sin embargo, esta solución es más lento que los que tienen foldl, debido a la llamada a reverse y ya que estamos construyendo esos poderes de diez solo para usarlos directamente de nuevo. En el lado positivo, esta forma de construir números está más cerca de la forma en que la gente suele pensar (¡al menos yo lo hago!), Mientras que las soluciones foldl en esencia usan Horner's rule.

Answer 6

No soy un experto en Haskell, pero esta es la forma más fácil que se me ocurre para encontrar una solución a este problema que no implique el uso de otras funciones externas.

ConcatDigits :: [Int] -> Int 
ConcatDigits [] = 0 
ConcatDigits xs = ConcatReversed (ReverseDigits xs) 1 

ReverseDigits :: [Int] -> [Int] 
ReverseDigits [] = [] 
ReverseDigits (x:xs) = (ReverseDigits xs) : x 

ConcatReversed :: [Int] -> Int -> Int 
ConcatReversed [] d = 0 
ConcatReversed (x:xs) d = (x*d) + ConcatReversed xs (d*10) 

Como puede ver, he supuesto que está tratando de concaturar una lista de dígitos. Si por casualidad este no es tu caso, estoy bastante seguro de que esto no funcionará. :(

En mi solución, en primer lugar he definido una función llamada ReverseDigits, que revierte la lista original. Por ejemplo [1,2,3] a [3,2,1]

Después eso, yo uso una función ConcatReversed que toma una lista de dígitos y el número d, que es el resultado de diez potencias el primer dígito en la posición de la lista. Si la lista está vacía, devuelve 0, y si no, devuelve el primer dígito en la lista de tiempos d, además de la llamada a ConcatReversed pasar el resto de la lista y d veces diez.

esperan que el código de hablar por sí mismo, porque creo que mi pobre explicación Inglés no era muy útil.