Sparkline in unicode: Difference between revisions

and generates a sparkline-type bar graph of the values on a single line of output.

 

(Unicode values U+2581 through U+2588).

 

* A space is not part of the generated sparkline.

* The sparkline may be accompanied by simple statistics of the data such as its range.

<br><br>

 

=={{header|APL}}==

Note → this is in a 0-indexed version of APL

▂▃▄▅▅▆▇█▇▆▅▅▄▃▂

sparkln 1.5, 0.5 3.5, 2.5 5.5, 4.5 7.5, 6.5

▂▁▄▃▆▅█▇

Note → APL accepts the input with commas and spaces naturally. If one wanted to read input as a string they could use ⍎⍞ to do so.

 

=={{header|AppleScript}}==

 

 

on sparkLine(xs)

on |λ|(x)

end |λ|

end script

end |λ|

end script

end sparkLine

 

else

end if

 

end |λ|

end script

 

 

 

-- foldl :: (a -> b -> a) -> a -> [b] -> a

end tell

end foldl

 

-- map :: (a -> b) -> [a] -> [b]

end map

 

end |λ|

end script

 

 

on mReturn(f)

f

else

end mReturn

 

set ca to current application

set oRgx to ca's NSRegularExpression's regularExpressionWithPattern:strRegex ¬

end regexMatches

 

on splitRegex(strRegex, str)

set lstMatches to regexMatches(strRegex, str)

{str}

end if

 

 

=={{header|AutoHotkey}}==

{{works with|AutoHotkey_L}}

strings := ["1 2 3 4 5 6 7 8 7 6 5 4 3 2 1"

, "1.5, 0.5 3.5, 2.5 5.5, 4.5 7.5, 6.5"]

Chars .= Chr(0x2581 + Round(7 * (A_LoopField - Min) / Rng))

return, {"Min": Min, "Max": Max, "Rng": Rng, "Chars": Chars}

{{out}}

<pre>Min: 1, Max: 8, Range: 7

Min: 0.5, Max: 7.5, Range: 7.0

▂▁▄▃▆▅█▇</pre>

 

=={{header|C}}==

===Linux version===

Accepts data via command line, prints out usage on incorrect invocation.

#include<string.h>

#include<stdlib.h>

return 0;

}

Invocation and output :

<pre>

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

 

#include <iostream>

#include <sstream>

 

return 0;

{{out}}

<pre>Min: 1; Max: 8; Range: 7

 

=={{header|Clojure}}==

(let [sparks "▁▂▃▄▅▆▇█"

high (apply max nums)

(recur (read-line)))))

 

 

{{Out}}

 

=={{header|Common Lisp}}==

(loop with min = (apply #'min numbers)

with max = (apply #'max numbers)

 

(string->sparkline "1 2 3 4 5 6 7 8 7 6 5 4 3 2 1")

{{out}}

<pre>Min: 1, Max: 8, Range: 7

=={{header|D}}==

{{trans|Python}}

import std.stdio, std.range, std.algorithm, std.conv,

std.string, std.regex;

immutable div = (mm[1] - mm[0]) / (bars.length - 1);

numbers.map!(n => bars[cast(int)((n - mm[0]) / div)]).writeln;

The output is the same as the Python entry

(but it only accepts one series of values at a time).

 

=={{header|Elixir}}==

def sparkline(str) do

values = str |> String.split(~r/(,| )+/)

IO.puts Enum.map(values, &(round((&1 - min) / (max - min) * 7 + 0x2581)))

end

Usage:

str2 = "1.5, 0.5 3.5, 2.5 5.5, 4.5 7.5, 6.5"

 

RC.sparkline(str1)

IO.puts "" # newline

{{out}}

<pre>

 

=={{header|F_Sharp|F#}}==

open System.Globalization

open System.Text.RegularExpressions

|> List.map (fun x -> bars.[int ((x - min)/(max - min) * barsCount)])

|> String.Concat

{{out}}

<pre>Numbers separated by anything: 1 2 3 4 5 6 7 8 7 6 5 4 3 2 1

▂▁▄▃▆▅█▇

Numbers separated by anything:

</pre>

 

=={{header|FALSE}}==

variables:

s: sign (1 or -1)

q;1-q: {move pointer}

]#

This implementation can only accept one series of numbers at a time.

{{out}}

 

=={{header|Go}}==

 

import (

}

return

{{out}}

<pre>

 

=={{header|Groovy}}==

def (min, max) = [list.min(), list.max()]

def div = (max - min) / 7

list.collect { (char)(0x2581 + (it-min) * div) }.join()

}

Test Code

println " Dataset: $dataset"

println "Sparkline: ${sparkline(dataset)}"

{{out}}

<pre>

 

=={{header|Haskell}}==

 

toSparkLine xs = map cl xs

where

bot = minimum xs

range = top - bot

 

makeSparkLine :: String -> (String, Stats)

, "3 2 1 0 -1 -2 -3 -4 -3 -2 -1 0 1 2 3"

, "-1000 100 1000 500 200 -400 -700 621 -189 3"

{{Out}}

<pre>▁▁██

 

Or, stripping back a little:

import Data.List (findIndex)

 

sparkLine :: [Float] -> String

 

main :: IO ()

main =

{{Out}}

<pre>▁▁██

 

=={{header|J}}==

y spkln~ 4 u:16b2581+i.8 NB. ▁▂▃▄▅▆▇█

:

N =. # x

x {~ <. (N-1) * (y-MIN) % MAX-MIN

'''Examples''':<pre> spkln 1 2 3 4 5 6 7 8 7 6 5 4 3 2 1

▁▂▃▄▅▆▇█▇▆▅▄▃▂▁

 

=={{header|Java}}==

public class Sparkline

{

}

}

{{out}}

<pre>

 

</pre>

 

=={{header|JavaScript}}==

===ES6===

 

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>▁▁██

 

=={{header|jq}}==

min as $min

| ( (max - $min) / 7 ) as $div

def string2array:

def tidy: select( length > 0 );

'''Task'''

( "1 2 3 4 5 6 7 8 7 6 5 4 3 2 1",

 

=={{header|Julia}}==

sparkchars = '\u2581':'\u2588'

dyn = length(sparkchars)

println("$v → ", sparklineit(v))

v = 10rand(10)

 

{{out}}

<pre>[6, 3, 9, 5, 1, 10, 0, 1, 3, 6] → ▅▃█▄▁█▁▁▃▅

 

=={{header|Kotlin}}==

{{trans|Java}}

internal const val n = bars.length - 1

 

println(s2)

println(s2.toSparkline())

{{Out}}

<pre>1 2 3 4 5 6 7 8 7 6 5 4 3 2 1

 

=={{header|LiveCode}}==

local utfbase=0x2581

local tStats, utfp, tmin,tmax,trange

end repeat

put plot

 

Test

▂▁▄▃▆▅█▇</pre>

 

=={{header|M2000 Interpreter}}==

This statement a=cdr(a) make a new array from a excluding the first item, so can be return the empty array (,). In Row$(a) a is passing by value, but is a pointer to array, so we get a pointer to point to same array. When we do the a=cdr(a) we change pointer so variable (a) point to a new array.

 

 

Module CheckIt {

Function Row$(a) {

}

Checkit

 

Function Param() get a string an put it as inline code in expressions

 

Module CheckIt {

Font "Dejavu Sans Mono"

}

Checkit

 

Third program use strings for stack input, which skip coma as white space. We have to pass to current stack, here calling a function (which always have a new stack for values). First we flush the stack (make it empty), then we use Stack Dat$ to parse the dat$ (also empty the string). Last we rtuern an array using array() using as argument a stack object. Read only function [] do two things replace the current stack object with an empty one, and return the old stack.

 

 

Module CheckIt {

Function ExtractDat(dat$) {

}

Checkit

{{out}}

<pre>

</pre >

 

<pre>

toSparkline["1 2 3 4 5 6 7 8 7 6 5,4 3 2 1 "]

toSparkline[" 1.5, 0.5 3.5, 2.5 5.5, 4.5 7.5, 6.5 "]

▂▁▄▃▆▅█▇

</pre>

 

=={{header|Nim}}==

{{trans|Python}}

 

const barcount = float(bar.high)

 

let

line = readLineFromStdin "Numbers please separated by space/commas: "

mn = min(numbers)

mx = max(numbers)

var sparkline = ""

for n in numbers:

{{out}}

<pre>Numbers please separated by space/commas: 1 2 3 4 5 6 7 8 7 6 5 4 3 2 1

min: 0.5; max: 7.5

▂▁▄▃▆▅█▇</pre>

 

=={{header|Perl}}==

our @sparks=map {chr} 0x2581 .. 0x2588;

my @n=map {0+$_} grep {length} @_ or return "";

my($min,$max)=($n[0])x2;

# one sparkline per line

print sparkline( split /[\s,]+/ ) while <>;

{{out}}

<pre>

8 values; range -8e+307..-1e+307

█▇▆▅▄▃▂▁</pre>

 

=={{header|Phix}}==

{{out}}

<pre>

 

=={{header|PicoLisp}}==

(let (Min (apply min Lst) Max (apply max Lst) Rng (- Max Min))

(for N Lst

(prin

(char (+ 9601 (*/ (- N Min) 7 Rng)) ) ) )

Test:

Output:

<pre>▁▂▃▄▅▆▇█▇▆▅▄▃▂▁

 

=={{header|Python}}==

 

# Unicode: 9601, 9602, 9603, 9604, 9605, 9606, 9607, 9608

mn, mx, sp = sparkline(numbers)

print(' min: %5f; max: %5f' % (mn, mx))

 

{{out}}

 

 

 

 

 

# sparkLine :: [Float] -> [String]

def sparkLine(xs):

def go(xs):

ys = sorted(xs)

w = (mx - mn) / 8

lbounds = list(map(lambda i: mn + (w * i), range(1, 8)))

return [

' '.join(map(str, xs)),

'\t'.join([

 

 

# main :: IO ()

def main():

 

 

 

# Just :: a -> Maybe a

def Just(x):

return {'type': 'Maybe', 'Nothing': False, 'Just': x}

 

# Nothing :: Maybe a

def Nothing():

return {'type': 'Maybe', 'Nothing': True}

 

 

# even :: Int -> Bool

def even(x):

return 0 == x % 2

 

# findIndex :: (a -> Bool) -> [a] -> Maybe Int

def findIndex(p):

def go(xs):

try:

except StopIteration:

return Nothing()

 

 

# maybe :: b -> (a -> b) -> Maybe a -> b

def maybe(v):

 

 

# mean :: [Num] -> Float

def mean(xs):

return sum(xs) / float(len(xs))

 

# readFloats :: String -> [Float]

def readFloats(s):

return list(map(

float,

))

 

 

if __name__ == '__main__':

{{Out}}

<pre>▁▁██

1.5 0.5 3.5 2.5 5.5 4.5 7.5 6.5

Min 0.5 Mean 4.0 Median 4.0 Max 7.5</pre>

 

=={{header|REXX}}==

{{Works with|ooRexx}}

{{Works with|Regina|3.4}}

 

parse arg aaa

return

{{out}}

<pre>

 

It should also be noted that the CMS and TSO versions of REXX (and practically all others) don't support ''single line comments''.

if arg()==0 then do /*Optional arguments? Then use defaults*/

call sparkGraph 1 2 3 4 5 6 7 8 7 6 5 4 3 2 1

end /*j*/

 

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

output: ▂▁▄▃▆▅█▇

</pre>

 

=={{header|Ruby}}==

loop {print 'Numbers please separated by space/commas: '

numbers = gets.split(/[\s,]+/).map(&:to_f)

div = (max - min) / (bar.size - 1)

puts min == max ? bar.last*numbers.size : numbers.map{|num| bar[((num - min) / div).to_i]}.join

 

{{out}} Used Go testcases

 

=={{header|Rust}}==

const BARS: &'static str = "▁▂▃▄▅▆▇█";

 

print_sparkline(s2);

}

{{out}}

"▁▂▃▄▅▆▇█▇▆▅▄▃▂▁"

 

=={{header|S-lang}}==

% Just to demonstrate alternate ways of defining unicode:

private variable spchrs = "\u{2581}\u{2582}\u{2583}\u{2584}\u{2585}\u{2586}\u{2587}\u{2588}";

sparkline("1 2 3 4 5 6 7 8 7 6 5 4 3 2 1");

sparkline("1.5, 0.5 3.5, 2.5 5.5, 4.5 7.5, 6.5 ");

{{out}}

"▁▂▃▄▅▆▇█▇▆▅▄▃▂▁"

 

=={{header|Scala}}==

numStr.split( "[\\s,]+" ).map(_.toFloat) match {

case v if v.isEmpty => ""

 

// A random test...

{{out}}

<pre> ▁▂▃▄▅▆▇█▇▆▅▄▃▂▁

 

=={{header|Seed7}}==

include "scanfile.s7i";

include "float.s7i";

data := readDataLine;

end while;

 

{{out}}

▂▁▄▃▆▅█▇

Numbers separated by anything:

</pre>

 

=={{header|Sidef}}==

{{trans|Ruby}}

loop {

print 'Numbers, please, separated by space/commas: ';

var div = ((max - min) / bar.end);

say (min == max ? bar.last*numbers.len : numbers.map{|num| bar[(num - min) / div]}.join);

{{out}}

<pre>Numbers, please, separated by space/commas: 1 2 3 4 5 6 7 8 7 6 5 4 3 2 1

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

 

proc extractValues {series} {

set max [tcl::mathfunc::max {*}$values]

return [join [lmap v $values {renderValue $min $max $v}] ""]

Demonstrating:

"1 2 3 4 5 6 7 8 7 6 5 4 3 2 1"

"1.5, 0.5 3.5, 2.5 5.5, 4.5 7.5, 6.5"

puts "Series: $series"

puts "Sparkline: [sparkline $series]"

{{out}}

<pre>

Series: 1.5, 0.5 3.5, 2.5 5.5, 4.5 7.5, 6.5

Sparkline: ▂▁▄▃▆▅█▇

</pre>

 

=={{header|zkl}}==

var sl=(sparks.len()-1);

println("Range [",min,"-",max,"]", xs);

xs.pump(String,'wrap(x){ sparks[(x - min)*sl/range] }).println();

two:=("1.5, 0.5 3.5, 2.5 5.5 4.5 7.5, 6.5" - ",").split(" ").apply("toFloat");

{{out}}

<pre>

▂▁▄▃▆▅█▇

</pre>