28

Contribution

Une liste de mots séparés par un nombre quelconque d'espaces.

Sortie

Un graphique ASCII horizontal, où la n-ième ligne est composée d'autant d'astérisques ( *) que le n-ième mot est long.

Exemple d'utilisation

L' >entrée des signaux utilisateur, vous ne devez pas la saisir lors du test du programme.

> This is an example histogram of word length
****
**
**
*******
*********
**
****
******

> a aa aaa aaaa aaaaa
*
**
***
****
*****

> double space  example
******
*****
*******

Implémentation de référence

En cas de doute sur la spécification, la sortie de votre programme doit correspondre exactement à celle du programme ci-dessous sous toutes les entrées.

puts gets.chomp.split.map{|word| '*' * word.length}.join("\n")

code-golf ascii-art string Caridorc
la source

Une nouvelle ligne de fin est-elle autorisée? croise les doigts

Beta Decay

@BetaDecay Oui, autorisé ...........

Caridorc

L'entrée aura-t-elle jamais des espaces de début ou de fin?

PhiNotPi

8

Ce que vous décrivez n'est pas un histogramme. Un histogramme montrerait le nombre de mots avec x caractères sur la ligne x. Dans le premier exemple, la ligne 1 aurait 0 astérisques (aucun mot de longueur 1) la ligne 2 aurait 3 astérisques (is, an, of) et ainsi de suite.

nitro2k01

1

Ok, je réalise que tu as raison. C'est horizontal.

nitro2k01

24

Rétine , 5 + 3 = 8 octets

 +
\n
.
*

Chaque ligne va dans son propre fichier, j'ai donc ajouté 1 octet pour chaque fichier supplémentaire. En outre, le \ndoit être remplacé par un véritable retour à la ligne.

Chaque paire de lignes est une paire de remplacement de modèle. +correspond à un ou plusieurs espaces et le remplace par une nouvelle ligne. .correspond à n'importe quel caractère sauf une nouvelle ligne, et il le remplace par un *. Ceci est appliqué globalement, donc chaque caractère est remplacé par un *.

NinjaBearMonkey
la source

11

Pyth, 9 octets

jm*ld\*cz

Explication:

jm*ld\*cz
       cz    chop input on whitespace
 m           map to
   ld        length of the segment
  *  \*      number of asterisks
j            joined on newlines

isaacg
la source

10

CJam, 10 octets

r{,'**Nr}h

Comment ça marche :

r{     r}h         e# This do-while loop basically reads all the whitespace separated tokens
                   e# from input. It separates the tokens on running lengths of whitespace
  ,                e# Take the length of the token
   '**             e# Get a string of that many '*' characters
      N            e# Print a new line

Essayez-le en ligne ici

Optimiseur
la source

10

R - 33

write(gsub(".","*",scan(,"")),"")

où

scan(,"") lit à partir de stdin et divise l'espace blanc en un vecteur de caractères.
gsub(".", "*", ...)remplace tous les caractères dans *.
write(..., "") imprime sur stdout avec "\ n" comme séparateur par défaut.

flodel
la source

10

Python 3, 43 octets:

for w in input().split():print('*'*len(w))

Merci à @BetaDecay d' avoir signalé une erreur de syntaxe.

Exemple d'exécution:

> This is an example histogram of word length
****
**
**
*******
*********
**
****
******

(La chaîne ci-dessous est entrée comme un littéral, plutôt que comme du texte)

> 'example\twith\nweird\rwhite   space'
*******
****
*****
**********

Bonus: histogramme vertical

Merci à @Caridorc d' avoir signalé mon erreur qui faisait que les bonus comportaient 1 à plusieurs lignes.

l=[len(x)for x in input().split()]
for i in range(len(l)-1,0,-1):print(''.join(['*'if j>=i else' 'for j in l]))

Démo:

> This is an example histogram of word length
   **   
   **  *
   **  *
*  ** **
*  ** **
********
********

Bonus: histogramme vertical (à l'envers)

l=[len(x)for x in input().split()]
for i in range(len(l)-1):print(''.join(['*'if j>i else' 'for j in l]))

Démo:

> This is an example histogram of word length
********
********
*  ** **
*  ** **
   **  *
   **  *
   **

JF
la source

La verticale est coupée d'un

Caridorc

6

R, 38 octets (avec un peu d'aide dans les commentaires)

cat(gsub(" +|$","\n",gsub("\\S","*",x)))

Comment ça marche

gsub remplace tous les espaces sans *
le deuxième gsubajoute \n(nouvelle ligne) à la fin de chaque élément
cat imprime en conséquence

Démo

David Arenburg
la source

6

> <> , 38 37 octets

Malédiction vous double cas d'espace * secoue le poisson *.

<v&0
 >i:84*=?v0(?;67*o&1&
 \ &0o?&a/

Vous pouvez l' essayer en ligne (tout ce que vous avez à faire est de donner votre avis via le champ près du bas, puis d' Giveappuyer sur le bouton). Les suggestions pour continuer à jouer au golf sont toujours les bienvenues, en particulier les idées pour éliminer ces espaces inutiles devant les deuxième et troisième lignes.

Si vous étiez autorisé à imprimer une nouvelle ligne supplémentaire pour des espaces supplémentaires, le code pourrait être un énorme 27 octets :

>i:84*=?v0(?;67*o
^     oa<

Explication

Remarque: l'ordre de l'explication correspondra à l'emplacement du pointeur (donc si le code est expliqué hors de ce que l'on considérerait comme de l'ordre, c'est parce que c'est l'ordre dans lequel le pointeur l'exécute).

Ligne 1:

<v&0
<      redirects flow leftward
   0   pushes 0 onto the stack
  &    pops 0 and puts it in the register 
 v     redirects flow downward

Ligne 2:

>i:84*=?v0(?;67*o&1&
>                     redirects flow leftward
 i:                   pushes input and then duplicates it
   84*                pushes 32 (the space character numerically)
      =?v             pops 32 and input and redirects flow downward if they're equal
         0(?;         pops input and terminates if input is less than 0*
             67*o     pushes 42 (asterisk) and prints it
                 &1&  pushes register value and then puts 1 in the register

*in ><>, the command i returns -1 if no input is given

Ligne 3:

NB Cette ligne va en sens inverse, alors lisez de droite à gauche.

 ^ &0o?&a<
         <  redirects flow leftward
        a   pushes 10 (newline) onto the stack
     o?&    prints a newline if the register is not 0
   &0       sets the register to 0
 ^          redirects flow upwards (back to the second line)

Fondamentalement, le programme teste pour s'assurer que l'entrée (qui est lue un caractère à la fois) n'est pas un espace, puis imprime un astérisque. Il se termine s'il n'y a pas d'entrée (la valeur d'entrée est -1). Pour être sûr qu'il n'imprime pas de sauts de ligne supplémentaires, il utilise la valeur de registre, qu'il définit soit à 0 soit à 1. En raison de la façon dont je le configure, il ne se soucie pas des valeurs étrangères poussées sur la pile (par exemple la valeur du registre lorsqu'il le définit 1après l'impression d'un astérisque); ils restent sur la pile à la fin du programme mais ne font rien.

Je sais que cela peut être un peu déroutant depuis que j'ai utilisé 84*et 67*au lieu de " "et "*"respectivement, mais c'était parce que je n'avais pas envie de mettre des chaînes dans le programme pour une raison quelconque.

cole
la source

Vous êtes les bienvenus;)

Beta Decay

6

Javascript ES6

Fonction, 46 caractères

f=s=>s.replace(/\S/g,'*').replace(/\s+/g,'\n')

Programme, 55 caractères

alert(prompt().replace(/\S/g,"*").replace(/\s+/g,"\n"))

Qwertiy
la source

Votre fonction

comporte en

@ obscurité3560, merci pour la correction. J'ai utilisé des expressions comme "f=s=>s.replace(/\S/g,'*').replace(/\s+/g,'\n')".lengthpour mesurer la longueur et j'ai oublié \.

Qwertiy

6

Perl, 16 octets (15 caractères + `-p`)

y/ /
/s;s/./*/g

Courir comme:

$ perl -pe 's/ +/
/g;s/./*/g' <<< 'This is a test'
****
**
*
****

Enregistré un octet supplémentaire, grâce à @ThisSuitIsBlackNot , je n'avais jamais rencontré y///sauparavant!

Dom Hastings
la source

C'est excellent! Vous pouvez enregistrer 1 octet en remplaçant la première substitution par une translittération:y/ /\n/s;

ThisSuitIsBlackNot

@ThisSuitIsBlackNot Ooh nice! Je vous remercie!

Dom Hastings du

5

Gema, 11 9 caractères

 =\n
?=\*

Exemple d'exécution:

bash-4.3$ gema ' =\n;?=\*' <<< 'This is an example histogram of word length'
****
**
**
*******
*********
**
****
******

bash-4.3$ gema ' =\n;?=\*' <<< 'a aa aaa aaaa aaaaa'
*
**
***
****
*****

bash-4.3$ gema ' =\n;?=\*' <<< 'double space  example'
******
*****
*******

homme au travail
la source

5

PHP 5.3, 55 53 51 50 octets

<?for(;$i<strlen($a);){echo$a{$i++}!=' '?'*':"
";}

Utilisation:
appelez le script et définissez une variable globale ($ a)
php -d error_reporting=0 script.php?a="This is an example histogram of word length"

Sortie:

****
**
**
*******
*********
**
****
******

jrenk
la source

4

Java, 102 octets

class R{public static void main(String[]a){for(String s:a)System.out.println(s.replaceAll(".","*"));}}

Koekje
la source

4

Haskell, 31 octets

putStr.unlines.map(>>"*").words

Exemple d'utilisation:

Main> putStr.unlines.map(>>"*").words $ "This is an example histogram of word length"
****
**
**
*******
*********
**
****
******

nimi
la source

vous pourriez remplacer putStr.parf= pour réduire le nombre d'octets, ou utiliser main=interact$au lieu de putStr.pour lire à partir de STDIN et en faire un programme complet

HEGX64

@ HEGX64: mais f=unlines.map(>>"*").wordsrenvoie quelque chose comme "****\n**\n**\n"et ne génère pas de "graphique graphique ASCII horizontal" comme demandé.

nimi

4

CJam, 11 octets

En concurrence pour la deuxième place dans CJam après que @Optimizer ait trouvé une solution intelligente de 10 octets. Il s'agit d'une solution simple de 11 octets:

lS%:,'*f*N*

Essayez-le en ligne

Solution alternative qui utilise une boucle au lieu des deux cartes, également 11 octets:

lS%{,'**N}/

Explication de la première solution:

l     Get input.
S%    Split at spaces.
:,    Apply length operator to each word.
'*f*  Map each length to corresponding repetitions of '*.
N*    Join with newlines.

Reto Koradi
la source

4

JavaScript (ES6), 37

f=s=>s.replace(/./g,m=>m<"!"?`
`:'*')

Version plus courte en utilisant une seule replace.

Cristian Lupascu
la source

2

Bon sang, je viens de terminer ma fonction ES6, 38 octets. Prenez mon vote positif pendant que je m'enfuis de honte! : D

MayorMonty

4

J, 10 octets

   '*'$~$&>;:'This is an example histogram of word length'
****     
**       
**       
*******  
*********
**       
****     
******

Bonus: vertical (12 octets)

   |:'*'$~$&>;:'This is an example histogram of word length'
********
********
*  ** **
*  ** **
   **  *
   **  *
   **   
    *   
    *

Bonus: inversé vertical (14 octets)

   |.|:'*'$~$&>;:'This is an example histogram of word length'
    *   
    *   
   **   
   **  *
   **  *
*  ** **
*  ** **
********
********

hoosierEE
la source

3

Python 3, 72 octets

Une belle doublure :)

print(''.join(map(lambda x:"*"*len(x)+"\n"*int(x!=""),input().split())))

Sortie:

>>> print(''.join(map(lambda x:"*"*len(x)+"\n"*int(x!=""),input().split())))
Hello world  how are you?
*****
*****
***
***
****

Il y a un retour à la ligne ici. Si vous le voulez sans, vous devez ajouter 5 octets:

print(''.join(map(lambda x:"*"*len(x)+"\n"*int(x!=""),input().split()))[:-1])

Beta Decay
la source

3

Julia, 50 octets

s->print(join(["*"^length(w)for w=split(s)],"\n"))

Cela crée une fonction sans nom qui prend une chaîne en entrée et imprime sur STDOUT.

Non golfé:

function f(s::String)
    # Construct a vector of horizontal bars
    bars = ["*"^length(w) for w in split(s)]

    # Join the bars with newlines
    j = join(bars, "\n")

    # Print the result to STDOUT
    print(j)
end

Alex A.
la source

3

JavaScript (ES5)

Programme, 54 caractères

alert(prompt().replace(/\S/g,'*').replace(/ +/g,'\n'))

Fonction, 60 caractères

function(i){return i.replace(/\S/g,'*').replace(/ +/g,'\n')}

Exemple d'utilisation:

var h=function(i){return i.replace(/\S/g,'*').replace(/ +/g,'\n')},
d=document,g=d.getElementById.bind(d),i=g('i'),o=g('o')
i.onchange=function(){o.textContent=h(i.value)}

<input id="i"/>
<pre id="o"></pre>

Développer l'extrait

Patrick Roberts
la source

3

Matlab - 54 octets

s=input('');o=repmat('*',1,numel(s));o(s==32)=char(10)

Cela s'exécute à partir de la console, prendra une chaîne en entrée stdinet produira le graphique de mots horizontal dans stdout:

Exemple:

>> s=input('');o=repmat('*',1,numel(s));o(s==32)=char(10)
'This is an example histogram of word length'
o =
****
**
**
*******
*********
**
****
******

Ou nous pourrions essayer de créer des formes fantaisistes:

>> s=input('');o=repmat('*',1,numel(s));o(s==32)=char(10)
'a aa aaa aaaaaa aaaaaaaaaa aaaaaaaaaaa aaaaaaaaaa aaaaaa aaa aa a aa aaa aaaaaa aaaaaaaaaa'
o =
*
**
***
******
**********
***********
**********
******
***
**
*
**
***
******
**********

Hoki
la source

Approche très intelligente!

Luis Mendo

3

Matlab / Octave, 75 octets

Utilisation d'une fonction anonyme:

@(s)char(arrayfun(@(n)repmat('*',1,n),diff([0 find([s 32]==32)])-1,'un',0))

Merci à Hoki d'avoir repéré une erreur qui a empêché la détection du dernier mot.

Exemple d'utilisation (Matlab):

>> @(s)char(arrayfun(@(n)repmat('*',1,n),diff([0 find([s 32]==32)])-1,'un',0)) % define function
ans = 
    @(s)char(arrayfun(@(n)repmat('*',1,n),diff([0,find([s,32]==32)])-1,'un',0))
>> ans('This is an example histogram of word length') % call function
ans =
****     
**       
**       
*******  
*********
**       
****     
******

Ou essayez-le en ligne (Octave).

Luis Mendo
la source

3

PowerShell, 35 31 octets

Assez compétitif pour un changement. Go go gadget unary operators. J'oublie également que les parens sur certaines fonctions, comme -splitet -replaceutilisées ici, sont facultatifs.

%{$_-split"\s+"-replace".","*"}

Appelé via une entrée de pipeline (équivalent à stdin pour PowerShell):

PS C:\Tools\Scripts\golfing> "a aa aaa" | %{$_-split"\s+"-replace".","*"}
*
**
***

En prime, si nous pouvons à la place utiliser des arguments de ligne de commande, nous pouvons descendre à 20 octets et avoir quelque chose qui fonctionne à la fois avec et sans une seule chaîne en entrée:

$args-replace".","*"

PS C:\Tools\Scripts\golfing> .\horizontal-graph-word-length.ps1 "double space  example"
******
*****
*******

PS C:\Tools\Scripts\golfing> .\horizontal-graph-word-length.ps1 double space  example
******
*****
*******

AdmBorkBork
la source

3

Javascript (ES6)

Nouvelle solution (39 octets):

s=>[...s].map(c=>c==' '?`
`:'*').join``

Solution Regex (42 octets):

s=>s.replace(/\S/g,"*").replace(/ +/g,`
`)

Solution non regex (71 octets):

s=>s.split(" ").map(v=>"*".repeat(v.length)).filter(a=>a!="").join(`
`)

Ces solutions définissent des fonctions anonymes. Attribuez-les à des variables ou appelez-les ainsi:

(s=>s.replace(/\S/g,"*").replace(/ +/g,`
`))("[your string here]")

(s=>s.split(" ").map(v=>"*".repeat(v.length)).filter(a=>a!="").join(`
`))("[your string here]")

adroitwhiz
la source

2

SWI-Prolog, 40 octets

a([A|T]):-(A=32,nl;put(42)),(T=[];a(T)).

Appelé avec des chaînes de code, par exemple a(`This is an example histogram of word length`).

Fatalize
la source

2

STATA, 72 octets

di _r(a)
token "$a"
while ("`1'")!=""{
di _d(`=length("`1'")')"*"
ma s
}

Non golfé

display _request(a) //get input via prompt
tokenize "$a" //split a by spaces into the variables 1,2,...
while ("`1'")!=""{ //while the first variable is not empty
display _dup(`=length("`1'")')"*" //display "*" duplicated for every character in variable 1.
macro shift //move variable 2 to 1, 3 to 2, etc.
}

Notez que ce code ne fonctionne pas dans l'interpréteur en ligne et nécessite l'interpréteur STATA propriétaire non libre.

bmarks
la source

2

C ++ 14, 107 106 octets

#include<iostream>
main(){std::string s;for(;std::cin>>s;){for(char c:s)std::cout<<'*';std::cout<<'\n';}}

patate douce
la source

2

K5, 31 octets

`0:{(#x)#"*"}'f@&0<#:'f:" "\0:`

kirbyfan64sos
la source

2

O, 22 octets

i' /rl{e{'.'*%p}{;}?}d

Explication

i                         Read the user input
 ' /r                     Split on spaces and reverse
     l{             }d    For each element
       e           ?      If it's not empty
        {'.'*%            Replace every char with an asterick
              p}          And print it
                {;}       Else, just pop it off the stack

kirbyfan64sos
la source

2

Faisceau, 92 octets

Ce n'est pas une réponse compétitive du tout et vraiment assez tard, mais j'ai joué un peu avec Beam ces derniers temps et je voulais voir si je pouvais le faire faire. J'ai enfin eu du succès :)

'''''''>`++++++)v
vgLsP-(---`<''P'<
>rnp+v
  >Sv>++v
    (>`v+
    H^ )+
^Sp`@p'<+
^  @++++<

Afficher l'extrait de code

var ITERS_PER_SEC = 100000;
var TIMEOUT_SECS = 50;
var ERROR_INTERRUPT = "Interrupted by user";
var ERROR_TIMEOUT = "Maximum iterations exceeded";
var ERROR_LOSTINSPACE = "Beam is lost in space";

var code, store, beam, ip_x, ip_y, dir, input_ptr, mem;
var input, timeout, width, iterations, running;

function clear_output() {
document.getElementById("output").value = "";
document.getElementById("stderr").innerHTML = "";
}

function stop() {
running = false;
document.getElementById("run").disabled = false;
document.getElementById("stop").disabled = true;
document.getElementById("clear").disabled = false;
document.getElementById("timeout").disabled = false;
}

function interrupt() {
error(ERROR_INTERRUPT);
}

function error(msg) {
document.getElementById("stderr").innerHTML = msg;
stop();
}

function run() {
clear_output();
document.getElementById("run").disabled = true;
document.getElementById("stop").disabled = false;
document.getElementById("clear").disabled = true;
document.getElementById("input").disabled = false;
document.getElementById("timeout").disabled = false;

code = document.getElementById("code").value;
input = document.getElementById("input").value;
timeout = document.getElementById("timeout").checked;
	
code = code.split("\n");
width = 0;
for (var i = 0; i < code.length; ++i){
	if (code[i].length > width){ 
		width = code[i].length;
	}
}
console.log(code);
console.log(width);
	
running = true;
dir = 0;
ip_x = 0;
ip_y = 0;
input_ptr = 0;
beam = 0;
store = 0;
mem = [];
	
input = input.split("").map(function (s) {
		return s.charCodeAt(0);
	});
	
iterations = 0;

beam_iter();
}

function beam_iter() {
while (running) {
	var inst; 
	try {
		inst = code[ip_y][ip_x];
	}
	catch(err) {
		inst = "";
	}
	switch (inst) {
		case ">":
			dir = 0;
			break;
		case "<":
			dir = 1;
			break;
		case "^":
			dir = 2;
			break;
		case "v":
			dir = 3;
			break;
		case "+":
			++beam;
			break;
		case "-":
			--beam;
			break;
		case "@":
			document.getElementById("output").value += String.fromCharCode(beam);
			break;
		case ":":
			document.getElementById("output").value += beam+"\n";
			break;
		case "/":
			switch (dir) {
				case 0:
					dir = 2;
					break;
				case 1:
					dir = 3;
					break;
				case 2:
					dir = 0;
					break;
				case 3:
					dir = 1;
					break;
			}
		case "\\":
			switch (dir) {
				case 0:
					dir = 3;
					break;
				case 1:
					dir = 2;
					break;
				case 2:
					dir = 1;
					break;
				case 3:
					dir = 0;
					break;
			}
			break;
		case "!":
			if (beam != 0) {
				switch (dir) {
				case 0:
					dir = 1;
					break;
				case 1:
					dir = 0;
					break;
				case 2:
					dir = 3;
					break;
				case 3:
					dir = 2;
					break;
				}
			}
			break;
		case "?":
			if (beam == 0) {
				switch (dir) {
				case 0:
					dir = 1;
					break;
				case 1:
					dir = 0;
					break;
				case 2:
					dir = 3;
					break;
				case 3:
					dir = 2;
					break;
				}
			}
			break;
		case "|":
			switch (dir) {
			case 0:
				dir = 1;
				break;
			case 1:
				dir = 0;
				break;
			}
			break;
		case "_":
			switch (dir) {
			case 0:
				dir = 1;
				break;
			case 1:
				dir = 0;
				break;
			}
			break;
		case "H":
			stop();
			break;
		case "S":
			store = beam;
			break;
		case "L":
			beam = store;
			break;
		case "s":
			mem[beam] = store;
			break;
		case "g":
			store = mem[beam];
			break;
		case "P":
			mem[store] = beam;
			break;
		case "p":
			beam = mem[store];
			break;
		case "u":
			if (beam != store) {
				dir = 2;
			}
			break;
		case "n":
			if (beam != store) {
				dir = 3;
			}
			break;
		case "`":
			--store;
			break;
		case "'":
			++store;
			break;
		case ")":
			if (store != 0) {
				dir = 1;
			}
			break;
		case "(":
			if (store != 0) {
				dir = 0;
			}
			break;
		case "r":
			if (input_ptr >= input.length) {
				beam = 0;
			} else
			{
				beam = input[input_ptr];
				++input_ptr;
			}
			break;
		}
	// Move instruction pointer
	switch (dir) {
		case 0:
			ip_x++;
			break;
		case 1:
			ip_x--;
			break;
		case 2:
			ip_y--;
			break;
		case 3:
			ip_y++;
			break;
	}
	if (running && (ip_x < 0 || ip_y < 0 || ip_x >= width || ip_y >= code.length)) {
		error(ERROR_LOSTINSPACE);
	}
	++iterations;
	if (iterations > ITERS_PER_SEC * TIMEOUT_SECS) {
		error(ERROR_TIMEOUT);
	}
}
}

<div style="font-size:12px;font-family:Verdana, Geneva, sans-serif;">Code:
    <br>
    <textarea id="code" rows="4" style="overflow:scroll;overflow-x:hidden;width:90%;">'''''''>`++++++)v
vgLsP-(---`<''P'<
>rnp+v
  >Sv>++v
&nbsp;   (>`v+
&nbsp;   H^ )+
^Sp`@p'<+
^  @++++<
	</textarea>
    <br>Input:
    <br>
    <textarea id="input" rows="2" style="overflow:scroll;overflow-x:hidden;width:90%;">This is an example histogram of word length</textarea>
    <p>Timeout:
        <input id="timeout" type="checkbox" checked="checked">&nbsp;
        <br>
        <br>
        <input id="run" type="button" value="Run" onclick="run()">
        <input id="stop" type="button" value="Stop" onclick="interrupt()" disabled="disabled">
        <input id="clear" type="button" value="Clear" onclick="clear_output()">&nbsp; <span id="stderr" style="color:red"></span>
    </p>Output:
    <br>
    <textarea id="output" rows="6" style="overflow:scroll;width:90%;"></textarea>
</div>

Expand snippet

MickyT
la source

1

AWK

 awk '{for(i=1;i<=NF;i++){while(k++<length($i)){printf "*"};k=0;print ""}}'

exemples

 echo "this is programming" | awk '{for(i=1;i<=NF;i++){while(k++<length($i)){printf "*"};k=0;print ""}}'

sortie:-

****
**
***********

Shravan Yadav
la source

Graphique horizontal de la longueur des mots

Réponses:

Rétine , 5 + 3 = 8 octets

Pyth, 9 octets

CJam, 10 octets

R - 33

Python 3, 43 octets:

Bonus: histogramme vertical

R, 38 octets (avec un peu d'aide dans les commentaires)

> <> , 38 37 octets

Explication

Javascript ES6

Fonction, 46 caractères

Programme, 55 caractères

Perl, 16 octets (15 caractères + `-p`)

Gema, 11 9 caractères

PHP 5.3, 55 53 51 50 octets

Java, 102 octets

Haskell, 31 octets

CJam, 11 octets

JavaScript (ES6), 37

J, 10 octets

Python 3, 72 octets

Sortie:

Julia, 50 octets

JavaScript (ES5)

Programme, 54 caractères

Fonction, 60 caractères

Matlab - 54 octets

Matlab / Octave, 75 octets

PowerShell, 35 31 octets

Javascript (ES6)

SWI-Prolog, 40 octets

STATA, 72 octets

C ++ 14, 107 106 octets

K5, 31 octets

O, 22 octets

Explication

Faisceau, 92 octets

AWK

Graphique horizontal de la longueur des mots

Réponses:

Rétine , 5 + 3 = 8 octets

Pyth, 9 octets

CJam, 10 octets

R - 33

Python 3, 43 octets:

Bonus: histogramme vertical

R, 38 octets (avec un peu d'aide dans les commentaires)

> <> , 38 37 octets

Explication

Javascript ES6

Fonction, 46 caractères

Programme, 55 caractères

Perl, 16 octets (15 caractères + -p)

Gema, 11 9 caractères

PHP 5.3, 55 53 51 50 octets

Java, 102 octets

Haskell, 31 octets

CJam, 11 octets

JavaScript (ES6), 37

J, 10 octets

Python 3, 72 octets

Sortie:

Julia, 50 octets

JavaScript (ES5)

Programme, 54 caractères

Fonction, 60 caractères

Matlab - 54 octets

Matlab / Octave, 75 octets

PowerShell, 35 31 octets

Javascript (ES6)

SWI-Prolog, 40 octets

STATA, 72 octets

C ++ 14, 107 106 octets

K5, 31 octets

O, 22 octets

Explication

Faisceau, 92 octets

AWK

Perl, 16 octets (15 caractères + `-p`)