Stem-and-leaf plot: Difference between revisions

{{trans|Kotlin}}

 

x.sort()

V i = x[0] I/ 10 - 1

]

 

 

{{out}}

 

=={{header|ACL2}}==

(cond ((endp xs) (list x))

((> x (first xs))

(reverse (stem-and-leaf-bins (reverse (isort xs))

0

 

=={{header|Ada}}==

[[GNAT]] used for sorting, could use any other sorting method.

Does not handle negative stems properly.

with Ada.Text_IO; use Ada.Text_IO;

with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

end loop;

end stemleaf;

Output:

<pre>

14 | 1 6

</pre>

 

=={{header|AutoHotkey}}==

#NoEnv

Data := "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"

Return ToReturn

}

Output:

<pre>

 

=={{header|AWK}}==

# syntax: GAWK -f STEM-AND-LEAF_PLOT.AWK

#

function max(x,y) { return((x > y) ? x : y) }

function min(x,y) { return((x < y) ? x : y) }

<p>output:</p>

<pre>

</pre>

 

{{works with|BBC BASIC for Windows}}

Sort% = FN_sortinit(0, 0)

NEXT

PRINT

Output:

<pre>

13 | 1 2 3 9

14 | 1 6

</pre>

 

=={{header|C}}==

#include <stdlib.h>

 

 

return 0;

1 | 2 3 8 8

2 | 3 5 7 7 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

 

=={{header|C sharp|C#}}==

using System.Collections.Generic;

using System.Linq;

}

}

<pre> 0 | 7 7

1 | 2 3 8 8

 

=={{header|C++}}==

#include <iomanip>

#include <iostream>

std::cout << std::endl;

}

Output:

<pre> 0 | 7 7

 

=={{header|Ceylon}}==

shared void run() {

print("``formatInteger(i).padLeading(2)``| ``" ".join(stemsToLeaves[i] else [])``");

}

 

=={{header|Clojure}}==

[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

 

(stem-and-leaf data)

 

{{out}}

 

=={{header|D}}==

 

void main() {

foreach (i; loHi[0]/10 .. loHi[1]/10 + 1)

writefln("%2d | %(%d %) ", i, histo.get(i, []).sort());

Output:

<pre> 0 | 7 7

{{trans|Ruby}}

{{works with|Elixir|1.3}}

def plot(data, leaf_digits\\1) do

multiplier = Enum.reduce(1..leaf_digits, 1, fn _,acc -> acc*10 end)

data = ~w(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)

|> Enum.map(&String.to_integer(&1))

 

{{out}}

 

=={{header|Euphoria}}==

 

procedure leaf_plot(sequence s)

114, 34, 133, 45, 120, 30, 127, 31, 116, 146 }

 

 

Output:

 

=={{header|F Sharp|F#}}==

 

let data =

printfn "")

 

Output:

<pre>

 

=={{header|Factor}}==

prettyprint sequences sorting ;

 

120 43 27 27 18 28 48 125 107 114 34 133 45 120 30 127 31

116

{{out}}

<pre>

 

=={{header|Forth}}==

12 , 127 , 28 , 42 , 39 , 113 , 42 , 18 , 44 , 118 , 44 ,

37 , 113 , 124 , 37 , 48 , 127 , 36 , 29 , 31 , 125 , 139 ,

drop ;

 

Output:

<pre>

Note that the MOD function can produce unexpected values for negative numbers, and, different computer/compiler/language combinations may produce different surprises. In this case, negative values produce negative remainder values, but the ABS function suppresses the surprise.

SUBROUTINE COMBSORT(A,N)

INTEGER A(*) !The array.

CALL TOPIARY(VALUES,121)

END

 

Output: (If additional spacing is desired, I2 format could be used, etc.)

14|16

</pre>

 

=={{header|Go}}==

 

import (

}

}

Output:

<pre>

 

=={{header|Haskell}}==

import Control.Arrow

import Control.Monad

stems = map (flip(,)[]) $ uncurry enumFromTo $ minimum &&& maximum $ fst $ unzip stemLeaf

showStemLeaves f w (a,b) = f w (show a) ++ " |" ++ concatMap (f w. show) b

Output:

<pre>*Main> task nls

Or alternatively – aiming more for legibility than for economy or concision:

 

import Data.Ord (comparing)

import Data.Function (on)

main :: IO ()

main = putStrLn $ unlines plotLines

{{Out}}

<pre> 0 | 7 7

=={{header|HicEst}}==

The dialog prompts for bitmap or a text image, and for the stem base. Data are read in from clipboard.

 

DLG(CHeckbox=bitmap, NameEdit=base, DNum, MIn=1, MAx=16) ! 1 <= stem base <= 16

WRITE(Format="i3, ':'") stem

ENDIF

Shown is the given example for bitmap=0 and base 16

<pre> 0 : 7 7 C D

 

=={{header|Icon}} and {{header|Unicon}}==

prune := integer(\A[1]) | 10 # Boundary between leaf and stem

every put(data := [], integer(!&input))

}

write()

Sample output from data.

<pre>->stem <stem.data

=={{header|J}}==

'''Solution: (Tacit)'''

leaf =: 10&|

stemleaf =: (stem@{. ; leaf)/.~ stem

expandLeaves=: (expandStems e. ])@[ #inv ]

 

 

'''Solution: (Explicit)'''

leaves=. 10 | y

stems=. y <.@:% 10

xleaves=. (xstems e. stems) #inv leaves NB. expand leaves to match xstems

(": ,.xstems) ; ":&> xleaves

 

'''Example:'''

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

 

(showStemLeaf -: showStemLeafX) nls NB. both solutions give same result

 

=={{header|Java}}==

{{works with|Java|1.5+}}

import java.util.LinkedList;

import java.util.List;

printPlot(plot);

}

{{works with|Java|1.8+}}

import java.util.Collection;

import java.util.Collections;

;

}

Output:

<pre>0 | [7, 7]

It turns out that HTML+CSS renders the plot quite attractively.

 

<head>

<meta http-equiv="Content-Type" content="text/html;charset=utf-8" >

 

</body>

 

The output looks like:

 

===JavaScript ES6===

// main :: IO String

const main = () => {

// MAIN ------------------------------------------------------------------

return main();

{{Out}}

<pre> 0 | 7 7

 

=={{header|jq}}==

 

# align-right:

else [ $stem + 1, (.[1] + "\n\($stem+1|right) | \($d % 10)" )]

end )

'''Example''':

[ 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,

data | stem_and_leaf

{{Out}}

$ jq -n -r -f stem-and-leaf_plot.jq

0 | 77

12 | 00112234445556777788

13 | 1239

 

=={{header|Julia}}==

 

This is a rather elaborate function that creates a string depicting a stem and leaf plot. Much of the elaboration is to handle the case of negative numbers that have a stem of 0. There is also a bit of work to allow for leaf sizes other than 1 (some power of 10).

function stemleaf{T<:Real}(a::Array{T,1}, leafsize=1)

ls = 10^int(log10(leafsize))

return slp

end

 

'''Main'''

println("Using the Task's Test Data")

test = """12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29

println("Using: ", test)

println(stemleaf(test, 10))

 

{{out}}

=={{header|Kotlin}}==

{{trans|C}}

 

fun leafPlot(x: IntArray) {

)

leafPlot(data)

 

{{out}}

 

=={{header|Lua}}==

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,

print ""

Output:

<pre> 0 | 7 7

 

=={{header|Maple}}==

local i, j, k, tf, LeafStemTable, LeafStemIndices;

k:=0;

Y := [ 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];

 

 

<pre>0 | 7 7

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

For[i = Min@ Quotient[inputdata, 10],i <= Max@ Quotient[inputdata, 10], i++,

(Print[i, If[(padding - len[i]) > 0, (padding - len[i])*" " <> " |", " |"] ,

StringJoin[(" " <> #) & /@ Map[ToString, #]]])&@

{{out}}

<pre>0 | 7 7

=={{header|MATLAB}} / {{header|Octave}}==

 

if nargin < 2, stem_unit = 10; end;

if nargin < 3,

x = [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];

 

Output:

<pre>

 

=={{header|Maxima}}==

 

data: [12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124, 37, 48, 127,

12|00112234445556777788

13|1239

 

=={{header|Nim}}==

import math

import strutils

var negativePlot = StemLeafPlot()

negativePlot.init(1, negativeData)

 

{{out}}

The definition of the function <code>unique</code> below can be omited if one uses the [http://code.google.com/p/ocaml-extlib/ extlib].

 

let rec aux acc = function

| [] -> (List.rev acc)

else aux (x::acc) xs

in

 

[ 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;

List.iter (Printf.printf " %d") vs;

print_newline()

 

we can output the same latex code than the Perl example replacing the main function as follow:

 

print_endline "\

\\documentclass{report}

print_endline "\

\\end{tabular}

 

=={{header|Perl}}==

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

print " $leaf";

}

{{out}}

<pre> 0 | 7 7

=== LaTeX output ===

generating {{header|LaTeX}}

 

my @data = sort {$a <=> $b} qw( 12 127 28 42 39 113 42 18 44 118 44

\end{tabular}

\end{document}

 

LaTeX output of the Perl program:

 

\usepackage{fullpage}

\begin{document}

14 & 1

\end{tabular}

 

The parameter to the <code>tabular</code> environment defines the columns of the table. “r” and “c” are right- and center-aligned columns, “|” is a vertical rule, and “<code>*{''count''}{''cols''}”</code> repeats a column definition ''count'' times.

=={{header|Phix}}==

{{trans|Euphoria}}

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">procedure</span> <span style="color: #000000;">leaf_plot</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">leaf_plot</span><span style="color: #0000FF;">(</span><span style="color: #000000;">data</span><span style="color: #0000FF;">)</span>

{{out}}

<pre style="font-size: 8px">

 

=={{header|PicoLisp}}==

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

(sort *Data) ) )

(for I (range (caar L) (car (last L)))

Output:

<pre> 0 | 7 7

 

=={{header|PowerShell}}==

$Set = -split '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'

@( $Stem.ToString().PadLeft( 2, " " ), '|' ) + ( ( $Data | Where Stem -eq $Stem ).Leaf | Sort ) -join " "

}

{{out}}

<pre>

14 | 1 6

</pre>

 

=={{header|Python}}==

 

Adjusting <code>Stem.leafdigits</code> allows you to modify how many digits of a value are used in the leaf, with the stem intervals adjusted accordingly.

from pprint import pprint as pp

from math import floor

 

if __name__ == '__main__':

 

'''Sample Output'''

 

Here is an another example using an OrderedDict and Counter

 

x= [12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124, 37, 48,

 

stemleaf(x)

 

Output :

 

Or, generalising a little to write a purely declarative function (in terms of '''groupby''' and '''reduce''') which takes stem and leaf accessor functions as its first arguments:

from functools import (reduce)

 

 

 

<pre> 0 | 7 7

1 | 2 3 8 8

6 | 1 3 8

7 | 1

9 | 6 9

10 | 4 5 5 5 5 6 7 9 9 9

=={{header|R}}==

 

x <- c(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,

 

stem(x)

 

Output :

 

=={{header|Racket}}==

#lang racket

(define (show-stem+leaf data)

(newline)))

(show-stem+leaf (sequence->list (in-producer read eof)))

 

Sample run:

 

Handles negative stems properly.

12 127 28 42 39 113 42 18 44 118 44

37 113 124 37 48 127 36 29 31 125 139

my $leafs = %h{$stem} // [];

say $stem.fmt($stem_format), ' | ', ~$leafs.map: * % $stem_unit;

 

Output:<pre> 0 | 7 7

 

Also, all numbers that are processed are normalized. &nbsp; Using a &nbsp; ''sparse array'' &nbsp; bypasses the need for sorting.

parse arg @ /* [↓] Not specified? Then use default*/

if @='' then @=12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139,

end /*m*/

say right(k, w) '║' space($) /*display a line of stem─and─leaf plot.*/

'''output''' &nbsp; when using the (internal) defaults as input:

<pre>

===negative, zero, and positive numbers===

This REXX version also handles negative numbers.

parse arg @ /*obtain optional arguments from the CL*/

if @='' then @='15 14 3 2 1 0 -1 -2 -3 -14 -15' /*Not specified? Then use the default.*/

end /*m*/

say right(k, w) '║' space($) /*display a line of stem─and─leaf plot.*/

'''output''' &nbsp; when using the (internal) defaults as input:

<pre>

 

=={{header|Ring}}==

# Project : Stem-and-leaf plot

 

next

see nl

Output:

<pre>

=={{header|Ruby}}==

This implementation will handle negative values.

def initialize(data, options = {})

opts = {:leaf_digits => 1}.merge(options)

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

 

{{out}}

 

'''Simple version'''

def initialize(data, leaf_digits=1)

@leaf_digits = leaf_digits

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

{{out}}

<pre>

=={{header|Scala}}==

{{works with|Scala|2.8}}

val lineFormat = "%" + (numbers map (_.toString.length) max) + "d | %s"

val map = numbers groupBy (_ / 10)

println(lineFormat format (stem, map.getOrElse(stem, Nil) map (_ % 10) sortBy identity mkString " "))

}

 

Example:

 

=={{header|Seed7}}==

 

const proc: leafPlot (in var array integer: x) is func

begin

leafPlot(data);

 

Output:

=={{header|Sidef}}==

{{trans|Raku}}

12 127 28 42 39 113 42 18 44 118 44

37 113 124 37 48 127 36 29 31 125 139

var leafs = (h{stem} \\ [])

say(stem_format % stem, ' | ', leafs.map { _ % stem_unit }.join(' '))

{{out}}

<pre>

=={{header|Stata}}==

 

. input x

12

12* | 00112234445556777788

13* | 1239

 

=={{header|Tcl}}==

{{works with|Tcl|8.5}}

 

# How to process a single value, adding it to the table mapping stems to

48 125 107 114 34 133 45 120 30 127 31 116 146

}

Output:

<pre>

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

digits=*

ENDLOOP

DO format

Output:

<pre style='height:30ex;overflow:scroll'>

13 1'2'3'9

14 1'6

</pre>

 

=={{header|Ursala}}==

#import nat

 

#show+

 

Reading from right to left on the bottom line of the <code>stemleaf_plot</code> function, we

obtain the quotient and remainder of every datum divided by ten, partition by

{{trans|Kotlin}}

{{libheader|Wren-fmt}}

 

var leafPlot = Fn.new { |x|

34, 133, 45, 120, 30, 127, 31, 116, 146

]

 

{{out}}

13 | 1 2 3 9

14 | 1 6

</pre>

 

=={{header|zkl}}==

{{trans|C}}

xs=xs.sort();

i := xs[0] / 10 - 1;

34, 133, 45, 120, 30, 127, 31, 116, 146 );

{{out}}

<pre>