Escreva um programa que analise a saída uptimee gere uma barra de progresso anatomicamente sugestiva (como mostrado) com um comprimento igual ao tempo de atividade atual em dias:

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

(34 dias = 34 sinais de igual)

A resposta mais curta vence.

Ruby, 39

Não é necessária nenhuma entrada (por descasque):

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

Ou 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

Eu não sou muito para expor meus gen uptimes na internet, então eu estou desenhando uma cerca em seu lugar. É a mesma contagem de caracteres. Pense em redefinir pentre as chamadas.

Pure bash, 71 caracteres, incluindo uptime.

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

Bem, bem, bem ... o meu é maior que o seu.

Perl - 26 24 caracteres

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

Funcionou assim:

$ 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 : Não citado o final 'D' - obrigado JB

Haskell, 88 caracteres

Como costuma ser o caso, Haskell não oferece a capacidade de golfe mais extrema de outras línguas, mas permite uma expressão elegante das estruturas matemáticas subjacentes ao problema. Com base no trabalho seminal nesse campo, pretendo introduzir uma implementação Haskell do operador de aproximação Holkins-Krahulik . Resumidamente, o operador ignora ambas as entradas e retorna uma função de impressão de falo parametrizada pelo comprimento do eixo.

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

Perl, 17 caracteres
Agora com dizer:

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

Rendimentos

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

foi:

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

Rendimentos

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

(Eu não posso "dizer", infelizmente)

57 caracteres

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

35 caracteres

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

assim,

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

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

Editar 2 : comentário de JB (use em \vez de '')

Windows PowerShell, 28

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

Finalmente

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

produz a saída correta, por isso deve ser capaz de lidar com uptimea saída. Porém, não posso testar, já que o GNUWin32 inclui um problema uptimeque tenta ler de um arquivo inexistente (Nota para pessoas que portam ferramentas Unix: Não tente assumir que o Windows é um Unix e segue os mesmos princípios ou convenções; (nenhum arquivo contém o tempo de inicialização no Windows).

Lisp comum, 84 caracteres

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

Isso leva a string de tempo de atividade como entrada. Parece que deveria haver um mapeamento de solução mais curto # 'sobre uma lista, mas, se sim, não consigo.

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

Nenhuma entrada é necessária, ela se destaca.

Python (42)

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

Nota: Python 3 usado para reduzir a contagem total de caracteres.

Python, 65 bytes

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

teste:

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 comum, 57 caracteres

(excluindo implementação / shebang específico do SO)

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

Com base em uma tentativa de satisfazer o desejo da resposta do Dr. Pain de uma maneira mais curta de escrever um personagem repetido. Este pode ser usado em um pipeline, como mostrado na pergunta.

(A string de formato especifica para justificar à direita a string vazia (entre ~<e ~>), em um campo de largura especificado por um argumento, preenchido usando o =caractere.)

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 chars

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

invocação para a letra da tarefa:

uptime | ./cg1570uptime-bar.sh

Muito mais curto

apenas 54 caracteres:

com esta variação:

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

invocação, não 100% de acordo com as regras:

./cg1570uptime-bar.sh $(uptime)

saída nos dois momentos:

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

Truques não diários:

 read t u d w

lê 06: 29: 53 = t, up = u, 16 = d descanso ... = w
sem w, tudo até o fim seria colocado em $ d.

O expand é normalmente usado para converter uma guia em uma quantidade de espaços em branco e usa um parâmetro se você não gostar de 8.

Agarrar o terceiro parâmetro com $ 3 in echo -e '\t'|expand -t $3|sed 's/ /=/g'é ainda mais curto, mas precisa de uma invocação, não se ajustando às palavras das regras.

bash / zenity 38 versão curta, 68 versão mais longa

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

A versão curta termina após $ d, quanto mais tempo levamos em conta que sabemos um valor máximo e gostamos de receber um texto útil:

Gema , 24 caracteres

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

Exemplo de execução:

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

Sem entrada. O resultado é enviado para a janela ativa.
O interno A_TickCounté o número de milissegundos desde que o computador foi reiniciado.