28

Entrada

Una lista de palabras separadas por cualquier número de espacios.

Salida

Un gráfico de arte ASCII horizontal, donde la enésima línea está compuesta por tantos asteriscos ( *) como la enésima palabra es larga.

Ejemplo de uso

Las >señales de entrada del usuario, no debe ingresarlo al probar el programa.

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

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

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

Implementación de referencia

En caso de duda sobre la especificación, la salida de su programa debe coincidir exactamente con la del programa siguiente en todas las entradas.

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

code-golf ascii-art string

— Caridorc
fuente

Entonces, ¿se permite una nueva línea final? cruza los dedos

— Beta Decay

@BetaDecay Sí, permitido ...........

— Caridorc

¿La entrada alguna vez tendrá espacios iniciales o finales?

— PhiNotPi

8

Lo que estás describiendo no es un histograma. Un histograma mostraría la cantidad de palabras con x caracteres en la línea x. En el primer ejemplo, la línea 1 tendría 0 asteriscos (sin palabras con longitud 1) la línea 2 tendría 3 asteriscos (es, un, de) y así sucesivamente.

— nitro2k01

1

Ok, me doy cuenta de que tienes razón. Horizontal es.

— nitro2k01

24

Retina , 5 + 3 = 8 bytes

 +
\n
.
*

Cada línea va en su propio archivo, así que agregué 1 byte por cada archivo adicional. Además, \ndebe reemplazarse por una nueva línea real.

Cada par de líneas es un par de reemplazo de patrones. +coincide con uno o más espacios y lo reemplaza con una nueva línea. .coincide con cualquier carácter, excepto una nueva línea, y lo reemplaza con un *. Esto se aplica globalmente, por lo que cada personaje se reemplaza con un *.

— NinjaOsoMono
fuente

11

Pyth, 9 bytes

jm*ld\*cz

Explicación:

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

— isaacg
fuente

10

CJam, 10 bytes

r{,'**Nr}h

Cómo funciona :

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

Pruébalo en línea aquí

— Optimizador
fuente

10

R - 33

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

dónde

scan(,"") lee desde stdin y se divide en espacios en blanco en un vector de caracteres.
gsub(".", "*", ...)reemplaza todos los personajes en *.
write(..., "") imprime en stdout con "\ n" como separador predeterminado.

— flodel
fuente

10

Python 3, 43 bytes:

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

Gracias a @BetaDecay por señalar un error de sintaxis.

Ejecución de muestra:

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

(La siguiente cadena se ingresa como literal, en lugar de como texto)

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

Bonus: histograma vertical

Gracias a @Caridorc por señalar mi error que hizo que los bonos tuvieran de 1 a muchas filas.

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

Manifestación:

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

Bonificación: histograma vertical (al revés)

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

Manifestación:

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

— JF
fuente

Vertical es desactivada por uno

— Caridorc

6

R, 38 bytes (con algo de ayuda en los comentarios)

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

Cómo funciona

gsub reemplaza todos los espacios sin con *
segundo gsubagrega\n (nueva línea) al final de cada elemento
cat imprime en consecuencia

Manifestación

— David Arenburg
fuente

6

> <> , 38 37 Bytes

Maldición, caja de doble espacio * sacude pescado *.

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

Puede probarlo en línea (todo lo que necesita hacer es ingresar datos a través del campo cerca de la parte inferior y luego presionar el botónGive botón). Las sugerencias para seguir jugando al golf son siempre bienvenidas, especialmente ideas para eliminar esos espacios derrochadores frente a la segunda y tercera línea.

Si se le permitiera imprimir una nueva línea adicional para espacios adicionales, el código podría ser de 27 bytes :

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

Explicación

Nota: el orden de la explicación corresponderá a la ubicación del puntero (por lo tanto, si el código se explica fuera de lo que uno consideraría orden, es porque es el orden en que el puntero lo ejecuta).

Línea 1:

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

Línea 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

Línea 3:

Nota: esta línea va en reversa, así que lea de derecha a izquierda.

 ^ &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)

Básicamente, la prueba del programa para asegurarse de que la entrada (que se lee un carácter a la vez) no es un espacio y luego imprime un asterisco. Termina si no hay entrada (el valor de entrada es -1). Para asegurarse de que no imprime nuevas líneas adicionales, utiliza el valor de registro, que establece en 0 o 1. Debido a la forma en que lo configuré, no le importan los valores extraños introducidos en la pila (p. Ej. el valor del registro cuando lo establece 1después de imprimir un asterisco); permanecen en la pila cuando finaliza el programa pero no hacen nada.

Sé que puede ser un poco confuso desde que lo usé 84*y en 67*lugar de " "y "*"respectivamente, pero eso fue porque no tenía ganas de poner cadenas en el programa por cualquier razón.

— col
fuente

De nada;)

— Beta Decay

6

Javascript ES6

Función, 46 caracteres

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

Programa, 55 caracteres

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

— Qwertiy
fuente

Su función tiene en realidad 46 caracteres y su programa tiene 55.

— adroitwhiz

@ darkness3560, gracias por la corrección. Usé expresiones como "f=s=>s.replace(/\S/g,'*').replace(/\s+/g,'\n')".lengthmedir la longitud y me olvidé \.

— Qwertiy

6

Perl, 16 bytes (15 caracteres + `-p`)

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

Correr como:

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

Ahorré un byte adicional, gracias a @ThisSuitIsBlackNot , ¡no me había encontrado y///santes!

— Dom Hastings
fuente

¡Esto es excelente! Puede guardar 1 byte cambiando la primera sustitución a una transliteración:y/ /\n/s;

— ThisSuitIsBlackNot

@ThisSuitIsBlackNot ¡Oh, qué bien! ¡gracias!

— Dom Hastings

5

Gema, 11 9 caracteres

 =\n
?=\*

Ejecución de muestra:

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

— hombre trabajando
fuente

5

PHP 5.3, 55 53 51 50 bytes

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

Uso:
Llame al Script y defina una variable global ($ a)
php -d error_reporting=0 script.php?a="This is an example histogram of word length"

Salida:

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

— jrenk
fuente

4

Java, 102 bytes

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

— Koekje
fuente

4

Haskell, 31 bytes

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

Ejemplo de uso:

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

— nimi
fuente

puede reemplazar putStr.con f=para reducir el recuento de bytes, o usar en main=interact$lugar de putStr.leer desde STDIN y convertirlo en un programa completo

— HEGX64

@ HEGX64: pero f=unlines.map(>>"*").wordsdevuelve algo parecido "****\n**\n**\n"y no genera un "gráfico de arte ASCII horizontal" como se solicitó.

— nimi

4

CJam, 11 bytes

Compitiendo por el segundo lugar en CJam después de que @Optimizer encontró una solución inteligente de 10 bytes. Esta es una solución sencilla de 11 bytes:

lS%:,'*f*N*

Pruébalo en línea

Solución alternativa que utiliza un bucle en lugar de los dos mapas, también 11 bytes:

lS%{,'**N}/

Explicación para la primera solución:

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
fuente

4

JavaScript (ES6), 37

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

Versión más corta usando solo uno replace.

— Cristian Lupascu
fuente

2

Maldición, acabo de terminar mi función ES6, 38 bytes. ¡Toma mi voto positivo mientras huyo avergonzado! : D

— MayorMonty

4

J, 10 bytes

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

Bono: vertical (12 bytes)

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

Bono: invertido vertical (14 bytes)

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

— hoosierEE
fuente

3

Python 3, 72 bytes

Un buen trazador de líneas :)

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

Salida:

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

Hay una nueva línea final aquí. Si lo quieres sin, debes agregar 5 bytes:

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

— Decaimiento Beta
fuente

3

Julia, 50 bytes

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

Esto crea una función sin nombre que toma una cadena como entrada e imprime en STDOUT.

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

3

JavaScript (ES5)

Programa, 54 caracteres

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

Función, 60 caracteres

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

Ejemplo de uso:

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>

Expandir fragmento

— Patrick Roberts
fuente

3

Matlab - 54 bytes

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

Esto se ejecuta desde la consola, tomará una cadena de entrada stdiny generará el gráfico de palabra horizontal en stdout:

Ejemplo:

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

O podríamos intentar hacer algunas formas elegantes:

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

Enfoque muy inteligente!

— Luis Mendo

3

Matlab / Octave, 75 bytes

Usando una función anónima:

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

Gracias a Hoki por detectar un error que evitó que se detectara la última palabra.

Ejemplo de uso (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 =
****     
**       
**       
*******  
*********
**       
****     
******

O pruébelo en línea (Octave).

— Luis Mendo
fuente

3

PowerShell, 35 31 bytes

Bastante competitivo para un cambio. Go go gadget operadores unarios. También sigo olvidando que los parens en algunas funciones, como -splity que se -replaceusan aquí, son opcionales.

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

Llamado a través de la entrada de canalización (equivalente a stdin para PowerShell):

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

Como beneficio adicional, si en su lugar podemos usar argumentos de línea de comandos, podemos bajar a 20 Bytes y tener algo que funcione con y sin una sola cadena como entrada:

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

3

Javascript (ES6)

Nueva solución (39 bytes):

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

Solución de expresiones regulares (42 bytes):

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

Solución no regex (71 bytes):

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

Estas soluciones definen funciones anónimas. Asignarlos a variables o llamarlos así:

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

2

SWI-Prolog, 40 bytes

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

Llamado con cadenas de código, por ejemplo a(`This is an example histogram of word length`).

— Fatalizar
fuente

2

STATA, 72 bytes

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

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

Tenga en cuenta que este código no funciona en el intérprete en línea y requiere el intérprete STATA patentado no libre.

— comentarios
fuente

2

C ++ 14, 107106 bytes

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

— patata dulce
fuente

2

K5, 31 bytes

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

— kirbyfan64sos
fuente

2

O, 22 bytes

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

Explicación

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
fuente

2

Haz, 92 bytes

Esta no es una respuesta competitiva en absoluto y realmente bastante tarde, pero últimamente he estado jugando un poco con Beam y quería ver si podía lograrlo. Finalmente obtuve algo de éxito :)

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

Mostrar fragmento de código

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>

Expandir fragmento

— MickyT
fuente

1

AWK

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

ejemplos

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

salida:-

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

— Shravan Yadav
fuente

Gráfico horizontal de longitud de palabra

Retina , 5 + 3 = 8 bytes

Pyth, 9 bytes

CJam, 10 bytes

R - 33

Python 3, 43 bytes:

Bonus: histograma vertical

R, 38 bytes (con algo de ayuda en los comentarios)

> <> , 38 37 Bytes

Explicación

Javascript ES6

Función, 46 caracteres

Programa, 55 caracteres

Perl, 16 bytes (15 caracteres + -p)

Gema, 11 9 caracteres

PHP 5.3, 55 53 51 50 bytes

Java, 102 bytes

Haskell, 31 bytes

CJam, 11 bytes

JavaScript (ES6), 37

J, 10 bytes

Python 3, 72 bytes

Salida:

Julia, 50 bytes

JavaScript (ES5)

Programa, 54 caracteres

Función, 60 caracteres

Matlab - 54 bytes

Matlab / Octave, 75 bytes

PowerShell, 35 31 bytes

Javascript (ES6)

SWI-Prolog, 40 bytes

STATA, 72 bytes

C ++ 14, 107106 bytes

K5, 31 bytes

O, 22 bytes

Explicación

Haz, 92 bytes

AWK

Perl, 16 bytes (15 caracteres + `-p`)