Stem-and-leaf plot: Difference between revisions
Content added Content deleted
No edit summary |
(→{{header|Haskell}}: ( alternatively – aiming more for legibility than for concision)) |
||
Line 1,033: | Line 1,033: | ||
13 | 1 2 3 9 |
13 | 1 2 3 9 |
||
14 | 1 6</pre> |
14 | 1 6</pre> |
||
Or alternatively – aiming more for legibility than for economy or concision: |
|||
<lang haskell>import Data.List (groupBy, intersperse, mapAccumL, sortBy) |
|||
import Data.Ord (comparing) |
|||
import Data.Function (on) |
|||
-- Strings derived from integers, |
|||
-- and split into [(initial string, final character)] tuples. |
|||
xs :: [(String, Char)] |
|||
xs = (\x -> (init x, last x)) <$> (show <$> [ |
|||
12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124, 37, 48, 127, |
|||
36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123, 35, 113, 122, 42, 117, |
|||
119, 58, 109, 23, 105, 63, 27, 44, 105, 99, 41, 128, 121, 116, 125, 32, |
|||
61, 37, 127, 29, 113, 121, 58, 114, 126, 53, 114, 96, 25, 109, 7, 31, |
|||
141, 46, 13, 27, 43, 117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, |
|||
52, 71, 118, 117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, |
|||
57, 122, 109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, |
|||
114, 34, 133, 45, 120, 30, 127, 31, 116, 146]) |
|||
-- Re-reading the initial strings as Ints |
|||
-- (empty strings read as 0), |
|||
ns :: [(Int, Char)] |
|||
ns = (\x -> let s = fst x |
|||
in ( |
|||
if null s |
|||
then 0 |
|||
else (read s :: Int), |
|||
snd x |
|||
) |
|||
) <$> xs |
|||
-- and sorting and grouping by these initial Ints, |
|||
-- interpreting them as data-collection bins. |
|||
bins :: [[(Int, Char)]] |
|||
bins = groupBy (on (==) fst) $ |
|||
sortBy (mappend (comparing fst) (comparing snd)) |
|||
ns |
|||
-- Forming bars by the ordered accumulation of final characters in each bin, |
|||
bars :: [(Int, String)] |
|||
bars = (\grp -> (((fst . head) grp), snd <$> grp)) <$> bins |
|||
-- and obtaining a complete series, with empty bar strings |
|||
-- interpolated for any missing integers. |
|||
series :: [(Int, String)] |
|||
series = (concat . snd) $ mapAccumL |
|||
(\a x -> |
|||
let n = fst x |
|||
in if a == n |
|||
then (a + 1, [x]) |
|||
else ( |
|||
n + 1, |
|||
((\i -> (i, "")) <$> [a .. (n - 1)]) ++ [x] |
|||
) |
|||
) |
|||
1 |
|||
bars |
|||
-- Assembling the series as a list of strings with right-justified indices, |
|||
justifyRight :: Int -> Char -> String -> String |
|||
justifyRight n c s = drop (length s) (replicate n c ++ s) |
|||
plotLines :: [String] |
|||
plotLines = foldr ( |
|||
\x a -> ( |
|||
justifyRight 2 ' ' (show (fst x)) ++ |
|||
" | " ++ (intersperse ' ' (snd x)) |
|||
) : a |
|||
) |
|||
[] |
|||
series |
|||
-- and passing these over to IO as a newline-delimited string. |
|||
main :: IO () |
|||
main = putStrLn $ unlines plotLines</lang> |
|||
{{Out}} |
|||
<pre> 0 | 7 7 |
|||
1 | 2 3 8 8 |
|||
2 | 3 5 7 7 7 7 7 7 8 8 9 9 |
|||
3 | 0 1 1 1 1 2 3 4 5 6 7 7 7 8 9 |
|||
4 | 0 0 1 2 2 2 2 3 3 3 4 4 4 5 6 7 8 8 |
|||
5 | 2 3 7 8 8 |
|||
6 | 1 3 8 |
|||
7 | 1 |
|||
8 | |
|||
9 | 6 9 |
|||
10 | 4 5 5 5 5 6 7 9 9 9 |
|||
11 | 1 3 3 3 3 4 4 4 5 5 5 6 6 6 6 7 7 7 7 8 8 9 9 |
|||
12 | 0 0 1 1 2 2 3 4 4 4 5 5 5 6 7 7 7 7 8 8 |
|||
13 | 1 2 3 9 |
|||
14 | 1 6</pre> |
|||
=={{header|HicEst}}== |
=={{header|HicEst}}== |