Sparkline in unicode: Difference between revisions

=={{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}}==

use framework "Foundation"

use scripting additions

set my text item delimiters to dlm

return s

{{Out}}

<pre>▁▁██

=={{header|Arturo}}==

 

barcount: to :floating dec size bar

 

print sparkLine

print ""

 

{{out}}

=={{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|Delphi}}==

program Sparkline_in_unicode;

 

Readln;

end.

=={{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

 

=={{header|Factor}}==

math.statistics sequences splitting ;

 

"0, 1, 19, 20"

"0, 999, 4000, 4999, 7000, 7999"

{{out}}

<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}}==

import Data.Char (chr)

 

, "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:

{{Trans|Python}}

import Data.List (findIndex)

import Data.List.Split (splitOneOf)

fmap read

. filter (not . null)

{{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>

===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)

arrays = map(lin -> split(lin, r"\s+|\s*,\s*") .|> s -> parse(Float64, s), lines)

foreach(v -> println("$v → ", sparklineit(v)), arrays)

{{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

 

 

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>

 

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

<pre>

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

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

return

{{out}}

<pre>

=={{header|Nim}}==

{{trans|Python}}

 

const bar = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"]

sparkline.add bar[i]

echo "min: ", mn.formatFloat(precision = 0), "; max: ", mx.formatFloat(precision = -1)

{{out}}

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

 

=={{header|OCaml}}==

let num_bars = 8

 

|> String.split_on_char ';'

|> List.iter print_sparkline

{{out}}

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

=={{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>

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

 

=={{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}}

If the search result is 'not found' (Nothing), then we use the highest (nominally 8th, or index 7) block.

 

 

from functools import reduce

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>▁▁██

 

=={{header|R}}==

bars <- intToUtf8(seq(0x2581, 0x2588), multiple = T) # ▁ ▂ ▃ ▄ ▅ ▆ ▇ █

n_chars <- length(bars)

sparkline(c(0, 0, 1, 1))

sparkline(c(0, 1, 19, 20))

{{out}}

[1] "▂▁▄▃▆▅█▇"

[1] "▁▂▃▄▅▆▇█▇▆▅▄▃▂▁"

[1] "▁▁██"

[1] "▁▁██"

 

=={{header|Racket}}==

#lang racket (require syntax/parse)

 

(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")

{{out}}

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

"▂▁▄▃▆▅█▇"

 

=={{header|Raku}}==

(formerly Perl 6)

while prompt 'Numbers separated by anything: ' -> $_ {

my @numbers = map +*, .comb(/ '-'? [[\d+ ['.' \d*]?] | ['.' \d+]] /);

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

{{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>

=={{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)

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}}

=={{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"

return graph

end sparklineGraph

{{out}}

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

Sparkline: ▂▁▄▃▆▅█▇

</pre>

 

=={{header|Wren}}==

{{trans|Go}}

{{libheader|Wren-pattern}}

 

var p = Pattern.new("[,+1/s|+1/s,|+1/s|,]")

System.print(s)

System.print()

 

{{out}}

 

=={{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>

 

=={{header|Zoea}}==

program: sparkline

input: '1 2, 3 4.5 5 6,7 8'

derive: [1,2,3,4,5,6,7,8]

output: '▁▂▃▄▅▆▇█'

 

=={{header|Zoea Visual}}==