शब्द लंबाई का क्षैतिज ग्राफ

28

इनपुट

किसी भी स्थान द्वारा अलग-अलग शब्दों की एक सूची।

उत्पादन

एक क्षैतिज ASCII कला ग्राफ, जहां n-th लाइन कई तारांकन ( *) के रूप में n-th शब्द के रूप में लंबी होती है।

उदाहरण उपयोग

>संकेतों उपयोगकर्ता इनपुट, आप इसे इनपुट जब कार्यक्रम का परीक्षण नहीं करना चाहिए।

> 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")
code-golf  ascii-art  string 
— Caridorc
स्रोत
तो एक अनुगामी न्यूलाइन की अनुमति है? उंगलियों को पार करता है
— बीटा डेके
@ बीटाडेके हां, की अनुमति दी ...........
— कारिडोरक
क्या इनपुट में कभी प्रमुख या अनुगामी स्थान होंगे?
— PhiNotPi
8
आप जो वर्णन कर रहे हैं वह हिस्टोग्राम नहीं है। एक हिस्टोग्राम लाइन x पर x वर्णों के साथ शब्दों की संख्या दिखाएगा। पहले उदाहरण में, लाइन 1 में 0 तारांकन होगा (लंबाई 1 के साथ कोई शब्द नहीं) पंक्ति 2 में 3 तारांकन (, ए, का) और इसी तरह होगा।
— नाइट्रो 2k01
1
ठीक है, मुझे पता है कि तुम सही हो। क्षैतिज यह है।
— नाइट्रो 2k01

जवाबों:

24

रेटिना , 5 + 3 = 8 बाइट्स

 +
\n
.
*

प्रत्येक पंक्ति अपनी फ़ाइल में जाती है, इसलिए मैंने प्रत्येक अतिरिक्त फ़ाइल के लिए 1 बाइट जोड़ी है। इसके अलावा, \nएक वास्तविक newline के साथ प्रतिस्थापित किया जाना चाहिए।

लाइनों की प्रत्येक जोड़ी एक पैटर्न-प्रतिस्थापन जोड़ी है। +एक या अधिक रिक्त स्थान से मेल खाता है और इसे एक नई रेखा के साथ बदलता है। एक नई रेखा को छोड़कर. किसी भी चरित्र से मेल खाता है , और यह बदल देता है कि ए के साथ । यह विश्व स्तर पर लागू होता है, इसलिए प्रत्येक वर्ण को एक के साथ बदल दिया जाता है ।**

— NinjaBearMonkey
स्रोत
11

अजगर, 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
— isaacg
स्रोत
10

आर - 33

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

कहा पे

  • scan(,"") स्टड से पढ़ता है और सफेद-अंतरिक्ष पर एक चरित्र वेक्टर में विभाजित करता है।
  • gsub(".", "*", ...)सभी वर्णों को बदलता है *।
  • write(..., "") डिफ़ॉल्ट विभाजक के रूप में "\ n" के साथ प्रिंट करने के लिए प्रिंट करता है।
— flodel
स्रोत
10

पायथन 3, 43 बाइट्स:

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

सिंटैक्स त्रुटि को इंगित करने के लिए @BetaDecay का धन्यवाद ।

नमूना रन:

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

(पाठ के बजाय नीचे स्ट्रिंग को शाब्दिक रूप में दर्ज किया गया है)

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

बोनस: ऊर्ध्वाधर हिस्टोग्राम

मेरी त्रुटि को इंगित करने के लिए @Caridorc को धन्यवाद जिसने बोनस को कई पंक्तियों में 1 बना दिया है।

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
********
********
*  ** **
*  ** **
   **  *
   **  *
   **
— जेएफ
स्रोत
कार्यक्षेत्र एक से दूर है
— Caridorc
6

आर, 38 बाइट्स (टिप्पणियों में कुछ मदद के साथ)

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

यह काम किस प्रकार करता है

  • gsub सभी नो-स्पेस को बदल देता है *
  • प्रत्येक तत्व के अंत में दूसरा gsubजोड़ता है \n(न्यूलाइन)
  • cat तदनुसार प्रिंट करता है

डेमो

— डेविड अर्नबर्ग
स्रोत
6

> <> , 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:

एनबी यह रेखा रिवर्स में जाती है, इसलिए दाएं से बाएं पढ़ें।

 ^ &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 है)। यह सुनिश्चित करने के लिए कि यह अतिरिक्त newlines नहीं छापता है, यह रजिस्टर मान का उपयोग करता है, जिसे यह या तो 0 या 1 पर सेट करता है। जिस तरह से मैंने इसे सेट किया है, यह स्टैक पर धकेल दिए गए बाहरी मूल्यों के बारे में परवाह नहीं करता है (जैसे जब वह इसे सेट करता है तो रजिस्टर का मूल्य1 तारांकन चिह्न मुद्रित बाद ); जब कार्यक्रम समाप्त हो जाता है तो वे स्टैक पर रहते हैं लेकिन कुछ भी नहीं करते हैं।

मैं इसे भ्रामक थोड़ा के बाद से मैं का इस्तेमाल किया हो सकता है पता है 84*और 67*के बजाय " "और "*"क्रमशः, लेकिन वह था, क्योंकि मैं किसी भी कारण से कार्यक्रम में तार डाल की तरह महसूस नहीं किया था।

— गोभी
स्रोत
— बीटा डिके
6

जावास्क्रिप्ट ईएस 6

समारोह, 46 वर्ण

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

कार्यक्रम, 55 वर्ण

alert(prompt().replace(/\S/g,"*").replace(/\s+/g,"\n"))
— Qwertiy
स्रोत
आपका समारोह वास्तव में 46 वर्ण लंबा है, और अपने कार्यक्रम 55 है
— adroitwhiz
@ dark3560, सुधार के लिए धन्यवाद। मैंने "f=s=>s.replace(/\S/g,'*').replace(/\s+/g,'\n')".lengthलंबाई को मापने के बारे में अभिव्यक्त किया और इसके बारे में भूल गया \।
— क्वाटर्ली
6

पर्ल, 16 बाइट्स (15 वर्ण + -p)

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

ऐसे दोड़ो:

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

एक अतिरिक्त बाइट को बचाया , @ThisSuitIsBlackNot के लिए धन्यवाद , मैंने y///sपहले सामना नहीं किया था !

— डोम हेस्टिंग्स
स्रोत
यह उत्कृष्ट है! ट्रांसलिटरेशन के पहले प्रतिस्थापन को बदलकर आप 1 बाइट बचा सकते हैं:y/ /\n/s;
— ThisSuitIsBlackNot
@ThisSuitIsBlackNot ऊँ अच्छा! धन्यवाद!
— डोम हेस्टिंग्स 21
5

गीमा, ११ ९ वर्ण

 =\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'
******
*****
*******
— आदमी काम पर है
स्रोत
5

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"

: 

****
**
**
*******
*********
**
****
******
— jrenk
स्रोत
4

जावा, 102 बाइट्स

class R{public static void main(String[]a){for(String s:a)System.out.println(s.replaceAll(".","*"));}}
— Koekje
स्रोत
4

हास्केल, 31 बाइट्स

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

उपयोग उदाहरण:

Main> putStr.unlines.map(>>"*").words $ "This is an example histogram of word length"
****
**
**
*******
*********
**
****
******
— nimi
स्रोत
आप बदल सकते putStr.साथ f=बाइट गिनती कम करने के लिए, या का उपयोग main=interact$करने के बजाय putStr.stdin से पढ़ सकते हैं और यह एक पूरा कार्यक्रम बनाने के लिए
— HEGX64
@ HEGX64: लेकिन f=unlines.map(>>"*").wordsऐसा कुछ देता है "****\n**\n**\n"और अनुरोध के अनुसार "क्षैतिज ASCII कला ग्राफ" का उत्पादन नहीं करता है।
— nimi
4

सीजेएम, 11 बाइट्स

@Optimizer के बाद CJam में दूसरे स्थान के लिए प्रतिस्पर्धा में एक चतुर 10 बाइट समाधान मिला। यह एक सीधा 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.
— रेटो कोराडी
स्रोत
4

जावास्क्रिप्ट (ईएस 6), 37

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

केवल एक का उपयोग कर छोटा संस्करण replace।

— क्रिस्टियन लुपस्कू
स्रोत
2
डेमिट, मैंने अभी अपना ES6 फंक्शन, 38 बाइट्स पूरा किया। जब मैं शर्म से भागता हूं तो मेरा उत्थान करो! : डी
— मेयरमोनी
4

जे, 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'
    *   
    *   
   **   
   **  *
   **  *
*  ** **
*  ** **
********
********
— hoosierEE
स्रोत
3

पायथन 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])
— बीटा डिके
स्रोत
3

जूलिया, 50 बाइट्स

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

यह एक अनाम फ़ंक्शन बनाता है जो इनपुट के रूप में एक स्ट्रिंग लेता है और STDOUT को प्रिंट करता है।

Ungolfed:

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
— एलेक्स ए।
स्रोत
3

जावास्क्रिप्ट (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>
स्निपेट का विस्तार करें

— पैट्रिक रॉबर्ट्स
स्रोत
3

मतलाब - 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 =
*
**
***
******
**********
***********
**********
******
***
**
*
**
***
******
**********
— Hoki
स्रोत
बहुत चालाक दृष्टिकोण!
— लुइस मेंडू
3

मतलाब / ऑक्टेव, 75 बाइट्स

एक अनाम फ़ंक्शन का उपयोग करना:

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

होकी को एक गलती के लिए धन्यवाद जिसने अंतिम शब्द का पता लगाने से रोक दिया।

उदाहरण का उपयोग करें (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 =
****     
**       
**       
*******  
*********
**       
****     
******

या इसे ऑनलाइन (ऑक्टेव) आज़माएं ।

— लुइस मेंडो
स्रोत
3

पॉवरशेल, 35 31 बाइट्स

एक बदलाव के लिए बहुत प्रतिस्पर्धात्मक। गो गो गैजेट यूनीरी ऑपरेटर्स। मैं यह भी भूल जाता हूं कि कुछ फ़ंक्शंस पर, जैसे कि -splitऔर -replaceयहाँ उपयोग किए गए, वैकल्पिक हैं।

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

पाइपलाइन इनपुट के माध्यम से कॉल किया जाता है (पावरस्ले के लिए स्टड के बराबर):

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
******
*****
*******
— AdmBorkBork
स्रोत
3

जावास्क्रिप्ट (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]")
— adroitwhiz
स्रोत
2

एसडब्ल्यूआई-प्रोलॉग, 40 बाइट्स

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

कोड तार के साथ कहा जाता है, जैसे a(`This is an example histogram of word length`).

— Fatalize
स्रोत
2

STATA, 72 बाइट्स

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

Ungolfed

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 दुभाषिया की आवश्यकता होती है।

— bmarks
स्रोत
2

सी ++ 14, 107 106 बाइट्स

#include<iostream>
main(){std::string s;for(;std::cin>>s;){for(char c:s)std::cout<<'*';std::cout<<'\n';}}
— sweerpotato
स्रोत
2

ओ, 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
— kirbyfan64sos
स्रोत
2

बीम, 92 बाइट्स

यह बिल्कुल भी प्रतिस्पर्धी जवाब नहीं है और वास्तव में काफी देर हो चुकी है, लेकिन मैं हाल ही में बीम के साथ खेल रहा हूं और देखना चाहता हूं कि क्या मुझे ऐसा करने के लिए मिल सकता है। अंत में कुछ सफलता मिली :)

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

कोड स्निपेट दिखाएं

— MickyT
स्रोत
1

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 ""}}'

उत्पादन: -

****
**
***********
— श्रवण यादव
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.