Clignotant douze


43

De nombreux appareils électroniques, en particulier les plus anciens, clignotent 12:00lorsque l’heure n’a pas été réglée. Le but de ce défi est de recréer cela.

Plus précisément, la tâche consiste à afficher 12:00et --:--alternativement dans une boucle infinie .

La période doit être d'une seconde divisée en deux périodes égales de 0,5 seconde. Ici, "1 seconde" et "uniformément" peuvent être interprétés librement. Par exemple, il est acceptable que le code marque une pause de 0,5 seconde entre l'affichage des chaînes, même si la période résultante sera alors légèrement supérieure à 1 seconde. Une pause initiale avant d'afficher la première chaîne est acceptable.

Chaque nouvelle chaîne peut être affichée en remplaçant la chaîne précédente ou dans une nouvelle ligne . Les espaces de fin sont autorisés, sauf que si chaque nouvelle chaîne est sur une ligne différente, il ne doit pas y avoir de lignes vides entre des chaînes consécutives.

Le code le plus court en octets gagne.



@ FlipTack Je pense que oui, mais je n'étais pas sûr. Des pensées, quelqu'un?
Luis Mendo

@ LuisMendo Je ne pense pas, je pense que la balise KG est principalement destinée à une chaîne fixe. Cela a plus à faire, l'attente et l'alternance des chaînes.
Rɪᴋᴇʀ

Les soumissions peuvent-elles attendre 0,5 seconde avant d'afficher le résultat initial?
FlipTack

1
IMHO, l'instruction "Chaque nouvelle chaîne peut être affichée en remplaçant l'ancienne chaîne ou dans une nouvelle ligne" a rendu ce défi difficile.
Setop

Réponses:


4

Gelée , 20 octets

.“12:00“--:--”ṄœS¥€ß

Comment ça marche

.“12:00“--:--”ṄœS¥€ß  Main link. No arguments.

.                     Set the return value to 0.5.
 “12:00“--:--”        Yield ["12:00", "--:--"].
                 ¥    Combine the two links to the left into a dyadic chain.
              Ṅ       Print the left argument.
               œS     Sleep as many seconds as the right argument specifies.
                  €   Map the created dyadic chain over the string array, with
                      right argument equal to the return value, i.e., 0.5.
                   ß  Recursive call the main link.

Donc, vous êtes en train de transformer les deux chaînes de la liste en liens, avec une commande sleep supplémentaire? Doux.
Steenbergh

32

HTML / CSS, 131 108 106 101 + 18 17 = 149 126 125 123 118 octets

a{background:#FFF;margin:-5ch;animation:a 1s steps(2,start)infinite}@keyframes a{to{visibility:hidden
<tt>--:--<a>12:00

Edit: 23 octets enregistrés grâce à @insertusernamehere. Enregistré 1 octet en passant de <pre>à <tt>. 2 octets sauvés grâce à @darrylyeo. 5 octets sauvegardés grâce à @DBS.


1
@ insertusernamehere Bah, j'ai joué au golf a{position:absolute}mais j'ai complètement oublié le pre...
Neil

Avez-vous encore besoin de la balise pre? le css mentionne seulement a.
ev3commander

@ ev3commander J'ai sauvegardé un octet en basculant sur <tt>.
Neil

Vous pouvez supprimer }}complètement la finale .
darrylyeo

Je pense que vous devriez être en mesure de simplifier margin-leftà marginpuisque vous travaillez à partir en haut à gauche de toute façon margin:-5ch;devrait avoir le même effet.
DBS

15

Shell et pv26 octets

Cet yesoutil standard et l’ pv élément de pipeline Shell permettent de mesurer les données transitant par

yes '12:00
--:--'|pv -qlL2

2
Belle solution, mais le langage devrait probablement être "Shell et pv", car (à ma connaissance, le pv) n'est inclus dans aucun shell et ne fait pas partie des fonctions de base de GNU ou de BSD.
Mitchell Spector le

1
C'est un bon tour! (qui, je crois, a été mis au point par @ Digital Trauma ici ). Bien que dans ce cas, cela ressemble un peu à l'esprit du défi, car la déclaration de mission était d '"afficher 12h00 et -: - alternativement" (imitant un affichage clignotant), mais ce code ne produira que caractère par caractère à un débit constant de 12 caractères par seconde à la place. Ce qui signifie que "12:00" ne restera à l'écran que pendant 1/12 (0,08) seconde ("12: 0 _" = 1 / 12s => "12:00" = 2 / 12s => "-").
Zeppelin

@zeppelin merci pour les références: J'ai utilisé l'exemple de @ DigitalTrauma -qlL2pour créer 2 lignes par secondes au lieu de -qL12: 12 caractères par seconde. La longueur du script est la même
F. Hauri

15

Python2, 80 75 73 69 67 66 octets

import time
n=0
while[time.sleep(.5)]:print"1-2-::0-0-"[n::2];n^=1

J'ai remarqué que ma magie de chaîne était un peu plus longue que de la sélectionner dans un tableau. Nevermind, compris.

Explication :

  • Je mets un compteur n à 0, qui sera basculé entre 0 et 1.

  • Je boucle sans fin avec la boucle while 1.

  • Je crée une chaîne 1-2-::0-0-, qui contient la chaîne 12:00et --:--entrelacé.

    • En partant de l'index 0 avec un pas de 2, on obtient: 12:00

    • En partant de l'index 1 avec un pas de 2, on obtient: --:--

  • J'utilise n pour faire la séquence répétée 0 , 1 , 0 , 1 , 0 ... qui sera l'index de départ de la chaîne.

    • En utilisant n^=1, dans chaque boucle, nous obtenons cette séquence. ^être l'opérateur XOR.
    • Si n == 0 -> n^=1résulte en 1
    • Si n == 1 -> n^=1résulte en 0
  • J'imprime la chaîne et je dors ( .5-> 0.5) secondes.

@ FlipTack a enregistré 4 octets! -> Mettez la boucle dans une ligne.

@Rod enregistré 2 octets! -> n+=1to n^=1, donc n%2to n.

@xnor a sauvegardé un octet! -> while 1-> while[time.sleep(.5)].


7
vous pouvez remplacer n+=1par n^=1, puis utiliser [n::2], enregistre 2 octets et évite les gros nombres c:
Rod

4
si vous changez le print"1-2-::0-0-"[n::2]pour print"\b"*6+"1-2-::0-0-"[n::2],elle ajoutera quelques octets mais il clignote en place
Buzz

1
@Buzz vous pouvez utiliser \rau lieu de \b\b\b...vous déplacer au début de la ligne. Quoi qu'il en soit, cela ne ferait qu'ajouter des octets à la solution actuelle.
FlipTack

Vous pouvez enregistrer un octet en le faisant while[time.sleep(.5)]:.
xnor

@xnor J'étais tellement sûr que cela ne pourrait pas être joué plus au golf. Ce site continue de m'étonner. Merci!
Yytsi

15

Octave, 63 62 61 55 octets

c='--:--00:21';while c=flip(c)disp(c(1:5));pause(.5)end

Sauvegardé deux octets grâce à Tom Carpenter! L'utilisation d'une seule chaîne au lieu de deux dans un tableau de cellules était plus courte.

Explication:

c='--:--00:21';  % A string where the 5 first characters are --:-- or 12:00 when reversed
while c=flip(c)  % A string is always considered true in Octave, so this will loop forever
                 % while flipping the order of the string each time
 disp(c(1:5)     % display the 5 first characters of the string c
 pause(.5)       % Pause 0.5 second
end              % End loop

Quelques octets enregistrés car Octave ne nécessite pas de deux points ou de points-virgules entre flip(c)et disp(), et entre pause(.5)et end.


1
Belle idée à utiliser à la flipplace d'un compteur!
Luis Mendo

11

JavaScript, 59 octets

y=1;setInterval('console.log(["12:00","--:--"][y^=1])',500)

Explication

setInterval('...',500) définit un intervalle pour exécuter le code dans la chaîne toutes les 500 millisecondes, ou 1/2 par seconde.

y=1définit une variable y, à 1 initialement. De cette façon, la première chose imprimée est 12:00parce qu’elle yest utilisée pour accéder au tableau.

console.log(...)connecte quoi que ce soit à la console, que ce soit 12:00ou --:--.

["12:00","--:--"][y^=1]crée un tableau avec des chaînes contenant les deux états. Ensuite, yest utilisé pour accéder à l'un des éléments. Enfin, ^=ou l'opérateur composé XOR le fait y = y ^ 1. Cela inverse simplement le bit car 1 ^ 1vaut 0 et 0 ^ 1vaut 1, comme ce que @TuukkaX a fait . De cette façon, la chaîne journalisée alterne entre les deux éléments du tableau et crée ainsi l'effet clignotant.


A été capable de sauver un octet avec ceci:y=1;setInterval('console.log(y?"12:00":"--:--");y=!y',500)
woutr_be

Conseil ETHproductions à ma réponse: You can save some bytes with setInterval(...,i=500) :-). En gros, nous avons la même réponse et cela fonctionne pour vous aussi.
Christoph le

11

V , 31 30 27 25 24 octets

Enregistré 5 octets grâce à @ nmjcman101 en échangeant l'ordre 12:00et de --:--sorte que kpeut être retiré tout en retirant òafin qu'il puisse être ajouté implicitement à la fin

Enregistrée 1 octet grâce à @DJMcMayhem en mettant à la fois 12:00et --:--dans une ligne

i12:00--:--<ESC>bDòVp:sl500m

Ancienne solution:

i12:00<ESC>ò:sl500m
Óä/-
:sl500m
uò

<ESC> est 0x1b

Hexdump:

00000000: 6931 323a 3030 2d2d 3a2d 2d1b 6244 f256  i12:00--:--.bD.V
00000010: 703a 736c 3530 306d                      p:sl500m

Explication

i12:00--:--<ESC>   inserts 12:00\n--:--
bD                 go to the beginning of --:-- and delete it
ò                  recursively do:
 Vp                 select line and paste (effectively doing a replace)
 :sl500m            sleep for 500 milliseconds
                   the last ò is added implicitly at the end

Gif (obsolète)

Remarque: j'ai mis en évidence activé

giff


7
Vous avez pris des clins d'œil littéralement dans ce gif :-)
Luis Mendo le

La seconde òest donnée implicitement, vous pouvez donc la supprimer.
DJMcMayhem

@DJMcMayhem Cela, pour une raison quelconque, ne fonctionne pas sans la seconde ò. Il ne fonctionne qu'une fois
Kritixi Lithos

2
Échangez l'ordre de vos entrées pour ne pas avoir besoin de la première k. Ensuite, au lieu de pkddvous pouvez simplement utiliser Vp, comme pen mode de sélection visuel échange efficacement la sélection avec le registre par défaut.
nmjcman101

1
Je sais que vous avez des problèmes pour supprimer le ò, mais si cela fonctionne maintenant, je pense que vous devriez pouvoir le changer en òVp:sl500met laisser V l'ajouter ^Mòpour 2 octets.
nmjcman101

11

bash, 58 56 45 octets

sauvé 3 octets en supprimant --après setcomme 1er argument est un nombre.

set 12:00 --:--;for((a=1;;a=3-a)){ echo ${!a};sleep .5;}

16 octets enregistrés en utilisant la syntaxe de @DigitalTrauma :

f()(echo $1;sleep .5);f 12:00;f --:--;exec $0

Puis perdre 5 octets à cause du commentaire de zeppelin .

Cela n'a pas pu être testé en ligne de commande. Lorsque nous impliquons $0, cela doit être écrit dans un script pour pouvoir être exécuté.

Détourner

Avec un peu de préparation, cela pourrait devenir intéressant ( 412 octets ):

set -- "         ▗▖         
▗▄▄▖▗▄▄▖ ▝▘ ▗▄▄▖▗▄▄▖
         ▗▖         
         ▝▘         " " ▟▌ ▟▀▜▖ ▗▖ ▗▛▙ ▗▛▙ 
 ▐▌  ▗▟▘ ▝▘ █▗▐▌█▗▐▌
 ▐▌ ▗▛▗▖ ▗▖ ▜▖▟▘▜▖▟▘
▝▀▀▘▀▀▀▘ ▝▘  ▀▘  ▀▘ "
r=`tput cup 0`
clear;for((a=1;;a=3-a)){ printf "$r${!a}";sleep .5;}

Ou même deux mêmes lignes mais avec:

set -- '                                            






      HM!          .o#HMMMMM#o.                 .o#MMMMH#\\         .d#MMMMH#\\
    _HMMi         ?MMH*"""`"MMMb               dMMH"""`*MMH,      dMMH"""`*MMH.
##HMMMMMi        |MMP"       9MML             ?MMP      `MMM.    dMM?      `MMM.
`""`"9MM|        dMM!        -MMR     HMH}   .MMM        |MM}   .MMH        |MM|
     |MM|         "`         JMMT     dHH}   |MM|         MMM   |MM|        -MMM
     |MM!                 .,HMM*             |MM|         MMM.  ]MM|         MMM
     |MMi              _o#MMH*"              |MM|         MMM   {MM|         MMM
     |MMi           .dHMM#""                 |MM|         MMM"  {MM|        .MMM
     |MMi         .HMM*"                     `MM6        ,MMR   |MM}        |MMF
     |MMi        ,MMP"                        9MM,       dMM|    HMM,       dMM"
     {MMi        MMM?\\o,\\\\\\\\\\\\\\\\,     q##+    `HMM\\    .dMM?     `HMH\\    .dMM?
     |MM|       :MMMMMMMMMMMMMMM[     HMMk     `*HMM##MMM#"       `*HMM##MMMP"
      "`          "     ` ` ` `                   """"`""            """"""    ' '









                                      MHM|                                      
                                      HHH|                                      

               ______.  ._______.            ________.  ._______.               
               MMMMMM:  {MMMMMMM|            &MMMMMMM:  |MMMMMMM[               


                                      ###|                                      
                                      MMM|                                      
                                                                               '

3
s(){ echo $1;sleep .5;};for((;;)){ s 12:00;s --:--;}
Manatwork

2
@manatwork Nice! Je pense que ce n'est pas le même script! Vous devez les publier comme une réponse!
F. Hauri

Je dois admettre que l'art ASCII est absolument magnifique ... Avez-vous utilisé un outil pour le créer ou l'avez-vous créé à la main?
ETHproductions

2
@ETHproductions J'utilise Ghostscript : printf '%%\041\n/Helvetica findfont\n24 scalefont\nsetfont\nnewpath\n%s %s moveto\n(%s) show\nshowpage\n' -2.456 0.550003 12:00 | gs -sDEVICE=pnmraw -r600 -g470x146 -sOutputFile=- -q - | pnmscale -width 160 | ppmtopgm | pgmtopbm | pbmtoascii -2x4;-)
F. Hauri

1
... ouf()(echo $1;sleep .5);f 12:00;f --:--;$0
Digital Trauma

9

Perl, 49 octets

{select$,,$,,$,,0.5;say$|--?"12:00":"--:--";redo}

Perl ne sleeppeut pas dormir pendant une durée inférieure à 1 seconde, d'où l'utilisation de select undef, undef, undef, .5(jouée en remplaçant undefpar $,) pour dormir 0,5 seconde.
Autre chose intéressante: $|ne peut que tenir 0ou 1. Donc, $|--change simplement sa valeur, de 0à 1.
Et finalement, {... ;redo}agit comme une boucle infinie.


6

*> <> , 43 42 octets

<v":1200----"
S>@5dov>~r@@}r5
1&}o:&<^!?:-

Essayez-le ici!

Je sens que je devrais être capable de raccourcir ça, j'ai quelques idées à essayer ... En gros, ça fait une pile de :1200----. Il isole le :et retourne la pile en l'insérant :au milieu de l'un ----ou de l'autre 1200(en fonction de la fin de la pile).

Je dois également noter que la seule instruction *> <> utilisée est S(veille), sinon il s'agit d'un programme approprié> <>.

Mise à jour: 1 octet enregistré en déplaçant le :vers la droite au lieu de le protéger avec un registre.

Explication

Initialisation

<v":1200----"

Ici, nous construisons la pile que nous utiliserons pour la vie du programme.

<              move the IP left
  ":1200----"  push ":1200----" to the stack
 v             move the IP down into "output time"

Temps de sortie

 >@5dov
1&}o:&<^!?:-

C'est la section où le temps est réellement sorti. Le premier 5 est poussé vers la pile afin que la boucle ci-dessous sache s'exécuter 5 fois.

Initialisation:

 >@5dov

 >       move the IP right
  @      move the ":" back two spaces in the stack
   5     push 5 to the stack (let's call this `i`)
    do   output carriage return
      v  move IP down into "loop"

Loop:

1&}o:&<^!?:-

      <       move the IP left
     &        place i onto the register
  }o:         output a character and shift the stack left
 &            place i back onto the stack
1          -  decrement i by 1
       ^!?:   if i == 0, exit to "recover and swap"

Récupérer et échanger

S      >~r@@}r5

Ici, nous récupérons la :position qui en résulte après la sortie, et nous nous retrouvons avec une pile inversée. En fait, cela se termine bien dans "temps de sortie", provoquant une boucle infinie.

       >         move the IP right
        ~        remove trailing i from stack
         r@@     reverse the stack and move ":" to the front
            }r   reverse the stack again, keeping ":" on the front
S             5  sleep for 500ms

Solution de 45 octets

<v[5"12:00"1
d/S5
o/!?l
v>]?v
 00.>0"--:--"5[

Essayez-le ici!

Celui-ci est aussi fondamentalement un programme <>.

J'ai vraiment pensé qu'il serait possible d'économiser des octets avec cette approche. Ceci sort tout simplement 12:00, alors --:--. Je sauve des octets en réutilisant la routine de sortie o/!?l(je réutilise même ce miroir comme entrée et comme sortie). J'utilise plusieurs piles pour stocker l'état (avec sortie 12ou --) et sélectionne l'état avec lequel je devrais sortir v>]?v.

Explications à venir bientôt! (1/2)


6

HTML / CSS (Chrome uniquement), 80 + 4 = 84 octets

tt:after{content:"--:--";animation:a 1s infinite}@keyframes a{to{content:"12:00"
<tt>

Modifier : l'attribut "contenu" ne peut pas être animé par la spécification CSS , mais se trouve sur le navigateur Web de bureau Chrome.


1
Semble être spécifique à Chrome. Du moins ne fonctionne pas sur Firefox. Ce n'est pas un problème, la solution est toujours valable, ce serait bien de le spécifier.
Manatwork

6

Noodel , non concurrent de 16 octets

--:-- 12:00ḷçėḍh

Noodel est toujours un travail en cours. J'essaie juste de me mouiller avec quelques défis.

Essayez-le :)

Comment ça marche

--:--            # Creates the string literal "--:--" and places i into the front of the pipe.
                 # Space is a NOP command to separate the string literals.
      12:00      # Creates the string literal "12:00" and places it into the front of the pipe.
           ḷ     # Loop the following code unconditionally.
            ç    # Clear the screen and print a copy of what is in the pipe.
             ė   # Take what is in the front of the pipe and put it into the back.
              ḍh # Delay for half a second.

Voici un extrait de code :)

<div id="noodel" code="--:-- 12:00ḷçėḍh" input="" cols="10" rows="2"></div>

<script src="https://tkellehe.github.io/noodel/noodel-latest.js"></script>
<script src="https://tkellehe.github.io/noodel/ppcg.min.js"></script>


2
Si l'interprète a postposé le défi, veuillez le marquer comme "non compétitif" :). Noodel a l'air chouette, vérifiant.
redstarcoder

@redstarcoder Oups! Merci, j'ai oublié de mettre ça.
tkellehe

Pouvez-vous expliquer l'encodage? Il totalise beaucoup plus que 16 en UTF-8.
devRicher

1
J'ai regardé votre lien, il n'explique pas l'encodage. Vous voyez, tous les caractères ne sont pas 1 octet par "défaut" (UTF-8). Spécifiez un encodage existant ou créez-en un, sinon le nombre d'octets est incorrect. Il devrait y avoir un meta post quelque part à ce sujet. Sauf si vous définissez un codage, il s'agit de UTF-8 et 22 octets. @tkellehe
devRicher

1
Trouvé le meta post , d'ailleurs.
devRicher

5

QBIC , 37 33 octets

{sleep 01?@12:00`┘sleep 01?@--:--

QBasic ne peut malheureusement dormir que pendant des secondes entières. Je réfléchirai à la mise au point d'une méthode permettant plus de flexibilité bientôt. J'ai entré 1 comme 01pour simuler .5.

Explication:

{         Starts DO loop
sleep 01  Sleeps for 1 second
?@12:00`  Creates A$, sets value to "12:00" and prints A$
┘         Newline: a string literal doesn't break the line, so we need a newline to 
          control the compiled QBasic syntax
          <Rinse and repeat for "--:--">
          <DO-LOOP implicitly closed by QBIC>

Dans les versions plus anciennes de QBIC, $et (espace) étaient des caractères réservés. L'appel d'une fonction QBasic qui nécessitait des espaces (comme sleep x) ou $( left$(..)) nécessitait un littéral de code:

'QBASIC CODE`

Le code dans un bloc littéral de code est passé directement à QBasic sans être analysé par QBIC. En déchargeant des fonctions de ces symboles ( $devenus ', et les nouvelles lignes sont maintenant (alt-217) au lieu de ), les symboles ne sont plus considérés par QBIC comme des caractères spéciaux, mais simplement transmis. La même chose est effectivement vraie pour l'alphabet minuscule: il est utilisé pour représenter les variables numériques à la fois dans QBIC et QBasic et reste inchangé. Utiliser une fonctionnalité QBasic qui n'est pas implémentée dans QBIC (comme SLEEP) consiste simplement à ne pas utiliser les caractères réservés à QBIC. Ceci est facilité par les modifications récentes des symboles de commande.


4

JavaScript, 77 76 72 octets

setInterval('l=console.log,l("12:00"),setTimeout("l(`--:--`)",‌​500)',1e3)

Merci à Kritixi Lithos pour 1 octet et L. Serne pour 4 octets!


1000peut être raccourci à1e3
Kritixi Lithos

2
setIntervalet setTimeoutacceptez une chaîne avec du code comme premier argument, vous pourrez donc en enregistrer un autre 4B: setInterval('l=console.log,l("12:00"),setTimeout("l(-: -)",500)',1e3)
Luke

Les `s signifient cela est maintenant ES6, alors que la réponse précédente que nécessaire ES5.
Neil

4

Python 2, 88 85 73 71 octets

import time
c="--:--00:21"
while 1:print c[:5];c=c[::-1];time.sleep(.5)

Essayez-le ici!

En empruntant l’idée de Stewie Griffin de retourner la liste, le programme est devenu possible. Version non-lisée avec explication:

import time                      # Import time module
c = "--:--00:21"                 # String with two values
while 1:                         # Infinite Loop
    print c[::5]                 # Print the first 5 chars in string
    c = c[::-1]                  # Flip the string
    time.sleep(.5)               # Wait 0.5 seconds

Merci @ FlipTack pour la sauvegarde de 14 octets!


1
Vous pouvez
jouer au

4

PHP, 51 50 47

for(;;usleep(5e5))echo$i++%2?"--:--
":"12:00
";

1 octet enregistré en raison de manatwork et 3 autres enregistrés par insertusernamehere. Merci!


1
Si vous déplacez l' usleep(5e5)appel du for3ème paramètre de, le ,séparateur devient inutile, en enregistrant 1 caractère.
Manatwork

@manatwork merci! J'ai eu while(1)au début.
Christoph le

2
Vous pouvez enregistrer 3 octets supplémentaires : Supprimez l'espace blanc entre echoet $iet remplacez-le \npar une nouvelle ligne.
insertusernamehere

@ insertusernamehere même au golf cela me fait mal aux yeux: D mais bon ça marche.
Christoph

3

Pyth, 23 octets

#?=!Z"12:00""--:--".d.5

En pseudocode:

                Z = 0
#               while 1:
 ?=!Z               if ( Z = not Z ):
     "12:00"            print("12:00")
                    else:
     "--:--"            print("--:--")
 .d.5               sleep(0.5)

Utilise la variable pré-initialisée Zcomme bascule et inverse son état à chaque fois ifpour vérifier l'état.


mettez .d5 à l'avant de la boucle et retirez la citation
finale

3

ruby, 47 42 octets

Pas encore de réponse, alors voici mon premier essai:

%w{12:00 --:--}.cycle{|a|puts a;sleep 0.5}

3

GNU sed, 39 octets

EDITS:

  • Sommeil échangé et i12: 00 (pour rendre le code source plus esthétique)

Golfé

s/^/sleep .5/
h
i12:00
e
i--:--
x
e
G
D

A expliqué

s/^/sleep .5/   #Put 'sleep .5' to the pattern space
h               #Copy pattern space to hold space
i12:00          #Print "12:00" (insert before a line) 
e               #Execute command that is found in pattern space
i--:--          #Print "--:--"
x               #Exchange the contents of the hold and pattern spaces
e               #Execute command that is found in pattern space

G               #Append a newline to the contents of the pattern 
                #space, and then append the contents of the hold
                #space to that of the pattern space.

D               #Delete text in the pattern space up to the 
                #first newline, and restart cycle with the 
                #resultant pattern space, without reading a new 
                #line of input.

Essayez-le en ligne!


3

dc (bash), 37 octets

[12:00][--:--][[rp!sleep .5]xlax]dsax

Cela fonctionne en poussant les deux chaînes "12:00" et "-: -" sur la pile, puis en échangeant plusieurs fois les valeurs, en imprimant l'élément en haut de la pile et en dormant une demi-seconde.

Pour l'exécuter, vous pouvez l'enregistrer dans un fichier, puis taper

nom de fichier dc

ou vous pouvez l'exécuter directement à partir de la ligne de commande bash en tapant

dc <<< '[12:00] [-: -] [[rp! sleep .5] xlax] dsax'


3

Perl 6 ,  48 41  34 octets

loop {print "\r",<--:-- 12:00>[$_=!$_];sleep .5}
loop {put <--:-- 12:00>[$_=!$_];sleep .5}
sleep .put/2 for |<12:00 --:-->xx*

utiliser une forboucle peut le rendre un peu plus court:for |<12:00 --:-->xx* {sleep .5;.say}
smls

Encore plus court si vous utilisez le fait que sayretourne 1:sleep .say/2 for |<12:00 --:-->xx*
smls

2

Gelée, 22 octets

®‘©ị“12:00“--:--”ṄœS.ß

Ne fonctionne pas sur TIO. Faire fonctionner Jelly sur Android avec QPython3 était également une expérience amusante.

Explication

®‘©ị“12:00“--:--”ṄœS.ß    Main link. No arguments. 
®                         Read the register. Initially 0.
 ‘                        Increment. 
  ©                       Save to the register.
   ị                      Get the n'th (wrapping) item of...
    “12:00“--:--”         ["12:00", "--:--"]
                 Ṅ        Print the string and a newline. 
                  œS      Sleep for...
                    .     ...0.5 seconds. (. is an alias for 0.5)
                     ß    Call this link again. 

1
Est-ce que ça dort? Pouvez-vous ajouter une explication?
Steenbergh

1
@steenbergh ajouté. Désolé pour le retard, l'édition de ces tirets pour l'explication est un peu difficile sur l'application SE avec une police non monospace.
PurkkaKoodari

2

Mathematica, 38 octets

Dynamic@If[Clock[]>.5,"12:00","--:--"]

Explication

Clock[]

Émet une variable d’horloge qui passe continuellement de 0 à 1 toutes les secondes.

If[Clock[]>.5,"12:00","--:--"]

Si la variable d'horloge est supérieure à 0,5, indiquez "12:00". Sinon, éditer "-: -".

Dynamic@ ...

Rendre le programme dynamique (mise à jour constante)


2

Javascript, 57 55

setInterval('console.log(++i%2?"12:00":"--:--")',i=500)

2 octets économisés grâce aux ETHproductions


3
Vous pouvez économiser des octets avec setInterval(...,i=500):-)
ETHproductions

2

Postscript 225 214

Pour le plaisir seulement! N'envoyez pas ceci à une vraie imprimante !!

/Courier findfont 9 scalefont setfont{usertime 500 mod 5 lt{newpath 9 9 moveto 1 setgray 99 setlinewidth 99 99 lineto stroke 0 setgray}if newpath 9 9 moveto usertime 999 mod 500 lt{(--:--)}{(12:00)}ifelse show}loop

Essayez le:

gs -c '/Courier findfont 9 scalefont setfont{usertime 500 mod 5 lt{newpath 9 9 moveto 1 setgray 99 setlinewidth 99 99 lineto stroke 0 setgray}if newpath 9 9 moveto usertime 999 mod 500 lt{(--:--)}{(12:00)}ifelse show}loop'

ou

cat <<eops >/tmp/blinkingTwelve.ps
%!
/Courier findfont
9 scalefont
setfont
{
  usertime 500 mod 5 lt {
    newpath
    9 9 moveto
    1 setgray
    99 setlinewidth
    99 99 lineto
    stroke
    0 setgray
  } if
  newpath
  9 9 moveto
  usertime 999 mod 500 lt {
    (--:--)
  } {
    (12:00)
  } ifelse
  show
} loop
eops

puis

gs /tmp/blinkingTwelve.ps
gv /tmp/blinkingTwelve.ps

Mais n'essayez pas de l'ouvrir avec une visionneuse plus sophistiquée et de vous intéresser à la vignette du bureau!


Si la gs -c '...'commande affiche une page blanche, vous devrez peut-être agrandir la fenêtre d'affichage ou utiliser une résolution inférieure: gs -r45 -c '...'ou une taille de papier inférieuregs -r600 -g360x200 -c '...'
F. Hauri

2

Javascript (navigateur), 174 160 159 122 112 111 109 107 66 (91) octets

J'ai choisi de ne pas preutiliser de police monotypée . Mon nouveau compte est donc 66 . Certains caractères sont ajoutés pour utiliser des polices à espacement fixe, mais comme cela n'est pas nécessaire, je ne compterai pas ces 25 caractères supplémentaires.

Merci à ETHproductions pour avoir économisé 14 octets,

à Kritixi Lithos pour enregistrer 1 octet,

pour manipuler pour sauver 1 3 octets,

à Christoph pour avoir sauvé deux autres octets et

me faire économiser 37 octets en utilisant [..][b^=1]au lieu de setTimeout... et 10 autres en les remplaçant function(){..}par des guillemets ...

setInterval("document.body.innerHTML=++b%2?'12:00':'--:--'",b=500)
body{font-family:Courier}

... pire:

De 66 à quelque chose de plus ...

... mais pour le plaisir, dans l'esprit d'un affichage clignotant:

SVG="http://www.w3.org/2000/svg";XLNK="http://www.w3.org/1999/xlink";
s=["1200","----"];p=0;function d(n){for(i=n.length;i>0;i--) {
  document.getElementById('n'+i).setAttribute('class','n'+n[i-1])}
  document.getElementById('sz').setAttribute('class','n'+n[0])}
setInterval("p=1-p;d(s[p])",500);
#svg2 { --c: #FF6;stroke:#432;stroke-width:12;stroke-linecap:round;stroke-linejoin:round; stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none; } path.b { fill:#543;stroke:none; } .blue     { --c: #68F; } .green    { --c: #6F8; } .red      { --c: #F88; } .dec rect  { stroke: var(--c); } .n1 #B { stroke: var(--c); }  .n1 #C { stroke: var(--c); } .n2 #A { stroke: var(--c); }  .n2 #B { stroke: var(--c); } .n2 #D { stroke: var(--c); }  .n2 #E { stroke: var(--c); } .n2 #G { stroke: var(--c); }  .n3 #A { stroke: var(--c); } .n3 #B { stroke: var(--c); }  .n3 #C { stroke: var(--c); } .n3 #D { stroke: var(--c); }  .n3 #G { stroke: var(--c); } .n4 #B { stroke: var(--c); }  .n4 #C { stroke: var(--c); } .n4 #F { stroke: var(--c); }  .n4 #G { stroke: var(--c); } .n5 #A { stroke: var(--c); }  .n5 #C { stroke: var(--c); } .n5 #D { stroke: var(--c); }  .n5 #F { stroke: var(--c); } .n5 #G { stroke: var(--c); } .n6 #A { stroke: var(--c); }  .n6 #C { stroke: var(--c); } .n6 #D { stroke: var(--c); }  .n6 #E { stroke: var(--c); } .n6 #F { stroke: var(--c); }  .n6 #G { stroke: var(--c); } .n7 #A { stroke: var(--c); }  .n7 #B { stroke: var(--c); } .n7 #C { stroke: var(--c); } .n8 #A { stroke: var(--c); }  .n8 #B { stroke: var(--c); } .n8 #C { stroke: var(--c); }  .n8 #D { stroke: var(--c); } .n8 #E { stroke: var(--c); }  .n8 #F { stroke: var(--c); } .n8 #G { stroke: var(--c); } .n9 #A { stroke: var(--c); }  .n9 #B { stroke: var(--c); } .n9 #C { stroke: var(--c); }  .n9 #D { stroke: var(--c); } .n9 #F { stroke: var(--c); }  .n9 #G { stroke: var(--c); } .n0 #A { stroke: var(--c); }  .n0 #B { stroke: var(--c); } .n0 #C { stroke: var(--c); }  .n0 #D { stroke: var(--c); } .n0 #E { stroke: var(--c); }  .n0 #F { stroke: var(--c); } .n11 #B { stroke: var(--c); } .n11 #C { stroke: var(--c); } .n11 #E { stroke: var(--c); } .n11 #F { stroke: var(--c); } .nA #A { stroke: var(--c); }  .nA #B { stroke: var(--c); } .nA #C { stroke: var(--c); }  .nA #E { stroke: var(--c); } .nA #F { stroke: var(--c); }  .nA #G { stroke: var(--c); } .nB #C { stroke: var(--c); }  .nB #D { stroke: var(--c); } .nB #E { stroke: var(--c); }  .nB #F { stroke: var(--c); } .nB #G { stroke: var(--c); } .nC #A { stroke: var(--c); }  .nC #D { stroke: var(--c); } .nC #E { stroke: var(--c); }  .nC #F { stroke: var(--c); } .nD #B { stroke: var(--c); }  .nD #C { stroke: var(--c); } .nD #D { stroke: var(--c); }  .nD #E { stroke: var(--c); } .nD #G { stroke: var(--c); } .nE #A { stroke: var(--c); }  .nE #D { stroke: var(--c); } .nE #E { stroke: var(--c); }  .nE #F { stroke: var(--c); } .nE #G { stroke: var(--c); } .nF #A { stroke: var(--c); }  .nF #E { stroke: var(--c); } .nF #F { stroke: var(--c); }  .nF #G { stroke: var(--c); } .nR #E { stroke: var(--c); }  .nR #G { stroke: var(--c); } .nO #C { stroke: var(--c); }  .nO #D { stroke: var(--c); } .nO #E { stroke: var(--c); }  .nO #G { stroke: var(--c); } .n- #G { stroke: var(--c); }  .n1 #y { stroke: var(--c); } .n1 #z { stroke: var(--c); }
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="100%" height="100%" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 645 230" id="svg2"> <defs id="dfs4"><g id="n"><path d="M 15,5 155,5 145,225 5,225 z" class="b"/> <path id="A" d="M 45,15 125, 15"/><path id="B" d="M 135,25 125,105"/><path id="C" d="M 125,125 115,205"/><path id="D" d="M 25,215 105,215"/><path id="E" d="M 25,125 15,205"/><path id="F" d="M 35,25 25,105"/><path id="G" d="M 35,115 115,115"/><rect id="P" width="5" height="5" ry="2.5" x="130" y="205"/></g><g id="s"><path d="M 10,5 35,5 25,225 0,225 z" id="a" class="b"/><rect id="y" width="5" height="5" ry="2.5" x="13.5" y="145"/><rect id="z" width="5" x="17" height="5" ry="2.5" y="75"/></g></defs><use id="n1" xlink:href="#n" /><use id="n2" xlink:href="#n" transform="translate(150,0)" /><use xlink:href="#s" id="sz" transform="translate(305,0)"/><use id="n3" transform="translate(335,0)" xlink:href="#n" /><use id="n4" xlink:href="#n" transform="translate(485,0)" />
</svg>


1
1000peut devenir1e3
Kritixi Lithos

1
Vous pouvez enregistrer de nombreux octets en supprimant toutes les instances de window.; window.setTimeoutest le même que setTimeout.
ETHproductions

1
ttest plus court que preet implique également l’utilisation de la police de caractères monospace. (C'est juste un élément en ligne, pas un bloc, mais cela ne devrait faire aucune différence ici.)b=document.body.append(a=document.createElement('tt'))
manatwork

1
d=document;d.body.append(a=d.createElement('tt'));setInterval("a.innerHTML=++b%2?'12:00':'--:--'",b=500)sauve 5 octets
Christoph

1
Y a-t-il une raison de générer un élément? setInterval("document.body.innerHTML=++b%2?'12:00':'--:--'",b=500)est à la traîne du monospace sophistiqué mais n’a que 66 octets.
Christoph le

2

QuickBASIC , 167 piqûres (délicieux)

a%=VAL(RIGHT$(STR$(TIMER*100),2))
b%=a%+50
IF b%>99THEN b%=b%-99
DO
c%=VAL(RIGHT$(STR$(TIMER*100),2))
IF c%=a% THEN PRINT"--:--"
IF c%=b% THEN PRINT"12:00"
LOOP

Je n'allais jamais gagner de toute façon. QB n'a pas de floor (), et n'a pas non plus de fonction pour dormir pendant x millisecondes. Par conséquent, cela fonctionne en saisissant la partie à virgule flottante de la minuterie (le nombre de secondes écoulées depuis minuit, plus une fraction de la seconde en cours exprimée en décimale à deux chiffres). Nous y ajoutons ensuite une boucle "50 unités" pour déterminer le moment où la phase doit basculer de "-: -" à "12:00", et nous utilisons la décimale TIMER d'origine pour le basculement de "12:00". à "--:--".

Enfin, même si cela est conforme à QB4.5, DOSBox sur une machine assez puissante ignorera les temps. En effet, QB n’est vraiment pas assez rapide pour effectuer la DO-LOOP et les évaluations à l’intérieur du MS dans lequel nous effectuons la comparaison. Aurait besoin d’une boîte de la FUTURE!

Quoi qu'il en soit, j'ai maintenant l'air d'avoir 100 ans et j'ai rendu heureux tous les étudiants de l'université américaine, car ils ont probablement une réponse à donner à leur cours de Comp Sci - puisqu'ils enseignent encore cette ...


Pouvez-vous supprimer certains des espaces? c'est b% = b% - 99à dire b%=b%-99?
Rɪᴋᴇʀ

Oui, je suis à peu près sûr de pouvoir le faire, mais j’ai utilisé l’IDE ​​original qui, après avoir appuyé sur Entrée à la fin de la ligne, les aurait rajoutés. Je devais le modifier en dehors de l’IDE ​​sous DOS, puis comprendre les paramètres de l'éditeur de liens / du compilateur pour vérifier si ma solution fonctionnait toujours ... Cela peut donc être plus court, mais pas dans mon cadre d'effort.
Robert Lerner

Eh bien, vous devez utiliser ce code pour jouer au golf ou bien ce n’est pas une réponse valable et sera supprimé. Désolé pour ça. (Je comprends tout à fait ce que vous voulez dire, mais la communauté dans son ensemble a décidé de ne pas donner de réponses non-golfées)
Rɪᴋᴇʀ

Bon point, je vais supprimer les espaces.
Robert Lerner

2

Clojure, 79 62 octets

V2

-17 octets en passant d'une terrible boucle d'indexation à une liste infinie.

Crée une liste infinie de "12:00"et "--:--"répéter encore et encore, puis utilise doseqpour tirer constamment le message suivant, et l' imprimer.

(doseq[m(cycle["12:00""--:--"])](Thread/sleep 500)(println m))

V1

(loop[i 0](Thread/sleep 500)(println(["12:00""--:--"]i))(recur(if(= 0 i)1 0))))

Je ne pouvais pas penser à un bon moyen de compacter les constantes "12:00" et "-: -", donc je devais les coder en dur.

Ungolfed:

(loop [i 0] ; Track which sign we showed last
    (Thread/sleep 500)
    (println (["12:00" "--:--"] i)) ; Index the vector to get the string to print
    (recur (if (= 0 i)1 0))) ; Swap the index, and loop again

2

Pushy , 22 octets (non concurrents)

`--:`wO`12:0`&["500oWF

Cette réponse utilise les deux piles, en les retournant, en imprimant les caractères à tour de rôle:

`--:`    \ Push these characters to stack 1
 w       \ Mirror around center, yielding "--:--"
 O       \ On the second stack...
 `12:0`  \ Push these characters
 &       \ Duplicate the last (for :00)

 [        \ Infinitely:
  "       \   Print the current stack
  500oW   \   Wait 500 milliseconds
  F       \   Swap stacks
          \ (Implicit end loop)

La oWcommande fait partie d'un ensemble de commandes expérimentales postérieures au défi, rendant cette réponse non concurrente.


2

Windows PowerShell, 46 55 octets

function a{sleep -m 500;cls};for(){"12:00";a;"--:--";a}

Code d'origine:

a{sleep -m 500;cls};for(){"12:00";a;"--:--";a}
^ this won't work on other PCs. No idea why.
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.