Scrivi un programma che analizza l'output di uptimee genera una barra di avanzamento anatomicamente suggestiva (come mostrato) con una lunghezza pari al tempo di attività corrente in giorni:

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

(34 giorni = 34 segni di uguale)

Vince la risposta più breve.

Ruby, 39

Nessun input richiesto (sborsando):

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

O da stdin (40 caratteri):

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

Bash, 71 caratteri

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

Io non sono più di tanto in esporre le mie generazione uptime su internet, in modo da sto disegnando una recinzione, invece. È lo stesso numero di personaggi. Pensa al ripristino ptra le chiamate.

Bash puro, 71 caratteri inclusi uptime.

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

Bene, bene, bene ... il mio è più grande del tuo.

Perl - 26 24 caratteri

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

Funzionava così:

$ 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

modifica : non quotato la 'D' finale - grazie JB

Haskell, 88 caratteri

Come spesso accade, Haskell non offre la golfabilità più estrema di alcune altre lingue, ma consente un'espressione elegante delle strutture matematiche alla base del problema. Basandomi sul loro lavoro fondamentale in questo campo, intendo introdurre un'implementazione di Haskell dell'operatore di approssimazione Holkins-Krahulik . In breve, l'operatore ignora entrambi i suoi input e restituisce una funzione di stampa del fallo parametrizzata dalla lunghezza dell'albero.

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

Perl, 17 caratteri
Ora diciamo:

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

I rendimenti

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

era:

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

I rendimenti

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

(Non posso "dire", purtroppo)

57 caratteri

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

35 caratteri

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

così,

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

Modifica : era

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

Modifica 2 : commento di JB (utilizzare \invece di '')

Windows PowerShell, 28

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

Almeno

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

produce l'output corretto, quindi dovrebbe essere in grado di gestire uptimel'output. Non posso testare, tuttavia, poiché GNUWin32 include un file rotto uptimeche tenta di leggere da un file inesistente (Nota per le persone che eseguono il porting di strumenti Unix: non provare a supporre che Windows sia un Unix e aderisca agli stessi principi o convenzioni; lì non è un file contenente il tempo di avvio su Windows).

Lisp comune, 84 caratteri

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

Questo accetta la stringa di uptime come input. Sembra che ci dovrebbe essere una soluzione più breve che mappi # 'scrivi su un elenco, ma in tal caso non riesco a trovarlo.

GolfScript (24 caratteri)

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

Haskell (73 personaggi)

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

C (131 caratteri)

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

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

Nessun input richiesto, sborserà.

Python (42)

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

Nota: Python 3 utilizzato per ridurre il conteggio totale dei personaggi.

Python, 65 byte

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

test:

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

Lisp comune, 57 caratteri

(esclusa implementazione / shebang specifica del sistema operativo)

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

Basato sul tentativo di soddisfare la risposta del Dr. Pain un modo più breve di scrivere un personaggio ripetuto. Questo può essere utilizzato in una pipeline come mostrato nella domanda.

(La stringa di formato specifica di giustificare a destra la stringa vuota (tra ~<e ~>), in un campo di larghezza specificato da un argomento, riempito con il =carattere.)

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 caratteri

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

invocazione alla lettera dell'incarico:

uptime | ./cg1570uptime-bar.sh

Molto più breve

solo 54 caratteri:

con questa variazione:

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

invocazione, non 100% secondo le regole:

./cg1570uptime-bar.sh $(uptime)

uscita in entrambi i tempi:

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

Trucchi non quotidiani:

 read t u d w

legge 06: 29: 53 = t, su = u, 16 = d resto ... = w
senza w, tutto alla fine verrebbe messo in $ d.

L'espansione viene normalmente utilizzata per tradurre una scheda in una quantità di spazi vuoti e accetta un parametro se non ti piace 8.

Afferrare il terzo parametro con $ 3 in echo -e '\t'|expand -t $3|sed 's/ /=/g'è ancora più breve, ma ha bisogno di una chiamata, non adatta alle parole delle regole.

bash / zenity 38 versione corta, 68 versione più lunga

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

La versione breve termina dopo $ d, più a lungo tiene conto del fatto che conosciamo un valore massimo e ci piace avere un testo utile:

Gema , 24 personaggi

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

Esecuzione di esempio:

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

Tasto di scelta automatica , 39 byte

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

Nessun input Il risultato viene inviato alla finestra attiva.
Il A_TickCountnumero predefinito è il numero di millisecondi trascorsi dal riavvio del computer.