Sparkline in unicode: Difference between revisions
m
→{{header|Wren}}: Minor tidy
m (→{{header|Wren}}: Minor tidy) |
|||
(3 intermediate revisions by 3 users not shown) | |||
Line 36:
=={{header|APL}}==
Note → this is in a 0-indexed version of APL
'''Solution''':<
'''Example''':<
▂▃▄▅▅▆▇█▇▆▅▅▄▃▂
sparkln 1.5, 0.5 3.5, 2.5 5.5, 4.5 7.5, 6.5
▂▁▄▃▆▅█▇
</syntaxhighlight>
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}}==
<
use framework "Foundation"
use scripting additions
Line 360:
set my text item delimiters to dlm
return s
end unwords</
{{Out}}
<pre>▁▁██
Line 392:
=={{header|Arturo}}==
<
barcount: to :floating dec size bar
Line 409:
print sparkLine
print ""
]</
{{out}}
Line 424:
=={{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"]
Line 446:
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
Line 453:
Min: 0.5, Max: 7.5, Range: 7.0
▂▁▄▃▆▅█▇</pre>
=={{header|BASIC}}==
==={{header|VBScript}}===
<syntaxhighlight lang="vb">
'Sparkline
sub ensure_cscript()
if instrrev(ucase(WScript.FullName),"WSCRIPT.EXE")then
createobject("wscript.shell").run "CSCRIPT //nologo """ &_
WScript.ScriptFullName &"""" ,,0
wscript.quit
end if
end sub
class bargraph
private bar,mn,mx,nn,cnt
Private sub class_initialize()
bar=chrw(&h2581)&chrw(&h2582)&chrw(&h2583)&chrw(&h2584)&chrw(&h2585)&_
chrw(&h2586)&chrw(&h2587)&chrw(&h2588)
nn=8
end sub
public function bg (s)
a=split(replace(replace(s,","," ")," "," ")," ")
mn=999999:mx=-999999:cnt=ubound(a)+1
for i=0 to ubound(a)
a(i)=cdbl(trim(a(i)))
if a(i)>mx then mx=a(i)
if a(i)<mn then mn=a(i)
next
ss="Data: "
for i=0 to ubound(a) :ss=ss & right (" "& a(i),6) :next
ss=ss+vbcrlf + "sparkline: "
for i=0 to ubound(a)
x=scale(a(i))
'wscript.echo mn,mx, a(i),x
ss=ss & string(6,mid(bar,x,1))
next
bg=ss &vbcrlf & "min: "&mn & " max: "& mx & _
" cnt: "& ubound(a)+1 &vbcrlf
end function
private function scale(x)
if x=<mn then
scale=1
elseif x>=mx then
scale=nn
else
scale=int(nn* (x-mn)/(mx-mn)+1)
end if
end function
end class
ensure_cscript
set b=new bargraph
wscript.stdout.writeblanklines 2
wscript.echo b.bg("1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 5, 4, 3, 2, 1")
wscript.echo b.bg("1.5, 0.5 3.5, 2.5 5.5, 4.5 7.5, 6.5")
wscript.echo b.bg("0, 1, 19, 20")
wscript.echo b.bg("0, 999, 4000, 4999, 7000, 7999")
set b=nothing
wscript.echo "If bars don't display correctly please set the the console " & _
"font to DejaVu Sans Mono or any other that has the bargrph characters" & _
vbcrlf
wscript.stdout.write "Press any key.." : wscript.stdin.read 1
</syntaxhighlight>
{{out}}
<pre>
Data: 1 2 3 4 5 6 7 8 7 6 5 4 3 2 1
sparkline: ▁▁▁▁▁▁▂▂▂▂▂▂▃▃▃▃▃▃▄▄▄▄▄▄▅▅▅▅▅▅▆▆▆▆▆▆▇▇▇▇▇▇██████▇▇▇▇▇▇▆▆▆▆▆▆▅▅▅▅▅▅▄▄▄▄▄▄▃▃▃▃▃▃▂▂▂▂▂▂▁▁▁▁▁▁
min: 1 max: 8 cnt: 15
Data: 15 5 35 25 55 45 75 65
sparkline: ▂▂▂▂▂▂▁▁▁▁▁▁▄▄▄▄▄▄▃▃▃▃▃▃▆▆▆▆▆▆▅▅▅▅▅▅██████▇▇▇▇▇▇
min: 5 max: 75 cnt: 8
Data: 0 1 19 20
sparkline: ▁▁▁▁▁▁▁▁▁▁▁▁████████████
min: 0 max: 20 cnt: 4
Data: 0 999 4000 4999 7000 7999
sparkline: ▁▁▁▁▁▁▁▁▁▁▁▁▅▅▅▅▅▅▅▅▅▅▅▅████████████
min: 0 max: 7999 cnt: 6
If bars don't display correctly please set the the console
font to DejaVu Sans Mono or any other that has the bargrph characters
Press any key..
</pre>
=={{header|C}}==
Line 458 ⟶ 559:
===Linux version===
Accepts data via command line, prints out usage on incorrect invocation.
<syntaxhighlight lang="c">
#include<string.h>
#include<stdlib.h>
Line 506 ⟶ 607:
return 0;
}
</syntaxhighlight>
Invocation and output :
<pre>
Line 519 ⟶ 620:
=={{header|C++}}==
<
#include <iostream>
#include <sstream>
Line 587 ⟶ 688:
return 0;
}</
{{out}}
<pre>Min: 1; Max: 8; Range: 7
Line 595 ⟶ 696:
=={{header|Clojure}}==
<
(let [sparks "▁▂▃▄▅▆▇█"
high (apply max nums)
Line 609 ⟶ 710:
(recur (read-line)))))
(spark (read-line))</
{{Out}}
Line 618 ⟶ 719:
=={{header|Common Lisp}}==
<
(loop with min = (apply #'min numbers)
with max = (apply #'max numbers)
Line 660 ⟶ 761:
(string->sparkline "1 2 3 4 5 6 7 8 7 6 5 4 3 2 1")
(string->sparkline "1.5, 0.5 3.5, 2.5 5.5, 4.5 7.5, 6.5")</
{{out}}
<pre>Min: 1, Max: 8, Range: 7
Line 669 ⟶ 770:
=={{header|D}}==
{{trans|Python}}
<
import std.stdio, std.range, std.algorithm, std.conv,
std.string, std.regex;
Line 684 ⟶ 785:
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|Delphi}}==
<syntaxhighlight lang="delphi">
program Sparkline_in_unicode;
Line 739 ⟶ 840:
Readln;
end.
</syntaxhighlight>
=={{header|Elixir}}==
<
def sparkline(str) do
values = str |> String.split(~r/(,| )+/)
Line 748 ⟶ 849:
IO.puts Enum.map(values, &(round((&1 - min) / (max - min) * 7 + 0x2581)))
end
end</
Usage:
<syntaxhighlight lang="text">str1 = "1 2 3 4 5 6 7 8 7 6 5 4 3 2 1"
str2 = "1.5, 0.5 3.5, 2.5 5.5, 4.5 7.5, 6.5"
RC.sparkline(str1)
IO.puts "" # newline
RC.sparkline(str2)</
{{out}}
<pre>
Line 764 ⟶ 865:
=={{header|F_Sharp|F#}}==
<
open System.Globalization
open System.Text.RegularExpressions
Line 785 ⟶ 886:
|> List.map (fun x -> bars.[int ((x - min)/(max - min) * barsCount)])
|> String.Concat
|> printfn "%s"</
{{out}}
<pre>Numbers separated by anything: 1 2 3 4 5 6 7 8 7 6 5 4 3 2 1
Line 797 ⟶ 898:
=={{header|Factor}}==
<
math.statistics sequences splitting ;
Line 814 ⟶ 915:
"0, 1, 19, 20"
"0, 999, 4000, 4999, 7000, 7999"
} [ dup sparkline "%u -> %s\n" printf ] each</
{{out}}
<pre>
Line 824 ⟶ 925:
=={{header|FALSE}}==
<
variables:
s: sign (1 or -1)
Line 891 ⟶ 992:
q;1-q: {move pointer}
]#
]?</
This implementation can only accept one series of numbers at a time.
{{out}}
Line 900 ⟶ 1,001:
=={{header|Go}}==
<
import (
Line 973 ⟶ 1,074:
}
return
}</
{{out}}
<pre>
Line 1,011 ⟶ 1,112:
=={{header|Groovy}}==
<
def (min, max) = [list.min(), list.max()]
def div = (max - min) / 7
list.collect { (char)(0x2581 + (it-min) * div) }.join()
}
def sparkline(String text) { sparkline(text.split(/[ ,]+/).collect { it as Double }) }</
Test Code
<
println " Dataset: $dataset"
println "Sparkline: ${sparkline(dataset)}"
}</
{{out}}
<pre>
Line 1,031 ⟶ 1,132:
=={{header|Haskell}}==
<
import Data.Char (chr)
Line 1,087 ⟶ 1,188:
, "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>▁▁██
Line 1,105 ⟶ 1,206:
Or, stripping back a little:
{{Trans|Python}}
<
import Data.List (findIndex)
import Data.List.Split (splitOneOf)
Line 1,141 ⟶ 1,242:
fmap read
. filter (not . null)
. splitOneOf " ,"</
{{Out}}
<pre>▁▁██
Line 1,149 ⟶ 1,250:
=={{header|J}}==
'''Solution''' (''explicit''):<
y spkln~ 4 u:16b2581+i.8 NB. ▁▂▃▄▅▆▇█
:
Line 1,155 ⟶ 1,256:
N =. # x
x {~ <. (N-1) * (y-MIN) % MAX-MIN
)</
'''Solution''' (''tacit''):<
'''Solution''' (''look Ma, no hands!''):<
'''Examples''':<pre> spkln 1 2 3 4 5 6 7 8 7 6 5 4 3 2 1
▁▂▃▄▅▆▇█▇▆▅▄▃▂▁
Line 1,167 ⟶ 1,268:
=={{header|Java}}==
<
public class Sparkline
{
Line 1,209 ⟶ 1,310:
}
}
</syntaxhighlight>
{{out}}
<pre>
Line 1,223 ⟶ 1,324:
===ES6===
<
'use strict';
Line 1,380 ⟶ 1,481:
// MAIN ---
return main();
})();</
{{Out}}
<pre>▁▁██
Line 1,399 ⟶ 1,500:
=={{header|jq}}==
<
min as $min
| ( (max - $min) / 7 ) as $div
Line 1,407 ⟶ 1,508:
def string2array:
def tidy: select( length > 0 );
[split(" ") | .[] | split(",") | .[] | tidy | tonumber];</
'''Task'''
( "1 2 3 4 5 6 7 8 7 6 5 4 3 2 1",
Line 1,418 ⟶ 1,519:
=={{header|Julia}}==
<
sparkchars = '\u2581':'\u2588'
dyn = length(sparkchars)
Line 1,436 ⟶ 1,537:
arrays = map(lin -> split(lin, r"\s+|\s*,\s*") .|> s -> parse(Float64, s), lines)
foreach(v -> println("$v → ", sparklineit(v)), arrays)
</syntaxhighlight>
{{out}}
<pre>[6, 3, 9, 5, 1, 10, 0, 1, 3, 6] → ▅▃█▄▁█▁▁▃▅
Line 1,445 ⟶ 1,546:
=={{header|Kotlin}}==
{{trans|Java}}
<
internal const val n = bars.length - 1
Line 1,466 ⟶ 1,567:
println(s2)
println(s2.toSparkline())
}</
{{Out}}
<pre>1 2 3 4 5 6 7 8 7 6 5 4 3 2 1
Line 1,474 ⟶ 1,575:
=={{header|LiveCode}}==
<
local utfbase=0x2581
local tStats, utfp, tmin,tmax,trange
Line 1,495 ⟶ 1,596:
end repeat
put plot
end sparklines</
Test
Line 1,514 ⟶ 1,615:
<syntaxhighlight lang="m2000 interpreter">
Module CheckIt {
Function Row$(a) {
Line 1,549 ⟶ 1,650:
}
Checkit
</syntaxhighlight>
Function Param() get a string an put it as inline code in expressions
<syntaxhighlight lang="m2000 interpreter">
Module CheckIt {
Font "Dejavu Sans Mono"
Line 1,581 ⟶ 1,682:
}
Checkit
</syntaxhighlight>
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.
<syntaxhighlight lang="m2000 interpreter">
Module CheckIt {
Function ExtractDat(dat$) {
Line 1,619 ⟶ 1,720:
}
Checkit
</syntaxhighlight>
{{out}}
<pre>
Line 1,629 ⟶ 1,730:
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
<pre>
toSparkline["1 2 3 4 5 6 7 8 7 6 5,4 3 2 1 "]
Line 1,639 ⟶ 1,740:
=={{header|NetRexx}}==
<
options replace format comments java crossref symbols nobinary
Line 1,693 ⟶ 1,794:
return
</syntaxhighlight>
{{out}}
<pre>
Line 1,705 ⟶ 1,806:
=={{header|Nim}}==
{{trans|Python}}
<
const bar = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"]
Line 1,722 ⟶ 1,823:
sparkline.add bar[i]
echo "min: ", mn.formatFloat(precision = 0), "; max: ", mx.formatFloat(precision = -1)
echo sparkline</
{{out}}
<pre>Numbers please separated by space/commas: 1 2 3 4 5 6 7 8 7 6 5 4 3 2 1
Line 1,732 ⟶ 1,833:
=={{header|OCaml}}==
<
let num_bars = 8
Line 1,770 ⟶ 1,871:
|> String.split_on_char ';'
|> List.iter print_sparkline
</syntaxhighlight>
{{out}}
<pre>
Line 1,788 ⟶ 1,889:
=={{header|Perl}}==
<
our @sparks=map {chr} 0x2581 .. 0x2588;
sub sparkline :prototype(@) {
my @n=map {0+$_} grep {length} @_ or return "";
my($min,$max)=($n[0])x2;
Line 1,817 ⟶ 1,918:
# one sparkline per line
print sparkline( split /[\s,]+/ ) while <>;
</syntaxhighlight>
{{out}}
<pre>
Line 1,860 ⟶ 1,961:
=={{header|Phix}}==
Works fine on Linux, with or without unicode_console.e as that does little apart from check environment settings for clues, but on my Windows box, on which it invokes kernel32/SetConsoleOutputCP(CP_UTF8), unicode_console.e improves it only slightly, getting just two of the eight characters right. Changing the font on the windows(10) console to "NSimSum" or "SimSun-ExtB" (manually, by right clicking on the title bar and selecting properties/fonts) improves things considerably - suggestions welcome.
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"1.0.2"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (a fix for JS)</span>
Line 1,889 ⟶ 1,990:
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</
{{out}}
<pre>
Line 1,907 ⟶ 2,008:
=={{header|PicoLisp}}==
<
(let (Min (apply min Lst) Max (apply max Lst) Rng (- Max Min))
(for N Lst
(prin
(char (+ 9601 (*/ (- N Min) 7 Rng)) ) ) )
(prinl) ) )</
Test:
<
(sparkLine (scl 1 (str "1.5, 0.5 3.5, 2.5 5.5, 4.5 7.5, 6.5")))</
Output:
<pre>▁▂▃▄▅▆▇█▇▆▅▄▃▂▁
Line 1,921 ⟶ 2,022:
=={{header|Python}}==
<
# Unicode: 9601, 9602, 9603, 9604, 9605, 9606, 9607, 9608
Line 1,945 ⟶ 2,046:
mn, mx, sp = sparkline(numbers)
print(' min: %5f; max: %5f' % (mn, mx))
print(" " + sp)</
{{out}}
Line 1,979 ⟶ 2,080:
If the search result is 'not found' (Nothing), then we use the highest (nominally 8th, or index 7) block.
<
from functools import reduce
Line 2,148 ⟶ 2,249:
# MAIN ---
if __name__ == '__main__':
main()</
{{Out}}
<pre>▁▁██
Line 2,167 ⟶ 2,268:
=={{header|R}}==
<
bars <- intToUtf8(seq(0x2581, 0x2588), multiple = T) # ▁ ▂ ▃ ▄ ▅ ▆ ▇ █
n_chars <- length(bars)
Line 2,191 ⟶ 2,292:
sparkline(c(0, 0, 1, 1))
sparkline(c(0, 1, 19, 20))
</syntaxhighlight>
{{out}}
<syntaxhighlight lang="r">
[1] "▂▁▄▃▆▅█▇"
[1] "▁▂▃▄▅▆▇█▇▆▅▄▃▂▁"
Line 2,200 ⟶ 2,301:
[1] "▁▁██"
[1] "▁▁██"
</syntaxhighlight>
=={{header|Racket}}==
<
#lang racket (require syntax/parse)
Line 2,217 ⟶ 2,318:
(sparks "1 2 3 4 5 6 7 8 7 6 5 4 3 2 1")
(sparks "1.5, 0.5 3.5, 2.5 5.5, 4.5 7.5, 6.5")
</syntaxhighlight>
{{out}}
<
"▁▂▃▄▅▆▇█▇▆▅▄▃▂▁"
"▂▁▄▃▆▅█▇"
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku"
while prompt 'Numbers separated by anything: ' -> $_ {
my @numbers = map +*, .comb(/ '-'? [[\d+ ['.' \d*]?] | ['.' \d+]] /);
Line 2,232 ⟶ 2,333:
say "min: $mn.fmt('%5f'); max: $mx.fmt('%5f')";
say @bars[ @numbers.map: { @bars * ($_ - $mn) / ($mx - $mn) min @bars - 1 } ].join;
}</
{{out}}
<pre>Numbers separated by anything: 9 18 27 36 45 54 63 72 63 54 45 36 27 18 9
Line 2,252 ⟶ 2,353:
{{Works with|ooRexx}}
{{Works with|Regina|3.4}}
<
parse arg aaa
Line 2,319 ⟶ 2,420:
return
</syntaxhighlight>
{{out}}
<pre>
Line 2,344 ⟶ 2,445:
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
Line 2,368 ⟶ 2,469:
end /*j*/
say 'output: ' z; say; return /*show the output, + a blank line*/</
{{out|output|text= when using the default inputs:}}
<pre>
Line 2,380 ⟶ 2,481:
=={{header|Ruby}}==
{{trans|Raku}} with added protection for input like "0 0 0 0".
<
loop {print 'Numbers please separated by space/commas: '
numbers = gets.split(/[\s,]+/).map(&:to_f)
Line 2,387 ⟶ 2,488:
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
Line 2,414 ⟶ 2,515:
=={{header|Rust}}==
<
const BARS: &'static str = "▁▂▃▄▅▆▇█";
Line 2,432 ⟶ 2,533:
print_sparkline(s2);
}
</syntaxhighlight>
{{out}}
"▁▂▃▄▅▆▇█▇▆▅▄▃▂▁"
Line 2,439 ⟶ 2,540:
=={{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}";
Line 2,465 ⟶ 2,566:
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 ");
</syntaxhighlight>
{{out}}
"▁▂▃▄▅▆▇█▇▆▅▄▃▂▁"
Line 2,472 ⟶ 2,573:
=={{header|Scala}}==
<
numStr.split( "[\\s,]+" ).map(_.toFloat) match {
case v if v.isEmpty => ""
Line 2,487 ⟶ 2,588:
// A random test...
println( mkSparks( Stream.continually( math.abs(util.Random.nextInt % 8)).take(64).mkString(" ") ))</
{{out}}
<pre> ▁▂▃▄▅▆▇█▇▆▅▄▃▂▁
Line 2,494 ⟶ 2,595:
=={{header|Seed7}}==
<
include "scanfile.s7i";
include "float.s7i";
Line 2,546 ⟶ 2,647:
data := readDataLine;
end while;
end func;</
{{out}}
Line 2,559 ⟶ 2,660:
=={{header|SenseTalk}}==
This solution makes use of SenseTalk's "word" chunks, in this case delimited by any number of spaces and/or commas, to simplify parsing the input string. Also note the use of the <code>but no more than</code> operator to handle the edge case where a number equal to the top value would otherwise refer to the 9th symbol, which doesn't exist.
<
put sparklineGraph of "1.5, 0.5 3.5, 2.5 5.5, 4.5 7.5, 6.5"
put sparklineGraph of "0, 1, 19, 20"
Line 2,578 ⟶ 2,679:
return graph
end sparklineGraph
</syntaxhighlight>
{{out}}
<pre>
Line 2,589 ⟶ 2,690:
=={{header|Sidef}}==
{{trans|Ruby}}
<
loop {
print 'Numbers, please, separated by space/commas: ';
Line 2,597 ⟶ 2,698:
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
Line 2,608 ⟶ 2,709:
=={{header|Tcl}}==
{{works with|Tcl|8.6}}
<
proc extractValues {series} {
Line 2,622 ⟶ 2,723:
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"
Line 2,631 ⟶ 2,732:
puts "Series: $series"
puts "Sparkline: [sparkline $series]"
}</
{{out}}
<pre>
Line 2,639 ⟶ 2,740:
Sparkline: ▂▁▄▃▆▅█▇
</pre>
=={{header|Wren}}==
{{trans|Go}}
{{libheader|Wren-pattern}}
<
import "./pattern" for Pattern
var p = Pattern.new("[,+1/s|+1/s,|+1/s|,]")
Line 2,799:
System.print(s)
System.print()
}</
{{out}}
Line 2,837:
=={{header|zkl}}==
<
var sl=(sparks.len()-1);
Line 2,845:
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");
sparkLine(one); sparkLine(two);</
{{out}}
<pre>
Line 2,858:
=={{header|Zoea}}==
<syntaxhighlight lang="zoea">
program: sparkline
input: '1 2, 3 4.5 5 6,7 8'
Line 2,864:
derive: [1,2,3,4,5,6,7,8]
output: '▁▂▃▄▅▆▇█'
</syntaxhighlight>
=={{header|Zoea Visual}}==
|