मुझे एक स्क्रॉलिंग मार्की बनाओ

Question

परिचय

80 का गर्जन याद है? मेरा मतलब है, आप जानते हैं, जैसे 30 साल पहले? कोई सेल फोन, कोई इंटरनेट, कोई एटीएम, फ्लोरोसेंट कपड़े (वह क्या था?) और स्क्रॉलिंग मार्की है ! नहीं नहीं नहीं! एलईडी लाइट्स के साथ ऑनलाइन नहीं, बल्कि असली वाले।

चूंकि मैं उदासीन मूड में हूं, इसलिए मैं आपको एक स्क्रॉलिंग मार्की बनाना चाहूंगा।

चुनौती

एक प्रोग्राम बनाएं जहां आप एक पंक्ति स्ट्रिंग दर्ज कर सकते हैं। यदि आवश्यक हो तो पाठ को दोहराते हुए, आपको एक 80 वर्ण चौड़ा स्क्रॉलिंग मार्की बनाने की आवश्यकता है।

नियम

• उपयोगकर्ता को इनपुट के रूप में आपके प्रोग्राम में एक स्ट्रिंग दर्ज करने में सक्षम होना चाहिए। प्रोग्राम चलाते समय स्ट्रिंग एक कमांड लाइन पैरामीटर या एक स्ट्रिंग हो सकती है।
• आपके प्रोग्राम को लगातार 80 (दृश्यमान) वर्णों की एक स्ट्रिंग प्रिंट करनी चाहिए।
• स्ट्रिंग को प्रत्येक 0.1 सेकंड (अधिक या कम; मैं इसे टाइमिंग नहीं करूंगा) अपडेट किया जाना चाहिए, वर्णों को हर पुनरावृत्ति को एक स्थान पर बाईं ओर स्थानांतरित करना।
• स्ट्रिंग "घूमता है"। उपयोगकर्ता द्वारा आपूर्ति की गई स्ट्रिंग के अंत में, स्ट्रिंग का एक और उदाहरण दिखाई देना चाहिए।
• आपको प्रोग्राम को एक पंक्ति में आउटपुट करना होगा, बिना लाइनफीड के ('n' के बजाय '\ r' का उपयोग करें)
• आपका प्रोग्राम उपयोगकर्ता द्वारा बाधित होने तक विज्ञापन इनफ़िनिटम चलाना चाहिए ।
• यह एक कोडगॉल्फ है, इसलिए बाइट्स जीत में सबसे छोटा कोड है।
• एक काली पृष्ठभूमि पर लाल रंग में मुद्रण के लिए 10% बोनस ( अगले पूर्णांक तक गोल ) है।
• मानक खामियां लागू होती हैं।

पायथन 2.7 में संदर्भ कार्यान्वयन

यह कार्यक्रम गोल्फ नहीं है, लेकिन यह एक संदर्भ कार्यान्वयन (और इस प्रकार आकार की एक ऊपरी सीमा) प्रदान करता है।

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)

Comments

@ mbomb007 समान, लेकिन समान नहीं। इसके अलावा यह सवाल ऐसा लगता है कि यह (प्रेरणा के लिए अच्छा है) लेकिन यह कई मामलों में अलग है, मुझे लगता है। इसके अलावा, मुझे स्कोर (कोड लंबाई) काफी निराशाजनक लगा। मुझे लगता है कि हम बेहतर कर सकते हैं!

— agtoever

शायद कोड गोल्फ + लोकप्रियता प्रतियोगिता के रूप में?

— SuperJedi224 19

हम इंतजार करना है वास्तव में 100 एमएस?

— डेनिस

@ अच्छी तरह से, कम या ज्यादा। यह ठीक है अगर आप इसे चार को बचाने के लिए 99 पर सेट करते हैं। मान लीजिए कि अन्य निर्देशों के निष्पादन में 0.01 सेकंड लगेंगे। :-)

— agtoever

यदि इनपुट स्ट्रिंग 80 वर्णों से अधिक है तो क्या होना चाहिए? आपका संदर्भ कार्यान्वयन, और मेरा उत्तर, s []०: १६०] तक पहुंच जाता है और फिर वापस s [० ..] पर जाता है, वे लंबे स्ट्रिंग के अंत को कभी नहीं प्रिंट करते हैं, उदाहरण के लिए 1 2 3 4 5 6 7 8 9 10 11 ... 300लगभग ५६ के बाद कटौती का इनपुट ।

— TessellatingHeckler

Answer 1

सीजेएम, 31 बाइट्स

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

बिल्कुल 100 एमएस के लिए इंतजार कर रहा है।

यह केवल आधिकारिक जावा दुभाषिया के साथ काम करेगा , क्योंकि ऑनलाइन दुभाषिया कार्यक्रम से बाहर निकलने के बाद केवल आउटपुट दिखाता है।

काली पृष्ठभूमि पर लाल पाठ 36 के स्कोर के लिए 40 (या 39) बाइट्स में संभव है:

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

यह काम किस प्रकार करता है

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.

Comments

मुझे संदेह है कि वे इससे कम नहीं आएंगे। बधाई हो!

— agtoever

;स्पष्टीकरण में लगता है कि गलत है

— वेन

@Ven फिक्स्ड, धन्यवाद!

— डेनिस

Answer 2

पावरशेल, 118 113 112 108 102 101 99 96 - 10% = 86

कोड

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

इस चेतावनी के साथ कि यह अब दूसरे चरित्र के साथ पहला लूप शुरू करता है; नियम यह नहीं कहते हैं कि इसे स्ट्रिंग के सामने से शुरू करना है, और पहले वाले को समग्र रूप से शामिल किया गया है, इसलिए यह मेरे द्वारा ठीक है। मैं इसे किसी भी तरह 100 वर्णों तक पहुंचा दूंगा - संपादन: धन्यवाद @ConnorLSW संपादन के लिए इसे 100 से नीचे पाने के लिए।

अनुदेश

1. PowerShell चलाएँ (सामान्य कंसोल, यह PowerShell ISE में काम नहीं करता है)
2. पॉश में सिंगल लाइन संस्करण पेस्ट करें, एंटर दबाएं
3. एक संदेश लिखें, एंटर दबाएं
4. Ctrl-C तोड़ने के लिए

उत्पादन

टिप्पणियाँ

चर नाम और मापदंडों के साथ एक अधिक पठनीय संस्करण थोड़ा भरा:

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

• मापदंडों को केवल अद्वितीय होने के लिए लंबे समय तक पर्याप्त होना चाहिए, इसलिए -F Rउदाहरण के लिए, रेड फोरग्राउंडरकलर स्थापित करने के लिए पर्याप्त अद्वितीय है।
• 'ब्लैक ’को, ब्लू’ की तुलना में अद्वितीय होने के लिए a ब्ला ’होना है, लेकिन -B 0इसे एनुम मान 0 के रंग में सेट करना है जिसे ब्लैक के रूप में व्याख्या किया गया है।

वैकल्पिक, अधिक 'सही' मार्की:

संदर्भ कोड 80 वर्णों से अधिक लंबे तार को संभालता नहीं है, संदेश ~ 160 वर्णों में कुछ भी छोड़ देता है, और यह हर 99 * लेन (स्ट्रिंग) वर्णों को गड़बड़ करता है। उदाहरण के लिए यदि साइन की चौड़ाई 5 वर्ण लंबी थी, तो यह ऐसा करता है:

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

यह संस्करण साइन चौड़ाई के बजाय पाठ की लंबाई को मापता है, इसलिए यह पूरे स्ट्रिंग के माध्यम से चलता है। 106 - 10% = 95 चार्ट।

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

वैकल्पिक: हस्ताक्षर जो प्रश्न में .gif की तरह चक्र करता है, 118-10% = 106

क्योंकि यह बेहतर दिखता है।

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

Comments

मुझे पता है कि यह उत्तर बहुत पुराना है, लेकिन यह प्रश्न अभी सामने Blaहै 0- Write-Hostरंगों की संख्या की व्याख्या करेगा।

— Colsw

@ConnorLSW धन्यवाद, आपको यह 100 वर्णों से नीचे मिला! और मुझे पता नहीं है कि मैंने एक साल पहले आपकी टिप्पणी को क्यों याद किया (!) किसी ने सिर्फ उलाहना दिया और मैं यह देखने के लिए वापस आया कि यह क्या था।

— TessellatingHeckler

कोई चिंता नहीं, मुझे लगता है कि आप कुछ बाइट्स बचाने के while(1)लिए भी बदल सकते हैं for():)

— Colsw

@ConnorLSW तो आप कर सकते हैं, वह भी किया। (मैं शायद अपने अधिकांश गोल्फों में ऐसा कर सकता था, यह ऐसा कुछ नहीं है जिसे मैं सामान्य रूप से सोचता हूं)।

— TessellatingHeckler

आप उपयोग कर रहे हैं for(), तो आप बदल रहा है एक और बाइट बचा सकते हैं $s=(Read-Host)*180;for(){करने के लिएfor($s=(Read-Host)*180){

— क्लिस्टर्स

Answer 3

मतलाब, 76 बाइट्स

मुझे लगता है कि यहाँ अच्छा है कि आप सरणी सूचकांकों के रूप में वैक्टर रख सकते हैं। यह संबंधित सरणी प्रविष्टियों का एक वेक्टर लौटाता है, जो लंबाई के स्वतंत्र रूप से दिए गए स्ट्रिंग को जोड़ना बहुत आसान बनाता है।

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

परिणाम:

Comments

के साथ अच्छी चाल clc। आप जोड़ने के लिए भूल गया 's'मेंinput

— लुइस Mendo

तुम्हारा क्या मतलब है? यह पूरी तरह से ठीक काम करता है क्योंकि यह मैटलैब संस्करण में है जो मेरे पास है (R2010b)।

— दोष

जैसा कि अभी है, आपको स्ट्रिंग को उद्धरण के साथ इनपुट करने की आवश्यकता है। स्ट्रिंग सामग्री सीधे (बिना qoutes) में प्रवेश करने के लिए आपको जरूरत हैa=input('','s')

— लुइस मेंडो सेप

अब मैं देखता हूं, मुझे उस सुविधा के बारे में पता नहीं था। जैसा कि चश्मा को इसकी आवश्यकता नहीं है, मुझे लगता है 'कि इनपुट के रूप में सीमांकित तारों की आवश्यकता ठीक है । कई भाषाओं को एक स्ट्रिंग सीमांकक की आवश्यकता होती है या वे कमांड लाइन तर्क को वाक्य के रूप में (रिक्त स्थान द्वारा अलग किए गए शब्द) वैसे भी कई तर्क के रूप में व्याख्या करेंगे।

— दोष

Answer 4

QBasic, 116 113 बाइट्स - 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

यहाँ कुछ टिप्पणियों के साथ एक स्वरूपित संस्करण है:

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

नोटों की एक जोड़ी:

• मैं नहीं जानता कि क्यों PRINTके बाद FORपाश आवश्यक है। CLSहर बार कर्सर को ऊपरी बाएँ कोने में रीसेट करना चाहिए। लेकिन QB64 पर, कम से कम, अगर मैंने अतिरिक्त नहीं डाला PRINT, तो मार्की पहले के बजाय दूसरी पंक्ति पर समाप्त होता है। अगर किसी ने QBasic को DosBox या somesuch पर स्थापित किया है, तो मुझे यह जानने में दिलचस्पी होगी कि क्या वही बात वहां होती है या यदि यह QB64 बग है।
• कोड में एक छोटी गड़बड़ है क्योंकि यह TIMERदेरी के लिए (आधी रात के बाद से सेकंड की संख्या) पर निर्भर करता है । यदि कोड आधी रात को चल रहा है, तो मार्की अटक TIMERजाएगा क्योंकि इसके बाद रीसेट हो जाएगा 0और tउसके बाद हमेशा कम होगा।

Comments

मेरी पहली भाषा! IIRC, QB 4.5 में, एक मुद्रित स्ट्रिंग के अंत में एक अर्धविराम का मतलब है कि PRINT स्टेटमेंट एक गाड़ी वापसी को प्रिंट नहीं करता है।

— bgStack15

@ bgStack15 मेरा भी। : ^ D मुद्दा वास्तव में नहीं है, PRINTलेकिन इसके साथ - CLSइसके बाद CLS, कोई बात नहीं जो पहले छपी थी, अगला PRINTविवरण 1,1 पर आउटपुट होना चाहिए; लेकिन इसके बजाय, मैं एक ऐसी स्थिति में भाग गया, जहां यह 2,1 पर आउटपुट था।

— DLosc

Answer 5

पर्ल, 99 98 बाइट्स (-10% = 89)

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

कमांड लाइन पैरामीटर से इसका इनपुट लेता है।

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

Answer 6

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

दुभाषिया ध्वज के लिए +3 बाइट्स 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]}

एक बहुत ही भयानक स्कोर, लेकिन यह देखते हुए कि इस भाषा में कुछ भी करना कितना कठिन है, यह बदतर हो सकता है। इस उत्तर का अनुपात (बाइट्स लाल पाठ पाने के लिए इस्तेमाल किया जाता है) (लाल पाठ होने से बोनस) वास्तव में अच्छा है, पूरे आउटपुट को cशुरुआत में ही लाल कर दिया जाता है !

प्रत्येक टिक के बीच का समय इनपुट स्ट्रिंग की लंबाई के आधार पर भिन्न होता है लेकिन यह लगभग 0.1 सेकंड है।

वैसे, इस प्रोग्राम का आउटपुट कुल कचरा जैसा दिखता है क्योंकि दुभाषिया इतना खराब है। प्रत्येक मिलीसेकंड यह टर्मिनल को साफ करता है और सब कुछ फिर से बनाता है, इसलिए यह वास्तव में चंचल हो जाता है।

टिप्पणियों के साथ:

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
}

Answer 7

पर्ल - 120 बाइट्स (-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}}

Answer 8

मतलाब, 8188 * .9ab = 170

यह Matlab संस्करण R2014b या उच्चतर में काम करता है। परिणाम एक आंकड़ा विंडो पर दिखाया गया है।

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

निम्नलिखित उदाहरण में , पाठ को बेहतर विज़ुअलाइज़ेशन के लिए बोल्डफेस में टाइप किया गया है (उपरोक्त कोड में नहीं किया गया है क्योंकि इसमें कुछ बाइट्स खर्च होते हैं)। यह भी ध्यान दें कि जीआईएफ एनीमेशन की गति आवश्यक 0.1 एस ठहराव के अनुरूप नहीं है, लेकिन कार्यक्रम चलाकर दिखाए गए वास्तविक आंकड़े में समय सही है।

Answer 9

स्पेकबास, 130 बाइट्स (-10% = 117)

इसे 80 या अधिक वर्ण बनाने के लिए मूल स्ट्रिंग को गुणा करता है, फिर इसे 80 तक काटता है।

TEXTSpecBAS में एक कमांड है जो उसी तरह काम करता है PRINT(जैसे इस उदाहरण में) लेकिन एक चरित्र को बचाता है।

SCALEआदेश कोड करने के लिए कुछ अतिरिक्त वर्ण लेता है, लेकिन बनाता है यह देखने के लिए और अधिक मार्की-ish।

कार्यक्रम तब तक चलता रहता है जब तक आप 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

Answer 10

पर्ल, 63 (70 चार्ट - बोनस के लिए 10%)

दूसरों के लिए बहुत अलग समाधान नहीं है, लेकिन मैंने अपना समय बर्बाद कर दिया है, इसलिए मैंने सोचा कि मैं इसे भी पोस्ट करूंगा!

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

एएनएसआई कोड के लिए यूनिक्स-संगत टर्मिनल और कोरुटिल के लिए कॉल पर निर्भर करता है sleep। \x..उपरोक्त दो चार्ट वास्तव में एक शाब्दिक पंक्ति-फ़ीड हैं और इस हेक्स डंप के अनुसार एस्केप चार:

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`

Answer 11

रूबी, 79 76 75 बाइट्स

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

मैं अभी भी माणिक विशेषज्ञ नहीं हूं, संभवतः नीचे गोल्फ हो सकता है।

लाल और काले समान स्कोर के साथ:

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

Answer 12

पर्ल, 84 बाइट्स (- 10% = 76)

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

यह एक कमांड लाइन तर्क लेता है जो मार्की में पाठ है।

स्पष्टीकरण:

1. पाठ और स्टोर करने के लिए 80 रिक्त स्थान तैयार करें $_
2. प्रिंट बैकस्पेस ( \b) और एक स्पेस ( )। यह पिछले वर्ण को पिछले प्रिंट से निकाल देता है। फिर गाड़ी की वापसी और रंग प्रिंट करें।
3. पाठ के 80 अक्षरों को स्थिति से प्रिंट करें $p
4. $p = ($p+1) % length of text
5. 0.1 सेकंड के लिए सो जाओ

Answer 13

बैश, 121 बाइट्स

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

Answer 14

पायथन 3, 96 बाइट्स

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

यह केवल उन टर्मिनलों पर काम करेगा जो एएनएसआई से बचने के क्रम का समर्थन करते हैं। यदि आप विंडोज पर हैं, तो ansicon ट्राय करें ।

flushपायथन 3 में कीवर्ड के लिए हुर्रे , इसलिए हमें एक महंगी sys.stdout.flush()कॉल करने की आवश्यकता नहीं है ।

Answer 15

सी, 293 269 ​​बाइट्स

(पठनीयता के लिए नई कड़ियाँ जोड़ी गईं)

यह ईओएफ द्वारा समाप्त मानक इनपुट से इनपुट लेता है; इसलिए एक स्ट्रिंग, एक नई रेखा और फिर EOF (जैसे, 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);
}

Answer 16

स्माइलबेसिक बिग, 79 बाइट्स

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

मेरे पास एक अच्छा चित्रमय समाधान था जब मुझे एहसास हुआ कि इसे एक बार में 1 पूरे चरित्र को स्क्रॉल करना है।

Answer 17

जेली , 20 19 18 बाइट्स

• -1 पहले की जगह बाइट 80द्वारा ⁹(= 256) से गुणा किया है क्योंकि यह है कि कम से कम 80
• -1 बाइट को अनंत लूप को Çß(से Ç1¿) में बदलकर ।

---

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

@ डेनिस के कुछ ट्रिक्स के साथ यहां जवाब दें । जेली चुनौती से नई है, लेकिन वास्तव में इसके लिए विशेष रूप से अनुरूप नहीं है। सुधार करने के तरीके पर सुझाव का स्वागत है! यदि आपका कंसोल utf-8 में है, तो export LC_ALL=en_USप्रयास करने से पहले चलाएं या समान।

उदाहरण

व्याख्या

ẋ⁹ḣ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).

Answer 18

LOVE2D लुआ, 197-10% = 178 बाइट्स

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

रूट में 'tt' नामक फ़ाइल में इनपुट की आवश्यकता होती है, इस प्रकार स्कोर में 3 अतिरिक्त बाइट्स जोड़े गए।

कार्यक्षमता में वास्तव में बुनियादी, सिर्फ 80 पुनरावृत्तियों के पाश के लिए, I के सूचकांक में चरित्र को जोड़ते हैं और वर्तमान समय में सेकंड में वर्तमान स्ट्रिंग की लंबाई द्वारा संग्राहक होते हैं, इनपुट के दोहराया 80 वर्ण लंबे स्ट्रिंग देते हैं, जो शिफ्ट छोड़ दिया जाता है जैसे समय बीतता है।

मैंने हंसी के लिए LOVE2D का इस्तेमाल किया।

Answer 19

Sinclair ZX81 / Timex TS1000 / 1500 बुनियादी, 110 बाइट्स 182 बाइट्स (लिस्टिंग के लिए)

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

यह लाइन 2 में स्क्रीन स्थिति 0,0 पर स्ट्रिंग के पहले 32 80 वर्णों को प्रिंट करके काम करता है A$, और फिर लाइन 3 में स्टिंग की स्थिति 2 से अंत तक स्ट्रिंग में हेरफेर करता है (सिनक्लेयर ZX81 बेसिक इंडेक्स 1 से तार और शून्य नहीं ), इसलिए पहले चरित्र को अंत तक जोड़ना और इसे A$चर में वापस भेजना; फिर पंक्ति 2 में बिना शर्त लूप है।

Answer 20

कमोडोर 64, 434 बाइट्स

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

जैसा कि दिखाने के लिए 80 वर्णों की आवश्यकता होती है, और C64 डिफ़ॉल्ट रूप से केवल 40 वर्णों की होती है, तब स्क्रेली के 40 वर्ण स्क्रीन क्षेत्र की शीर्ष रेखा पर मुद्रित होते हैं, जबकि अन्य 40 नीचे की ओर मुद्रित होते हैं।

यह स्पष्ट करने के लिए कि {HOME}PETSCII के रूप में क्या और अन्य प्रतीकों का अनुवाद किया गया है, यहाँ मेरे एमुलेटर से लिया गया स्क्रीन ग्रैब है:

जब मैं सीबीएम पीआरजी स्टूडियो स्थापित हो जाता हूं (या जब मैं काम पर दोपहर के भोजन पर नहीं होता) तो मैं एक पूर्ण गोल्फ-संस्करण करूंगा।

Answer 21

रूबी, 79 77 चार्ट

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

Answer 22

PHP, 136 बाइट्स

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

• इसके साथ बुलाओ php -f marquee.php hello\ world "हेल्लो वर्ल्ड" स्ट्रिंग को मार्की करने के लिए कहें।
• किसी कारण के लिए, मुझे प्रारंभिक स्ट्रिंग के लिए 160 अक्षर करने थे, अन्यथा आउटपुट कुछ ऐसा होगा hello worlddddddddddddddddddddddddddddddddddddddd, लेकिन यह केवल 80 वर्णों के माध्यम से लूप होगा - मुझे उम्मीद है कि अभी भी मायने रखता है।

यह एक लंबा दिन रहा है, शायद कुछ ऐसा है जो मैं इसे सुधार सकता हूं

Answer 23

PHP, 85 बाइट्स

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

पहली कमांड लाइन तर्क से इनपुट लेता है; साथ चलाना -nr।

दूसरे चरित्र के साथ स्क्रॉल करना शुरू करता है। पहले चरित्र में शुरू करने के लिए एक बाइट जोड़ें: साथ और साथ
बदलें ।=++$i%%=;;;;$i++,