Wprowadzenie

Pamiętasz ryczące lata 80-te? Mam na myśli, wiesz, jak 30 lat temu? Bez telefonów komórkowych, bez internetu, bez bankomatów, fluorescencyjne ubrania (co to było ?!) i przewijane markizy ! Nie nie nie! Nie online, ale prawdziwe, ze światłami LED.

Ponieważ jestem w nostalgicznym nastroju, chciałbym, żebyś stworzył przewijany namiot.

Wyzwanie

Utwórz program, w którym możesz wprowadzić ciąg jednego wiersza. Program musi utworzyć markizę przewijającą o szerokości 80 znaków, w razie potrzeby powtarzając tekst.

Zasady

• Użytkownik musi mieć możliwość wprowadzenia ciągu znaków do programu jako danych wejściowych. Ciąg może być parametrem wiersza poleceń lub ciągiem wprowadzonym podczas działania programu.
• Twój program musi stale drukować ciąg dokładnie 80 (widocznych) znaków.
• Ciąg musi być aktualizowany co 0,1 sekundy (mniej więcej; nie będę go mierzył w czasie), przesuwając znaki co każdą iterację o jedną pozycję w lewo.
• Ciąg „obraca się”. Na końcu łańcucha podanego przez użytkownika musi pojawić się kolejne wystąpienie łańcucha.
• Musisz program wydrukować jego wynik w jednym wierszu, bez wysuwu wierszy (użyj „\ r” zamiast „\ n”)
• Twój program musi działać ad infinitum , dopóki użytkownik nie przerwie.
• To jest codegolf, więc wygrywa najkrótszy kod w bajtach.
• Jest 10% premii (w zaokrągleniu do góry do najbliższej liczby całkowitej) do drukowania w kolorze czerwonym na białym tle.
• Obowiązują standardowe luki.

Implementacja referencji w Pythonie 2.7

Ten program nie jest golfem, ale zapewnia implementację referencyjną (a zatem górną granicę wielkości).

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 bajtów

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

Czeka dokładnie 100 ms.

Będzie to działać tylko z oficjalnym interpreterem Java , ponieważ interpreter online wyświetla dane wyjściowe tylko po wyjściu z programu.

Czerwony tekst na czarnym tle jest możliwy w 40 (lub 39) bajtach, co daje wynik 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

Jak to działa

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, 118 113 112 108 102 101 99 96 - 10% = 86

Kod

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

Z zastrzeżeniem, że teraz zaczyna się pierwsza pętla z drugą postacią; Reguły nie mówią, że musi zaczynać się od przodu sznurka, a pierwsza jest ogólnie włączona, więc nie mam nic przeciwko. Jakoś dostanę go do 100 znaków - edytuj: dzięki @ConnorLSW za zmiany, aby uzyskać go poniżej 100.

Instrukcje

1. Uruchom PowerShell (normalna konsola, nie działa w PowerShell ISE)
2. Wklej wersję jednowierszową do PoSH, naciśnij enter
3. Wpisz wiadomość i naciśnij enter
4. Ctrl-C, aby przerwać

Wynik

Notatki

Bardziej czytelna wersja z nieco zmienionymi nazwami i parametrami zmiennych:

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

• Parametry muszą być wystarczająco długie, aby były unikalne, więc -F Rsą wystarczająco wyjątkowe, aby na przykład ustawić czerwony kolor pierwszego planu.
• „Czarny” musi być „Bla”, aby był unikalny w porównaniu z „Niebieskim”, ale -B 0ustawia kolor na wartość Enum 0, która jest interpretowana jako czarna.

Alternatywna, bardziej „poprawna” markiza:

Kod referencyjny nie obsługuje ładnie ciągów dłuższych niż 80 znaków, pomijając wszystko w wiadomości przekraczającej ~ 160 znaków, i resetuje usterkę co 99 * len (ciąg) znaków. np. jeśli szerokość znaku wynosiła 5 znaków, robi to:

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

Ta wersja indeksuje modulo długość tekstu zamiast szerokości znaku, więc biegnie przez cały ciąg. 106 - 10% = 95 znaków.

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

Alternatywnie: znak, który cykli jak .gif w pytaniu, 118-10% = 106

Ponieważ wygląda lepiej.

$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 bajtów

Uważam, że miło jest, że wektory mogą mieć indeksy tablicowe. Zwraca wektor odpowiadających pozycji tablicy, co bardzo ułatwia dołączenie danego ciągu niezależnie od długości.

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

Wynik:

QBasic, 116 113 bajtów - 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

Oto sformatowana wersja z kilkoma komentarzami:

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

Kilka uwag:

• Nie wiem, dlaczego konieczna jest pętla PRINTpo FOR. CLSpowinien za każdym razem resetować kursor do lewego górnego rogu. Ale przynajmniej na QB64, jeśli nie dodam dodatkowego PRINT, markiza kończy się na drugiej linii zamiast pierwszej. Jeśli ktoś ma skonfigurowane QBasic na DosBox lub coś takiego, chciałbym wiedzieć, czy to samo się tam dzieje, czy jest to błąd QB64.
• Kod ma małą usterkę, ponieważ polega na TIMER(opóźnieniu od liczby sekund od północy). Jeśli kod działa o północy, markiza utknie, ponieważ TIMERresetuje się 0i zawsze będzie mniejsza niż tpóźniej.

Perl, 99 98 bajtów (-10% = 89)

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

Pobiera dane wejściowe z parametru wiersza polecenia.

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

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

+3 bajty dla flagi interpretera 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]}

Całkiem okropny wynik, ale biorąc pod uwagę, jak trudno jest zrobić coś w tym języku, mogłoby być gorzej. Stosunek tej odpowiedzi do (bajtów używanych do uzyskania czerwonego tekstu) do (premia z posiadania czerwonego tekstu) jest naprawdę dobry, całe wyjście zmienia kolor na czerwony z csamym początkiem!

Czas między każdym tikiem różni się w zależności od długości ciągu wejściowego, ale wynosi około 0,1 sekundy.

Nawiasem mówiąc, dane wyjściowe tego programu wyglądają jak śmieci, ponieważ interpreter jest tak zły. Co milisekundę czyści terminal i przerysowuje wszystko, więc robi się naprawdę migotliwy.

Z komentarzami:

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 bajtów (-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

Działa to w wersji Matlab R2014b lub nowszej. Wynik jest pokazany w oknie figury.

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

W poniższym przykładzie tekst jest pogrubiony dla lepszej wizualizacji (nie zrobiono tego w powyższym kodzie, ponieważ kosztuje on kilka bajtów). Należy również zauważyć, że szybkość animacji GIF nie odpowiada wymaganej pauzie 0,1 s, ale taktowanie jest prawidłowe na rzeczywistym rysunku pokazanym przez uruchomienie programu.

SpecBAS, 130 bajtów (-10% = 117)

Mnoży oryginalny ciąg, aby uzyskać 80 lub więcej znaków, a następnie przycina go dokładnie do 80.

TEXT to polecenie w SpecBAS, które działa tak samo jak PRINT (w tym przykładzie), ale zapisuje jeden znak.

SCALEPolecenie dodaje kilka dodatkowych znaków w kodzie, ale sprawia, że wyglądają bardziej markizy-dosyć.

Program trwa do momentu naciśnięcia klawisza 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 znaków - 10% na bonus)

Nie jest to zupełnie inne rozwiązanie od pozostałych, ale zmarnowałem czas na tworzenie, więc pomyślałem, że też to opublikuję!

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

Opiera się na terminalu kompatybilnym z Uniksem dla kodów ANSI i wywołaniu coreutils sleep. Dwa \x..znaki powyżej są dosłownie dosuwane do wiersza i znaku ucieczki zgodnie z tym zrzutem heksów:

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`

Rubinowy, 79 76 75 bajtów

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

Nadal nie jestem ekspertem od rubinów, prawdopodobnie można grać w golfa.

Z czerwonym i czarnym tym samym wynikiem:

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

Perl, 84 bajtów (- 10% = 76)

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

Pobiera argument wiersza poleceń, który jest tekstem w namiocie.

Wyjaśnienie:

1. Dodaj do tekstu 80 spacji i zapisz $_
2. Wydrukuj backspace ( \b) i spację ( ). To usuwa ostatni znak z poprzedniego wydruku. Następnie wydrukuj zwrot karetki i kolor.
3. Wydrukuj 80 znaków tekstu z pozycji $p
4. $p = ($p+1) % length of text
5. Śpij przez 0,1 sekundy

bash, 121 bajtów

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 bajtów

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

Działa to tylko na terminalach obsługujących sekwencje specjalne ANSI. Jeśli korzystasz z systemu Windows, spróbuj ansicon .

Hurra za flushsłowo kluczowe w Pythonie 3, więc nie musimy wykonywać drogich sys.stdout.flush()połączeń.

C, 293 269 ​​bajtów

(Dodano nowe linie dla czytelności)

Pobiera to dane ze standardowego wejścia zakończonego przez EOF; więc najlepiej wpisać ciąg, nowy wiersz, a następnie EOF (np. 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);}}}

Nie golfowany:

#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 bajtów

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

Miałem dobre rozwiązanie graficzne, prawie gotowe, kiedy zdałem sobie sprawę, że musi przewijać 1 całą postać na raz.

Galaretka , 20 19 18 bajtów

• -1 bajt, zastępując pierwszy 80przez ⁹(= 256), ponieważ należy go pomnożyć przez co najmniej 80
• -1 bajt, zmieniając nieskończoną pętlę na Çß(z Ç1¿).

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

Kilka sztuczek z odpowiedzi @Dennis tutaj . Galaretka jest nowsza niż wyzwanie, ale nie jest specjalnie do niej dostosowana. Sugestie dotyczące poprawy są mile widziane! Jeśli twoja konsola jest w utf-8, uruchom export LC_ALL=en_USlub podobnie przed próbą.

Przykład

Wyjaśnienie

ẋ⁹ḣ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 bajtów

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

Wymaga, aby dane wejściowe znajdowały się w pliku o nazwie „tt” w katalogu głównym, dlatego do oceny dodano 3 dodatkowe bajty.

Niezwykle podstawowa funkcjonalność, tylko w pętli for 80 powtórzeń, dołącza znak o indeksie i plus bieżący czas w sekundach modulowany długością bieżącego ciągu, dając powtarzający się ciąg znaków o długości 80 znaków, który przesuwa się w lewo w miarę upływu czasu.

Użyłem LOVE2D do śmiechu.

Sinclair ZX81 / Timex TS1000 / 1500 BASIC, 110 bajtów 182 bajty (dla wpisu)

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

Działa, drukując pierwsze 32 80 znaków ciągu A$w pozycji ekranu 0,0 w drugim wierszu, a następnie manipulując ciągiem od pozycji 2 do końca żądła w wierszu 3 (Sinclair ZX81 BASIC indeksuje ciągi od 1, a nie zero ), dlatego dodając pierwszy znak na końcu i przekazując go z powrotem do A$zmiennej; wtedy jest bezwarunkowa pętla z powrotem do linii 2.

Commodore 64, 434 bajty

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

Ponieważ wymaga to 80 znaków do wyświetlenia, a C64 domyślnie ma tylko 40 znaków, wówczas 40 znaków przewijania jest drukowanych w górnej linii obszaru ekranu, a pozostałe 40 są drukowane blisko dołu.

Aby wyjaśnić, co {HOME}oznaczają te i inne symbole jako PETSCII, oto zrzut ekranu pobrany z mojego emulatora:

Zrobię pełną wersję gry w golfa, gdy zainstaluję CBM PRG Studio (lub gdy nie będę na lunchu w pracy).

Ruby, 79 77 znaków

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

PHP, 136 bajtów

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

• Zadzwoń za pomocą php -f marquee.php hello\ world ciągiem „hello world”.
• Z jakiegoś powodu musiałem zrobić 160 znaków dla początkowego ciągu, w przeciwnym razie wynik byłby podobny hello worlddddddddddddddddddddddddddddddddddddddd, ale będzie przechodził tylko przez 80 znaków - mam nadzieję, że nadal się liczy.

To był długi dzień, prawdopodobnie mogę coś zrobić, aby to poprawić

PHP, 85 bajtów

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

pobiera dane wejściowe z argumentu pierwszego wiersza poleceń; biegać z -nr.

Rozpoczyna przewijanie z drugim znakiem. Dodaj jeden bajt, aby rozpocząć od pierwszego znaku:
Wymień =++$i%się %=i ;;z ;;$i++,.