introduzione

Ricordi i ruggenti anni '80? Voglio dire, sai, 30 anni fa? Niente telefoni cellulari, niente internet, niente bancomat, vestiti fluorescenti (che cos'era quello ?!) e marqee scorrevoli ! No, no, no! Non quelli online, ma quelli veri, con luci a LED.

Dal momento che sono di umore nostalgico, vorrei che tu creassi un tendone scorrevole.

Sfida

Crea un programma in cui puoi inserire una stringa di una riga. Il programma deve creare un riquadro scorrevole di 80 caratteri, ripetendo il testo se necessario.

Regole

• L'utente deve essere in grado di inserire una stringa nel programma come input. La stringa può essere un parametro della riga di comando o una stringa immessa durante l'esecuzione del programma.
• Il programma deve stampare continuamente una stringa di esattamente 80 caratteri (visibili).
• La stringa deve essere aggiornata ogni 0,1 secondi (più o meno; non la temporizzerò), spostando i caratteri di ogni iterazione di una posizione a sinistra.
• La stringa "ruota". Alla fine della stringa fornita dall'utente, deve apparire un'altra istanza della stringa.
• Il programma deve stampare l'output su una riga, senza avanzamenti di riga (utilizzare un '\ r' anziché un '\ n')
• Il programma deve essere eseguito all'infinito , fino a quando un utente non lo interrompe.
• Questo è un codegolf, quindi vince il codice più breve in byte.
• C'è un bonus del 10% (arrotondato fino al successivo numero intero) per la stampa in rosso su uno sfondo nero.
• Si applicano scappatoie standard.

Implementazione di riferimento in Python 2.7

Questo programma non è golfato, ma fornisce un'implementazione di riferimento (e quindi un limite superiore alla dimensione).

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 byte

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

Attende esattamente 100 ms.

Funzionerà solo con l' interprete Java ufficiale , poiché l'interprete online mostra l'output solo dopo essere uscito dal programma.

Il testo rosso su sfondo nero è possibile in 40 (o 39) byte, per un punteggio di 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

Come funziona

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, 118113 11211810201 101 99 96 - 10% = 86

Codice

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

Con l'avvertenza che ora inizia il primo ciclo con il secondo personaggio; Le regole non dicono che debba iniziare dalla parte anteriore della stringa e la prima è inclusa nel complesso, quindi per me va bene. Lo porterò in qualche modo a 100 caratteri - modifica: grazie @ConnorLSW per le modifiche per portarlo sotto i 100.

Istruzioni

1. Esegui PowerShell (console normale, non funziona in PowerShell ISE)
2. Incolla la versione a linea singola in PoSH, premi invio
3. Digita un messaggio, premi invio
4. Ctrl-C per interrompere

Produzione

Appunti

Una versione più leggibile con i nomi delle variabili e i parametri compilati un po ':

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

• I parametri devono solo essere abbastanza lunghi da essere univoci, quindi -F Rè abbastanza unico da impostare un ForegroundColor rosso, per esempio.
• 'Nero' deve essere 'Bla' per essere unico rispetto a 'Blu', ma lo -B 0imposta per colorare il valore Enum 0 che viene interpretato come Nero.

Selezione alternativa, più "corretta":

Il codice di riferimento non gestisce bene le stringhe più lunghe di 80 caratteri, saltando qualsiasi cosa nel messaggio oltre ~ 160 caratteri e ripristina i glitch ogni 99 * len (stringa) caratteri. ad es. se la larghezza del segno era lunga 5 caratteri, lo fa:

   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|
    ...

Questa versione indicizza la lunghezza del testo anziché la larghezza del segno, percorrendo l'intera stringa. 106-10% = 95 caratteri.

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

Alternativa: indica quali cicli come .gif nella domanda, 118-10% = 106

Perché sembra migliore.

$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 byte

Quello che penso sia bello qui è che puoi avere vettori come indici di array. Questo restituisce un vettore delle corrispondenti voci dell'array, il che rende molto semplice aggiungere la stringa data indipendentemente dalla lunghezza.

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

Risultato:

QBasic, 116 113 byte - 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

Ecco una versione formattata con alcuni commenti:

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

Un paio di note:

• Non so perché sia necessario PRINTil FORciclo successivo.CLSdovrebbe reimpostare il cursore nell'angolo in alto a sinistra ogni volta. Ma almeno su QB64, se non aggiungo un extra PRINT, il riquadro di selezione finisce sulla seconda riga anziché sulla prima. Se qualcuno ha QBasic impostato su DosBox o su qualche altro, sarei interessato a sapere se la stessa cosa accade lì o se si tratta di un bug QB64.
• Il codice ha un piccolo difetto perché si basa su TIMER(numero di secondi dalla mezzanotte) per il ritardo. Se il codice viene eseguito a mezzanotte, il riquadro di selezione si bloccherà perché TIMERverrà reimpostato su 0e sarà sempre inferiore a quello tsuccessivo.

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

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

Prende il suo input dal parametro della riga di comando.

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

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

+3 byte per flag interprete 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 punteggio piuttosto orribile, ma considerando quanto sia difficile fare qualsiasi cosa in questa lingua potrebbe essere peggio. Il rapporto di questa risposta da (byte utilizzati per ottenere il testo rosso) a (bonus dall'avere testo rosso) è davvero buono, l'intero output diventa rosso con solo ilc all'inizio!

Il tempo tra ogni segno di spunta varia a seconda della lunghezza della stringa di input ma è di circa 0,1 secondi.

A proposito, l'output di questo programma sembra spazzatura totale perché l'interprete è così male. Ogni millisecondo cancella il terminale e ridisegna tutto, quindi diventa davvero tremolante.

Con commenti:

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 byte (-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

Funziona con Matlab versione R2014b o successiva. Il risultato è mostrato in una finestra di figura.

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

Nel seguente esempio , il testo viene digitato in grassetto per una migliore visualizzazione (non fatto nel codice sopra perché costa pochi byte). Si noti inoltre che la velocità dell'animazione GIF non corrisponde alla pausa di 0,1 s richiesta, ma la tempistica è corretta nella figura reale mostrata eseguendo il programma.

SpecBAS, 130 byte (-10% = 117)

Moltiplica la stringa originale per renderla 80 o più caratteri, quindi tagliala esattamente a 80.

TEXT è un comando in SpecBAS che funziona allo stesso modo di PRINT (in questo esempio) ma salva un carattere.

Il SCALEcomando aggiunge alcuni caratteri extra al codice, ma lo fa sembrare più marcato.

Il programma continua finché non si preme Esc.

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 caratteri - 10% per bonus)

Non è una soluzione estremamente diversa dalle altre, ma ho perso tempo a farlo, quindi ho pensato di pubblicarlo anch'io!

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

Si basa su un terminale compatibile Unix per i codici ANSI e la chiamata a coreutils ' sleep. I due \x..caratteri di cui sopra sono in realtà un avanzamento di riga letterale e caratteri di escape in base a questo dump esadecimale:

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`

Ruby, 79 76 75 byte

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

Non sono ancora un esperto di rubini, forse posso giocare a golf.

Con lo stesso punteggio rosso e nero:

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

Perl, 84 byte (- 10% = 76)

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

Questo accetta un argomento della riga di comando che è il testo nel riquadro di selezione.

Spiegazione:

1. Prepara 80 spazi al testo e archiviali $_
2. Stampa backspace ( \b) e uno spazio ( ). Ciò rimuove l'ultimo carattere dalla stampa precedente. Quindi stampare il ritorno a capo e il colore.
3. Stampa gli 80 caratteri del testo dalla posizione $p
4. $p = ($p+1) % length of text
5. Dormire per 0,1 secondi

bash, 121 byte

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 byte

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

Funzionerà solo su terminali che supportano sequenze di escape ANSI. Se sei su Windows, prova Ansicon .

Evviva la flushparola chiave in Python 3, quindi non dobbiamo effettuare sys.stdout.flush()chiamate costose .

C, 293 269 ​​byte

(Newline aggiunti per leggibilità)

Questo prende input da input standard terminato da EOF; quindi è meglio inserire una stringa, una nuova riga e quindi l'EOF (ad esempio, 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);}}}

Ungolfed:

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

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

Avevo quasi fatto una bella soluzione grafica quando mi sono reso conto che doveva scorrere 1 carattere intero alla volta.

Gelatina , 20 19 18 byte

• -1 byte sostituendo il primo 80con ⁹(= 256) perché deve essere moltiplicato per almeno 80
• -1 byte modificando il loop infinito in Çß(da Ç1¿).

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

Con alcuni trucchi dalla risposta di @Dennis qui . Jelly è più recente della sfida, ma non è stata appositamente studiata per questo. Suggerimenti su come migliorare sono i benvenuti! Se la tua console è in utf-8, esegui export LC_ALL=en_USo simili prima di provare.

Esempio

Spiegazione

ẋ⁹ḣ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 byte

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

Richiede che l'input sia in un file chiamato 'tt' nella radice, quindi sono stati aggiunti 3 byte extra al punteggio.

Funzionalità davvero di base, solo in un ciclo for di 80 iterazioni, aggiungi il carattere all'indice di i più il tempo corrente in secondi modulato dalla lunghezza della stringa corrente, dando una stringa ripetuta lunga 80 caratteri dell'input, che si sposta a sinistra col passare del tempo.

Ho usato LOVE2D per le risate.

Sinclair ZX81 / Timex TS1000 / 1500 BASIC, 110 byte 182 byte (per l'elenco)

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

Funziona stampando i primi 32 80 caratteri della stringa A$nella posizione 0,0 dello schermo nella riga due e quindi manipolando la stringa dalla posizione 2 alla fine della puntura nella riga 3 (Sinclair ZX81 BASIC indicizza le stringhe da 1 e non zero ), quindi aggiungendo il primo carattere alla fine e passandolo alla A$variabile; quindi c'è un loop incondizionato alla riga 2.

Commodore 64, 434 byte

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

Poiché ciò richiede 80 caratteri da mostrare, e il C64 di default è solo 40 caratteri, quindi 40 caratteri dello scrolly sono stampati sulla riga superiore dell'area dello schermo mentre gli altri 40 sono stampati vicino al fondo.

Per chiarire in cosa si {HOME}traducono gli e altri simboli come PETSCII, ecco una schermata presa dal mio emulatore:

Farò una versione completa del golf quando avrò installato CBM PRG Studio (o quando non sarò a pranzo al lavoro).

Rubino, 79 77 caratteri

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

PHP, 136 byte

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

• Chiamalo con la php -f marquee.php hello\ worldstringa di selezione "ciao mondo".
• Per qualche ragione, ho dovuto fare 160 caratteri per la stringa iniziale, altrimenti l'output sarebbe qualcosa di simile hello worlddddddddddddddddddddddddddddddddddddddd, ma passerà attraverso 80 caratteri - spero che conti ancora.

È stata una lunga giornata, probabilmente c'è qualcosa che posso fare per migliorarlo

PHP, 85 byte

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

accetta input dal primo argomento della riga di comando; Corri con-nr .

Inizia a scorrere con il secondo carattere. Aggiungi un byte per iniziare dal primo carattere:
sostituisci =++$i%con %=e ;;con ;;$i++,.