introduction

Rappelez-vous les années 80 rugissantes? Je veux dire, vous savez, comme il y a 30 ans? Pas de téléphones portables, pas d'Internet, pas de distributeurs automatiques de billets, des vêtements fluorescents (qu'est-ce que c'était?!) Et des marqee à défilement ! Non non Non! Pas ceux en ligne, mais les vrais, avec des lumières LED.

Comme je suis d'humeur nostalgique, j'aimerais que vous créiez un chapiteau défilant.

Défi

Créez un programme dans lequel vous pouvez saisir une chaîne d'une ligne. Votre programme doit créer un cadre de défilement de 80 caractères, en répétant le texte si nécessaire.

Règles

• L'utilisateur doit pouvoir saisir une chaîne dans votre programme en entrée. La chaîne peut être un paramètre de ligne de commande ou une chaîne entrée lors de l'exécution du programme.
• Votre programme doit imprimer en continu une chaîne d'exactement 80 caractères (visibles).
• La chaîne doit être mise à jour toutes les 0,1 seconde (plus ou moins; je ne la chronométrerai pas), décalant les caractères à chaque itération d'une position vers la gauche.
• La chaîne "tourne". À la fin de la chaîne fournie par l'utilisateur, une autre instance de la chaîne doit apparaître.
• Votre programme doit imprimer sa sortie sur une seule ligne, sans sauts de ligne (utilisez un '\ r' au lieu d'un '\ n')
• Votre programme doit s'exécuter à l' infini , jusqu'à une interruption utilisateur.
• Il s'agit d'un codegolf, donc le code le plus court en octets l'emporte.
• Il y a un bonus de 10% (arrondi jusqu'à à l'entier) pour l' impression en rouge sur un fond noir.
• Des échappatoires standard s'appliquent.

Implémentation de référence dans Python 2.7

Ce programme n'est pas golfé, mais il fournit une implémentation de référence (et donc une limite supérieure à la taille).

import time,sys
s=raw_input()*99
while 1:
    for i in range(80):
        print s[i:i+80]+'\r',
        sys.stdout.flush()
        time.sleep(0.1)

CJam, 31 octets

l80*{Dco_80<o(+es99+{es1$<}g;}h

Attend exactement 100 ms.

Cela ne fonctionnera qu'avec l' interpréteur Java officiel , car l'interpréteur en ligne n'affiche la sortie qu'après avoir quitté le programme.

Le texte rouge sur fond noir est possible en 40 (ou 39) octets, pour un score de 36:

0000000: 6c 38 30 2a 7b 22 0d 1b 5b 33 31 3b 34 30 6d 22 6f 5f  l80*{"..[31;40m"o_
0000012: 38 30 3c 6f 28 2b 65 73 39 39 2b 7b 65 73 31 24 3c 7d  80<o(+es99+{es1$<}
0000024: 67 3b 7d 68                                            g;}h

Comment ça fonctionne

l80*                             Read a line and repeat it 80 times.
    {                        }h  Do:
     Dco                           Print the character with code point 13.
        _80<o                      Print the first 80 characters of the string.
             (+                    Rotate the string one charcter to the left.
               es99+               Push the current time (ms) plus 99.
                    {     }g       Do:
                     es1$<           Compare the current time with the sum.
                                     Repeat the loop if 99 or less ms have passed.
                            ;      Discard the time stamp.
                                 Repeat the loop.

PowerShell, 118113112108102101 99 96-10% = 86

Code

$s=(Read-Host)*180;for(){Write-Host($s.substring(($i=++$i%80),80)+"`r")-N -F R -B 0;sleep -m 99}

Avec la mise en garde qu'il commence maintenant la première boucle avec le deuxième caractère; Les règles ne disent pas qu'elle doit commencer par le devant de la chaîne, et la première est incluse dans l'ensemble, donc ça me convient. Je vais l'avoir à 100 caractères en quelque sorte - éditer: merci @ConnorLSW pour les éditions pour l'avoir en dessous de 100.

Instructions

1. Exécutez PowerShell (console normale, cela ne fonctionne pas dans PowerShell ISE)
2. Collez la version monoligne dans PoSH, appuyez sur Entrée
3. Saisissez un message, appuyez sur Entrée
4. Ctrl-C pour casser

Production

Remarques

Une version plus lisible avec les noms de variables et les paramètres un peu remplis:

$test = (Read-Host) * 180
for () {
    Write-Host ($text.substring(($i=++$i%80), 80)+"`r") -NoNewLine -ForegroundColor Red -BackgroundColor Black
    sleep -Miliseconds 99
}

• Les paramètres doivent seulement être suffisamment longs pour être uniques, et -F Rsont donc suffisamment uniques pour définir une couleur rouge de premier plan, par exemple.
• «Black» doit être «Bla» pour être unique par rapport à «Blue», mais -B 0 définit sur la couleur Enum value 0 qui est interprétée comme Black.

Chapiteau alternatif, plus «correct»:

Le code de référence ne gère pas correctement les chaînes de plus de 80 caractères, ignorant tout ce qui se trouve dans le message au-delà de 160 caractères, et il réinitialise tous les 99 caractères len (chaîne). Par exemple, si la largeur du signe était de 5 caractères, cela fait ceci:

   here is my long test input
 0 |here |            
 1  |ere i|          ^^^^ never shown
 2   |re is|
 3    |e is |
 4     | is m|
 0 |here |
 1  |ere i|
    ...

Cette version indexe modulo la longueur du texte au lieu de la largeur du signe, donc il parcourt toute la chaîne. 106 - 10% = 95 caractères.

$l=($s=Read-Host).Length;for(){Write-Host(($s*160).substring(($i=++$i%$l),80)+"`r")-N -F R -B 0;sleep -m 99}

Alternative: signe quels cycles comme le .gif dans la question, 118-10% = 106

Parce que ça a l'air mieux.

$s=' '*80+(read-host)+' '*80;for(){write-host($s.Substring(($i=++$i%($s.length-80)),80)+"`r")-N -F R -B 0;sleep -m 99}

Matlab, 76 octets

Ce que je pense être bien ici, c'est que vous pouvez avoir des vecteurs comme indices de tableau. Cela renvoie un vecteur des entrées de tableau correspondantes, ce qui rend très facile l'ajout de la chaîne donnée indépendamment de la longueur.

a=input('');k=1:80;while 1;pause(.1);clc;k=mod(k+1,nnz(a));disp(a(k+1));end

Résultat:

QBasic, 116 113 octets - 10% = 105 102

INPUT s$
COLOR 4
1CLS
FOR i=a TO a+79
?MID$(s$,i MOD LEN(s$)+1,1);
NEXT
?
a=a+1
t=TIMER+.1
2ON(TIMER<t)+2GOTO 2,1

Voici une version formatée avec quelques commentaires:

INPUT s$
COLOR 4   ' 4 is the color code for red (the background's already black)

1 CLS   ' CLear Screen (and mark this as line number 1)

' The variable a represents an offset from the beginning of the string
' As a numeric variable, it is 0 at the beginning of the program
FOR i = a TO a + 79
    ' Print i'th character mod string length (+ 1 because QBasic strings
    ' are 1-indexed)
    PRINT MID$(s$, i MOD LEN(s$) + 1, 1);
NEXT i
PRINT
a = a + 1

' Do a busy-wait for .1 seconds
' (Unfortunately, QBasic's SLEEP command only takes integer values)
' Set t to the time we want to stop waiting, .1 seconds in the future
t = TIMER + .1
' We want to stay on line number 2 while TIMER < t; once that condition is
' no longer true, we want to goto the top of the outer loop (line number 1)
' Since true is -1 and false is 0 in QBasic, adding 2 to the conditional
' gives 1 for true and 2 for false; we can pass these values to the
' ON ... GOTO statement to branch conditionally
2 ON (TIMER < t) + 2 GOTO 2, 1

Quelques notes:

• Je ne sais pas pourquoi PRINTla FORboucle est nécessaire. CLSdevrait réinitialiser le curseur dans le coin supérieur gauche à chaque fois. Mais sur QB64, au moins, si je ne mets pas le supplément PRINT, le chapiteau se retrouve sur la deuxième ligne au lieu de la première. Si quelqu'un a configuré QBasic sur DosBox ou quelque chose comme ça, je serais intéressé de savoir si la même chose se produit là-bas ou s'il s'agit d'un bogue QB64.
• Le code a un petit problème car il s'appuie sur TIMER(nombre de secondes depuis minuit) pour le retard. Si le code s'exécute à minuit, le chapiteau restera bloqué car TIMERsera réinitialisé 0et toujours inférieur à celui tpar la suite.

Perl, 99 98 octets (-10% = 89)

$|=@_=split('',pop);printf("\e[31m\r%.80s",join('',@_)x80)while select($a,$a,$a,.1)|push@_,shift@_

Prend son entrée à partir du paramètre de ligne de commande.

perl marquee.pl "Welcome to Programming Puzzles & Code Golf "

pb , ⌈ (216 + 3) * 0,9⌉ = 198

+3 octets pour l'indicateur d'interprète d=1

c^w[Y=-1]{w[B!0]{>}t[X]<[X-79]w[X!0]{t[T-1]w[T=-1]{t[0]}<}vw[T=0]{^w[B!0]{t[B]^b[T]>v}<[X]^w[B!0]{t[B]vw[B!0]{>}b[T]<[X]^w[B=0]{>}b[0]>}v}}^w[1=1]{<[X-80]w[X!0]{<t[B]vb[T]^}w[B!0]{t[B]<b[T]>>}<[X]<t[B]w[B!0]{>}<b[T]}

Un score assez horrible, mais compte tenu de la difficulté de faire quoi que ce soit dans cette langue, cela pourrait être pire. Le rapport de cette réponse (octets utilisés pour obtenir du texte rouge) à (bonus d'avoir du texte rouge) est vraiment bon, la sortie entière devient rouge avec seulement lec au début!

Le temps entre chaque tick varie en fonction de la longueur de la chaîne d'entrée, mais il est d'environ 0,1 seconde.

Soit dit en passant, la sortie de ce programme ressemble à une ordure totale parce que l'interpréteur est si mauvais. Toutes les millisecondes, il efface le terminal et redessine tout, donc ça devient vraiment scintillant.

Avec commentaires:

c           # Change paint colour to red

^w[Y=-1]{   # While Y=-1 (arbitrary condition we can break later)

    w[B!0]{>}   # Go to end of input

    t[X]        # Save length of input in T

    # SET T TO MAX(T-79, 0)

    <[X-79]     # Go to (79, -1)

    w[X!0]{     # While X is not 0
        t[T-1]      # Subtract 1 from T
        w[T=-1]{    # If T is now negative
            t[0]        # Set it back to 0
        }
        <         # Move left (position doesn't matter except to end the loop eventually)
    }

    # DONE SETTING T TO MAX(T-79, 0)
    # If T == 0, the string needs to be doubled. Otherwise this part of the program is done

    v           # Move down to break the loop unless this is specifically undone
    w[T=0]{     # While T == 0
        ^w[B!0]{    # For each byte of input
            t[B]^b[T] # Copy it up 1 place
            >v        # Go to the next byte
        }
        <[X]^     # First byte of the copy
        w[B!0]{   # For each byte of the copy
            t[B]      # Save the byte's value
            vw[B!0]{>}# Go to the first empty spot after the original
            b[T]      # Write the saved value
            <[X]^w[B=0]{>} # Go back to the first byte of the copy
            b[0]>     # Erase it and go to the next one
        }
        v       # Back to Y=-1 to reset the loop from the very beginning
    }

}

# After ALL OF THAT nonsense, we're now at (0, 0) and the input string is guaranteed to be
# at least 80 characters long

^
w[1=1]{       # While 1=1 (should hold true until mathematics itself breaks down)
    <[X-80]        # Go to the 81st character
    w[X!0]{        # While X!=0
        <t[B]vb[T]^    # Go left and copy that character down
    }

    w[B!0]{      # For each byte in the string
        t[B]<b[T]>>  # Copy that byte left
    }

    <[X]<t[B]    # Go get the first value (copied to (-1, -1))
    w[B!0]{>}<b[T]# Bring it to the end of the string
}

Perl - 120 octets (-10% = 108)

$|=1;$_=<>;chomp;for(;;){print "\e[31m",substr(" "x80 .$_,$p++,80)," \r";select($z,$z,$z,0.1);if($p>length()+80){$p=0}}

Matlab, ⌈188 * .9⌉ = 170

Cela fonctionne dans la version Matlab R2014b ou supérieure. Le résultat est affiché sur une fenêtre de figure.

h=text(.1,.1,repmat(' ',1,80),'fontn','courier','ba','k','co','r');set(1,'pos',[90 90 990 90]);axis off
s=input('','s');n=0;while 1
n=n+1;pause(.1)
h.String=s(mod((0:79)+n,numel(s))+1);end

Dans l' exemple suivant , le texte est tapé en gras pour une meilleure visualisation (pas fait dans le code ci-dessus car il coûte quelques octets). Notez également que la vitesse de l'animation GIF ne correspond pas à la pause de 0,1 s requise, mais le timing est correct dans la figure réelle affichée en exécutant le programme.

SpecBAS, 130 octets (-10% = 117)

Multiplie la chaîne d'origine pour lui donner 80 caractères ou plus, puis la coupe exactement à 80.

TEXT est une commande dans SpecBAS qui fonctionne de la même manière que PRINT (dans cet exemple) mais enregistre un caractère.

La SCALEcommande ajoute quelques caractères supplémentaires au code, mais lui donne une apparence plus marquante.

Le programme continue jusqu'à ce que vous appuyiez sur Echap.

1 INPUT s$: LET s$=s$*CEIL(80/LEN s$)
2 TEXT PAPER 0;INK 2;SCALE 1,2;AT 1,1;s$( TO 80)
3 LET s$=s$(2 TO)+s$(1): PAUSE 5: GO TO 2

Perl, 63 (70 caractères - 10% pour le bonus)

Pas une solution très différente des autres, mais j'ai perdu mon temps à le faire, alors j'ai pensé que je le posterais aussi!

$_=<>;s/
/ /;print"\x0d\x1b[91m",substr"$_"x80,$z++%y///c,80 until`sleep .1`

Repose sur un terminal compatible Unix pour les codes ANSI et l'appel à coreutils ' sleep. Les deux \x..caractères ci-dessus sont en fait un saut de ligne littéral et un caractère d'échappement selon ce vidage hexadécimal:

0000000: 245f 3d3c 3e3b 732f 0a2f 202f 3b70 7269  $_=<>;s/./ /;pri
0000010: 6e74 220d 1b5b 3931 6d22 2c73 7562 7374  nt"..[91m",subst
0000020: 7222 245f 2278 3830 2c24 7a2b 2b25 792f  r"$_"x80,$z++%y/
0000030: 2f2f 632c 3830 2075 6e74 696c 6073 6c65  //c,80 until`sle
0000040: 6570 202e 3160                           ep .1`

Rubis, 79 76 75 octets

t,i=gets.chop*81,0
loop{system'cls'
$><<t[(i=(i+1)%80)..i+79]
sleep 0.1}

Je ne suis toujours pas un expert en rubis, peut-être peut-être joué au golf.

Avec le même score en rouge et noir:

t,i=gets.chop*81,0
loop{system'cls&color 4'
$><<t[(i=(i+1)%80)..i+79]
sleep 0.1}

Perl, 84 octets (- 10% = 76)

$_=' 'x80 .pop;$|=print"\b \r\e[31m".substr$_,++$p% length,80until select$z,$z,$z,.1

Cela prend un argument de ligne de commande qui est le texte dans le rectangle de sélection.

Explication:

1. Ajoutez 80 espaces au texte et stockez-les $_
2. Imprimez le retour arrière ( \b) et un espace ( ). Cela supprime le dernier caractère de l'impression précédente. Imprimez ensuite le retour chariot et la couleur.
3. Imprimer les 80 caractères du texte à partir de la position $p
4. $p = ($p+1) % length of text
5. Dormir pendant 0,1 seconde

bash, 121 octets

A=$(printf ' %.s' {1..80})$1
while :; do
printf "%s \r" "${A:((P++)):80}"
if [ $P == ${#A} ];then
 P=0
fi
sleep 0.1
done

Python 3, 96 octets

import time;s=input()*80
while 1:print("\033[2J",end=s[:80],flush=1);s=s[1:]+s[0];time.sleep(.1)

Cela ne fonctionnera que sur les terminaux qui prennent en charge les séquences d'échappement ANSI. Si vous êtes sous Windows, essayez ansicon .

Vive le flushmot - clé dans Python 3, nous n'avons donc pas besoin de faire un sys.stdout.flush()appel coûteux .

C, 293 269 ​​octets

(Ajout de nouvelles lignes pour plus de lisibilité)

Cela prend l'entrée de l'entrée standard terminée par EOF; il est donc préférable d'entrer une chaîne, une nouvelle ligne, puis l'EOF (par exemple, Ctrl ^ D).

#include<stdio.h>
#include<string.h>
#define Z '\0'
main(){int i=0,j;char m[80],o[80],n[2];
while(~(j=getchar())&&i<80)j-'\n'?m[i++]=j:0;m[i]=Z;
while(1){for(i=0;m[i]-Z;++i){strcpy(o,&m[i]);
for(j=0;j<i;)*n=m[j++],n[1]=Z,strcat(o,n);
printf("\x1b[40;31m%s\x1b[0m\r",o);}}}

Non golfé:

#include <stdio.h>
#include <string.h>
#define ANSI_COLOR_SET "\x1b[40;31m"
#define ANSI_COLOR_RESET "\x1b[0m"

int main(void)
{
  int i, j, c;
  char msg[80], out[80], next[2];

  for (i = 0; (c = getchar()) != EOF && i < 80; ++i) {
    if (c != '\n') {
      msg[i] = c;
    }
  }
  msg[i - 1] = '\0';

  while (1) {
    for (i = 0; msg[i] != '\0'; ++i) {
      strcpy(out, &msg[i]);
      for (j = 0; j < i; ++j) {
        next[0] = msg[j];
        next[1] = '\0';
        strcat(out, next);
      }
      printf(ANSI_COLOR_SET "%s\r" ANSI_COLOR_RESET, out);
    }
  }
  return(0);
}

SmileBASIC BIG, 79 octets

COLOR 3INPUT S$@L
CLS
FOR I=0TO 79?S$[(I+O)MOD LEN(S$)];
NEXT
WAIT 6O=O+1GOTO@L

J'avais une belle solution graphique presque terminée quand j'ai réalisé qu'elle devait faire défiler 1 caractère entier à la fois.

Gelée , 20 19 18 octets

• -1 octet en remplaçant le premier 80par ⁹(= 256) car il doit être multiplié par au moins 80
• -1 octet en changeant la boucle infinie en Çß(de Ç1¿).

ẋ⁹ḣ80ṙ1;”ÆṄœS.1
Çß

Avec quelques astuces de la réponse de @Dennis ici . La gelée est plus récente que le défi, mais pas vraiment spécialement conçue pour cela. Les suggestions sur la façon de s'améliorer sont les bienvenues! Si votre console est en utf-8, exécutez export LC_ALL=en_USou similaire avant d'essayer.

Exemple

Explication

ẋ⁹ḣ80ṙ1;”ÆṄœS.1         Monadic helper link - Argument: s
ẋ⁹                      Repeat s 256 times.
  ḣ80                   Head. Set {output} to first 80 characters from repeated s.
     ṙ1                 Rotate. Rotates {output} one character to the left.
       ;Ӯ              Concatenate character 0D, the carriage return, to {output}.
          Ṅ             Print and return {output}.
           œS.1         Wait 0.1 seconds before returning {output} from the
                        helper link.

Çß                      Monadic main link - Argument: s
Ç                       Execute helper link with argument s. Replace s by
                        result of helper link.
 ß                      Execute this link with argument s (while true).

LOVE2D Lua, 197-10% = 178 octets

f=io.open("t.t"):read().."  "love.graphics.setColor(255,0,0)love.window.setMode(640,14)function love.draw()s=""for i=1,80 do n=i+os.clock()s=s..f:sub(n%#f,n%#f) end love.graphics.print(s,0,0)end

Nécessite que l'entrée soit dans un fichier appelé 'tt' à la racine, donc 3 octets supplémentaires ont été ajoutés au score.

Fonctionnalité vraiment basique, juste dans une boucle for de 80 itérations, ajoutez le caractère à l'indice de i plus l'heure actuelle en secondes modulée par la longueur de la chaîne actuelle, donnant une chaîne répétée de 80 caractères de l'entrée, qui décale vers la gauche comme le temps passe.

J'ai utilisé LOVE2D pour les rires.

Sinclair ZX81 / Timex TS1000 / 1500 BASIC, 110 octets 182 octets (pour la liste)

1 LET A$="I LIKE TO SCROLL IT... HELLO MUM, BY DONKEYSOFT... THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG... STILL SCROLLING... "
2 PRINT AT 0,0;A$(1 TO 80)
3 LET A$=A$(2 TO )+A$(1)
4 GOTO 3

Il fonctionne en imprimant les 32 80 premiers caractères de la chaîne A$à la position d'écran 0,0 sur la ligne deux, puis en manipulant la chaîne de la position 2 à la fin de la piqûre de la ligne 3 (Sinclair ZX81 BASIC indexe les chaînes de 1 et non nul) ), donc en ajoutant le premier caractère à la fin et en le renvoyant à la A$variable; puis il y a une boucle inconditionnelle de retour à la ligne 2.

Commodore 64, 434 octets

0 A$="I LIKE TO SCROLL IT... SAMPLE SCROLLY ROUTINE FOR CODE-GOLF MADE BY DONKEYS
1 A$=A$+"OFT MMXVII... HELLO MUM... SCROLLING IS FUN, INNIT? GREETZ TO ALL...
2 POKE53280,6:PRINT"{CLEAR}";
3 PRINTLEFT$(A$,40)"{HOME}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}"MID$(A$,41,40)"{HOME}";
4 FORI=0TO99:NEXT:A$=RIGHT$(A$,142)+LEFT$(A$,1):GOTO3

Comme cela nécessite 80 caractères pour s'afficher, et le C64 par défaut n'est que de 40 caractères, alors 40 caractères du scrolly sont imprimés sur la ligne supérieure de la zone d'écran tandis que les 40 autres sont imprimés près du bas.

Pour clarifier ce que les {HOME}symboles et d'autres traduisent en PETSCII, voici une capture d'écran tirée de mon émulateur:

Je ferai une version golf complète lorsque j'aurai installé CBM PRG Studio (ou quand je ne déjeunerai pas au travail).

Rubis, 79 77 caractères

->(s){t=0;loop{system("clear");puts (s*80)[t..(80+t)];t=(t+1)%80;sleep(0.1)}}

PHP, 136 octets

<?php
$s="\e[0;31;40m".substr(str_repeat($argv[1],160),0,160);
while(true){for($i=0;$i<=80;$i++){usleep(100000);echo substr($s,$i)."\r";}}die;

• Appelez-le avec la php -f marquee.php hello\ worldchaîne "hello world".
• Pour une raison quelconque, j'ai dû faire 160 caractères pour la chaîne initiale, sinon la sortie ressemblerait à quelque chose hello worlddddddddddddddddddddddddddddddddddddddd, mais elle ne parcourra que 80 caractères - j'espère que cela compte toujours.

Ça a été une longue journée, il y a probablement quelque chose que je peux faire pour l'améliorer

PHP, 85 octets

for(;;usleep(1e5))echo substr(str_repeat($s=$argv[1],80),$i=++$i%strlen($s),80),"\r";

prend l'entrée du premier argument de la ligne de commande; courir avec-nr .

Commence le défilement avec le deuxième caractère. Ajoutez un octet pour commencer au premier caractère:
remplacez =++$i%par %=et ;;par ;;$i++,.