12

Scrivi il programma più breve che genera un istogramma (una rappresentazione grafica della distribuzione dei dati).

Regole:

È necessario generare un istogramma basato sulla lunghezza del carattere delle parole (punteggiatura inclusa) immessa nel programma. (Se una parola è lunga 4 lettere, la barra che rappresenta il numero 4 aumenta di 1)
Deve visualizzare le etichette delle barre correlate alla lunghezza dei caratteri rappresentata dalle barre.
Tutti i personaggi devono essere accettati.
Se le barre devono essere ridimensionate, deve esserci un modo mostrato nell'istogramma.

Esempi:

$ ./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 |##

code-golf graphical-output generation

— syb0rg
fonte

4

Scrivi una specifica invece di dare un singolo esempio che, solo in virtù del fatto di essere un singolo esempio, non può esprimere la gamma di stili di output accettabili e che non garantisce di coprire tutti i casi angolari. È utile avere alcuni casi di test, ma è ancora più importante avere una buona specifica.

— Peter Taylor,

@PeterTaylor Altri esempi forniti.

— syb0rg

1

1. Questo è etichettato come output grafico , il che significa che si tratta di disegnare sullo schermo o creare un file di immagine, ma i tuoi esempi sono ascii-art . È accettabile? (In caso contrario, Plannabus potrebbe non essere felice). 2. Definisci la punteggiatura come formare caratteri numerabili in una parola, ma non dichiari quali caratteri separano le parole, quali caratteri possono o meno ricorrere nell'input e come gestire i caratteri che possono verificarsi ma che non sono alfabetici, punteggiatura o separatori di parole. 3. È accettabile, richiesto o vietato ridimensionare le barre per adattarle a dimensioni ragionevoli?

— Peter Taylor,

@PeterTaylor Non l'ho taggato ascii-art, perché in realtà non è "arte". La soluzione di Phannabus va bene.

— Syb0rg,

@PeterTaylor Ho aggiunto alcune regole in base a ciò che hai descritto. Finora, tutte le soluzioni qui aderiscono ancora a tutte le regole.

— Syb0rg,

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

.

Un esempio più lungo

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
fonte

Cosa succede se ci sono parole con più di 9 lettere?

Funziona con parole di qualsiasi lunghezza

— tmartin

5

R, 55 47 caratteri

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

Fortunatamente R viene fornito con una funzione histgrafica per gli istogrammi, qui fornita con un breaksargomento in cui le interruzioni sono 0,5, 1,5, ... fino a max (input) +0,5. sapply(scan(,""),nchar)accetta un input (come stdin), lo separa seguendo gli spazi e conta il numero di caratteri di ciascun elemento.

Esempi:

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

inserisci qui la descrizione dell'immagine

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

inserisci qui la descrizione dell'immagine

Modificare:

Una variazione di 71 caratteri con un'etichetta dell'asse per ciascun valore possibile:

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

inserisci qui la descrizione dell'immagine

— plannapus
fonte

3

Adoro quando un linguaggio normalmente prolisso prende il comando!

Questo non è conforme alle specifiche, tuttavia ...

— Maniglia della porta

@Doorknob a quale specifica non è conforme?

— plannapus,

L'esempio mette alla prova.

— Maniglia della porta

3

Sono esempi, non specifiche ...

— plannapus,

5

Python - 83 caratteri

Sembra che possiamo prendere input da qualsiasi luogo, quindi questo accetta input durante l'esecuzione, piuttosto che dalla riga di comando, e usa il suggerimento di Ejrb per accorciarlo di 8.

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

Python - 91 caratteri

Questo cadrà tra virgolette.

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

Ingresso:

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

Produzione:

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

2

bello, puoi radere 4 caratteri rielaborando la tua seconda riga (nessuna modifica dell'algoritmo) da usare exece la concatenazione di stringhe:c=0;exec'c+=1;print"%3d|"%c+"#"*s.count(c);'*max(s)

— ejrb

4

Haskell - 126 caratteri

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

Questo prende l'input stdin, non la riga di comando:

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

Mi sembra buono! +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))

Output:
(la prima riga è la stringa di input)

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

Non giustifica i numeri come la soluzione Python di Lego Stormtroopr (che è anche più corta della mia), ma è la mia prima entrata in una gara di golf, quindi potrei anche lasciarla qui, immagino :)

— Roberto
fonte

Potresti modificare in un esempio di istogramma generato da questo programma?

— syb0rg

Sì, ma ho appena notato che ha un problema: non giustifica i numeri come soluzione di Lego Stormtroopr, quindi sto davvero pensando di ritirare la risposta.

— Roberto,

Finché ci sono etichette per le barre rappresentate, la risposta è accettabile.

— syb0rg

Ok, fatto allora! :)

— Roberto,

Questo prende l'input dall'input, non dagli argomenti. Questo è valido @ syb0rg?

3

Perl, 56

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

Aggiunta la riscrittura di @ manatwork e il suggerimento letterale di newline, grazie mille! Aggiunti gli aggiornamenti di @ chinese_perl_goth.

Utilizzo: salva come hist.pl ed esegui perl hist.pl This is a test

Esempio di output:

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

1

Perché non usare printf? Potresti risparmiare alcuni caratteri sulla formattazione. E un po 'cambiando da hash per array: $d[y///c]++for@ARGV;shift@d;printf"%2d|%s\n",++$i,"#"x$_ for@d.

— arte

Posso vedere un esempio di questo programma al lavoro?

— Syb0rg,

@manatwork printfnon mi è mai venuto in mente e per qualche ragione non pensavo di poter ottenere l'effetto che volevo con un array, fantastico! @ syb0rg aggiungendo ora

— Dom Hastings l'

2

ancora un po 'di golf, è arrivato a 57 byte:$d[y///c].='#'for@ARGV;printf"%2d|$d[$_]\n",$_ for+1..$#d

— perl goth cinese il

1

Abbiamo perso solo il trucco più semplice: usa una nuova riga letterale invece di \nrisparmiare 1 personaggio in più. Intendo in questo modo: pastebin.com/496z2a0n

— manatwork,

3

J, 48 47 46 45 43 caratteri

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

Uso:

   (;#&'#')/"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
fonte

Tacit, 38 [:((](;#&'#')"0[:+/=/)1+[:i.>./)#@>@;:: Provalo online!

— Giona il

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}

Non molto da golf. Golf più tardi.

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

— Maniglia
fonte

Funziona bene (++ voteCount). Qualcosa che potrei fare per esprimere meglio la domanda?

— syb0rg

1

@ syb0rg IMO la domanda è formulata bene, gli esempi parlano da soli. Anche se la tua ultima volta sembra avere un errore ... Conto 2 parole di 8 lettere (genera e genera) e 2 parole di 9 lettere (istogramma, istogramma)

— Maniglia

Freddo. Potresti cambiare b ?(?#*b[1].size):''con b&&?#*b[1].size.

— arte

2

Powershell, 97 93

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

Esempio:

PS Z:\> .\hist.ps1 This is an example of this program running
1  |
2  |###
3  |
4  |##
5  |
6  |
7  |###

— Danko Durbić
fonte

Posso vedere un esempio di questo programma in esecuzione?

— Syb0rg,

@ syb0rg Certo, ho aggiornato la risposta con un esempio.

— Danko Durbić,

Sembra buono! +1 a te!

— syb0rg

Bello. È possibile rimuovere spazi aggiuntivi e salvare 6 byte$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←⍞

Potrebbe essere più breve se potessi omettere le righe in cui il valore è 0.

Spiegazione:

⎕ML←3: imposta il livello di migrazione su 3 (questo rende ⊂(partizione) più utile).
I⊂⍨' '≠I←⍞: lettura input, suddivisione su spazi
M←↑∘⍴¨: ottieni le dimensioni della prima dimensione di ciascun articolo (lunghezza delle parole) e memorizza in M
K←⍳⌈/M: ottieni i numeri da 1 al valore più alto in M, archiviaK
+⌿K∘.=M: per ogni valore in M, vedi quante volte è contenuto in K.
⊃⍴∘'▓'¨: per ogni valore in questo, ottieni un elenco di tutti quei messaggi ▓e formattalo come matrice.
K,: antepone ciascun valore Ka ciascuna riga della matrice, fornendo le etichette.

Produzione:

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

2

Mathematica 97

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

Quando ho inserito il testo della Dichiarazione di Indipendenza come una singola stringa (attraverso il taglia e incolla, ovviamente), l'output generato era:

dichiarazione di indipendenza

— DavidC
fonte

2

Avanti, 201

È stato divertente, ma la mia presentazione su Ruby è più competitiva. ;-)

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

Esecuzione di esempio:

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

La lunghezza massima della parola è 99.

— Darren Stone
fonte

2

Ruby, 79

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

Esempio di esecuzione:

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

Si prega di vedere la mia presentazione Forth per una risata.

— Darren Stone
fonte

2

Ruby 1.8.7, 74

Un approccio leggermente diverso rispetto alle altre soluzioni di rubino:

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

produzione:

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

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

— AShelly
fonte

Inizialmente non ho visto questo invio, scusa! +1

— syb0rg

1

JavaScript ( 159 133)

Sicuramente non competitivo, ma finora l'unica soluzione JavaScript. Grazie a @manatwork per il consiglio sull'uso 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++]||""))

Ingresso

Code Golf è un sito di domande e risposte per la programmazione di appassionati di puzzle e golfisti di codici. È costruito e gestito da te come parte della rete Stack Exchange di siti di domande e risposte. Con il tuo aiuto, stiamo lavorando insieme per creare una libreria di puzzle di programmazione e le loro soluzioni.

Produzione

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

— quietmint
fonte

1

In effetti, questo non è davvero un campo in cui JavaScript eccelle. Ma con replace()invece di split()+ fore Arrayinvece di Object+ lunghezza variabile indipendente può essere ridotto con alcuni caratteri:

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++]||""))

. (E ancora più breve 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 il

@manatwork Un bel abuso di .lengthlì.

— quietmint

1

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

Campione:

./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|##

Risparmia 8 caratteri usando un fork a `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 \  \#

Dai lo stesso risultato:

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 )

render (sul mio 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
fonte

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

Uso:

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
fonte

1

8 ° , 162 byte

Codice

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

uso

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

Produzione

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

Codice Ungolfed ( SED è 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
fonte

Generazione dell'istogramma

K, 35

R, 55 47 caratteri

Modificare:

Python - 83 caratteri

Python - 91 caratteri

Haskell - 126 caratteri

Python 3.3 (93)

Perl, 56

J, 48 47 46 45 43 caratteri

Ruby, 98 85

Powershell, 97 93

APL (42)

Mathematica 97

Avanti, 201

Ruby, 79

JavaScript ( 159 133)

Ingresso

Produzione

Bash puro 120

Risparmia 8 caratteri usando un fork a tr: 112

PHP, 162

8 ° , 162 byte

Risparmia 8 caratteri usando un fork a `tr`: 112