입력

여러 공백으로 구분 된 단어 목록.

산출

n 번째 줄이 *n 번째 단어만큼 긴 별표 ( )로 구성된 가로 ASCII 아트 그래프 입니다.

사용법 예

>신호를 사용자 입력, 당신은 입력을 프로그램을 테스트해야하지.

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

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

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

참조 구현

사양이 의심스러운 경우 프로그램의 출력은 모든 입력에서 아래 프로그램의 출력과 정확하게 일치해야합니다.

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

망막 , 5 + 3 = 8 바이트

 +
\n
.
*

모든 줄은 자체 파일로 이동하므로 추가 파일마다 1 바이트를 추가했습니다. 또한 \n실제 줄 바꿈으로 바꿔야합니다.

각 라인 쌍은 패턴 교체 쌍입니다. +하나 이상의 공백과 일치하여 줄 바꿈으로 바꿉니다. 개행 .문자를 제외한 모든 문자와 일치하며 해당 문자 를 로 바꿉니다 *. 이것은 전체적으로 적용되므로 모든 문자가로 대체됩니다 *.

Pyth, 9 바이트

jm*ld\*cz

설명:

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 바이트

r{,'**Nr}h

작동 방식 :

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

여기에서 온라인으로 사용해보십시오

제 33 화

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

어디에

• scan(,"") stdin에서 읽고 공백에서 문자형 벡터로 분할합니다.
• gsub(".", "*", ...)모든 문자를로 바꿉니다 *.
• write(..., "") "\ n"을 기본 구분 기호로 사용하여 stdout에 인쇄합니다.

파이썬 3, 43 바이트 :

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

구문 오류를 지적한 @BetaDecay 에게 감사합니다 .

샘플 실행 :

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

(아래 문자열은 텍스트가 아닌 리터럴로 입력됩니다)

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

보너스 : 수직 히스토그램

보너스에 1 ~ 많은 행이있는 오류를 지적 한 @Caridorc 에게 감사드립니다 .

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

데모:

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

보너스 : 수직 히스토그램 (거꾸로)

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

데모:

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

R, 38 바이트 (의견에 도움이 됨)

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

작동 원리

• gsub 공백이없는 모든 공간을 *
• 두 번째 gsub는 \n각 요소의 끝에 (줄 바꿈)을 추가합니다
• cat 그에 따라 인쇄

데모

> <> , 38 37 바이트

두 배의 공간을 저주하여 물고기를 흔든다 *.

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

당신이 할 수있는 온라인 그것을 시도 (당신이 할 필요가 바닥 근처의 필드를 통해주고 입력하고 다음 공격 Give버튼). 추가 골프에 대한 제안, 특히 두 번째 및 세 번째 줄 앞의 낭비 공간을 제거하려는 아이디어는 언제나 환영합니다.

여분의 공백을 위해 추가 줄 바꿈을 인쇄 할 수 있다면 코드는 무려 27 바이트 가 될 수 있습니다 .

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

설명

참고 : 설명의 순서는 포인터의 위치와 일치합니다 (따라서 코드가 순서를 고려한 것에서 설명하면 포인터가 실행하는 순서이기 때문입니다).

1 행 :

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

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

3 행 :

NB이 줄은 반대로되어 있으므로 오른쪽에서 왼쪽으로 읽으십시오.

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

기본적으로 프로그램은 입력 (한 번에 한 문자 씩 읽음)이 공백이 아닌지 확인한 다음 별표를 인쇄합니다. 입력이 없으면 종료됩니다 (입력 값은 -1). 추가 줄 바꿈을 인쇄하지 않도록 레지스터 값을 사용합니다. 레지스터 값은 0 또는 1로 설정됩니다. 설정 방법으로 인해 스택에 밀린 외부 값에 신경 쓰지 않습니다 (예 : 1별표를 인쇄 한 후 설정할 때 레지스터의 값 ); 프로그램이 종료 될 때 스택에 남아 있지만 아무것도하지 않습니다.

나는 조금 내가 사용하기 때문에 혼동 될 수 알 84*과 67*대신 " "과 "*"각각,하지만 난 어떤 이유로 프로그램에서 문자열을 넣어 기분하지 않았다 때문이었다.

자바 스크립트 ES6

기능, 46 자

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

프로그램, 55 자

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

Perl, 16 바이트 (15 자 + -p)

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

다음으로 실행 :

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

@ThisSuitIsBlackNot 덕분에 추가 바이트를 절약했으며y///s 이전 에는 없었습니다 !

Gema, 11 9 자

 =\n
?=\*

샘플 실행 :

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 바이트

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

사용법 :
스크립트를 호출하고 전역 변수 ($ a) 출력을 정의하십시오
php -d error_reporting=0 script.php?a="This is an example histogram of word length"

.

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

자바, 102 바이트

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

하스켈, 31 바이트

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

사용 예 :

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

CJam, 11 바이트

@Optimizer가 영리한 10 바이트 솔루션을 찾은 후 CJam에서 2 위를 차지했습니다. 이것은 간단한 11 바이트 솔루션입니다.

lS%:,'*f*N*

온라인으로 사용해보십시오

두 개의 맵 대신 루프를 사용하는 대체 솔루션 (11 바이트) :

lS%{,'**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.

자바 스크립트 (ES6), 37

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

하나만 사용하는 짧은 버전 replace.

J, 10 바이트

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

보너스 : 세로 (12 바이트)

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

보너스 : 수직 뒤집기 (14 바이트)

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

파이썬 3, 72 바이트

좋은 라이너 :)

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

산출:

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

여기에 줄 바꿈이 있습니다. 당신이없이 그것을 원한다면, 당신은 5 바이트를 추가해야합니다 :

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

줄리아, 50 바이트

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

문자열을 입력으로 사용하여 STDOUT에 인쇄하는 명명되지 않은 함수를 작성합니다.

언 골프 드 :

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

자바 스크립트 (ES5)

프로그램, 54 문자

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

기능, 60 자

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

사용법 예 :

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 바이트

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

이것은 콘솔에서 실행되며 입력에서 문자열을 가져 와서 stdin가로 단어 그래프를 출력합니다 stdout.

예 :

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

또는 멋진 모양을 만들 수도 있습니다.

>> 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 바이트

익명 함수 사용하기 :

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

마지막 단어가 감지되지 않도록하는 실수를 발견 한 Hoki에게 감사합니다.

사용 예 (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 =
****     
**       
**       
*******  
*********
**       
****     
******   

또는 온라인으로 사용해보십시오 (옥타브).

PowerShell, 35 31 바이트

변화에 대한 경쟁이 치열합니다. 가젯 단항 연산자로 이동하십시오. 나는 또한 같은 일부 기능에 그 괄호를 잊고 유지 -split하고 -replace여기에 사용은 선택 사항입니다.

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

파이프 라인 입력을 통해 호출 (PowerShell의 stdin과 동일) :

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

보너스로 대신 명령 행 인수를 사용할 수 있다면 20 바이트로 줄 이면서 입력으로 단일 문자열을 사용하거나 사용하지 않고 작동하는 무언가를 가질 수 있습니다 .

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

자바 스크립트 (ES6)

새로운 솔루션 (39 바이트) :

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

정규식 솔루션 (42 바이트) :

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

비정규 솔루션 (71 바이트) :

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

이러한 솔루션은 익명 기능을 정의합니다. 변수에 지정하거나 다음과 같이 호출하십시오.

(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- 프롤로그, 40 바이트

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

예를 들어 코드 문자열로 호출 a(`This is an example histogram of word length`).

STATA, 72 바이트

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

언 골프

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

이 코드는 온라인 인터프리터에서 작동하지 않으며 비 독점적 인 STATA 인터프리터가 필요합니다.

C ++ 14, 107106 바이트

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

K5, 31 바이트

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

O, 22 바이트

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

설명

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

빔, 92 바이트

이것은 전혀 경쟁적인 답변이 아니며 매우 늦었지만 최근에 Beam과 약간 놀아 왔으며이 작업을 수행 할 수 있는지 확인하고 싶었습니다. 마침내 몇 가지 성공을 거두었습니다.)

'''''''>`++++++)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 ""}}'

예

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

산출:-

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