एक कैनवास के चारों ओर 8-बिट शैली की उछलती गेंद

20

इस सूची से प्रेरित होकर कमोडोर 64 यूजर गाइड:

10 PRINT "{CLR/HOME}"
20 POKE 53280,7 : POKE 53281,13
30 X = 1 : Y = 1
40 DX = 1 : DY = 1
50 POKE 1024 + X + 40 * Y, 81
60 FOR T = 1 TO 10 : NEXT
70 POKE 1024 + X + 40 * Y, 32
80 X = X + DX
90 IF X <= 0 OR X >= 39 THEN DX = -DX
100 Y = Y + DY
110 IF Y <= 0 OR Y >= 24 THEN DY = -DY
120 GOTO 50

अपने टर्मिनल, स्क्रीन, कैनवास या अन्य विज़ुअल डिस्प्ले क्षेत्र के आसपास बॉल-अलाइक ऑब्जेक्ट को उछालने के लिए अपनी चुनी हुई भाषा / मंच में एक समान कार्यक्रम बनाएं।

आपको C64 के PETSCII ग्राफिक्स की बिल्कुल नकल नहीं करनी है, एक सरल Oया oकरना होगा, और न ही आपको GOTOकमांड का उपयोग करना होगा यदि यह अभी भी आपकी भाषा में मौजूद है। जब तक आपकी गेंद आपके कैनवास के शीर्ष पर शुरू होती है और तब तक तिरछे यात्रा करती है जब तक कि यह एक कैनवास की सीमा से नहीं टकराती है, और फिर उसके अनुसार उछाल आती है:

  • नीचे की ओर और दाईं ओर यात्रा करना और स्क्रीन क्षेत्र के नीचे से टकराता है, ऊपर उछलता है और सही जारी रहता है;
  • ऊपर और दाहिनी ओर यात्रा करना और दाईं ओर की सीमा से टकराता है, और बाईं और ऊपर उछलता है;
  • बाएं और ऊपर की यात्रा करना और शीर्ष को हिट करना, बाएं और नीचे उछलता है;
  • बाएं और नीचे की यात्रा करना और बाएं-सबसे सीमा तक पहुंचता है, दाएं और नीचे उछलता है;
  • किसी भी कोने को हिट करता है और दिशा को उलट देता है;

फिर हम सब अच्छे हैं।

आपको गेंद को एक बार में 8-पिक्सेल पर ले जाने की ज़रूरत नहीं है, जैसे कि C64 पर BASIC लिस्टिंग में हो रहा है; आप एक बार में एक वर्ण ब्लॉक या एक पिक्सेल ले जा सकते हैं, जो भी आपको लगता है कि सबसे उपयुक्त है।

इस BASIC लिस्टिंग को काम करते हुए देखने के लिए, आप इसे इस ऑनलाइन कमोडोर 64 एमुलेटर के साथ टाइप कर सकते हैं, जिसमें आपका ब्राउज़र फ्लैश का समर्थन करता है।

code-golf  animation 
— शॉन बीबर
स्रोत
2
जावास्क्रिप्ट कैनवास। डी 'उह।
— मैथ्यू रो
मुझे यकीन नहीं है कि आप आजकल क्या कहते हैं। आपके पास बस स्क्रीन और बॉर्डर का क्षेत्र आपके टेलीविज़न सेट या VDU ​​के माध्यम से देखा जाता था ... और अब आपको टर्मिनलों, खिड़कियां, कैनवस, स्टडआउट आदि मिल गए हैं ... यह सब मेरे लिए बहुत भ्रमित करने वाला है।
— शॉन बेबर्स
यह बेहतर होगा अगर हमारे पास एक निरंतर पिक्सेल आकार मान था।
— मैथ्यू रो
4
क्या हम 1x1 के स्क्रीन आकार और प्रिंट ओ को हमेशा के लिए मान सकते हैं?
— मैथ्यू रो
1
— टाइटस

जवाबों:

3

6502 मशीन कोड (C64), 90 89 91 बाइट्स

+2 बाइट्स क्योंकि इसमें लोड एड्रेस की जरूरत है (सेल्फ मॉडिफिकेशन की वजह से PIC नहीं)

00 C0 20 44 E5 CA D0 FD C6 FC D0 F9 A2 20 86 FC A9 D8 85 9E A9 03 85 9F A4 CA
18 A5 9E 69 28 85 9E 90 02 E6 9F 88 10 F2 A4 C9 8A 91 9E C9 20 D0 08 E6 C9 E6
CA A2 51 10 D7 A5 C9 F0 04 C9 27 D0 08 AD 2F C0 49 20 8D 2F C0 A5 CA F0 04 C9
18 D0 B4 AD 31 C0 49 20 8D 31 C0 D0 AA

ऑनलाइन डेमो

उपयोग: sys49152

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

स्पष्टीकरण: (उपाध्यक्ष disassembly)

00 C0       .WORD $C000         ; load address
20 44 E5    JSR $E544           ; clear screen
CA          DEX
D0 FD       BNE $C003           ; inner wait (256 decrements)
C6 FC       DEC $FC
D0 F9       BNE $C003           ; outer wait (32 decrements in zeropage)
A2 20       LDX #$20            ; wait counter and screen code for "space"
86 FC       STX $FC             ; store wait counter
A9 D8       LDA #$D8            ; load screen base address ...
85 9E       STA $9E             ; ... -40 (quasi row "-1") ...
A9 03       LDA #$03            ; ... into vector at $9e/$9f
85 9F       STA $9F
A4 CA       LDY $CA             ; load current row in Y
18          CLC                 ; clear carry flag
A5 9E       LDA $9E             ; add ...
69 28       ADC #$28            ; ... $28 (40 cols) to ...
85 9E       STA $9E             ; ... vector
90 02       BCC $C023
E6 9F       INC $9F             ; handle carry
88          DEY                 ; count rows down
10 F2       BPL $C018
A4 C9       LDY $C9             ; load current col in Y
8A          TXA                 ; copy screen code from X to A
91 9E       STA ($9E),Y         ; store at position of screen
C9 20       CMP #$20            ; screen code was "space"
D0 08       BNE $C037           ; if not, ball was drawn
E6 C9       INC $C9             ; next column   | opcodes are modified
E6 CA       INC $CA             ; next row      | here for directions
A2 51       LDX #$51            ; screen code for "ball"
10 D7       BPL $C00E           ; and back to drawing code
A5 C9       LDA $C9             ; load current column
F0 04       BEQ $C03F           ; if zero, change X direction
C9 27       CMP #$27            ; compare with last column (39)
D0 08       BNE $C047           ; if not equal, don't change X direction
AD 2F C0    LDA $C02F           ; load opcode for X direction
49 20       EOR #$20            ; toggle between ZP INC and DEC
8D 2F C0    STA $C02F           ; store back
A5 CA       LDA $CA             ; load current row
F0 04       BEQ $C04F           ; if zero, change Y direction
C9 18       CMP #$18            ; compare with last row (24)
D0 B4       BNE $C003           ; if not equal, don't change Y direction
AD 31 C0    LDA $C031           ; load opcode for Y direction
49 20       EOR #$20            ; toggle between ZP INC and DEC
8D 31 C0    STA $C031           ; store back
D0 AA       BNE $C003           ; -> main loop

बस मज़े के लिए, यहाँ गेंद के लिए स्प्राइट का उपयोग करते हुए एक और अधिक पेशेवर संस्करण है और 385 बाइट्स में हिट होने पर सीमा को चमकता है (स्प्राइट डेटा जिसमें जगह में उपयोग किया जाता है )

00 C0 AD 15 D0 F0 30 A9 CC 85 FC A9 04 20 A2 C0 A9 97 8D 00 DD A9 15 8D 18 D0 
A9 00 8D 15 D0 8D 1A D0 A2 81 8E 0D DC A2 31 8E 14 03 A2 EA 8E 15 03 58 A6 D6 
4C F0 E9 A9 04 85 FC A9 CC 20 A2 C0 A2 31 86 01 A2 10 A9 D0 85 FC B1 FB C6 01 
91 FB E6 01 C8 D0 F5 E6 FC CA D0 F0 A9 37 85 01 A9 94 8D 00 DD A9 35 8D 18 D0 
8D 27 D0 A2 05 8E F8 CF A2 01 8E 15 D0 8E 1A D0 8E 12 D0 86 FD 86 FE A2 18 8E 
00 D0 A2 1B 8E 11 D0 A2 32 8E 01 D0 A2 7F 8E 0D DC AE 0D DC AE 20 D0 86 FB A2 
C1 8E 14 03 A2 C0 D0 8A 85 FE 8D 88 02 A9 00 85 FB 85 FD A2 04 A0 00 78 B1 FB 
91 FD C8 D0 F9 E6 FC E6 FE CA D0 F2 60 A6 FB 8E 20 D0 CE 19 D0 A5 FD F0 20 AD 
00 D0 18 69 04 8D 00 D0 90 03 EE 10 D0 C9 40 D0 2C AD 10 D0 29 01 F0 25 20 38 
C1 C6 FD F0 1E AD 00 D0 38 E9 04 8D 00 D0 B0 03 CE 10 D0 C9 18 D0 0C AD 10 D0 
29 01 D0 05 20 38 C1 E6 FD A5 FE F0 14 AD 01 D0 18 69 04 8D 01 D0 C9 E6 D0 19 
20 38 C1 C6 FE F0 12 AD 01 D0 38 E9 04 8D 01 D0 C9 32 D0 05 20 38 C1 E6 FE 4C 
31 EA A9 01 8D 20 D0 60 00 00 00 7E 00 03 FF C0 07 FF E0 1F FF F8 1F FF F8 3F 
FF FC 7F FF FE 7F FF FE FF FF FF FF FF FF FF FF FF FF FF FF 7F FF FE 7F FF FE 
3F FF FC 1F FF F8 1F FF F8 07 FF E0 03 FF C0 00 7E 00 00 00 00

ऑनलाइन डेमो - | - ca65 कोडांतरक स्रोत ब्राउज़ करें

बाउंसिंग बॉल को शुरू करें और रोकें sys49152।

  • यह C64 बेसिक चल रहा है, जो VIC-II एड्रेस स्पेस को ऊपर ले जाकर किया जाता है $C000, जिसके लिए स्क्रीन कंटेंट और कैरेक्टर सेट (फॉन्ट) को कॉपी करना पड़ता है।
  • यह सिस्टम IRQ में हुक करता है और झिलमिलाहट से बचने के लिए, इस IRQ के स्रोत को VIC-II ग्राफिक्स चिप में बदलता है, इसलिए अपडेट हमेशा फ्रेम के बीच किया जाता है।
  • खामियों:
    1. RUN/STOP + RESTORE टूट गया है, कोशिश मत करो।
    2. IRIC स्रोत के रूप में VIC-II के साथ, कर्सर थोड़ा धीमा हो जाता है और TI$साथ ही पीछे हो जाएगा।
    3. जब सीमा को फ्लैश किया जाता है तो रोकना (बहुत संभव नहीं है लेकिन संभव है), यह सफेद रहता है - आपको इसे मैन्युअल रूप से पुनर्स्थापित करना होगा।
— फेलिक्स पालमेन
स्रोत
1
यह पूरी तरह से स्वतंत्र नहीं है, क्या यह है? मुझे दो पूर्ण एलडीए और दो एसटीए दिखते हैं। फिर भी महान काम!
— टाइटस
धिक्कार है तुम सही हो: ओ मैं आत्म संशोधन भूल गया! जैसे ही मैं पीसी पर हूं, मैं अपडेट करूंगा।
— फेलिक्स पैलमेन
1
@ टिट्स तय ... और सिर्फ मनोरंजन के लिए, "बेहतर" संस्करण जोड़ा गया :)
— फेलिक्स पामेन
क्या आपने स्प्राइट की पैकिंग करने पर विचार किया है? (हम्म ... चारसेट रॉम का उपयोग करें?) और आई inc $d020ओवर पसंद करते हैं jsr flash?) हिटशिल्वितलारगेट्राउट इट्स शानदार!
— टाइटस
1
@ टिट्स 2 बाइट्स को बचाएगा, हाँ। लोड पते के लिए के रूप में, यह एक मान्य .prgफ़ाइल का हिस्सा है और मेरे मेटा सवाल से मुझे लगता है कि मुझे इसे शामिल करना है ... शायद इसे छोड़ सकता है अगर कोड स्वतंत्र था।
— फेलिक्स पैलमेन
14

बैश + यूनिक्स उपयोगिताओं, 125 117 बाइट्स

for((x=y=u=v=1;;x+=u,y+=v,u=(x<1||x>=`tput cols`-1)?-u:u,v=(y<1||y>=`tput lines`-1)?-v:v)){
tput cup $y $x
sleep .1
}

सैंपल रन का एनिमेशन:

सैंपल रन का एनिमेशन

— मिशेल स्पेक्टर
स्रोत
6
यह सटीक कोने मारा! : ओ
— mbomb007
11

CP-1610 विधानसभा, 67 … 64 62 DECLE = 78 बाइट्स

इस कोड को एक Intellivision पर चलाने का इरादा है । यह अपने एक हार्डवेयर स्प्राइट का उपयोग कर रहा है, जिसे एक MOB (मोबाइल ऑब्जेक्ट के लिए) के रूप में जाना जाता है।

एक CP-1610 ओपकोड को 10-बिट मान के साथ एन्कोड किया गया है, जिसे 'DECLE' के रूप में जाना जाता है। यह कार्यक्रम 62 DECLE लंबा है, $ 4800 से शुरू होकर $ 483D पर समाप्त होगा।

हेक्साडेसिमल डंप + स्रोत

                            ROMW  10            ; use 10-bit ROM
                            ORG   $4800         ; start program at address $4800

                    FRAME   EQU   $17E          ; frame #

                            ;; ------------------------------------------------ ;;
                            ;;  main entry point                                ;;
                            ;; ------------------------------------------------ ;;
                    main    PROC

4800 0001                   SDBD                ; load Interrupt Service Routine
4801 02B8 002B 0048         MVII  #isr,   R0    ; into R0

4804 0240 0100              MVO   R0,     $100  ; update ISR
4806 0040                   SWAP  R0
4807 0240 0101              MVO   R0,     $101

4809 02B9 0208              MVII  #$0208, R1    ; initialize R1 = X
480B 02BA 0108              MVII  #$0108, R2    ; initialize R2 = Y
480D 02BB 0001              MVII  #1,     R3    ; initialize R3 = DX
480F 009C                   MOVR  R3,     R4    ; initialize R4 = DY

4810 0002                   EIS                 ; enable interrupts

                            ;; ------------------------------------------------ ;;
                            ;;  main loop                                       ;;
                            ;; ------------------------------------------------ ;;
4811 0280 017E      @@loop  MVI   FRAME,  R0    ; R0 = current frame #

4813 0340 017E      @@spin  CMP   FRAME,  R0    ; wait for next frame
4815 0224 0003              BEQ   @@spin

4817 00D9                   ADDR  R3,     R1    ; X += DX

4818 0379 02A0              CMPI  #$2A0,  R1    ; reached right border?
481A 0204 0003              BEQ   @@updDx

481C 0379 0208              CMPI  #$208,  R1    ; reached left border?
481E 002F                   ADCR  PC

481F 0023           @@updDx NEGR  R3            ; DX = -DX

4820 00E2                   ADDR  R4,     R2    ; Y += DY

4821 037A 0160              CMPI  #$160,  R2    ; reached bottom border?
4823 0204 0003              BEQ   @@updDy

4825 037A 0108              CMPI  #$108,  R2    ; reached top border?
4827 002F                   ADCR  PC

4828 0024           @@updDy NEGR  R4            ; DY = -DY

4829 0220 0019              B     @@loop        ; loop forever

                            ENDP

                            ;; ------------------------------------------------ ;;
                            ;;  ISR                                             ;;
                            ;; ------------------------------------------------ ;;
                    isr     PROC

482B 01DB                   CLRR  R3            ; clear a bunch of STIC registers
482C 02BC 0020              MVII  #$20,   R4

482E 0263           @@clear MVO@  R3,     R4    ; (including background color,
482F 037C 0032              CMPI  #$32,   R4    ; border color, etc.)
4831 0226 0004              BLE   @@clear

4833 0259                   MVO@  R1,     R3    ; update X register of MOB #0
4834 0242 0008              MVO   R2,     $8    ; update Y register of MOB #0
4836 02BB 017E              MVII  #$017E, R3    ; update A register of MOB #0
4838 0243 0010              MVO   R3,     $10   ; (using a yellow "O")

483A 0298                   MVI@  R3,     R0    ; increment frame #
483B 0008                   INCR  R0
483C 0258                   MVO@  R0,     R3

483D 00AF                   JR    R5            ; return from ISR

                            ENDP

उत्पादन

उत्पादन

— Arnauld
स्रोत
10

HTML (Microsoft Edge / Internet Explorer), 81 बाइट्स

इन नेस्टेड <marquee>टैग्स के साथ 1998 का ​​प्रिटेंड करें:

<marquee behavior=alternate direction=down><marquee behavior=alternate width=99>O
स्निपेट का विस्तार करें

माइक्रोसॉफ्ट एज में परीक्षण किया गया है, हालांकि मैंने जो IE पढ़ा है, उससे भी अभी भी मार्केज़ का समर्थन करना चाहिए। क्रोम में निश्चित रूप से काम नहीं करता है ।

सेटिंग direction=up2 बाइट्स बचाएगी, लेकिन नियम को तोड़ दें कि गेंद को कैनवास के शीर्ष पर शुरू करना है।

— जैक ब्रोंस्टीन
स्रोत
दुर्भाग्य से, यह एक अमान्य जवाब है क्योंकि गेंद तिरछे तरीके से यात्रा नहीं करती है, जैसा कि चुनौती से आवश्यक है।
— एल'एंडिया स्टट्रान
क्या आपने इसे Microsoft Edge में आज़माया था? Chrome directionविशेषता का समर्थन नहीं करता है ।
— जैक ब्रूनस्टीन
हुह, मेरी माफी - यह एज में काम करता है। मैं पुष्टि कर सकता हूं कि यह क्रोम में काम नहीं करता है, और मैं फ़ायरफ़ॉक्स और इंटरनेट एक्सप्लोरर में काम कर सकता हूं। चार में से तीन खराब नहीं है (और इस उत्तर के लिए आपको केवल एक की आवश्यकता है)। +1
— एल'एंडिया स्ट्रैटन
1
+1 के लिए marquee, यह बहुत रचनात्मक है!
— मेटोनीम
मेरे लिए क्रोम में काम किया।
— ckjbgames 15
8

टीआई-बेसिक, 71 70

1->A
1->B
1->C
1->D
While 1
ClrHome
Output(B,A,0
A+C->A
B+D->B
If A<2 or A>15
~C->C
If B<2 or B>7
~D->D
End

काफी शाब्दिक अनुवाद, मुझे आश्चर्य नहीं होगा अगर इसे छोटा करने के लिए ट्रिक्स हैं।

स्क्रीन 16x8 और 1-अनुक्रमित है, इसलिए कॉन्स्टेंट अलग हैं।

~ स्रोत प्रतीक को नकार प्रतीक लिखने का तरीका है।

शेख़ी O का gif

यह हार्डवेयर पर चिकना दिखता है।

— हेरोल्ड
स्रोत
क्या आप सुनिश्चित हैं कि यह 70 बाइट्स है? इससे कम का दिखता है।
— 12M2121
@ 12M21 आप कितने बाइट्स गिनते हैं? अगर मैं एक कैलकुलेटर और 10 बाइट्स को एक खाली प्रोग्राम के लिए सहेजता हूं तो मुझे 80 बाइट्स मिलते हैं जो मेरी गिनती से सहमत हैं।
— हेरोल्ड
ओह, मुझे लगता है कि मैंने तब गलत गिना।
— 12M2121
7

Befunge, 209 बाइट्स

>10120130pppp>"l52?[J2["39*,,,,39*,,,,,,v
v+56/+55\%+55:+1g01*83-"6!"7\-"6!?"8-*86<
>00g1+:55+%\55+/"+!6"-48*,68>*#8+#6:#,_v$
v:+g03g01p02+-\g02*2!-*64\*2!:p00:+g02g<$
>10p:!2*\"O"-!2*30g\-+30p"2"::**>:#->#1_^

यह 80x25 के स्क्रीन आकार को मानता है, लेकिन आप आसानी "O"से अंतिम पंक्ति पर (79) और *64दूसरी अंतिम पंक्ति पर (24) को बदलकर सीमा को घुमा सकते हैं (ध्यान दें कि दूसरी अंतिम पंक्ति को दाएं से बाएं निष्पादित किया जाता है)। "2"अंतिम पंक्ति पर (50) को बदलकर गति को भी समायोजित किया जा सकता है ।

— जेम्स होल्डरनेस
स्रोत
7

जावा, 184 176 बाइट्स

class A{public static void main(String[]a)throws Exception{for(int X=1,Y=1,x=1,y=1;;System.out.print("\033["+X+";"+Y+"H"),Thread.sleep(50),X+=x=X%25<1?-x:x,Y+=y=Y%85<1?-y:y);}}

यह कर्सर को स्थानांतरित करने के लिए एएनएसआई एस्केप सीक्वेंस का उपयोग करता है, जो एक 85 x 25टर्मिनल डिस्प्ले के चारों ओर बाउंस करने वाली वस्तु है । नाम की फाइल में सेव करें A.java।

Ungolfed

class Terminal_Bouncing_Ball {
    public static void main(String[] args) throws InterruptedException {
        int X = 0, Y = 0, dx = 1, dy = 1;
        while (true) {
            System.out.print(String.format("\033[%d;%dH",X,Y));
            Thread.sleep(50);
            dx = (X < 1) ? 1 : (X > 71) ? -1 : dx;
            dy = (Y < 1) ? 1 : (Y > 237) ? -1 : dy;
            X += dx;
            Y += dy;
        }
    }
}

डेमो

उदाहरण

— आर। कप
स्रोत
यह कोड गोल्फ है, इसलिए आप हटाना चाहेंगे Thread.sleep(50) । और अपने गोल्फ और ungolfed कार्यक्रम मेल नहीं खाते।
— जैकब
4

क्लोजर, 398 380 375 बाइट्स

(ns g(:require[quil.core :as q]))(def w 1e3)(def h 1e3)(def f 100)(def b(atom{:x f :y f :n 1 :m 1}))(q/defsketch . :size[w h]:setup #(do(q/text-font(q/create-font""f))(q/fill 255 255 255)):draw #(let[s 9{x :x y :y n :n m :m}@b c(+ x(* n s))u(+ y(* m s))](q/background 0 0 0)(reset! b{:x c :y u :n(if(< 0 c(- w f))n(* -1 n)):m(if(<(+ 0 f)u h)m(* -1 m))})(q/text"O"(:x @b)(:y @b))))

-18 बाइट्स को डिफ़ॉल्ट नाम से बदलकर इसे डिफ़ॉल्ट करने के लिए, बाउंड्री चेक को इनलाइन करने के लिए, और बाउंड्री इश्यू (जिसे आप जीआईएफ में देख सकते हैं) को ठीक करके। फिक्सिंग जो वास्तव में बाइट्स को बचाती है।

-5 बाइट्स एक अधिक रसीला विनाशकारी सिंटेक्स को बदलकर और एक पिक्सेल द्वारा गेंद को सिकोड़ना।

क्विल का उपयोग करता है ।

मैंने फंक्शनल मोड में जाने की कोशिश की, लेकिन इसके लिए बहुत सारे अतिरिक्त कोड की आवश्यकता थी और अंत में यह अधिक महंगा था।

(ns bits.golf.ball-bounce
  (:require [quil.core :as q]))

(def width 1000)
(def height 1000)

(def font-size 100)

; Mutable state holding the properties of the ball. n and m are the directions on the x and y axis.
(def ball (atom {:x 300 :y 600 :n 1 :m 1}))

(q/defsketch b
  :size [width height] ; Window size

  :setup #(do
            (q/text-font (q/create-font "Arial" font-size)) ; Set the font
            (q/fill 255 255 255)) ; And the text color

  :draw
  #(let [speed 9
         ; Deconstruct the state
         {:keys [x y n m]} @ball
         next-x (+ x (* n speed))
         next-y (+ y (* m speed))

         ; I'm adding/subtracting the font-size so it stays in the window properly
         x-inbounds? (< 0 next-x (- width font-size))
         y-inbounds? (< (+ 0 font-size) next-y height)]

     ; Wipe the screen so the ball doesn't smear
     (q/background 0 0 0)

     ; Reset the state
     (reset! ball
             {:x next-x
              :y next-y
              :n (if x-inbounds? n (* -1 n))
              :m (if y-inbounds? m (* -1 m))})

     ; Draw the ball
     (q/text "O" (:x @ball) (:y @ball))))

बॉल शेख़ी GIF

(ध्यान दें, नया संस्करण स्क्रीन के नीचे जल्दी नहीं उछलता है, जैसे कि यह GIF में है।)

— Carcigenicate
स्रोत
मुझे बस एहसास हुआ कि मैं (+ 0 font-size)वहां हूं । शर्म की बात है। मैं अगले संस्करण में इसे ठीक कर दूँगा। मुझे 5 बाइट की तरह बचाना चाहिए।
— Carcigenicate
4

रैकेट 247 बाइट्स

(let*((w 500)(h(* w 0.6))(x 100)(y 0)(d 10)(e d)(G(λ(t)(set! x(+ x d))(when(or(> x w)(< x 0))
(set! d(* d -1)))(set! y(+ y e))(when(or(> y h)(< y 0))(set! e(* e -1)))
(underlay/xy(rectangle w h"solid""white")x y(circle 10"solid""black")))))(animate G))

Ungolfed: 

(require 2htdp/image
         2htdp/universe) 

(let* ((wd 500)            ; define variables and their initial values
       (ht 300)
       (x 100)
       (y 0)
       (dx 10)
       (dy 10)

       (imgfn              ; define function to draw one frame; called repeatedly by animate fn; 
        (λ (t)             ; t is number of ticks till now- sent by animate fn; ignored here;

                           ; update location (x and y values):
          (set! x (+ x dx))
          (when (or (> x wd) (< x 0))
            (set! dx (* dx -1)))             ; invert direction at edges
          (set! y (+ y dy))
          (when (or (> y ht) (< y 0))
            (set! dy (* dy -1)))             ; invert direction at edges

                           ; draw image: 
          (underlay/xy
           (rectangle wd ht "solid" "white") ; draw background
           x y                               ; go to location (x,y)
           (circle 10 "solid" "black")       ; draw ball
          ))))

  (animate imgfn))         ; animates the images created by imgfn (default rate 28 times/sec)

आउटपुट:

यहां छवि विवरण दर्ज करें

— rnso
स्रोत
1
रैकेट के साथ रैकेटबॉल खेलना!
— ckjbgames 21
यह अच्छा है!
— rnso
"रैकेट" "स्कीम" प्रोग्रामिंग भाषा से लिया गया है: स्कीम के बाद (एक कुटिल योजना) रैकेट (एक घोटाला या ठगी) है!
— rnso
@ इससे भी बेहतर!
— ckjbgames
3

जेली, 37 बाइट्स

“ñc‘Ọ24ḶŒḄṖ⁸ị⁷x⁸µ80ḶŒḄṖ⁸ị⁶x⁸‘œS.1
Ç1¿

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

प्रत्येक दिशा में कोऑर्डिनेट्स को दो सूचियों के तत्वों के रूप में दर्शाया जा सकता है [0, 1,..., 24, 23,..., 1]और [0, 1,..., 80, 79,..., 1], चलो उन्हें कॉल करते हैं Yऔर X, जो अनंत रूप से दोहराए जाते हैं। इस अनंत दोहराव को मॉड्यूलर इंडेक्सिंग - ịजेली में उपयोग करके अनुकरण किया जा सकता है । उदाहरण: iवें पुनरावृत्ति में गेंद स्थिति में है (X[i%|X|], Y[i%|Y|]) = (iịY, iịX)। मूविंग बॉल सिर्फ कर्सर होता है जिसे iịYन्यूलाइन्स उत्सर्जित करके स्थिति में डाल दिया जाता हैiịX स्पेस ।

डेमो

https://i.gyazo.com/b8eac64097cb6d3a18185877c2f4c945.gif

व्याख्या

“ñc‘Ọ24ḶŒḄṖ⁸ị⁷x⁸µ80ḶŒḄṖ⁸ị⁶x⁸‘œS.1        Monadic helper link - argument i.
                                         Resets the terminal, prints Y[i] newlines,
                                         X[i] spaces and returns i + 1.
“ñc‘                                     Set the output to [27, 99]
    Ọ                                    Convert to characters and print (\x1bc)
                                          -> Cursor is at position (0,0)
     24Ḷ                                 Lowered range of 24. Yields [0,...,23].
        ŒḄ                               Bounce. Yields [0,...,23,22,...,0].
          Ṗ                              Pop. Yields [0,...,23,22,...,1] = Y.
           ⁸ị                            Modular index i (⁸) into Y. The current
                                         value is the Y coordinate, y.
              x                          Repeat y times
             ⁷                           the newline character ('\n').
               ⁸                         Output that (y times '\n') and continue
                                         with value i.
                                          -> Cursor is at position (0, y)
                µ                        Monadic chain separation.
                 80ḶŒḄṖ                  Same as above, but this time yielding X.
                       ⁸ị                Modular index i into X, yielding the
                                         value for x.
                          x              Repeat x times
                         ⁶               the whitespace character.
                           ⁸             Output that (x times ' ') and continue
                                         with value i.
                                         -> Cursor is at position (x, y), the
                                            final position.
                             œS.1        Wait 0.1 seconds.
                            ‘            Return i + 1.

Ç1¿                                      Main (niladic) link.
 1¿                                      While true.
Ç                                        Call the helper link. The first time
                                         there is no argument and i will be [],
                                         which is cast to 0 when used as integer
                                         (e.g. try ‘¶Ç). After that, the previous
                                         return value (i + 1) is used.
— PidgeyUsedGust
स्रोत
2

स्माइलबासिक, 85 74 बाइट्स

SPSET.,9M=MAINCNT
SPOFS.,ASIN(SIN(M/5))*122+192,112+71*ASIN(SIN(M/3))EXEC.

गेंद की स्थिति को 2 त्रिकोण तरंगों के साथ मॉडल किया जा सकता है, और सबसे छोटा तरीका जो मैं उन्हें स्माइलबासिक में उत्पन्न करने के लिए पा सकता था, वह आर्किसिन (साइन (एक्स)) था। (MOD का उपयोग करने वाला एल्गोरिथ्म लंबा था क्योंकि SB MODइसके बजाय उपयोग करता था %)

— 12Me21
स्रोत
2

CSS / HTML, 200 + 7 = 207 बाइट्स

p{position:relative}a{position:absolute;animation:infinite linear alternate;animation-name:x,y;animation-duration:7.9s,2.3s}@keyframes x{from{left:0}to{left:79ch}}@keyframes y{from{top:0}to{top:24em}}
<p><a>O
स्निपेट का विस्तार करें

यह संस्करण आपको कैनवास के आकार को दिखाता है और एनीमेशन को एक अधिक प्रतिष्ठित अनुभव भी देता है:

कोड स्निपेट दिखाएं

— नील
स्रोत
2

दिल्लोग एपीएल, 44 बाइट्स

{⎕SM∘←0,G←⍺+⍵⋄G∇⍵×1-2×⊃1 G∨.≥G⎕SD⊣⎕DL.1}⍨1 1

स्पष्टीकरण:

  • {...}⍨1 1 : दिए गए फ़ंक्शन को ⍵ = call = 1 1 के साथ कॉल करें
    • ⎕SM∘←0,G←⍺+⍵: दुकान ⍺+⍵में G, एक प्रदर्शित 0में उस स्थान पर⎕SM खिड़की।
    • ⎕DL.1: एक सेकंड का 1/10 वा इंतजार करें
    • ⊃1 G∨.≥G⎕SD: यदि जांच Gमें है ⎕SMखिड़की सीमा ( 1≥Gया G≥⎕SD, ⎕SDहै रों creen घ imensions)
    • 1-2×: मानचित्र [1,0]पर[¯1,1] यात्रा की दिशा फ्लिप करने के लिए
    • ⍵×: यात्रा की वर्तमान दिशा को उससे गुणा करें
    • G∇: पुनरावृत्ति, Gनया स्थान होने दें ( ⍺) और ⍵....नई दिशा ( ⍵) बनें ।
— मारीनस
स्रोत
क्या यह लगातार खुले और बंद टर्मिनलों को माना जाता है क्योंकि यह चलता है? टर्मिनल के बंद होने के बाद इसे बंद करना काफी मुश्किल है, क्योंकि टर्मिनल बंद हो जाता है और हर सेकेंड के दसवें हिस्से (कम से कम विंडोज पर) को फिर से खोल देता है।
— ren
1
@wptreanor: तय
— मारीनस
शांत, उत्कृष्ट काम!
— ren
2

PHP, 112 97 94 103 102 बाइट्स

for(;;usleep(1e5),$i%=624)echo($r=str_repeat)(A^K,99),$r(A^a,abs($i%78-39)),O,$r(A^K,abs($i++%48-24));

Oशीर्ष दाएं कोने से शुरू होकर, 40x25 ग्रिड पर एक पूंजी बाउंस होती है ;
स्क्रीन को साफ़ करने के लिए 99 नए अंक प्रिंट करता है।

साथ चलाना -nr।

A^K= chr(10)= newline
A^a= chr(32)= स्थान

— टाइटस
स्रोत
1
हाय टाइटस यह मुझे फिर से है। for($d=$e=-1;;usleep(1e5))echo($r=str_repeat)(A^K,99),$r(A^a,$x+=$d*=$x%79?1:-1),O,$r(A^K,$y+=$e*=$y%24?1:-1);। मोडुलो 0 और N पर गलत है और दिशा को बदल देता है। अफसोस की बात है कि हमें init $ d और $ e-1 है, लेकिन फिर भी कुछ बचत मिलती है। $x%79<=>.5एक ही बाइट के लिए भी काम करता है।
— क्रिस्टोफ
1
अरे @Christoph वापस स्वागत है। अजीब बात है: जब मैंने आपका सामान कॉपी किया था तो उसमें 110 के बजाय 116 बाइट्स थे। लेकिन इसने मुझे बहुत छोटे से प्रेरित किया।
— टाइटस
हम निश्चित रूप से एक अच्छी टीम हैं;) नकल पर अजीब बात मुझे पता नहीं क्यों मिला है।
— क्रिस्टोफ
2

सिमोंस बेसिक (C64), 66 65 बाइट्स

एक बाइट ने धन्यवाद @ShaunBebbers को बचाया।

मुझे यहां केवल एक लाइन की आवश्यकता है, क्योंकि सिमोंस बेसिक में एक मोड्यूलो फ़ंक्शन है।
AfaIk, इसके लिए एक भौतिक C64 और एक SimonsIC BASIC मॉड्यूल
(या किसी अन्य BASIC एक्सटेंशन जिसमें modफ़ंक्शन होता है) की आवश्यकता होती है।

0fori=0to623:print"{CLR}":poke1024+40*abs(mod(i,48)-24)+abs(mod(i,78)-39),81:next:goto

इन 69 अक्षरों में टाइप करें:

0fOi=0TO623:?"{CLR}":pO1024+40*aB(mod(i,48)-24)+aB(mod(i,78)-39),81:nE:gO

{CLR}है PETSCII 147 है, जो स्क्रीन को साफ करता है। इसे टाइप करने के लिए Shift + CLR / HOME का उपयोग करें।

bytecount

जब डिस्क को बचाया है, यह 65 बाइट्स लेता है, क्योंकि आदेशों tokenized रहे हैं:
for, to, poke, abs, nextऔर gotoप्रत्येक बाइट से एक हैं; modदो बाइट्स लेता है।
यह कोड संख्या के 59 बाइट्स को पॉइंटर्स के लिए 4 बाइट्स और लाइन नंबर के लिए 2 बाइट्स बनाता है।

संदर्भ के लिए, C64 की मैपिंग देखें और खोजें $800(BASIC प्रोग्राम टेक्स्ट)।
(आप वीडियो स्क्रीन मेमोरी क्षेत्र पर पा सकते हैं $400।)

टूट - फूट

कार्यक्रम I0 से 623 (= 48 और एलसीएम 1 के एलसीएम 1) से छोरों । पाश में

  • स्क्रीन साफ ​​हो गई है
  • I क्रमशः 24..0..23 को 39..0..38 पर मैप किया जाता है
  • और बूँद (PETSCII 81) को वीडियो मेमोरी में इसी स्थिति में रखा जाता है
    (जैसे मूल कार्यक्रम करता है)।

जब लूप किया जाता है, तो लाइन 0 पर कूदकर प्रोग्राम को पुनरारंभ किया जाता है।

C64 बेसिक, 77 76 बाइट्स

0fori=0to623:print"{CLR}"
1poke1024+40*abs(i-48*int(i/48)-24)+abs(i-78*int(i/78)-39),81:next:goto

दुर्भाग्य से मुझे दो लाइनों की आवश्यकता है, क्योंकि सभी संभव संक्षिप्तताओं के साथ भी इसमें 83 अक्षर होंगे - C64 लाइन संपादक का उपयोग करने के लिए बहुत सारे: 

0fOi=0to623:?"{CLR}":pO1024+40*aB(i-48*int(i/48)-24)+aB(i-78*int(i/78)-39),81:nE:gO

(एक हेक्स संपादक का उपयोग एक लंबी लाइन बनाने के लिए किया जा सकता है - जो इसे 73 बाइट्स बना देगा।)

— टाइटस
स्रोत
1
कमोडोर कमांड विभाजक हैं :और नहीं;
— शॉन बीबर्स
1
इसके अलावा, यदि आप लाइन शून्य पर शुरू करते हैं, तो आप बस gotoअपने दो-लाइनर संस्करण में उपयोग कर सकते हैं , जैसा कि gotoबिना आधार संख्या के goto 0दो आधार पर है
— शॉन बेबर्स
यदि आप अपनी C64 बुनियादी सूची पर अधिक कमांड प्राप्त करना चाहते हैं, तो इसे 128 मोड में C128 में दर्ज करें, इसे डिस्क पर सहेजें और इसे C64 मोड में वापस लोड करें, C128 में डिफ़ॉल्ट रूप से एक 160 वर्ण सीमा है ताकि इस अवरोध को तोड़ा जा सके कमोडोर कीवर्ड संक्षिप्ताक्षर का उपयोग करना।
— शॉन बेबर्स
@ShaunBebbers जानकर अच्छा लगा। बहुत समय हो गया। मैं इसे मशीन कोड में भी लागू करना चाहता था ... कर्नेल रूटीन पर पुनरावृत्ति करने की कोशिश कर रहा हूं; सुनिश्चित नहीं है कि जब मुझे बैकअप लेना है तो क्या रजिस्टर करें; पूर्ण कर्नेल सूची ऑनलाइन है ; मैं अभी और खुदाई करने के लिए समय नहीं निकाल सकता। आप को पूरा करना चाहते हैं यह ?
— टाइटस
मैं एक एमसी संस्करण बनाने जा रहा था, हालांकि मुझे लगता है कि इसे अपनी चुनौती के लिए प्रस्तुत करना मेरे लिए भी अति-भयावह होगा। सबसे तेज़ तरीका से स्क्रीन करने के लिए सीधे बाइट लिखने के लिए किया जाएगा $0400करने के लिए $07e7; या स्प्राइट का उपयोग करें। कर्नेल के साथ $ffd2(आउटपुट संचायक) का उपयोग करना काम करेगा क्योंकि आप कर्सर पर एक्स और वाई पॉस आसानी से पर्याप्त सेट कर सकते हैं (मुझे उस के लिए कॉल याद नहीं है), लेकिन आपको इस मामले में अंतिम चरित्र की स्थिति से बचना होगा। एक पंक्ति फ़ीड।
— शॉन बेबर्स
1

पायथन 2, 176 168 बाइट्स

यह 80x24 के एक टर्मिनल आकार को मानता है। निश्चित रूप से इष्टतम नहीं है, लेकिन मैं हाँ करने के लिए नया हूँ।

import time;x=y=d=e=1
while 1:
 m=[[' 'for i in' '*80]for j in' '*24];x+=d;y+=e;m[y][x]='O';time.sleep(.1)
 if x%79<1:d=-d
 if y%23<1:e=-e 
 for r in m:print''.join(r)

X <1or x> 79 के बजाय x% 79 <1 का सुझाव देने के लिए R. Kap का धन्यवाद और y के लिए ditto।

— ट्रिस्टन बैचैन
स्रोत
के x<1or x>78साथ x%79<0और के y<1or y>22साथ बदलकर आप कुछ बाइट्स बचा सकते हैं y%23<1।
— आर। काप।
1

Rebol / देखें, 284 266 बाइट्स

rebol[]p: 3x9 d:[3 3]view layout[b: box blue 99x99 effect[draw[circle p 2]]rate :0.01 feel[engage: func[f a e][if a = 'time[case/all[p/x < 2[d/1: abs d/1]p/y < 2[d/2: abs d/2]p/x > 98[d/1: negate d/1]p/y > 98[d/2: negate d/2]]p/x: p/x + d/1 p/y: p/y + d/2 show b]]]]

Ungolfed:

rebol []

p: 3x9     ;; starting position
d: [3 3]   ;; direction

view layout [
    b: box blue 99x99 effect [
        draw [
            circle p 2
        ]
    ]

    rate :0.01 feel [
        engage: func [f a e] [
            if a = 'time [
                case/all [
                    p/x < 2  [d/1: abs d/1]
                    p/y < 2  [d/2: abs d/2]
                    p/x > 98 [d/1: negate d/1]
                    p/y > 98 [d/2: negate d/2]
                ]
                p/x: p/x + d/1
                p/y: p/y + d/2
                show b
            ]
        ]
    ]
]
— ड्रेगटुन
स्रोत
1

सी 294 बाइट्स

#include<graphics.h> f(){int d=0;g,x,y,a=0,b=0;initgraph(&d,&g,NULL);x=30;y=30;while(1){x+=6;y+=7;if(y<60)b=0;if(x<60)a=0;if((y>getmaxy()-40)) b=!b;if((x>getmaxx()-40))a=!a;if(b){y-=18;x+=3;}if(a){x-=15;y+=2;}usleep(10000);setcolor(4);cleardevice();circle(x, y,30);floodfill(x,y,4);delay(45);}}

Ungolfed संस्करण:

#include<graphics.h>
void f()
{
 int d=DETECT,g,x,y,r=30,a=0,b=0;
 initgraph(&d,&g,NULL);
 x=30;
 y=30;

 while(1)
 {
   x+=6;
   y+=7;

   if(y<60)
     b=0;
   if(x<60)
     a=0;     

   if((y>getmaxy()-40))
        b=!b;

   if((x>getmaxx()-40))
        a=!a;

    if(b)
    {       
        y-=18;
        x+=3;
    }

    if(a)
    {       
       x-=15;
       y+=2;               
    } 
    usleep(10000);
    setcolor(RED);
    cleardevice();
    circle(x,y,r);
    floodfill(x,y,RED);
    delay(45);

  }   

}

व्याख्या

  • इसलिए इसे शुरू करने के लिए, मुझे graphics.hअपनी /usr/includeनिर्देशिका में जाना था । इसलिए, मैं खोज की है और इस मैं क्या पाया है। यह लिनक्स के लिए एसडीएल का उपयोग करके टर्बो ग्राफिक्स कार्यान्वयन है। एक भी OpenGL का उपयोग कर सकता है। विंडोज़ में, मुझे लगता है कि यह पहले से ही स्थापित है, मैकओएस के बारे में निश्चित नहीं है।
  • void initgraph(int *graphdriver, int *graphmode, char *pathtodriver);सिस्टम को इनिशियलाइज़ करता है और इसे ग्राफिक्स मोड में डालता है, इस मामले में ग्राफिक्स ड्राइवर का स्वतः पता चल जाता है। अधिक जानकारी के लिए कृपया इस लिंक को देखें।
  • xऔर yनिर्देशांक हैं जो गेंद की स्थिति को निर्धारित करते हैं।
  • aऔर bझंडे, aशून्य पर सेट होते हैं, जब xमूल्य 60 से नीचे गिरता है और 60 से नीचे bआने पर शून्य पर सेट yहोता है।
  • झंडे टॉगल कर रहे हैं जब xऔर yखिड़की की सीमा मूल्यों से अधिक है, और निर्देशांक तदनुसार समायोजित कर रहे हैं।
  • मैंने usleepऐसा इसलिए रखा ताकि मेरे सीपीयू पर जोर न पड़े।
  • आम तौर पर एक का उपयोग करना चाहिए closegraph()विंडो को बंद करने के लिए, कॉल का । लेकिन यहां गायब है।

लिंकर ध्वज के साथ संकलित किया जाना चाहिए -lgraph

यह असली हार्डवेयर पर आसानी से चलता है। :)

उछलती हुई लाल गेंद

— हाबिल टॉम
स्रोत
क्या आयात कार्यक्रम इस कार्यक्रम को चलाने के लिए आवश्यक हैं?
— क्रिकेई लिथोस
@ कृतिलिथोस यस सर; अपडेट किया गया! आपको शामिल करने की आवश्यकता है graphics.h। यह उत्तर askubuntu.com/questions/525051/… मददगार था।
— हाबिल टॉम
1

MATL , 42 बाइट्स

1thXH_XI`Xx8E70hZ"79HZ}&(DH4M\1>EqI*XIH+XH

यह एक 70 × 16 स्क्रीन और चरित्र का उपयोग करता है O। यदि आप कुछ उछाल की प्रतीक्षा करते हैं, तो आप गेंद को एक कोने से टकराते देखेंगे।

MATL ऑनलाइन पर कोशिश करो!

स्क्रीन आकार कोड में आसानी से संशोधित किया जा सकता है। प्रासंगिक हिस्सा है 8E70, जो धक्का देता है 8, इसे दोगुना करता है, और धक्का देता है 70। उदाहरण के लिए, एक 80 × 25 स्क्रीन के द्वारा प्रतिस्थापित किया जाता है 5W80, जो धक्का देता है 5, इसे वर्ग करता है, और धक्का देता है 80(या इसके द्वारा प्रतिस्थापित किया जाता है 25 80, लेकिन इसके लिए एक और बाइट की आवश्यकता होती है)।

साथ ही, tDकोड के अंत में जोड़ना वास्तविक समय में वर्तमान स्थिति दिखाता है (ऊर्ध्वाधर, फिर क्षैतिज, 1 1ऊपरी बाएं है)। एक उदाहरण के लिए, एक 80×18स्क्रीन के लिए,

1thXH_XI`Xx9E80hZ"79HZ}&(DH4M\1>EqI*XIH+XHtD

यह भी कोशिश करो!

व्याख्या

यह एक अनंत लूप का उपयोग करता है। स्थिति को क्लिपबोर्ड Hमें 1 × 2 वेक्टर के Iरूप में रखा जाता है, और क्लिपबोर्ड में दिशा को 1 × 2 वेक्टर के रूप में 1या प्रविष्टियों के साथ रखा जाता है -1।

प्रत्येक पुनरावृत्ति स्क्रीन को साफ करती है, रिक्त स्थान के एक मैट्रिक्स को परिभाषित करती है, Oप्रासंगिक स्थिति में लिखती है , और इसे प्रदर्शित करती है। फिर स्थिति और निर्देश को अद्यतन करने की आवश्यकता है।

स्थिति- 1आधारित है, और इस प्रकार स्क्रीन के किनारे हैं 1और अधिकतम स्क्रीन आकार है। इसलिए यदि स्थिति मोडुलो स्क्रीन आकार 0या 1तो पहले या दूसरे घटकों में देता है, जिसका अर्थ है कि हम क्रमशः एक ऊर्ध्वाधर या क्षैतिज किनारे पर पहुंच गए हैं, तो दिशा वेक्टर का घटक नकारात्मक है। उसके बाद, नई स्थिति को प्राप्त करने के लिए नई दिशा को वर्तमान स्थिति में जोड़ा जाता है।

— लुइस मेंडू
स्रोत
1

यहाँ ZX स्पेक्ट्रम लिस्टिंग है।

  10 FOR n=0 to 7
  20 READ a: POKE USR "a"+n, a
  30 NEXT n
  40 DATA 60,126,243,251,255,255,126,60
  50 LET x=10:LET y=10:LET vx=1: LET vy=1
  60 PRINT AT y,x;"\a"
  70 IF x<1 OR x>30 THEN LET vx=-vx
  80 IF y<1 OR x>20 THEN LET vy=-vy
  90 LET x=x+vx: LET y=y+vy
 100 PRINT AT y-vy,x-vx;" ": GO TO 60
— DrIB
स्रोत
अच्छा पहला प्रवेश DrlB - क्या आप कृपया एक बाइट गिनती शामिल कर सकते हैं। मुझे लगता है कि यह 16K मशीनों सहित किसी भी विशिष्टता पर काम करेगा?
— शॉन बेबर्स 12
हाय यह 201 बाइट्स है, आप पहले 4 पंक्तियों को छोड़ सकते हैं लेकिन फिर आपको केवल एक "चरित्र" शेख़ी मिलती है लेकिन यह आपको 64 बाइट्स बचाता है। मैं अनुकूलन करने की कोशिश करूंगा। यह सब पर कुछ भी नहीं फैंसी और किसी भी स्पेक्ट्रम मॉडल पर काम करेंगे :)
— DrIB
ठीक है, मैं इसे नीचे 185 कटौती करने में कामयाब रहा हूँ, बिना रेखाओं को गेंद ग्राफिक्स को गिराए। यह थोड़ा कम पठनीय है, लेकिन यह तेज़ है।
— DrIB
1

सी + शाप, 190 बाइट्स

#include<curses.h>
w;h;x;y;d;main(e){initscr();curs_set(0);getmaxyx(stdscr,h,w);for(d=e;;usleep(20000),mvaddch(y,x,32)){mvaddch(y+=d,x+=e,48);if(!y||y>h-2)d=-d;if(!x||x>w-2)e=-e;refresh();}}

स्पष्टीकरण:

#include<curses.h>
w;h;x;y;d;
main(e)
{
    initscr();
    curs_set(0);
    getmaxyx(stdscr,h,w);

    // initialize distances to 1 (e is 1 when called without arguments)
    // wait for 1/5 second, then write space character at current pos
    for(d=e;;usleep(20000),mvaddch(y,x,32))
    {
        // advance current pos and write ball character (`0`)
        mvaddch(y+=d,x+=e,48);

        // check and change direction:
        if(!y||y>h-2)d=-d;
        if(!x||x>w-2)e=-e;

        // trigger output to screen:
        refresh();
    }
}
— फेलिक्स पालमेन
स्रोत
1

लुआ ( LuaVE 2D ), 130 बाइट्स

x,y,a,b=0,0,1,1
function love.draw()a=(x<0 or x>800)and-a or a
b=(y<0 or y>600)and-b or b
x=x+a
y=y+b
love.graphics.points(x,y)end

लोआ सबसे अच्छी भाषा नहीं है, जब यह कोड गोल्फ की बात आती है, लेकिन यहाँ आप जाते हैं! उल्लेख के लायक कुछ बिंदु:

  • डिफ़ॉल्ट कैनवास का आकार 800 x 600 है। इसे कॉन्फ़िगरेशन फ़ाइल में बदला जा सकता है, लेकिन मुझे कोई आकार प्रतिबंध नहीं दिखाई दिए, इसलिए मैंने इसे छोड़ दिया है।

  • love.draw()LetVE का ड्राइंग फ़ंक्शन है और इसका एक पूर्व निर्धारित नाम है। वैकल्पिक L --VE फ़ंक्शंस जिनका उपयोग किया जा सकता है love.update(dt)और love.run()- पहले लंबे समय तक, बाइट्स में और बाद वाले को छोटा, हाँ, लेकिन बिना अंतर्निहित लूप के। इस प्रकार, draw()यह हमारी सबसे अच्छी शर्त है।

  • उपरोक्त संस्करण love.graphics.pointsगेंद को खींचने के लिए उपयोग करता है। हालांकि छोटा है, मुझे यकीन नहीं है कि इसकी अनुमति है। यहाँ एक GIF है कि यह कैसे चलता है:

एनिमेटेड स्क्रीनशॉट - बिंदु

जैसा कि आप देख सकते हैं (या शायद नहीं कर सकते), स्क्रीन पर एक एकल पिक्सेल चल रहा है। जबकि यह बाइट बचाता है, यह परिणामों की सबसे संतोषजनक नहीं है।

तो मैंने एक वैकल्पिक 131 बाइट्स समाधान बनाया है :

x,y,a,b=0,0,1,1
function love.draw()a=(x<0 or x>795)and-a or a
b=(y<0 or y>595)and-b or b
x=x+a
y=y+b
love.graphics.print(0,x,y)end

यह एक का उपयोग करता है love.graphics.print- जो पाठ को प्रिंट करता है - और 0एक गेंद के रूप में, यह बहुत अधिक दृश्यमान और आकर्षक बनाता है।

एनिमेटेड स्क्रीनशॉट - शून्य

— माथियस एवलर
स्रोत
1

सीएचआईपी -8, 36 34 28 बाइट्स

FF29 'LDF I,vF //load digit sprite for the value of vF (should be 0)

4000 'SNE v0,0 //if x is 0...
6201 'LD v2,1 //set x velocity to 1
403C 'SNE v0,3C //if x is 3C...
62FF 'LD v2,FF //set x velocity to -1
4100 'SNE v1,0 //if y is 0...
6301 'LD v3,1 //set y velocity to 1
411B 'SNE v1,1B //if y is 1B...
63FF 'LD v3,FF //set y velocity to -1

D015 'DRW v0,v1,5 //draw sprite
D015 'DRW v0,v1,5 //draw sprite again to clear it.
8024 'ADD v0,v2 //add x velocity to x
8134 'ADD v1,v3 //add y velocity to y

1202 'JMP 202 //jump to second instruction

यहां कोई फैंसी ट्रिक नहीं ...

एक दुभाषिया की आवश्यकता होती है जो स्प्राइट्स को सही ढंग से खींचता है (केवल एक स्प्राइट प्रति फ्रेम खींचा जा सकता है, जो आपको देखने में सक्षम होने के लिए कार्यक्रम को धीमा कर देता है)।

कम गुणवत्ता वाला वीडियो

— 12Me21
स्रोत
0

जेडएक्स स्पेक्ट्रम बेसिक - 179 बाइट्स

यहाँ यह सिर्फ थोड़ा सा गाढ़ा है। यह गेंद ग्राफिक्स के साथ 179 बाइट्स शामिल है

  10 LET a=10: LET b=10: LET c=1: LET d=-1: FOR e=0 TO 7: READ f: POKE USR "a"+e, f: NEXT e
  20 DATA 60, 126,243,251,255,255,126,60
  30 PRINT AT b,a;"\a"
  40 IF a<1 OR a>30 THEN LET c=-c
  50 IF b<1 OR b>20 THEN LET d=-d
  60 LET a=a+c: LET b=b+d: PRINT AT b-d, a-c;" ": GO TO 30
— DrIB
स्रोत
कृपया जवाब के लिए उपयोग किए जाने वाले मार्क-अप को देखें, चरित्र का उपयोग करके oया Oआप प्रतीकात्मक लिस्टिंग में कुछ बाइट्स को बचाने में सक्षम हो सकते हैं; जब आप एक ही प्रश्न का फिर से जवाब देने के बजाय, आपने समाधानों में सुधार किया है, तो आप पिछले उत्तरों को संपादित करने में सक्षम हैं
— शॉन बेयबर्स
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.