Đầu vào

Một danh sách các từ được phân tách bằng bất kỳ số lượng khoảng trắng.

Đầu ra

Một biểu đồ nghệ thuật ASCII nằm ngang, trong đó dòng thứ n được tạo bởi nhiều dấu hoa thị ( *) khi từ thứ n dài.

Ví dụ sử dụng

Các >đầu vào tín hiệu sử dụng, bạn không nên đầu vào nó khi kiểm tra chương trình.

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

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

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

Thực hiện tham khảo

Trong trường hợp nghi ngờ về đặc điểm kỹ thuật, đầu ra của chương trình của bạn phải khớp chính xác với chương trình dưới đây trong tất cả các đầu vào.

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

Võng mạc , 5 + 3 = 8 byte

 +
\n
.
*

Mỗi dòng đi trong tệp riêng của nó, vì vậy tôi đã thêm 1 byte cho mỗi tệp bổ sung. Ngoài ra, \nnên được thay thế bằng một dòng mới thực tế.

Mỗi cặp dòng là một cặp thay thế mẫu. +phù hợp với một hoặc nhiều khoảng trắng và thay thế nó bằng một dòng mới. .phù hợp với bất kỳ ký tự nào ngoại trừ một dòng mới và nó thay thế bằng một *. Điều này được áp dụng trên toàn cầu, vì vậy mọi ký tự được thay thế bằng a *.

Bình thường, 9 byte

jm*ld\*cz

Giải trình:

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

CJam, 10 byte

r{,'**Nr}h

Cách thức hoạt động :

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

Dùng thử trực tuyến tại đây

R - 33

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

Ở đâu

• scan(,"") đọc từ stdin và tách trên khoảng trắng thành một vectơ ký tự.
• gsub(".", "*", ...)thay thế tất cả các nhân vật vào *.
• write(..., "") in ra thiết bị xuất chuẩn với "\ n" làm dấu phân cách mặc định.

Python 3, 43 byte:

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

Cảm ơn @BetaDecay đã chỉ ra lỗi cú pháp.

Chạy mẫu:

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

(Chuỗi bên dưới được nhập dưới dạng chữ, thay vì dưới dạng văn bản)

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

Tiền thưởng: biểu đồ dọc

Cảm ơn @Caridorc đã chỉ ra lỗi của tôi khiến tiền thưởng có từ 1 đến nhiều hàng.

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

Bản giới thiệu:

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

Phần thưởng: biểu đồ dọc (lộn ngược)

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

Bản giới thiệu:

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

R, 38 byte (với một số trợ giúp trong nhận xét)

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

Làm thế nào nó hoạt động

• gsub thay thế tất cả các khoảng trống bằng *
• thứ hai gsubthêm \n(dòng mới) vào cuối mỗi phần tử
• cat in phù hợp

Bản giới thiệu

> <> , 38 37 byte

Nguyền rủa bạn đôi trường hợp không gian * lắc cá *.

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

Bạn có thể thử trực tuyến (tất cả những gì bạn cần làm là cung cấp đầu vào thông qua trường gần phía dưới và sau đó nhấn Givenút). Những gợi ý cho việc chơi gôn tiếp tục luôn được hoan nghênh, đặc biệt là những ý tưởng để loại bỏ những không gian lãng phí đó trước hàng thứ hai và thứ ba.

Nếu bạn được phép in một dòng mới bổ sung cho các khoảng trắng thừa, mã có thể là một con số khổng lồ 27 byte :

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

Giải trình

Lưu ý: thứ tự giải thích sẽ tương ứng với vị trí của con trỏ (vì vậy nếu mã được giải thích theo thứ tự người ta sẽ xem xét thứ tự, thì đó là vì đó là thứ tự mà con trỏ thực thi nó).

Dòng 1:

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

Dòng 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

Dòng 3:

NB Dòng này đi ngược lại, vì vậy đọc từ phải sang trái.

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

Về cơ bản, chương trình kiểm tra để đảm bảo đầu vào (được đọc một ký tự một lần) không phải là khoảng trắng và sau đó in dấu hoa thị. Nó chấm dứt nếu không có đầu vào (giá trị đầu vào là -1). Để đảm bảo nó không in các dòng mới bổ sung, nó sử dụng giá trị đăng ký, nó đặt thành 0 hoặc 1. Do cách tôi thiết lập, nó không quan tâm đến các giá trị không liên quan được đẩy lên ngăn xếp (ví dụ: giá trị của thanh ghi khi nó đặt thành 1sau khi in dấu hoa thị); họ vẫn ở trên ngăn xếp khi chương trình kết thúc nhưng không làm gì cả.

Tôi biết nó có thể hơi khó hiểu kể từ khi tôi sử dụng 84*và 67*thay vào đó " "và "*"tương ứng, nhưng đó là vì tôi không cảm thấy muốn đưa các chuỗi vào chương trình vì bất kỳ lý do gì.

Javascript ES6

Chức năng, 46 ký tự

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

Chương trình, 55 ký tự

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

Perl, 16 byte (15 ký tự + -p)

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

Chạy như:

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

Đã lưu một byte bổ sung, nhờ @ ThisSuitIsBlackNot , tôi đã không gặp phải y///strước đây!

Gema, 11 9 ký tự

 =\n
?=\*

Chạy mẫu:

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

PHP 5.3, 55 53 51 50 byte

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

Cách sử dụng:
Gọi Script và xác định biến toàn cục ($ a)
php -d error_reporting=0 script.php?a="This is an example histogram of word length"

Kết quả:

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

Java, 102 byte

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

Haskell, 31 byte

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

Ví dụ sử dụng:

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

CJam, 11 byte

Cạnh tranh vị trí thứ hai tại CJam sau khi @Optimizer tìm thấy giải pháp 10 byte thông minh. Đây là một giải pháp 11 byte đơn giản:

lS%:,'*f*N*

Dùng thử trực tuyến

Giải pháp thay thế sử dụng một vòng lặp thay vì hai bản đồ, cũng là 11 byte:

lS%{,'**N}/

Giải thích cho giải pháp đầu tiê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.

JavaScript (ES6), 37

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

Phiên bản ngắn hơn chỉ sử dụng một replace.

J, 10 byte

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

Phần thưởng: dọc (12 byte)

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

Phần thưởng: lật dọc (14 byte)

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

Python 3, 72 byte

Một lót tốt đẹp :)

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

Đầu ra:

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

Có một dòng mới ở đây. Nếu bạn muốn mà không có, bạn phải thêm 5 byte:

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

Julia, 50 byte

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

Điều này tạo ra một hàm không tên, lấy một chuỗi làm đầu vào và in ra STDOUT.

Ung dung:

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

JavaScript (ES5)

Chương trình, 54 ký tự

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

Chức năng, 60 ký tự

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

Ví dụ sử dụng:

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>

Matlab - 54 byte

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

Điều này chạy từ bàn điều khiển, sẽ lấy một chuỗi trong đầu vào từ stdinvà sẽ xuất ra biểu đồ từ ngang trong stdout:

Ví dụ:

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

Hoặc chúng ta có thể thử tạo một số hình dạng lạ mắt:

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

Matlab / Octave, 75 byte

Sử dụng chức năng ẩn danh:

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

Cảm ơn Hoki vì đã phát hiện ra một lỗi khiến cho từ cuối cùng bị phát hiện.

Ví dụ sử dụng (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 =
****     
**       
**       
*******  
*********
**       
****     
******   

Hoặc thử trực tuyến (Octave).

PowerShell, 35 31 byte

Khá cạnh tranh cho một sự thay đổi. Đi đi các nhà khai thác đơn phương tiện ích. Tôi cũng quên rằng parens trên một số chức năng, như -splitvà -replaceđược sử dụng ở đây, là tùy chọn.

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

Được gọi thông qua đầu vào đường ống (tương đương với stdin cho PowerShell):

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

Như một phần thưởng, thay vào đó, nếu chúng ta có thể sử dụng các đối số dòng lệnh, chúng ta có thể giảm xuống còn 20 Byte và có một cái gì đó hoạt động cả có và không có một chuỗi làm đầu vào:

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

Javascript (ES6)

Giải pháp mới (39 byte):

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

Giải pháp Regex (42 byte):

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

Giải pháp phi regex (71 byte):

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

Những giải pháp này xác định các chức năng ẩn danh. Chỉ định chúng cho các biến hoặc gọi chúng như vậy:

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

SWI-Prolog, 40 byte

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

Được gọi với các chuỗi mã, ví dụ a(`This is an example histogram of word length`).

STATA, 72 byte

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

Bị đánh cắp

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

Lưu ý rằng mã này không hoạt động trong trình thông dịch trực tuyến và yêu cầu trình thông dịch STATA độc quyền không miễn phí.

C ++ 14, 107 106 byte

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

K5, 31 byte

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

O, 22 byte

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

Giải trình

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

Chùm tia, 92 byte

Đây hoàn toàn không phải là một câu trả lời cạnh tranh và thực sự khá muộn, nhưng tôi đã chơi xung quanh với Beam một chút gần đây và muốn xem liệu tôi có thể khiến nó làm điều này không. Cuối cùng cũng có một số thành công :)

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

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>

AWK

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

ví dụ

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

đầu ra: -

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