แรงบันดาลใจจากรายชื่อนี้จากคู่มือผู้ใช้ Commodore 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

จัดทำโปรแกรมที่คล้ายกันในภาษา / แพลตฟอร์มที่คุณเลือกเพื่อตีกลับวัตถุที่มีลักษณะคล้ายลูกบอลรอบ ๆ เทอร์มินัลหน้าจอผ้าใบหรือพื้นที่แสดงภาพอื่น ๆ

คุณไม่จำเป็นต้องเลียนแบบกราฟิก PETSCII ของ C64 อย่างง่าย ๆOหรือoจะทำและคุณไม่จำเป็นต้องใช้GOTOคำสั่งถ้ามันยังมีอยู่ในภาษาของคุณ ตราบใดที่ลูกบอลของคุณเริ่มที่ด้านบนของผืนผ้าใบของคุณและเดินทางในแนวทแยงจนกว่ามันจะถึงขีด จำกัด ผ้าใบและจากนั้นตีกลับตามดังนี้:

• การเดินทางลงและไปทางขวาและไปที่ด้านล่างของพื้นที่หน้าจอเด้งขึ้นและดำเนินการต่อไปทางขวา
• การเดินทางขึ้นไปทางขวาและไปถึงขอบเขตที่ถูกต้องที่สุดและตีกลับไปทางซ้ายและขึ้น;
• การเดินทางไปทางซ้ายและขึ้นและไปด้านบนตีกลับไปทางซ้ายและลง;
• การเดินทางไปทางซ้ายและลงและไปถึงขอบซ้ายสุดตีกลับไปทางขวาและลง
• ชมมุมใดก็ได้และกลับทิศทาง;

ถ้าอย่างนั้นเราก็ทำได้ดี

คุณไม่จำเป็นต้องย้ายลูกบอล 8-pixel ในเวลาเดียวกันเช่นเกิดขึ้นในรายการ BASIC บน C64; คุณสามารถย้ายบล็อกอักขระหนึ่งตัวหรือทีละหนึ่งพิกเซลไม่ว่าคุณจะคิดว่าอะไรเหมาะสมที่สุด

หากต้องการดูรายการพื้นฐานของ BASIC นี้คุณสามารถพิมพ์ได้ด้วยCommodore 64 emulator ออนไลน์ที่ให้เบราว์เซอร์ของคุณรองรับ Flash

รหัสเครื่อง 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

ฉันพยายามอย่างหนักเพื่อลดขนาด (เช่นไม่ใช้ IRQ สำหรับการจับเวลา แต่วนลูปที่ว่างเปล่าแทน) ยังคงเป็นไปไม่ได้ที่จะถึงระดับของC64 ที่ตีกอล์ฟพื้นฐานของติตัส : โอ้โห แต่มันดูริบหรี่น้อยกว่า;)

คำอธิบาย: (ถอดแยกชิ้นส่วนรอง)

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 BASIC ทำงานได้ซึ่งทำได้โดยการย้ายพื้นที่ที่อยู่ VIC-II ขึ้นไป$C000ซึ่งต้องคัดลอกเนื้อหาหน้าจอและชุดอักขระ (แบบอักษร)
• มันเชื่อมต่อกับ IRQ ของระบบและเพื่อหลีกเลี่ยงการสั่นไหวเปลี่ยนแหล่งที่มาของ IRQ นี้เป็นชิปกราฟิก VIC-II ดังนั้นการอัพเดตจะกระทำระหว่างเฟรมเสมอ
• บกพร่อง:
  1. RUN/STOP + RESTORE เสียหายอย่าพยายาม
  2. ด้วย VIC-II ในฐานะแหล่ง IRQ เคอร์เซอร์จะกะพริบช้าลงเล็กน้อยและช้าลงTI$เช่นกัน
  3. เมื่อหยุดในขณะที่ขอบแฟลช (เป็นไปได้ยาก แต่เป็นไปได้มาก) มันจะเป็นสีขาว - คุณจะต้องเรียกคืนด้วยตนเอง

ยูทิลิตี Bash + Unix ขนาด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
}

แอนิเมชันของการรันตัวอย่าง:

ชุดประกอบCP-1610 , 67 … 64 62 DECLEs = 78 ไบต์

รหัสนี้มีวัตถุประสงค์ที่จะทำงานบนIntellivision ใช้สไปรต์ฮาร์ดแวร์ตัวหนึ่งซึ่งรู้จักกันในชื่อ MOB (สำหรับ Mobile Object)

CP-1610 opcode ถูกเข้ารหัสด้วยค่า 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

เอาท์พุต

HTML (Microsoft Edge / Internet Explorer), 81 ไบต์

แกล้งทำเป็นปี 1998 ด้วย<marquee>แท็กที่ซ้อนกันเหล่านี้:

<marquee behavior=alternate direction=down><marquee behavior=alternate width=99>O

ทดสอบใน Microsoft Edge แต่จากสิ่งที่ฉันอ่าน IE ก็ควรสนับสนุน marquees ตัดสินใจไม่ทำงานใน Chrome

การตั้งค่าdirection=upจะช่วยประหยัด 2 ไบต์ แต่ผิดกฎที่ลูกบอลต้องเริ่มที่ด้านบนของผืนผ้าใบ

TI-BASIC, 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 ค่าคงที่จึงแตกต่าง

~ เป็นวิธี SourceCoder ในการเขียนสัญลักษณ์ปฏิเสธ

มันดูราบรื่นกว่าบนฮาร์ดแวร์

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) ในบรรทัดสุดท้าย

Java, 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);}}

สิ่งนี้ใช้ประโยชน์จากANSI Escape Sequencesเพื่อย้ายเคอร์เซอร์ใหม่ซึ่งเป็นวัตถุที่เด้งรอบ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;
        }
    }
}

การสาธิต

Clojure, 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 ไบต์โดยการเปลี่ยนชื่อตัวอักษรเป็นสตริงว่างเปล่าเพื่อเริ่มต้นฝังการตรวจสอบขอบเขตและแก้ไขปัญหาขอบเขตด้านล่าง (ซึ่งคุณสามารถดูได้ใน GIF) การแก้ไขไบต์ที่บันทึกจริง

-5 ไบต์โดยการเปลี่ยนเป็นไวยากรณ์การทำลายล้างที่กระชับมากขึ้นและลดขนาดลูกบอลเป็นพิกเซล

ใช้Quil

ฉันพยายามที่จะเปลี่ยนไปใช้โหมดการทำงาน แต่มันต้องใช้รหัสพิเศษจำนวนมากและสิ้นสุดลงว่ามีราคาแพงกว่า

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

แร็กเก็ต 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)

เอาท์พุท:

เยลลี่, 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ช่องว่าง

การสาธิต

คำอธิบาย

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

SmileBASIC, 85 74 ไบต์

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

ตำแหน่งของลูกบอลสามารถสร้างแบบจำลองด้วยคลื่นสามเหลี่ยม 2 ลูกและวิธีที่สั้นที่สุดที่ฉันสามารถหาได้ใน SmileBASIC คือ arcsine (sine (x)) (อัลกอริทึมที่ใช้ MOD นั้นยาวกว่าเนื่องจากใช้ SB MODแทน%)

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

รุ่นนี้จะแสดงขนาดของผืนผ้าใบและให้ความรู้สึกที่มีชีวิตชีวามากขึ้นกับภาพเคลื่อนไหว:

p {
  position: relative;
  width: 80ch;
  height: 25em;
  border: 1px solid black;
}
a {
  position: absolute;
  animation: infinite alternate;
  animation-name: x, y;
  animation-duration: 7.9s, 2.3s;
  animation-timing-function: steps(79), steps(23);
}
@keyframes x {
  from {
    left: 0;
  } to {
    left: 79ch;
  }
}
@keyframes y {
  from {
    top: 0;
  } to {
    top: 24em;
  }
}

<p><a>O</a></p>

Dyalog APL ขนาด 44 ไบต์

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

คำอธิบาย:

• {...}⍨1 1 : เรียกใช้ฟังก์ชันที่กำหนดด้วย⍺ = ⍵ = 1 1
  • ⎕SM∘←0,G←⍺+⍵: store ⍺+⍵in G, แสดง a 0ที่ตำแหน่งนั้นใน⎕SMหน้าต่าง
  • ⎕DL.1: รอ 1 / 10th ของวินาที
  • ⊃1 G∨.≥G⎕SD: ตรวจสอบว่าGอยู่ใน⎕SMเขตแดนหน้าต่าง ( 1≥GหรือG≥⎕SD, ⎕SDเป็นs creen d imensions)
  • 1-2×: แผนที่[1,0]เข้าสู่[¯1,1] , เพื่อพลิกทิศทางการเดินทาง
  • ⍵×: คูณทิศทางปัจจุบันของการเดินทางด้วยสิ่งนั้น
  • G∇: เรียกซ้ำให้Gเป็นตำแหน่งใหม่ ( ⍺) และ⍵....เป็นทิศทางใหม่ ( ⍵)

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)= ช่องว่าง

Simons´ BASIC (C64), 66 65 ไบต์

บันทึกหนึ่งไบต์ขอบคุณ @ShaunBebbers

ฉันต้องการเพียงบรรทัดเดียวที่นี่เพราะ Simons´ Basic มีฟังก์ชั่นโมดูโล
หลังจากนี้, ต้องใช้ฟิสิคัล C64 และโมดูล Basons Simons
(หรือส่วนขยายพื้นฐานอื่น ๆ ที่มี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(ข้อความโปรแกรมพื้นฐาน)
(คุณสามารถค้นหาพื้นที่หน่วยความจำหน้าจอวิดีโอได้ที่$400 )

ชำรุด

โปรแกรมวนลูปIจาก 0 ถึง 623 (= LCM จาก 48 และ 78 ลบ 1) ในการวนซ้ำ

• หน้าจอจะถูกล้าง
• I ได้รับการแมปกับ 39..0..38 ตามลำดับ 24..0..23
• และหยด (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 ไบต์)

Python 2, 176 168 Bytes

นี่ถือว่าเป็นขนาดเทอร์มินัล 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)

ขอบคุณ R. Kap สำหรับการแนะนำ x% 79 <1 แทน x <1 หรือ x> 79 และเหมือนกันสำหรับ y

Rebol / View, 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
            ]
        ]
    ]
]

C 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);}}

เวอร์ชันที่ไม่ถูกปรับแต่ง:

#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ไดเรกทอรีของฉัน ดังนั้นฉันค้นหาและนี่คือสิ่งที่ฉันพบ เป็นการใช้งานกราฟิก TurboC โดยใช้ SDL สำหรับ Linux เราสามารถใช้ OpenGL ได้เช่นกัน ใน windows ฉันคิดว่ามันติดตั้งแล้วไม่แน่ใจเกี่ยวกับ MacOS
• void initgraph(int *graphdriver, int *graphmode, char *pathtodriver);เริ่มต้นระบบและทำให้อยู่ในโหมดกราฟิกในกรณีนี้ไดรเวอร์กราฟิกจะตรวจพบโดยอัตโนมัติ โปรดอ้างอิงลิงค์นี้สำหรับรายละเอียดเพิ่มเติม
• x และ yเป็นพิกัดที่กำหนดตำแหน่งของลูก
• aและตั้งค่าbสถานะaเป็นศูนย์เมื่อxค่าลดลงต่ำกว่า 60 และbตั้งค่าเป็นศูนย์เมื่อyลดลงต่ำกว่า 60
• ธงจะถูกสลับเมื่อ xและyเกินกว่าค่าขอบเขตของหน้าต่างและพิกัดจะถูกปรับตาม
• ฉันใส่ usleepเพื่อให้ CPU ของฉันไม่เครียด
• ปกติควรใช้closegraph()สายเพื่อปิดหน้าต่าง แต่มันหายไปที่นี่

จะต้องรวบรวมด้วยธงลิงเกอร์ -lgraph

มันทำงานได้ราบรื่นกว่าบนฮาร์ดแวร์จริง :)

MATL , 42 ไบต์

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

Oนี้จะใช้หน้าจอและตัวอักษร 70 × 16 หากคุณรอสองสามครั้งคุณจะเห็นลูกบอลชนมุม

ลองที่ 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ในองค์ประกอบแรกหรือครั้งที่สองซึ่งหมายความว่าเราได้มาถึงขอบแนวตั้งหรือแนวนอนตามลำดับส่วนประกอบของเวกเตอร์ทิศทางนั้นถูกทำให้ไร้ผล หลังจากนั้นทิศทางใหม่จะถูกเพิ่มไปยังตำแหน่งปัจจุบันเพื่อรับตำแหน่งใหม่

นี่คือรายการ ZX Spectrum

  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

C + curses, 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();
    }
}

Lua ( LÖVE 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

Lua ไม่ใช่ภาษาที่ดีที่สุดเมื่อพูดถึงการตีกอล์ฟ แต่ที่นี่คุณจะไป! บางจุดที่ควรกล่าวถึง:

• ขนาดผ้าใบเริ่มต้นคือ 800 x 600 มันสามารถเปลี่ยนแปลงได้ในไฟล์กำหนดค่า แต่ฉันไม่เห็นข้อ จำกัด ขนาดใด ๆ ดังนั้นฉันจึงปล่อยไว้ตามที่เป็น

• love.draw()เป็นฟังก์ชั่นการวาดของLÖVEและมีชื่อที่กำหนดไว้ล่วงหน้า ฟังก์ชั่นทางเลือก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เป็นลูกบอลทำให้มองเห็นได้และน่าสนใจยิ่งขึ้น

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

ไม่มีเทคนิคแฟนซีที่นี่ ...

ต้องใช้ล่ามที่ดึงสไปรต์ได้อย่างถูกต้อง (สามารถสไปรต์ได้เพียงหนึ่งเฟรมต่อเฟรมซึ่งจะทำให้โปรแกรมช้าลงพอที่จะให้คุณมองเห็น)

วิดีโอคุณภาพต่ำ

ZX Spectrum BASIC - 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