Schreiben Sie ein Programm, das die Ausgabe von analysiert uptimeund einen anatomisch anregenden Fortschrittsbalken (wie abgebildet) mit einer Länge erzeugt, die der aktuellen Betriebszeit in Tagen entspricht:

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

(34 Tage = 34 Gleichheitszeichen)

Kürzeste Antwort gewinnt.

Rubin, 39

Keine Eingabe erforderlich (durch Ausschälen):

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

Oder von Standard (40 Zeichen):

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

Bash, 71 Zeichen

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

Ich bin nicht so sehr damit beschäftigt, meine Gen- Uptimes im Internet zu veröffentlichen, also male ich stattdessen einen Zaun. Es ist die gleiche Anzahl von Zeichen. Denken Sie daran, pzwischen den Anrufen zurückzusetzen.

Pure Bash, einschließlich 71 Zeichen uptime.

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

Na ja, na ja, meine ist größer als deine.

Perl - 26 24 Zeichen

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

Lief so:

$ 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

edit : Nicht zitiertes 'D' - danke JB

Haskell, 88 Zeichen

Wie so oft bietet Haskell nicht die extremste Golffähigkeit einiger anderer Sprachen, erlaubt jedoch einen eleganten Ausdruck der mathematischen Strukturen, die dem Problem zugrunde liegen. Aufbauend auf ihrer wegweisenden Arbeit in diesem Bereich möchte ich eine Haskell-Implementierung des Holkins-Krahulik-Approximationsoperators vorstellen . Kurz gesagt, der Bediener ignoriert beide Eingaben und gibt eine durch die Wellenlänge parametrisierte Phallus-Druckfunktion zurück.

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

Perl, 17 Zeichen
Jetzt mit sagen:

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

Ausbeuten

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

war:

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

Ausbeuten

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

(Ich kann leider nicht "sagen")

57 Zeichen

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

35 Zeichen

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

so,

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

Bearbeiten : war

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

Edit 2 : Kommentar von JB ( \statt verwenden '')

Windows PowerShell, 28

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

Mindestens

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

liefert die korrekte Ausgabe, sollte also in der Lage sein, die uptimeAusgabe zu verarbeiten. Ich kann es jedoch nicht testen, da GNUWin32 einen Fehler enthält uptime, der versucht, aus einer nicht vorhandenen Datei zu lesen ist keine Datei, die die Startzeit unter Windows enthält).

Common Lisp, 84 Zeichen

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

Dies übernimmt die Uptime-Zeichenfolge als Eingabe. Es scheint, dass es eine kürzere Lösung geben sollte, die eine Liste überschreibt, aber wenn ja, kann ich es nicht finden.

GolfScript (24 Zeichen)

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

Haskell (73 Zeichen)

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

C (131 Zeichen)

#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 Zeichen

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

Es sind keine Eingaben erforderlich.

Python (42)

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

Hinweis: Python 3 wird zur Reduzierung der Gesamtzahl der Zeichen verwendet.

Python, 65 Bytes

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

Prüfung:

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";

Common Lisp, 57 Zeichen

(außer Implementierung / OS-spezifischer Shebang)

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

Basierend auf dem Versuch, den Wunsch von Dr. Pain nach einer kürzeren Schreibweise für eine wiederholte Figur zu erfüllen . Dieser kann wie in der Frage gezeigt in einer Pipeline verwendet werden.

(Die Formatzeichenfolge gibt an, dass die leere Zeichenfolge (zwischen ~<und ~>) in einem durch ein Argument angegebenen Feld mit dem =Zeichen aufgefüllt rechtsbündig ausgerichtet werden soll .)

K, 35

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

Bash 67 Zeichen

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

Aufruf zum Brief der Aufgabe:

uptime | ./cg1570uptime-bar.sh

Viel kürzer

nur 54 Zeichen:

mit dieser variante:

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

Aufruf, nicht 100% in Übereinstimmung mit den Regeln:

./cg1570uptime-bar.sh $(uptime)

Ausgabe in beiden Zeiten:

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

Nicht alltägliche Tricks:

 read t u d w

liest 06: 29: 53 = t, up = u, 16 = d Rest ... = w
ohne w, alles bis zum Ende würde in $ d gesetzt.

expand wird normalerweise verwendet, um eine Registerkarte in eine Anzahl von Leerzeichen zu übersetzen, und verwendet einen Parameter, wenn Sie 8 nicht mögen.

Das Aufrufen des 3. Parameters mit $ 3 in echo -e '\t'|expand -t $3|sed 's/ /=/g'ist noch kürzer, erfordert jedoch einen Aufruf, der nicht den Worten der Regeln entspricht.

Bash / Zenity 38 kurze Version, 68 längere Version

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

Die kurze Version endet nach $ d, je länger berücksichtigt wird, dass wir einen Maximalwert kennen und gerne hilfreichen Text haben:

Gema , 24 Zeichen

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

Probelauf:

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

AutoHotkey , 39 Bytes

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

Keine Eingabe. Das Ergebnis wird an das aktive Fenster gesendet.
Der eingebaute in A_TickCountist die Anzahl der Millisekunden seit der Computer neu gestartet wurde.