एक प्रोग्राम लिखें जो आउटपुट को पार्स करता है uptimeऔर दिनों में वर्तमान अपटाइम के बराबर लंबाई के साथ शारीरिक रूप से विचारोत्तेजक प्रगति बार (जैसा दिखाया गया है) उत्पन्न करता है:

$ uptime
23:01  up 34 days,  7:30, 5 users, load averages: 0.23 0.27 0.24
$ uptime|<command>
8==================================D

(34 दिन = 34 बराबर संकेत)

सबसे छोटा उत्तर जीतता है।

रूबी, ३ ९

कोई इनपुट आवश्यक नहीं है (बाहर गोलाबारी करके):

`w`=~/up (\d*)/;puts '8'+'='*$1.to_i+'D'

या स्टडिन (40 वर्ण) से:

gets=~/up (\d*)/;puts '8'+'='*$1.to_i+'D'

बैश, 71 वर्ण

a=`uptime` a=${a#*p } a=${a%% *};while((a--));do p==$p;done;echo I${p}I

मैं इंटरनेट पर अपने जीन अपटम्स को उजागर करने में उतना नहीं हूं , इसलिए मैं इसके बजाय एक बाड़ आकर्षित कर रहा हूं। यह एक ही वर्ण गणना है। pकॉल के बीच रीसेट करने के बारे में सोचें ।

शुद्ध बैश, सहित 71 वर्ण uptime।

$ uptime
 23:35:12 up 159 days,  4:15, 15 users,  load average: 1.07, 0.63, 0.38

अच्छा, अच्छा, अच्छा ... मेरा तुमसे बड़ा है।

पर्ल - २६ २४ अक्षर

/p (\d+)/;say+8,"="x$1,D

भागा ऐसा:

$ uptime
 04:52:39 up 17 days, 11:27,  3 users,  load average: 0.21, 0.07, 0.02
$ uptime | perl -nE '/p (\d+)/;say+8,"="x$1,D'
8=================D

संपादित करें : अंतिम 'D' को अ-चिह्नित किया गया - धन्यवाद JB

हास्केल, 88 वर्ण

जैसा कि अक्सर होता है, हास्केल कुछ अन्य भाषाओं के सबसे चरम गोल्फ की पेशकश नहीं करता है, लेकिन समस्या को अंतर्निहित गणितीय संरचनाओं की एक सुरुचिपूर्ण अभिव्यक्ति की अनुमति देता है। इस क्षेत्र में उनके सेमिनल कार्य का निर्माण, मेरा उद्देश्य होल्किंस-क्राहुलिक अनुमोदन ऑपरेटर के हास्केल कार्यान्वयन को शुरू करना है । संक्षेप में, ऑपरेटर अपने दोनों इनपुटों को नजरअंदाज करता है और शाफ्ट लंबाई द्वारा पैरामीटरित एक phallus- प्रिंटिंग फ़ंक्शन देता है।

_⁑≈≈≈⊃_=(\n->concat["8",take n$repeat '=',"D"])
main=interact$(0⁑≈≈≈⊃1).read.(!!2).words

पर्ल, 17 अक्षर
अब कहते हैं:

say+8,"="x$F[2],D

पैदावार

uptime | perl -naE 'say+8,"="x$F[2],D'

था:

print"8"."="x$F[2]."D"

पैदावार

]# uptime | perl -anle 'print"8"."="x$F[2]."D"'
8=========================D

(मैं "नहीं कह सकता", दुख की बात है)

57 अक्षर

python -c "print'8'+'='*int(raw_input().split()[2])+'D'"

35 वर्ण

awk '{printf"#%"$3"sp",p}'|tr \  \*

इसलिए,

uptime
12:27μμ  up 111 days,  2:36, 1 user, load averages: 0,07 0,03 0,00
uptime | awk '{printf"#%"$3"sp",p}'|tr ' ' '*'

#***************************************************************************************************************p

संपादित करें : था

printf "#%`awk '{print $3}'`sp"|tr ' ' '*'

संपादन 2 : जेबी की टिप्पणी ( \इसके बजाय उपयोग करें '')

विंडोज पॉवरशेल, 28

"8$('='*(-split$input)[2])D"

कम से कम

echo 23:01  up 34 days,  7:30, 5 users, load averages: 0.23 0.27 0.24|powershell -file uptime.ps1 

सही आउटपुट देता है, इसलिए इसे आउटपुट को संभालने में सक्षम होना चाहिए uptime। हालांकि, मैं परीक्षण नहीं कर सकता, क्योंकि GNUWin32 में एक टूटी हुई है uptimeजो एक गैर-मौजूद फ़ाइल से पढ़ने का प्रयास करता है (Unix टूल पोर्ट करने वाले लोगों पर ध्यान दें: यह मानने की कोशिश न करें कि Windows एक यूनिक्स है और उसी सिद्धांतों या रूढ़ियों का पालन करता है; कोई फ़ाइल नहीं है जिसमें विंडोज पर बूट समय हो)।

कॉमन लिस्प, 84 वर्ण

(defun p(s)(write 8)(loop repeat(read-from-string(subseq s 9))do(write'=))(write'D))

यह अपटाइम स्ट्रिंग को इनपुट के रूप में लेता है। ऐसा लगता है कि एक सूची पर # समाधान लिखने के लिए एक छोटा सा समाधान होना चाहिए, लेकिन अगर मैं इसके साथ नहीं आ सकता हूं।

GolfScript (24 अक्षर)

' '/{(;}3*(\;~'='*8\'D'

हास्केल (73 अक्षर)

main=getLine>>=putStr.('8':).(++"D").(`take`repeat '=').read.(!!2).words

सी (131 अक्षर)

#define r(a);read(0,x,a),
#define p ;putchar(
x[9];main(i){for(r(1)i<3;i+=*x==32)r(9)0
p'8');for(i=atoi((int)x+2);i--p'='))p'D');}

PHP, 62 अक्षर

<?$d=split(" ",`uptime`);echo 8;while($d[3]--)echo"=";echo"D";

कोई इनपुट की आवश्यकता नहीं है, यह बाहर खोल देता है।

पायथन (42)

print('8'+int(input().split()[2])*"="+'D')

नोट: कुल चरित्र संख्या को कम करने के लिए पायथन 3 का उपयोग किया जाता है।

पायथन, 65 बाइट्स

import sys
print '8'+'='*int(sys.stdin.readline().split()[2])+'D'

परीक्षा:

echo '23:01  up 34 days,  7:30, 5 users, load averages: 0.23 0.27 0.24'|./time.py
8==================================D

PHP, 61

<?$n=split(' ',$argv[1]);$v=8;while($n[2]--)$v.'=';echo"$vD";

आम लिस्प, 57 वर्ण

(कार्यान्वयन को छोड़कर / ओएस-विशिष्ट शेबंग)

#!/opt/local/bin/sbcl --script
(do()((eql(read-char)#\p)(format t"8~v,,,'=<~>D"(read))))

डॉ। दर्द के जवाब को संतुष्ट करने के प्रयास के आधार पर एक दोहराया चरित्र लिखने के लिए एक छोटे तरीके की इच्छा है। यह एक पाइपलाइन में इस्तेमाल किया जा सकता है जैसा कि प्रश्न में दिखाया गया है।

(प्रारूप स्ट्रिंग एक तर्क द्वारा निर्दिष्ट चौड़ाई के क्षेत्र में खाली स्ट्रिंग (बीच में ~<और ~>) को सही-सही ठहराने के लिए निर्दिष्ट करता है, =चरित्र का उपयोग करके गद्देदार ।)

के, ३५

-1"8",(("I"$(" "\:0:0)@3)#"="),"D";

।

$ uptime
17:21:47 up 242 days,  7:22, 35 users,  load average: 0.33, 0.34, 0.44
$ uptime | q t.k
8============================================================================ ...

बैश 67 चर्स

read t u d w
echo -e '\t'|expand -t $d|sed 's/^/8/;s/ /=/g;s/$/B/;'

असाइनमेंट के पत्र के लिए आह्वान:

uptime | ./cg1570uptime-bar.sh

बहुत कम

सिर्फ 54 वर्ण:

इस भिन्नता के साथ:

echo -e '\t'|expand -t $3|sed 's/^/8/;s/ /=/g;s/$/B/;'

आह्वान, नियमों के अनुसार 100% नहीं:

./cg1570uptime-bar.sh $(uptime)

दोनों समय में उत्पादन:

uptime && uptime | ./cg1570uptime-bar.sh 
06:29:53 up 16 days, 21:03, 10 users,  load average: 1.29, 1.34, 1.23
8================B

गैर-रोज़ चालें:

 read t u d w

06: 29: 53 = टी, अप = यू, 16 = डी बाकी ... = डब्ल्यू
बिना डब्ल्यू, अंत तक सब कुछ $ डी में डाल दिया जाएगा।

विस्तार का उपयोग आम तौर पर एक टैब को रिक्त स्थान में अनुवाद करने के लिए किया जाता है और अगर आपको 8 पसंद नहीं है तो एक पैरामीटर लेता है।

$ 3 में 3 पैरामीटर के साथ हथियाना और echo -e '\t'|expand -t $3|sed 's/ /=/g'भी कम है, लेकिन नियमों के शब्दों के लिए उपयुक्त नहीं, एक आह्वान की आवश्यकता है।

bash / zenity 38 लघु संस्करण, 68 लंबा संस्करण

read c o d e
zenity --scale --value=$d --max-value=497 --text=uptime

लघु संस्करण $ d के बाद समाप्त होता है, अब इस बात को ध्यान में रखता है कि हम एक अधिकतम-मूल्य जानते हैं और सहायक पाठ करना पसंद करते हैं:

गामा , 24 वर्ण

<D> d=8@repeat{$1;=}D;?=

नमूना रन:

bash-4.4$ uptime
 18:35:31 up 13 days,  7:53, 16 users,  load average: 0.31, 0.85, 1.24

bash-4.4$ uptime | gema '<D> d=8@repeat{$1;=}D;?='
8=============D

ऑटोहोटकी , 39 बाइट्स

d:=A_TickCount//=8.64e+7
Send 8{= %d%}D

कोई निवेश नहीं। परिणाम सक्रिय विंडो में भेजा जाता है। कंप्यूटर के रिबूट होने के बाद से
निर्मित A_TickCountमें मिलीसेकंड की संख्या है।