Écrivez un programme qui analyse la sortie de uptimeet génère une barre de progression anatomiquement suggestive (comme indiqué) avec une longueur égale à la disponibilité actuelle en jours:

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

(34 jours = 34 signes égaux)

La réponse la plus courte l'emporte.

Rubis, 39

Aucune entrée requise (par décorticage):

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

Ou depuis stdin (40 caractères):

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

Bash, 71 caractères

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

Je ne suis pas tellement en train d' exposer mes temps de disponibilité gen sur Internet, donc je dessine une clôture à la place. C'est le même nombre de caractères. Pensez à réinitialiser pentre les appels.

Pure bash, 71 caractères inclus uptime.

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

Bien, bien, bien ... le mien est plus grand que le vôtre.

Perl - 26 24 caractères

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

Ran comme ça:

$ 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 : Non cité le «D» final - merci JB

Haskell, 88 caractères

Comme c'est souvent le cas, Haskell n'offre pas la jouabilité au golf la plus extrême de certaines autres langues, mais permet une expression élégante des structures mathématiques sous-jacentes au problème. Sur la base de leur travail séminal dans ce domaine, je vise à introduire une implémentation Haskell de l' opérateur Holkins-Krahulik Approximation . En bref, l'opérateur ignore ses deux entrées et renvoie une fonction d'impression phallus paramétrée par la longueur de l'arbre.

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

Perl, 17 caractères
Maintenant avec dis:

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

Rendements

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

était:

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

Rendements

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

(Je ne peux pas "dire", malheureusement)

57 caractères

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

35 caractères

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

donc,

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

Modifier : était

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

Edit 2 : commentaire de JB (utiliser à la \place de '')

Windows PowerShell, 28

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

Au moins

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

donne la sortie correcte, il devrait donc être capable de gérer uptimela sortie de. Je ne peux pas tester, cependant, car GNUWin32 inclut un cassé uptimequi essaie de lire à partir d'un fichier inexistant (Remarque pour les personnes qui portent des outils Unix: N'essayez pas de supposer que Windows est un Unix et adhère aux mêmes principes ou conventions; il n’existe pas de fichier contenant l’heure de démarrage sous Windows).

Lisp commun, 84 caractères

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

Cela prend la chaîne de disponibilité comme entrée. Il semble qu'il devrait y avoir une correspondance de solution plus courte # 'écrivant sur une liste, mais si c'est le cas, je ne peux pas la proposer.

GolfScript (24 caractères)

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

Haskell (73 caractères)

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

C (131 caractères)

#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 caractères

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

Aucune entrée requise, cela s'explique.

Python (42)

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

Remarque: Python 3 utilisé pour réduire le nombre total de caractères.

Python, 65 octets

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

tester:

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 commun, 57 caractères

(hors implémentation / shebang spécifique au système d'exploitation)

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

Basé sur une tentative de satisfaire la réponse du Dr Pain souhait du un moyen plus court d'écrire un caractère répété. Celui-ci peut être utilisé dans un pipeline comme indiqué dans la question.

(La chaîne de format spécifie pour justifier à droite la chaîne vide (entre ~<et ~>), dans un champ de largeur spécifié par un argument, complété à l'aide du =caractère.)

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 caractères

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

invocation à la lettre de mission:

uptime | ./cg1570uptime-bar.sh

Plus court

54 caractères seulement:

avec cette variation:

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

invocation, pas à 100% conformément aux règles:

./cg1570uptime-bar.sh $(uptime)

sortie dans les deux temps:

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

Astuces non quotidiennes:

 read t u d w

lit 06: 29: 53 = t, up = u, 16 = d reste ... = w
sans w, tout à la fin serait mis dans $ d.

expand est normalement utilisé pour traduire un onglet en une quantité de blancs et prend un paramètre si vous n'aimez pas 8.

Saisir le 3ème paramètre avec 3 $ echo -e '\t'|expand -t $3|sed 's/ /=/g'est encore plus court, mais nécessite une invocation, qui ne correspond pas aux mots des règles.

bash / zenity 38 version courte, 68 version plus longue

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

La version courte se termine après $ d, la plus longue tient compte du fait que nous connaissons une valeur maximale et aimons avoir un texte utile:

Gema , 24 caractères

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

Exemple d'exécution:

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 octets

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

Pas d'entrée. Le résultat est envoyé à la fenêtre active.
La valeur intégrée A_TickCountest le nombre de millisecondes depuis le redémarrage de l'ordinateur.