Escriba un programa que analice la salida uptimey genere una barra de progreso anatómicamente sugerente (como se muestra) con una duración igual al tiempo de actividad actual en días:

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

(34 días = 34 signos iguales)

La respuesta más corta gana.

Ruby, 39

No se requiere entrada (excluyendo):

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

O de stdin (40 caracteres):

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

Bash, 71 caracteres

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

No estoy mucho en la exposición de mis generación tiempos de actividad en Internet, por lo que estoy dibujando una cerca de su lugar. Es el mismo recuento de personajes. Piense en restablecer pentre llamadas.

Pure bash, 71 caracteres incluidos uptime.

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

Bueno, bueno, bueno ... el mío es más grande que el tuyo.

Perl - 26 24 caracteres

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

Corrió así:

$ 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

editar : Sin comillas la 'D' final - gracias JB

Haskell, 88 personajes

Como suele ser el caso, Haskell no ofrece la capacidad de juego más extrema de algunos otros idiomas, pero permite una expresión elegante de las estructuras matemáticas subyacentes al problema. Sobre la base de su trabajo seminal en este campo, mi objetivo es presentar una implementación de Haskell del operador de aproximación Holkins-Krahulik . Brevemente, el operador ignora ambas entradas y devuelve una función de impresión falo parametrizada por la longitud del eje.

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

Perl, 17 caracteres
Ahora con decir:

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

Rendimientos

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

fue:

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

Rendimientos

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

(No puedo "decir", tristemente)

57 caracteres

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

35 caracteres

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

entonces,

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

Editar : fue

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

Edición 2 : comentario de JB (usar en \lugar de '')

Windows PowerShell, 28

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

Al menos

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

produce la salida correcta, por lo que debería poder manejar uptimela salida. Sin embargo, no puedo probarlo, ya que GNUWin32 incluye un archivo roto uptimeque intenta leer desde un archivo no existente (Nota para las personas que portan herramientas Unix: no intentes asumir que Windows es Unix y se adhiere a los mismos principios o convenciones; hay no es un archivo que contenga el tiempo de arranque en Windows).

Lisp común, 84 caracteres

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

Esto toma la cadena de tiempo de actividad como entrada. Parece que debería haber un mapeo de solución más corto # 'escribir sobre una lista, pero si es así, no puedo encontrarlo.

GolfScript (24 caracteres)

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

Haskell (73 caracteres)

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

C (131 caracteres)

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

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

No se requiere entrada, se despliega.

Pitón (42)

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

Nota: Python 3 se usa para reducir el recuento total de caracteres.

Python, 65 bytes

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

prueba:

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 común, 57 caracteres

(excluyendo implementación / shebang específico del sistema operativo)

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

Basado en un intento de satisfacer la respuesta del Dr. Pain deseo de una forma más corta de escribir un personaje repetido. Este se puede usar en una tubería como se muestra en la pregunta.

(La cadena de formato especifica que se justifique a la derecha la cadena vacía (entre ~<y ~>), en un campo de ancho especificado por un argumento, rellenado con el =carácter).

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 caracteres

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

invocación a la carta de la asignación:

uptime | ./cg1570uptime-bar.sh

Mucho más corto

solo 54 caracteres:

con esta variación:

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

invocación, no 100% de acuerdo con las reglas:

./cg1570uptime-bar.sh $(uptime)

salida en ambos tiempos:

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

Trucos no cotidianos:

 read t u d w

lee 06: 29: 53 = t, arriba = u, 16 = d descanso ... = w
sin w, todo hasta el final se pondría en $ d.

expand se usa normalmente para traducir una pestaña en una cantidad de espacios en blanco y toma un parámetro si no le gusta 8.

Agarrar el tercer parámetro con $ 3 echo -e '\t'|expand -t $3|sed 's/ /=/g'es aún más corto, pero necesita una invocación, que no se ajusta a las palabras de las reglas.

bash / zenity 38 versión corta, 68 versión más larga

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

La versión corta termina después de $ d, cuanto más tiempo tenga en cuenta que conocemos un valor máximo y nos gustaría tener texto útil:

Gema , 24 personajes

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

Ejecución de muestra:

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

Sin entrada. El resultado se envía a la ventana activa.
El valor incorporado A_TickCountes el número de milisegundos desde que se reinició la computadora.