जन्मदिन मुबारक हो, रैफेल सेको!

33

रैफेल सेको एक प्रोग्रामर है जिसने अस्सी के दशक के अंत में ZX स्पेक्ट्रम कंप्यूटर के लिए कुछ बेहतरीन वीडियो गेम का उत्पादन किया था। दूसरों के बीच, उन्होंने अत्यधिक प्रशंसित साइबरनॉयड और एक्सोलॉन विकसित किया ।

राफेल 10 मई 2017 को 50 साल का हो रहा है । यह चुनौती उनके लिए एक छोटी सी श्रद्धांजलि है, उन खुश घंटों के लिए जो हममें से कई लोगों ने उन भयानक खेलों को खेलने में बिताए, और प्रेरणा के लिए।

चुनौती

उद्देश्य एक आयताकार मार्की का निर्माण करना है जो साइबरनॉइड की मुख्य मेनू स्क्रीन में देखा गया है , लेकिन ASCII कला में।

विशेष रूप से, स्ट्रिंग "Happy birthday Raffaele Cecco "(अंतिम स्थान पर ध्यान दें) को स्नैपशॉट के बीच एक स्थिर ठहराव समय के साथ 12 × 5 आयत के किनारों के साथ घूमते हुए दिखाया जाएगा।

उदाहरण के लिए, यह मानते हुए कि पाठ को दक्षिणावर्त और घुमाया हुआ काउंटर-क्लॉकवाइज़ (नीचे दिए गए विकल्प देखें) प्रदर्शित किया गया है, यहाँ आयताकार मार्की के लगातार तीन स्नैपशॉट हैं:

Happy birthd
           a
o          y
c           
ceC eleaffaR

फिर

appy birthda
H          y

o          R
cceC eleaffa

फिर

ppy birthday
a           
H          R
           a
occeC eleaff

और इसी तरह।

नियम

कोई इनपुट नहीं लिया जाएगा। आउटपुट STDOUT या समकक्ष के माध्यम से, या एक ग्राफिकल विंडो में होगा।

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

निम्नलिखित विकल्प स्वीकार किए जाते हैं:

  • पाठ को दक्षिणावर्त या प्रति-दक्षिणावर्त प्रदर्शित किया जा सकता है, और इसे दक्षिणावर्त या प्रति-दक्षिणावर्त घुमाया जा सकता है (उदाहरण क्लॉकवाइज़ प्रदर्शन और काउंटर-क्लॉकवाइज़ घूर्णन से ऊपर का चित्रण)।
  • रोटेशन को अनंत लूप में चक्र पर जाना चाहिए (जब तक कि कार्यक्रम बंद नहीं किया जाता है), और किसी भी चरण में शुरू हो सकता है।
  • स्नैपशॉट के बीच ठहराव का समय लगभग स्थिर होना चाहिए, लेकिन स्वतंत्र रूप से 0.1 और 1 एस के बीच चुना जा सकता है। पहला स्नैपशॉट प्रदर्शित करने से पहले एक प्रारंभिक विराम स्वीकार्य है।
  • पत्र ऊपरी-मामले, निचले-मामले या मिश्रित मामले (जैसा कि ऊपर उदाहरण में) हो सकता है।
  • खाली स्थान की ओर जाने या पीछे जाने की अनुमति है।

प्रोग्राम या फ़ंक्शंस की अनुमति है, किसी भी प्रोग्रामिंग भाषा में । मानक खामियों को मना किया जाता है।

यदि संभव हो, तो कृपया आउटपुट दिखाने के लिए gif फ़ाइल प्रदान करें, या प्रोग्राम का परीक्षण करने के लिए लिंक।

बाइट्स में सबसे छोटा कोड जीतता है।

code-golf  string  ascii-art 
— लुइस मेंडो
स्रोत
4
क्या होगा अगर यह अधिलेखित करना असंभव है? क्या हम 99 लाल गुब्बारे का उपयोग कर सकते हैं ... newlines?
— टाइटस
@ टिट्स केवल अगर वह प्रभावी रूप से स्क्रीन को साफ करता है और चलती पाठ की छाप देता है (जीआईएफ कृपया!)
— लुइस मेंडू
"यह किसी भी तरह से किया जा सकता है, उदाहरण के लिए, स्क्रीन को प्रभावी ढंग से साफ़ करने के लिए नई संख्याओं की उचित संख्या लिखकर।" - क्या यह कंसोल साइज़ पर निर्भर नहीं है? क्या यह एक नईलाइन प्रिंट करना स्वीकार्य है अगर यह (अगली आयत के साथ) का अर्थ है कि अगला पुनरावृत्ति पिछले एक (मेरे छोटे कंसोल में) को बदल देता है ?
— जोनाथन एलन
1
@ जोनाथन ओके, बस प्रभाव को देखने के लिए उस कंसोल के साथ एक जिफ प्रदान करें
— लुइस मेंडू

जवाबों:

8

जेली , 74  65 बाइट्स

“ÆÇÐÑ÷øœ‘Ṭœṗ⁸ṙ©-¤4421œ?U0¦;"⁷,⁶ẋ⁵¤¤ṁ9¤ȮœS.®ß
“9ɲcḟ#%⁴1t(ŀȷUCOw⁾»Ç

विंडोज संस्करण 6 लाइन उच्च cp-65001 कंसोल में चल रहा है।
पुनरावृत्तियों के बीच एक आधा सेकंड (प्लस मूल्यांकन) विराम है:

आउटपुट का gif

कैसे?

“9ɲcḟ#%⁴1t(ŀȷUCOw⁾»Ç - Main link: no arguments
“9ɲcḟ#%⁴1t(ŀȷUCOw⁾»  - compression of [d( Happy)+d( birthday)+d( Raff)+s(aele)+d( Ce)+d(cc)+s(o)] - d=dictionaryLookup, s=stringEncode.
                     -              = " Happy birthday Raffaele Cecco"
                   Ç - call last link (1) as a monad

“ÆÇÐÑ÷øœ‘Ṭœṗ⁸ṙ©-¤4421œ?U0¦;"⁷,⁶ẋ⁵¤¤ṁ9¤ȮœS.®ß - Link 1, rotate, print, recurse: string s
                ¤                            - nilad followed by link(s) as a nilad:
            ⁸                                -   link's left argument (initially s)
               -                             -   literal -1
             ṙ                               -   rotate left -1 (e.g. "blah" -> "hbla")
              ©                              -   copy to register and yield
“ÆÇÐÑ÷øœ‘                                    - literal: [13,14,15,16,28,29,30]
         Ṭ                                   - untruth: [0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1]
          œṗ                                 - partition right at truthy indexes of left
                                             -   chops up the rotated string into 8
                                             -   e.g. [" Happy birth",'d','a','y'," Raffaele Ce",'c','c','o'])
             4421œ?                          - get the 4421st permutation of those items
                                             -   e.g. [" Happy birth",'o','d','c','a','c','y'," Raffaele Ce"]
                         ¦                   - apply to indexes:
                        0                    -   0 (right most)
                       U                     -   upend  (e.g. " Raffaele Ce" -> "eC eleaffaR ")
                                     ¤       - nilad followed by link(s) as a nilad:
                                  ¤          -   nilad followed by link(s) as a nilad:
                                 ¤           -     nilad followed by link(s) as a nilad:
                              ⁶              -       literal space
                                ⁵            -       literal 10
                               ẋ             -       repeat: "          "
                            ⁷                -     literal new line
                             ,               -     pair: ['\n',"          "]
                                     9       -   literal 9
                                    ṁ        -   mould like: ['\n',"          ",'\n',"          ",'\n',"          ",'\n',"          ",'\n']
                           "                 - zip with:
                          ;                  -   concatenation
                                             -     e.g. [" Happy birth\n","o          ","d\n","c          ","a\n","c          ","y\n","eC eleaffaR           ","\n"])
                                      Ȯ      - print and yield
                                         .   - literal 0.5
                                       œS    - after sleeping right seconds yield left
                                          ®  - recall value from register (s rotated by 1)
                                           ß - call this link (1) with the same arity (as a monad)
— जोनाथन एलन
स्रोत
16

HTML + ES6, 200 बाइट्स

<pre id=o><script>setInterval(_=>o.innerHTML=(f=k=>k--?f(k)+(k<11?s[k]:k>47?s[74-k]:k%12?++k%12?' ':s[10+k/12]+`
`:s[30-k/12]):'')(60,s=s.slice(1)+s[0]),99,s="Happy birthday Raffaele Cecco ")</script>
स्निपेट का विस्तार करें

— Arnauld
स्रोत
ये बहुत अच्छा दिखता है!
— लुइस मेंडू
@LuisMendo जो यादें वापस लाता है, हालांकि मुझे साइबरनॉइड II पहले से बेहतर याद है। मुझे यकीन है कि मैंने इस प्रभाव को क्रैपट्रोस के एक जोड़े में भी देखा है। ;-)
— अर्नुलद
हां, मैंने दूसरा :-)
— लुइस मेंडू
11

जेडएक्स स्पेक्ट्रम बेसिक, 187 बाइट्स

एनायड ने कहा कि फिलिप ने मुझे कुछ मिनटों के लिए हरा दिया :-) नंबर अनपेक्षित\{15} कंट्रोल कोड हैं - अगर आप टिंकर करना चाहते हैं तो ज़मेकबा के साथ संकलित करें । ध्यान दें कि पूर्ण आयत तुरंत मुद्रित नहीं होती है, लेकिन यह पहले कुछ फ़्रेमों के बाद आती है।

1 let a$=" Happy birthday Raffaele Cecco":dim b$(code"\{15}"):dim c$(pi*pi)
3 let b$=a$(sgn pi)+b$:let a$=a$(val"2" to)+a$(sgn pi):print "\{0x16}\{0}\{0}";a$(to code"\{12}")'b$(sgn pi);c$;a$(val"13")'b$(val"2");c$;a$(code"\{14}")'b$(pi);c$;a$(len b$)'b$(val"4" to):go to pi

इसे यहां आज़माएं (ऑनलाइन JS-emulated version, press enter to start) ... http://jsspeccy.zxdemo.org/cecco/

आप एक PRINT AT करने के बजाय फ्रेम के बीच स्क्रीन को साफ करके चार बाइट्स बचा सकते हैं, लेकिन इसके लायक होने के लिए यह बहुत ही चंचल है ...

1 let a$=" Happy birthday Raffaele Cecco":dim b$(code"\{15}"):dim c$(pi*pi)
3 let b$=a$(sgn pi)+b$:let a$=a$(val"2" to)+a$(sgn pi):cls:print a$(to code"\{12}")'b$(sgn pi);c$;a$(val"13")'b$(val"2");c$;a$(code"\{14}")'b$(pi);c$;a$(len b$)'b$(val"4" to):go to pi
— गैस-पाइपलाइन करनेवाला
स्रोत
1
आह, लेकिन आप बहुत सारे बाइट्स जीतते हैं :-)
— फिलिप केंडल
2
PPCG में आपका स्वागत है!
— मार्टिन एंडर
1
खेल में आपका स्वागत है। ZX देखने में हमेशा अच्छा होता है। अच्छा जवाब। +1।
— एलपेड्रो
10

वी, 75 71 70 बाइट्स

4 बाइट्स ने @DJMcMayhem को धन्यवाद दिया

iHappy birthd
±± a
o±° y
c±± 
ceC eleaffaR6ògÓÉ {dêjP2Ljjx1Lp5LxkpGd

यहां एक TIO लिंक दिया गया है, लेकिन ध्यान दें कि यह TIO पर काम नहीं करेगा क्योंकि यह प्रोग्राम अनंत रूप से चलता है। इसे ऑनलाइन आज़माएं!

चूँकि इस कोड में unprintables होते हैं, यहाँ एक हेक्सडम्प है।

00000000: 6948 6170 7079 2062 6972 7468 640a b1b1  iHappy birthd...
00000010: 2061 0a6f b1b0 2079 0a63 b1b1 200a 6365   a.o.. y.c.. .ce
00000020: 4320 656c 6561 6666 6152 1b36 f267 d3c9  C eleaffaR.6.g..
00000030: 207b 64ea 6a50 324c 166a 6a78 314c 7035   {d.jP2L.jjx1Lp5
00000040: 4c78 6b70 4764                           LxkpGd

सोने का समय 500 मिली सेकंड है।

giffy

— क्रिकटी लिथोस
स्रोत
क्या आप TIO लिंक दे सकते हैं?
— R
कुछ सुझाव (सभी परीक्षण नहीं): H|-> {। <C-v>êx-> dê, और 5L->}
— DJMcMayhem
के बीच तीन लाइनों को बदलने: इसके अलावा, आपके repchar आदेश सभी 9 जब आप 10 या 11. उदाहरण के लिए इस्तेमाल कर सकते हैं का उपयोग कर रहे ±± a, o° yऔरc±±<space>
— DJMcMayhem
@DJMcMayhem सब कुछ काम करता है लेकिन 5L=> }।
— कृति लिथोस
@ रिकर हो गया, लेकिन ध्यान दें कि TIO लिंक एनीमेशन नहीं दिखा सकता है
— Kritii Lithos
9

जेडएक्स स्पेक्ट्रम बेसिक, 274 बाइट्स

खैर, किसी को यह करना था। बालकों को यह बहुत धीमा होने और एनिमेशन के बीच कोई ठहराव नहीं होने के कारण अयोग्य घोषित करने की इच्छा हो सकती है, लेकिन मैं एक विशेष मामले का दावा कर रहा हूं :-)

10 LET m$=" Happy birthday Raffaele Cecco": LET o=0: LET l=LEN m$: LET f=4: LET t=12: LET a=t+f: LET b=27
20 FOR j=SGN PI TO l: LET i=j+o: IF i>l THEN LET i=i-l
40 LET x=(i-SGN PI AND i<=t)+(11 AND i>t AND i<=a)+(b-i AND i>a AND i<=b)
50 LET y=(i-t AND i>t AND i<=a)+(f AND i>a AND i<=b)+(b+f-i AND i>b): PRINT AT y,x;m$(j): NEXT j
80 LET o=o+SGN PI: IF o>=l THEN LET o=o-l
90 GO TO t

बहुत गोल्फ भी नहीं है। 274 बाइट्स इस प्रोग्राम को सहेजते समय स्पेक्ट्रम द्वारा टेप की गई बाइट्स की संख्या है।

— फिलिप केंडल
स्रोत
1
आप का उपयोग कर के सभी मुसीबत के लिए चला गया SGN PIके लिए 1(5 बाइट्स बचाता है) लेकिन आप भूल NOT PIके लिए 0और VALअन्य स्थिरांक के लिए ...
— नील
1
NOT PIमैं बस चूक गया। जानबूझकर ऐसा नहीं किया VALक्योंकि यह काफी धीमा था जैसा कि यह था, और VALबहुत धीमा है।
— फिलिप केंडल
1
ZX बेसिक को हमेशा मुझसे अपवेट मिलता है। यहां कोई पांडित्य नहीं। मुझे अच्छे पुराने दिन याद हैं ... अच्छा जवाब।
— एलपेड्रो
8

एसवीजी (एचटीएमएल 5), 267 बाइट्स

<svg width=200 height=90><defs><path id=p d=M40,20h120v50h-120v-50h120v50h-120v-50></defs><text font-size="19" font-family="monospace"><textPath xlink:href=#p>Happy birthday Raffaele Cecco<animate attributeName=startOffset from=340 to=0 dur=5s repeatCount=indefinite>
स्निपेट का विस्तार करें

खैर, यह है आयताकार, और यह है एक मार्की, और यह है ASCII पाठ ...

— नील
स्रोत
1
... और यह सुचारू रूप से चलता है :-)
— लुइस मेंडो
7

PHP, 184 बाइट्स

for($r=" ";++$i;sleep(print chunk_split(str_pad($r,96,"
",0),12)),$r=$k="0")for(;$c="ABCDEFGHIJKWco{zyxwvutsrqpdXL@"[$k];)$r[ord($c)-64]="Happy Birthday Raffaele Cecco "[($i+$k++)%30];

स्क्रीन को साफ़ करने के लिए 39 newlines प्रिंट करता है; साथ चलाना -nr।
वास्तविक ठहराव 1 सेकंड है; लेकिन मैंने जिफ को उगल दिया।

जन्मदिन मुबारक

ungolfed

$p = "ABCDEFGHIJKWco{zyxwvutsrqpdXL@";  # (positions for characters)+64 to ASCII
$t = "Happy Birthday Raffaele Cecco ";  # string to rotate
for($r=" ";                     # init result to string
    ++$i;                       # infinite loop
    $r=$k="0")                      # 6. reset $r and $k
{
    for(;$c=$p[$k];)                # 1. loop through positions
        $r[ord($c)-64]=                 # set position in result
        $t[($i+$k++)%30];               # to character in string
    sleep(                          # 5. wait 1 second
        print                       # 4. print
            chunk_split(
            str_pad($r,96,"\n",0)   # 2. pad to 96 chars (prepend 36 newlines)
            ,12)                    # 3. insert newline every 12 characters
        );
}
— टाइटस
स्रोत
5

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

import time;s="Happy_birthday_Raffaele_Cecco_"
while[time.sleep(1)]:print(s[:12]+'\n%s%%11s'*3%(*s[:-4:-1],)%(*s[12:15],)+'\n'+s[-4:14:-1]+'\n'*30);s=s[1:]+s[0]

इसे ऑनलाइन आज़माएं! (कोई जवाब नहीं)

— XNOR
स्रोत
मुझे पता था कि तुम अंदर आओगे और मुझे पायथन से हराओगे। मैं इतना अच्छा कर रहा था! कम से कम मेरा "बग" का उपयोग करता है जिसे आप पायथन 3 :-) के साथ उपयोग नहीं कर सकते। हमेशा की तरह अच्छा जवाब। +1
— एलपेड्रो
5

पायथन 2, 218 200 190 181 176 बाइट्स

import time;f='Happy birthday Raffaele Cecco '
while[time.sleep(1)]:v=f[::-1];print'\n'*90,f[:12],''.join('\n'+a+' '*10+b for a,b in zip(v[:3],f[12:16])),'\n',v[3:15];f=f[1:]+f[0]

-18 बाइट्स को strफॉर्मेटिंग हटाकर

-10 बाइट्स, @Uriel और @ElPedro सुझावों के लिए धन्यवाद

-9 बाइट को नेगेटिव इंडेक्सिंग हटाकर

-5 बाइट्स के fरूप में vऔर whileहालत उलट भंडारण द्वारा

repl.it

— Wondercricket
स्रोत
1
आप व्हाट्सएप को बीच में काट सकते हैं while 1:और printअगले ;को एक (वास्तविक) न्यूलाइन के साथ बदल सकते हैं । इसके अलावा f='H..। इसके अलावा f[:1]वास्तविक है f[0]।
— ऊरीएल
ओपी कहता है कि समय 0.1 और 1 सेकंड के बीच कुछ भी हो सकता है इसलिए time.sleep(1)इसे 200 से कम क्यों न करें?
— एलपेड्रो
3

रूबी + जीएनयू कोर यूटिल्स, 136 बाइट्स

s='Happy birthday Raffaele Cecco '
loop{puts`clear`+s[0,12],(0..2).map{|i|s[~i]+' '*10+s[12+i]},s[15,12].reverse
s=s[1,29]+s[0];sleep 1}
— मूल्य स्याही
स्रोत
3

पायथन 2, 182 179 173 160 बाइट्स

i="Happy birthday Raffaele Cecco "
while[s for s in i*18**4]:print'\n'*99,'\n'.join([i[:12]]+[i[-z]+' '*10+i[11+z]for z in 1,2,3]+[i[15:-3][::-1]]);i=i[1:]+i[0]

इसे repl.it पर आज़माएँ

TIO पर काम नहीं करता है, तो repl.it का उपयोग करने पर मेरा पहला प्रयास

1000000 तक गिनती करने के लिए "टाइम-वेस्टिंग" लूप का उपयोग करके संपादित करना मेरी मशीन पर 0.1 और 1s के बीच और repl.it पर लगातार देरी देता है और आयात को बचाता है time। मुझे लगता है कि अगर आप इसे 64 एमबी रैम के साथ पुराने 286 कंप्यूटर पर चलाते हैं तो यह 1 सेकंड से अधिक हो सकता है, लेकिन मुझे पूरा यकीन है कि ऐसा होने वाला नहीं है। अगर ऐसा होता है तो बस 1000000 कम करें और मुझे बाइट्स के एक जोड़े को बचाने :-)

पाइथन 2 में उस सूची की समझ को याद रखने के लिए 2 -6 को संपादित करें , sइसलिए मैं बाद में इसका उपयोग कर सकता हूं और यह भी याद रख सकता हूं कि 0 और "" के अलावा कुछ भी अच्छी तरह से याद नहीं है। कीड़े या सुविधाएँ? परवाह मत करो। यह मुझे 6 बाइट्स बचा लिया है :-)

3 3 एक और 13 को घुमाकर और फिर से जोड़कर और बदलने के 3000000लिए मध्य पंक्तियों के लिए एक सूची समझ का उपयोग करके संपादित करें40**4 । पिछले एक के लिए @FelixDombek को धन्यवाद। हालांकि मेरी सूची समझ की चाल को खोना पड़ा।

— ElPedro
स्रोत
1
क्या आप बड़ी संख्या के लिए वैज्ञानिक संकेतन या एक शक्ति अभिव्यक्ति का उपयोग कर सकते हैं?
— फेलिक्स डॉमबेक
1
पावर अभिव्यक्ति हां, वैज्ञानिक संकेतन संख्या (क्योंकि यह एक फ्लोट बन जाता है, जिसे आप तार के साथ गुणा नहीं कर सकते हैं)।
— L3viathan
3
एक बाइट के 999999बजाय अप्रचलित 1000000: वी
— मूल्य इंक
धन्यवाद @ValueInk, लेकिन टपकी सूची समझ "बग" का उपयोग करके मुझे वास्तव में 3000000 तक बढ़ाना पड़ा और अभी भी 3 बाइट्स
— बचाईं
दुर्भाग्यवश नहीं। @ L3viathan उस पर सही है।
— एलपेड्रो
2

ZX81 Z80 मशीन कोड, 158 130 बाइट्स

ठीक है इसलिए इसमें बहुत सारे बाइट्स हैं जब तक इसे इकट्ठा नहीं किया जाता है लेकिन फिर यह 130 बाइट्स तक गिर जाता है। यकीन नहीं होता कि अगर कोई नियम तोड़ता है? इसकी मेरी पहली पोस्ट और केवल एक अतिथि के रूप में।

यह प्रोग्राम 'ब्रूट फोर्स' का उपयोग करता है ताकि संदेश को प्रदर्शित करने के बजाय चतुर फ़ंक्शन का उपयोग किया जा सके, जिस तरह से इसे शीर्ष रेखा, दाहिने हाथ को ऊर्ध्वाधर, नीचे की रेखा और बाएं हाथ को लंबवत के लिए अलग-अलग कोड चंक्स से देखा जा सकता है। एनीमेशन संदेश की सामग्री को घुमाकर प्राप्त किया जाता है और फिर इसे थोड़े विलंब के बाद प्रदर्शित किया जाता है जो कि बहुत सटीक 0.2 सेकंड होना चाहिए क्योंकि यह 50 फ्रेम की दर से 10 फ्रेम के लिए इंतजार कर रहा है (वैसे भी यूके के स्पेसी जेडिस के लिए)।

मुझे एनीमेशन को प्राप्त करने के लिए संदेश को घुमाने की अवधारणा के लिए kmurta को श्रेय देना होगा - जो कि 28 बाइट्स बचाता है !!!

main    
  ld hl,happyBirthday           ;load the address of the message
  ld de,(D_FILE)                ;load the base of screen memory
  inc de                        ;increase it by one to bypass the $76
  ld bc,12                  ;ready for 12 loops
  ldir                      ;transfer HL to DE 12 times and increase both accordingly
  ex de,hl                  ;put HL into DE (HL was the message position)
  ld b,4                        ;prepare to loop 4 times
  dec hl                        ;decrease HL (screen location) by 1
rightVertical
  push de                       ;save the character position
  ld de,13                  ;load 13 (for the next line)
  add hl,de                 ;add to HL  
  pop de                        ;get the message position back
  ld a,(de)                 ;load the character into A
  ld (hl),a                 ;save it to HL
  inc de                        ;increase the character position
  djnz rightVertical            ;repeat until B = 0
  dec hl                        ;decrease HL (screen location) by 1 to step back from the $76 char
  ld b,11                       ;prepare for 11 loops
lastLine
  ld a,(de)                 ;load the current character into A
  ld (hl),a                 ;save to the screen
  dec hl                        ;decrease the screen position (as we are going backwards)
  inc de                        ;increase character position
  djnz lastLine             ;repeat until B = 0
  ld b,3                        ;get ready for the left vertical
  inc hl                        ;increase the screen position by 1 as we have gone 1 too far to the left and wrapped to the line above
leftVertical
  push de                       ;save the character position
  ld de,13                  ;load 13 (for the next line)
  sbc hl,de                 ;subtract it to move up a line in memory
  pop de                        ;get the character pos back
  ld a,(de)                 ;load the character
  ld (hl),a                 ;save it to the screen
  inc de                        ;next character
  djnz leftVertical         ;repeat until B = 0 
delayCode
  ld   hl,FRAMES                ;fetch timer                 
  ld   a,(hl)                 ;load into A                        
  sub  10                       ;wait 10 full frames (0.2 of a second)
delayLoop        
  cp  (hl)                  ;compare HL to 0
  jr   nz,delayLoop         ;if not 0 then repeat until it is   
shuffleMessage
  ld a, (happyBirthday)     ;load the first character of the message
  push af                       ;save the first character of the message
  ld hl, happyBirthday      ;load the address of the message
  inc hl                        ;increase by one to get the second char
  ld de, happyBirthday      ;load the start of the message
  ld bc, 29                 ;number of times to loop
  ldir                      ;load HL (char 2) into DE (char 1) and repeat
  pop af                        ;get char 1 back    
  ld (de),a                 ;out it at the end of the string
  jr main                       ;repeat
happyBirthday
    DEFB    _H,_A,_P,_P,_Y,__,_B,_I,_R,_T,_H,_D,_A,_Y,__,_R,_A,_F,_F,_A,_E,_L,_E,__,_C,_E,_C,_C,_O,__

क्षमा करें, मैं इसे चलाने के लिए एक लिंक पोस्ट नहीं कर सकता क्योंकि यह EightyOne (या अन्य एमुलेटर) या एक वास्तविक जेडी के लिए .P प्रारूप में संकलित कार्यक्रम है यदि आपके पास इसे लोड करने के लिए एक ZXPand या समान है।

.P को http://www.sinclairzxworld.com/viewtopic.php?f=11&t=2376&p=24988#p24988 पर डाउनलोड किया जा सकता है

— लार्डो बोफिन
स्रोत
अच्छा जवाब! मुझे Z80 मशीन कोड में एक याद आ रही थी :-) और साइट पर आपका स्वागत है!
— लुइस मेंडो
क्या आप शायद प्रोग्राम चलाने का एक gif प्रदान कर सकते हैं?
— लुइस मेंडो
क्षमा करें - मेरे पास सॉफ्टवेयर बनाने का कोई जिफ़ नहीं है!
— लार्डो बोफिन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.