Histogrammgenerierung

12

Schreiben Sie das kürzeste Programm, das ein Histogramm generiert (eine grafische Darstellung der Datenverteilung).

Regeln:

  • Es muss ein Histogramm erstellt werden, das auf der Zeichenlänge der in das Programm eingegebenen Wörter (einschließlich Interpunktion) basiert. (Wenn ein Wort 4 Buchstaben lang ist, erhöht sich der Balken für die Zahl 4 um 1)
  • Es müssen Balkenbeschriftungen angezeigt werden, die mit der Zeichenlänge korrelieren, die die Balken darstellen.
  • Alle Zeichen müssen akzeptiert werden.
  • Wenn die Balken skaliert werden müssen, muss es eine Möglichkeit geben, die im Histogramm angezeigt wird.

Beispiele:

$ ./histogram This is a hole in one!
1 |#
2 |##
3 |
4 |###

$./histogram Extensive word length should not be very problematic.
1 |
2 |#
3 |#
4 |##
5 |
6 |##
7 |
8 |
9 |#
10|
11|
12|#

./histogram Very long strings of words should be just as easy to generate a histogram just as short strings of words are easy to generate a histogram for.
1 |##
2 |#######
3 |#
4 |#######
5 |###
6 |#
7 |##
8 |##
9 |##
syb0rg
quelle
4
Bitte schreiben Sie eine Spezifikation, anstatt ein einziges Beispiel anzugeben, das allein als einziges Beispiel nicht den Bereich akzeptabler Ausgabestile ausdrücken kann und das nicht garantiert, dass alle Eckfälle abgedeckt werden. Es ist gut, ein paar Testfälle zu haben, aber es ist noch wichtiger, eine gute Spezifikation zu haben.
Peter Taylor
@ PeterTaylor Weitere Beispiele angegeben.
Syb0rg
1
1. Dies ist eine grafische Ausgabe mit Tags , was bedeutet, dass es darum geht, auf dem Bildschirm zu zeichnen oder eine Bilddatei zu erstellen, aber Ihre Beispiele sind ASCII-Kunst . Ist beides akzeptabel? (Wenn nicht, dann ist der Planabus möglicherweise nicht glücklich). 2. Sie definieren Interpunktion als Bildung zählbarer Zeichen in einem Wort, geben jedoch nicht an, welche Zeichen Wörter trennen, welche Zeichen in der Eingabe vorkommen können und welche nicht und wie Zeichen behandelt werden, die möglicherweise vorkommen, aber keine alphabetische Interpunktion sind oder Worttrennzeichen. 3. Ist es akzeptabel, erforderlich oder verboten, die Stangen neu zu skalieren, damit sie in eine vernünftige Größe passen?
Peter Taylor
@PeterTaylor Ich habe es nicht als ASCII-Kunst markiert, weil es wirklich keine "Kunst" ist. Die Lösung von Phannabus ist in Ordnung.
Syb0rg
@PeterTaylor Ich habe einige Regeln hinzugefügt, die auf dem basieren, was Sie beschrieben haben. Bisher entsprechen alle Lösungen hier noch allen Regeln.
Syb0rg

Antworten:

3

K, 35

{(1+!|/g)#`$(#:'=g:#:'" "\:x)#'"#"}

.

k){(1+!|/g)#`$(#:'=g:#:'" "\:x)#'"#"}"Very long strings of words should be just as easy to generate a histogram just as short strings of words are easy to generate a histogram for."
1| ##
2| #######
3| #
4| #######
5| ###
6| #
7| ##
8| ##
9| ##

.

Ein längeres Beispiel

k){(1+!|/g)#`$(#:'=g:#:'" "\:x)#'"#"}"Please write a specification rather than giving a single example which, solely by virtue of being a single example, cannot express the range of acceptable output styles, and which doesnt guarantee to cover all corner cases. Its good to have a few test cases, but its even more important to have a good spec."
1 | #####
2 | ######
3 | #######
4 | ########
5 | ######
6 | ##############
7 | ###
8 | #
9 | ##
10| #
11|
12|
13| #
tmartin
quelle
Was passiert, wenn es Wörter mit mehr als 9 Buchstaben gibt?
Es funktioniert für Wörter beliebiger Länge
tmartin
5

R, 55 47 Zeichen

hist(a<-sapply(scan(,""),nchar),br=.5+0:max(a))

Glücklicherweise verfügt R über eine Plotfunktion histfür Histogramme, die hier mit einem breaksArgument versehen ist, bei dem die Unterbrechungen 0,5, 1,5, ... bis max (Eingabe) +0,5 betragen. sapply(scan(,""),nchar)Nimmt eine Eingabe (als stdin), trennt sie nach den Leerzeichen und zählt die Anzahl der Zeichen jedes Elements.

Beispiele:

hist(a<-sapply(scan(,""),nchar),br=.5+0:max(a))
1: Extensive word length should not be very problematic.
9: 
Read 8 items

Geben Sie hier die Bildbeschreibung ein

hist(a<-sapply(scan(,""),nchar),br=.5+0:max(a))
1: Very long strings of words should be just as easy to generate a histogram just as short strings of words are easy to generate a histogram for.
28: 
Read 27 items

Geben Sie hier die Bildbeschreibung ein

Bearbeiten:

Eine Variation mit 71 Zeichen mit einer Achsenbeschriftung bei jedem möglichen Wert:

hist(a<-sapply(scan(,""),nchar),br=.5+0:max(a),ax=F);axis(1,at=1:max(a))

Geben Sie hier die Bildbeschreibung ein

Planapus
quelle
3
Ich liebe es, wenn eine normalerweise wortreiche Sprache die Führung übernimmt!
Dies entspricht jedoch nicht der Spezifikation ...
Türknauf
@Doorknob Welche Spezifikation entspricht nicht?
Planapus
Die Beispiel-Testfälle.
Türknauf
3
Sie sind Beispiele, keine Spezifikationen ...
Planapus
5

Python - 83 Zeichen

Es scheint, dass wir Eingaben von überall nehmen können, also nimmt dies Eingaben während der Ausführung und nicht über die Befehlszeile entgegen und verwendet Ejrbs Vorschlag, um sie um 8 zu verkürzen.

s=map(len,raw_input().split())
c=0;exec'c+=1;print"%3d|"%c+"#"*s.count(c);'*max(s)

Python - 91 Zeichen

Dies wird mit Anführungszeichen umfallen.

import sys;s=map(len,sys.argv[1:])
for i in range(1,max(s)+1):print"%3d|"%i+'#'*s.count(i)

Eingang:

> python hist.py Please write a specification rather than giving a single example which, solely by virtue of being a single example, cannot express the range of acceptable output styles, and which doesnt guarantee to cover all corner cases. Its good to have a few test cases, but its even more important to have a good spec.

Ausgabe:

  1|#####
  2|######
  3|#####
  4|##########
  5|######
  6|#############
  7|####
  8|#
  9|##
 10|#
 11|
 12|
 13|#

quelle
2
Schön, Sie können 4 Zeichen sparen, indem Sie Ihre zweite Zeile (keine Änderung des Algorithmus) überarbeiten, um sie zu verwenden, execund die Verkettung von Zeichenfolgen:c=0;exec'c+=1;print"%3d|"%c+"#"*s.count(c);'*max(s)
ejrb
4

Haskell - 126 Zeichen

p[d]=[' ',d];p n=n
h l=[1..maximum l]>>= \i->p(show i)++'|':(l>>=($"#").drop.abs.(i-))++"\n"
main=interact$h.map length.words

Dies erfolgt über die Eingabe stdinund nicht über die Befehlszeile:

& head -500 /usr/share/dict/words | runhaskell 15791-Histogram.hs 
 1|##
 2|##
 3|######
 4|###############
 5|################################################
 6|###############################################################
 7|###################################################################
 8|###########################################################################
 9|#############################################################
10|##########################################################
11|#########################################################
12|#########################
13|#######
14|###
15|#####
16|###
17|#
18|
19|#
20|#
MtnViewMark
quelle
Sieht gut für mich aus! +1
syb0rg
3

Python 3.3 (93)

a=[len(i) for i in input().split()]
for i in range(1,max(a)+1):
 print(i,'|',"#"*a.count(i))

Ausgabe:
(Die erste Zeile ist die Eingabezeichenfolge)

Very long strings of words should be just as easy to generate a histogram just as short strings of words are easy to generate a histogram for.
1 | ##
2 | #######
3 | #
4 | #######
5 | ###
6 | #
7 | ##
8 | ##
9 | ##

Es rechtfertigt keine Zahlen als Python-Lösung von Lego Stormtroopr (die auch kürzer als meine ist), aber es ist mein erster Eintrag in einem Golfwettbewerb, also könnte ich es genauso gut hier lassen, denke ich :)

Roberto
quelle
Könnten Sie ein Beispiel eines von diesem Programm generierten Histogramms bearbeiten?
Syb0rg
Ja, aber ich habe gerade bemerkt, dass es ein Problem gibt: Es rechtfertigt die Zahlen nicht als Lego Stormtrooprs Lösung, also denke ich tatsächlich darüber nach, die Antwort zurückzuziehen.
Roberto
Solange für die dargestellten Balken Beschriftungen vorhanden sind, ist die Antwort akzeptabel.
Syb0rg
Ok, dann fertig! :)
Roberto
Dies erfolgt über Eingaben, nicht über Argumente. Ist das gültig @ syb0rg?
3

Perl, 56

$d[y///c].='#'for@ARGV;printf"%2d|$d[$_]
",$_ for+1..$#d

@ Manatworks Umschreib- und wörtlicher Newline-Vorschlag hinzugefügt, vielen Dank! @ Chinese_perl_goth's Updates hinzugefügt.

Verwendung: Als hist.pl speichern und ausführen perl hist.pl This is a test

Beispielausgabe:

$perl ~/hist.pl This is a test of the histogram function and how it will count the number of words of specific lengths. This sentence contains a long word 'complexity'.
 1|##
 2|#####
 3|####
 4|######
 5|##
 6|#
 7|
 8|#####
 9|#
10|
11|#
Dom Hastings
quelle
1
Warum nicht verwenden printf? Sie könnten einige Zeichen bei der Formatierung sparen. Und noch mehr, indem Sie von Hash zu Array wechseln : $d[y///c]++for@ARGV;shift@d;printf"%2d|%s\n",++$i,"#"x$_ for@d.
Manatwork
Kann ich ein Beispiel für dieses Programm bei der Arbeit sehen?
Syb0rg
@manatwork printfkam mir überhaupt nicht in den Sinn und aus irgendeinem Grund dachte ich nicht, dass ich mit einem Array den gewünschten Effekt erzielen könnte, erstaunlich! @ Syb0rg jetzt hinzufügen
Dom Hastings
2
Golfen Sie noch mehr, haben Sie es auf 57 Bytes reduziert:$d[y///c].='#'for@ARGV;printf"%2d|$d[$_]\n",$_ for+1..$#d
Chinese Perl Goth
1
Wir haben nur den einfachsten Trick verpasst: Verwenden Sie einen wörtlichen Zeilenumbruch, anstatt \n1 weiteres Zeichen zu sparen . Ich meine , wie diese: pastebin.com/496z2a0n
Manatwork
3

J, 48 47 46 45 43 Zeichen

(;#&'#')/"1|:((],[:+/=/)1+[:i.>./)$;._1' ',

Verwendungszweck:

   (;#&'#')/"1|:((],[:+/=/)1+[:i.>./)$;._1' ','Very long strings of words should be just as easy to generate a histogram just as short strings of words are easy to generate a histogram for.'
┌─┬───────┐
│1│##     │
├─┼───────┤
│2│#######│  
├─┼───────┤
│3│#      │
├─┼───────┤
│4│#######│
├─┼───────┤
│5│###    │
├─┼───────┤
│6│#      │
├─┼───────┤
│7│##     │
├─┼───────┤
│8│##     │
├─┼───────┤
│9│##     │
└─┴───────┘
Gareth
quelle
Tacit, 38 [:((](;#&'#')"0[:+/=/)1+[:i.>./)#@>@;:: Probieren Sie es online aus!
Jonah
2

Ruby, 98 85

a=$*.group_by &:size
1.upto(a.max[0]){|i|b=a.assoc i
puts"%-2i|#{b&&?#*b[1].size}"%i}

Nicht viel Golf gespielt. Wird später mehr Golf spielen.

c:\a\ruby>hist This is a test for the histogram thingy. yaaaaaaaaaaaay
1 |#
2 |#
3 |##
4 |##
5 |
6 |
7 |#
8 |
9 |#
10|
11|
12|
13|
14|#
Türknauf
quelle
Funktioniert gut (++ voteCount). Was könnte ich tun, um die Frage besser zu formulieren?
Syb0rg
1
@ syb0rg IMO die Frage ist gut formuliert, die Beispiele sprechen für sich. Obwohl Ihr letztes Mal einen Fehler zu haben scheint ... Ich zähle 2 Wörter mit 8 Buchstaben (generieren und generieren) und 2 Wörter mit 9 Buchstaben (Histogramm, Histogramm)
Türknauf
Cool. Sie könnte sich ändern , b ?(?#*b[1].size):''mit b&&?#*b[1].size.
Manatwork
2

Powershell, 97 93

$a=@{};$args-split ' '|%{$a[$_.length]++};1..($a.Keys|sort)[-1]|%{"{0,-2} |"-f $_+"#"*$a[$_]}

Beispiel:

PS Z:\> .\hist.ps1 This is an example of this program running
1  |
2  |###
3  |
4  |##
5  |
6  |
7  |###
Danko Durbić
quelle
Kann ich ein Beispiel für dieses Programm sehen?
Syb0rg
@ syb0rg Klar, ich habe die Antwort mit einem Beispiel aktualisiert.
Danko Durbić
Sieht gut aus! +1 für dich!
Syb0rg
Nett. Sie könnten zusätzliche Leerzeichen entfernen und 6 Bytes sparen$a=@{};-split$args|%{$a[$_.length]++};1..($a.Keys|sort)[-1]|%{"{0,-2}|"-f$_+"#"*$a[$_]}
mazzy
2

APL (42)

⎕ML←3⋄K,⊃⍴∘'▓'¨+⌿M∘.=K←⍳⌈/M←↑∘⍴¨I⊂⍨' '≠I←⍞

Könnte kürzer sein, wenn ich Zeilen weglassen könnte, in denen der Wert 0 ist.

Erläuterung:

  • ⎕ML←3: Setzen Sie die Migrationsstufe auf 3 (dies macht (Partition) nützlicher).
  • I⊂⍨' '≠I←⍞: Eingabe lesen, auf Leerzeichen aufteilen
  • M←↑∘⍴¨: Ermittelt die Größe der ersten Dimension jedes Elements (Wortlängen) und speichert in M
  • K←⍳⌈/M: Holen Sie sich die Zahlen von 1 bis zum höchsten Wert in M, speichern Sie inK
  • +⌿K∘.=M: MSehen Sie für jeden Wert in , wie oft er enthalten ist K.
  • ⊃⍴∘'▓'¨: Holen Sie sich für jeden Wert darin eine Liste mit so vielen s und formatieren Sie sie als Matrix.
  • K,: Stellen Sie jeden Wert Kjeder Zeile in der Matrix voran und geben Sie die Beschriftungen an.

Ausgabe:

      ⎕ML←3⋄K,⊃⍴∘'▓'¨+⌿M∘.=K←⍳⌈/M←↑∘⍴¨I⊂⍨' '≠I←⍞
This is a hole in one!
1 ▓  
2 ▓▓ 
3    
4 ▓▓▓
      ⎕ML←3⋄K,⊃⍴∘'▓'¨+⌿M∘.=K←⍳⌈/M←↑∘⍴¨I⊂⍨' '≠I←⍞
Very long strings of words should be just as easy to generate a histogram just as short strings of words are easy to generate a histogram for.
1 ▓▓     
2 ▓▓▓▓▓▓▓
3 ▓      
4 ▓▓▓▓▓▓▓
5 ▓▓▓    
6 ▓      
7 ▓▓     
8 ▓▓     
9 ▓▓     
Marinus
quelle
2

Mathematica 97

Histogram["" <> # & /@ StringCases[StringSplit[InputString[]], WordCharacter] /. 
a_String :> StringLength@a]

Wenn ich den Text der Unabhängigkeitserklärung als einzelne Zeichenfolge eingebe (natürlich durch Ausschneiden und Einfügen), wurde folgende Ausgabe generiert:

Unabhängigkeitserklärung

DavidC
quelle
2

Viertens 201

Das hat Spaß gemacht, aber meine Ruby-Einreichung ist wettbewerbsfähiger. ;-);

variable w 99 cells allot w 99 cells erase : h begin
1 w next-arg ?dup while swap drop dup w @ > if dup w
! then cells + +! repeat w @ 1+ 1 ?do i . 124 emit i
cells w + @ 0 ?do 35 emit loop cr loop ; h

Probelauf:

$ gforth histo.fth Forth words make for tough golfing!
1 |
2 |
3 |#
4 |#
5 |###
6 |
7 |
8 |#

Die maximale Wortlänge beträgt 99.

Darren Stone
quelle
2

Ruby, 79

(1..(w=$*.group_by &:size).max[0]).map{|i|puts"%2i|#{?#*w.fetch(i,[]).size}"%i}

Beispiellauf:

$ ruby hist.rb Histograms, histograms, every where, nor any drop to drink.
 1|
 2|#
 3|##
 4|#
 5|#
 6|##
 7|
 8|
 9|
10|
11|##

Bitte sehen Sie meine Forth-Einreichung für ein Lachen.

Darren Stone
quelle
2

Ruby 1.8.7, 74

Eine etwas andere Einstellung als die anderen Rubinlösungen:

i=0;$*.map{|v|v.size}.sort.map{|v|$><<(i+1..v).map{|n|"
%2i:"%i=n}+['#']}

Ausgabe:

ruby hist.rb `head -400 /usr/share/dict/words`

 1:#
 2:###
 3:######
 4:#############################
 5:#####################################################
 6:############################################################
 7:########################################################################
 8:######################################################
 9:############################################################
10:########################
11:###########################
12:######
13:#####
AShelly
quelle
Ich habe diese Einsendung anfangs nicht gesehen, sorry! +1
syb0rg
1

JavaScript ( 159 133)

Auf keinen Fall wettbewerbsfähig, aber bisher die einzige JavaScript-Lösung. Vielen Dank an @manatwork für den Tipp zur Verwendung String.replace.

prompt(o=[]).replace(/\S+/g,function(p){o[l=p.length]=(o[l]||'')+'#'});for(i=1;i<o.length;)console.log(i+(i>9?"|":" |")+(o[i++]||""))

Eingang

Code Golf ist eine Frage- und Antwortseite zum Programmieren von Puzzle-Enthusiasten und Code-Golfern. Es wird von Ihnen als Teil des Stack Exchange-Netzwerks von Q & A-Sites erstellt und ausgeführt. Mit Ihrer Hilfe arbeiten wir zusammen, um eine Bibliothek mit Programmierpuzzles und deren Lösungen zu erstellen.

Ausgabe

1 |##
2 |#######
3 |#########
4 |########
5 |######
6 |###
7 |####
8 |####
9 |
10|#
11|###
quietmint
quelle
1
In der Tat ist dies kein Bereich, in dem sich JavaScript auszeichnet. Aber mit replace()anstelle von split()+ forund Arrayanstelle von Object+ kann eine separate Längenvariable mit wenigen Zeichen reduziert werden : prompt(o=[]).replace(/\S+/g,function(p){o[l=p.length]=(o[l]||"")+"#"});for(i=1;i<o.length;)console.log(i+(i>9?"|":" |")+(o[i++]||"")). (Und noch kürzer in Harmony : prompt(o=[]).replace(/\S+/g,p=>o[l=p.length]=(o[l]||"")+"#");for(i=1;i<o.length;)console.log(i+(i>9?"|":" |")+(o[i++]||"")).)
Manatwork
@manatwork Netter Missbrauch von .lengthdort.
quietmint
1

Pure Bash 120

d="$@"
d=${d//[ -z]/#}
for a;do((b[${#a}]++));done
e="${!b[@]}"
for((i=1;i<=${e##* };i++));do
echo $i\|${d:0:b[i]}
done

Stichprobe:

./histogram.sh Very long strings of words should be just as easy to generate a histogram just as short strings of words are easy to generate a histogram for.
1|##
2|#######
3|#
4|#######
5|###
6|#
7|##
8|##
9|##

Speichern Sie 8 Zeichen, indem Sie eine Gabel verwenden, um tr: 112

for a;do((b[${#a}]++));done
e="${!b[@]}"
for((i=1;i<=${e##* };i++));do
printf "%d|%${b[i]}s\n" $i
done|tr \  \#

Geben Sie das gleiche Ergebnis:

bash -c 'for a;do((b[${#a}]++));done;e="${!b[@]}";for((i=1;i<=${e##* };i++));
do printf "%d|%${b[i]}s\n" $i;done|tr \  \#' -- $( sed 's/<[^>]*>//g;
s/<[^>]*$//;s/^[^<]*>//' < /usr/share/scribus/loremipsum/english.xml )

rendern (auf meinem Host :)

1|############################################################
2|#################################################################################################################################################################################################################
3|####################################################################################################################################################################################################################################################
4|####################################################################################################################################################################################################
5|####################################################################################################################################################################
6|#######################################################################################
7|##########################################################################################
8|###################################################
9|###############################
10|####################
11|#########
12|############
13|#####
14|####
15|##
16|
17|
18|
19|
20|
21|
22|
23|
24|
25|
26|
27|
28|
29|
30|
31|
32|
33|
34|#
F. Hauri
quelle
1

PHP, 162

<?php error_reporting(0);$b=0;while($argv[$b])$c[strlen($argv[++$b])]++;for($t=1;$t<=max(array_keys($c));$t++)echo $t.'|'.($c[$t]?str_repeat('#',$c[$t]):'')."\n";

Verwendungszweck:

php histogram.php Very long strings of words should be just as easy to generate a histogram just as short strings of words are easy to generate a histogram for.
1|##
2|#######
3|#
4|#######
5|###
6|#
7|##
8|##
9|##
Piotr Kepka
quelle
1

8. 162 Bytes

Code

a:new ( args s:len nip tuck a:@ ( 0 ) execnull rot swap n:1+ a:! ) 0 argc n:1- loop 
a:len n:1- ( dup . "|" . a:@ ( 0 ) execnull "#" swap s:* . cr ) 1 rot loop bye

Verwendungszweck

$ 8th histogram.8th Nel mezzo del cammin di nostra vita mi ritrovai per una selva oscura

Ausgabe

1|
2|##
3|####
4|#
5|##
6|###
7|
8|#

Ungolfed Code ( SED ist Stack Effect Diagram)

a:new               \ create an empty array 
( 
    args s:len      \ length of each argument
                    \ SED: array argument lengthOfArgument
    nip             \ SED: array lengthOfArgument
    tuck            \ SED: lengthOfArgument array lengthOfArgument
    a:@             \ get item array at "lengthOfArgument" position
    ( 0 ) execnull  \ if null put 0 on TOS
                    \ SED: lengthOfArgument array itemOfArray
    rot             \ SED: array itemOfArray lengthOfArgument    
    swap            \ SED: array lengthOfArgument itemOfArray
    n:1+            \ increment counter for the matching length
    a:!             \ store updated counter into array 
) 0 argc n:1- loop  \ loop through each argument
\ print histogram
a:len n:1- ( dup . "|" . a:@ ( 0 ) execnull "#" swap s:* . cr ) 1 rot loop 
bye                 \ exit program
Chaos Manor
quelle