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

선택한 언어 / 플랫폼에서 유사한 프로그램을 만들어 단말기, 스크린, 캔버스 또는 기타 시각적 표시 영역 주위에 공 모양의 물체를 튀기십시오.

C64의 PETSCII 그래픽을 정확하게, 단순 O하거나 간단하게 모방 o할 필요는 없으며, GOTO아직 언어로 존재 하는 명령 을 사용할 필요도 없습니다 . 공이 캔버스 상단에서 시작하여 캔버스 한계에 도달 할 때까지 대각선으로 이동 한 후 다음과 같이 튀는 경우

• 아래쪽과 오른쪽으로 이동하고 화면 영역의 아래쪽을 치고 튀어 오른쪽으로 계속합니다.
• 상하로 여행하고 가장 오른쪽 경계를 치고 왼쪽과 위로 튀어 오릅니다.
• 왼쪽과 위로 이동하고 상단을 때리고 왼쪽과 아래로 튕 깁니다.
• 왼쪽과 아래쪽으로 이동하여 가장 왼쪽 경계에 도달하면 오른쪽과 아래로 튀어 오릅니다.
• 모든 코너를 명중하고 방향을 반대로합니다.

그럼 우리 모두 잘 지내요

C64의 BASIC 목록에서와 같이 한 번에 8 픽셀 씩 공을 움직일 필요는 없습니다. 한 번에 한 문자 블록이나 한 픽셀 씩 이동할 수 있습니다.

이 기본 목록이 작동하는지 확인하려면 브라우저에서 Flash를 지원하는 이 온라인 Commodore 64 에뮬레이터 를 사용하여 입력 할 수 있습니다 .

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를 사용하지 않고 대신 어리석은 빈 루프). Titus의 골프 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. 경계선이 깜빡이는 동안 ( 아마도 가능하지는 않지만) 중지 하면 흰색으로 유지됩니다 . 수동으로 복원해야합니다.

배시 + 유닉스 유틸리티 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는 'DECLE'로 알려진 10 비트 값으로 인코딩됩니다. 이 프로그램의 길이는 4800 달러에서 4848D로 끝나는 62 DECLE입니다.

16 진 덤프 + 소스

                            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 바이트

다음과 같이 중첩 된 <marquee>태그로 1998 년을 가장하십시오 .

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

IE에서 읽은 내용에서도 여전히 선택 윤곽을 지원해야하지만 Microsoft Edge에서 테스트되었습니다. 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 방법입니다.

하드웨어에서 더 매끄럽게 보입니다.

펀드, 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)을 교체하여 속도를 조정할 수도 있습니다 .

자바, 184176 바이트

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 이스케이프 시퀀스 를 사용 하여 커서를 재배치하는데, 이는 85 x 25터미널 디스플레이 주변에서 튀는 객체입니다 . 라는 파일에 저장하십시오 A.java.

언 골프

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

언 골프 드 :

(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무한 반복되는. 이 무한 반복은 ịJelly에서 사용하는 모듈 식 인덱싱을 사용하여 에뮬레이션 할 수 있습니다 . 예 : 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.

스마일 BASIC, 85 74 바이트

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

공의 위치는 2 개의 삼각파로 모델링 할 수 있으며 SmileBASIC에서 볼을 생성 할 수있는 가장 짧은 방법은 arcsine (sine (x))입니다. (SB MOD대신을 사용하므로 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: 주어진 함수를 ⍺ = given = 1 1로 호출
  • ⎕SM∘←0,G←⍺+⍵: 가게 ⍺+⍵에가 G하는 표시 0에서 해당 위치에 ⎕SM창을여십시오.
  • ⎕DL.1: 1/10 초 기다립니다
  • ⊃1 G∨.≥G⎕SD다음의 경우 체크 G상기 인 ⎕SM창 경계 ( 1≥G또는 G≥⎕SD, ⎕SD은 IS 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)= 줄 바꿈
A^a= chr(32)= 공백

Simons의 기본 (C64), 66 65 바이트

@ShaunBebbers 덕분에 1 바이트가 절약되었습니다.

Simons 'Basic은 모듈로 기능을 가지고 있기 때문에 한 줄만 필요합니다.
AfaIk, 이것은 물리적 C64와 Simons의 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을 사용하여 입력하십시오.

바이트 수

디스크에 저장하면 명령이 토큰 화되어 있기 때문에, 그것은 65 바이트를 취합니다
for, to, poke, abs, next및 goto각 바이트 하나입니다; mod2 바이트가 걸립니다.
이것은 59 바이트의 코드와 포인터의 경우 4 바이트, 줄 번호의 경우 2 바이트를 만듭니다.

참조 는 C64 맵핑 및 $800(BASIC 프로그램 텍스트) 검색을 참조하십시오 .
(비디오 화면 메모리 영역은$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

불행히도 두 줄이 필요합니다. 가능한 모든 약어를 사용하더라도 C64 줄 편집기를 사용하기에는 너무 많은 83자가 필요합니다.

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

(16 진 편집기를 사용하여 더 긴 행을 작성할 수 있습니다. 73 바이트가됩니다.)

파이썬 2, 176168 바이트

이것은 터미널 크기가 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을 제안하고 y에 대해 ditto를 제안한 R. Kap에게 감사합니다.

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

언 골프 드 :

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디렉토리 에 도착해야했다 . 따라서, 나는 이것을 검색 했다. 내가 찾은 것입니다. Linux 용 SDL을 사용하는 TurboC Graphics 구현입니다. OpenGL을 사용할 수도 있습니다. Windows에서는 MacOS에 대해 잘 모르고 이미 설치되어 있다고 생각합니다.
• void initgraph(int *graphdriver, int *graphmode, char *pathtodriver);시스템을 초기화하고 그래픽 모드로 전환합니다.이 경우 그래픽 드라이버가 자동으로 감지됩니다. 자세한 내용은이 링크 를 참조하십시오.
• x그리고 y볼의 위치를 결정하는 좌표이다.
• a그리고 b플래그이다 a때 0으로 설정된 x값이 60 아래로 떨어질 때와 b경우에 0으로 설정된다 y(60) 아래로 떨어진다.
• 플래그가 교체되는 경우 x와y 창의 경계 값을 초과 초과 되며 좌표는 그에 따라 조정됩니다.
• 내가 넣어 usleep내 CPU가 스트레스를받지 않도록한다.
• closegraph()창을 닫으려면 일반적으로 전화를 사용해야합니다 . 그러나 여기에 없습니다.

링커 플래그로 컴파일해야합니다 -lgraph

실제 하드웨어에서 더 매끄럽게 실행됩니다. :)

MATL , 42 바이트

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

이것은 70 × 16 스크린과 캐릭터를 사용 O합니다. 몇 번의 바운스를 기다리는 경우 공이 코너에 닿는 것을 볼 수 있습니다.

MATL Online에서 사용해보십시오!

코드에서 화면 크기를 쉽게 수정할 수 있습니다. 관련 부분은 8E70, 밀고 8, 두 배로, 밀고 70있습니다. 예를 들어, 80 × 25 스크린으로 대체 5W80되는 푸시 5사각형 그것과 밀고 80(또는 대체하여25 80 만 1 바이트가 더 필요함).

또한 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각각 세로 또는 가로 가장자리에 도달했다면 방향 벡터의 해당 구성 요소는 무시됩니다. 그 후, 새로운 방향이 현재 위치에 추가되어 새로운 위치를 얻습니다.

Here's the ZX Spectrum listing.

  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 bytes

#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();}}

Explanation:

#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 bytes

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 is not the best language when it comes to code golf, but here you go! A few points worth mentioning:

• The default canvas size is 800 x 600. It can be changed in the configuration file, but I didn't see any size restrictions, so I left it as is.

• love.draw()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 bytes

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

No fancy tricks here...

Requires an interpreter that draws sprites correctly (only one sprite can be drawn per frame, which slows down the program enough for you to be able to see it).

Low quality video

ZX Spectrum BASIC - 179 bytes

Here it is just condensed a little bit. It's 179 bytes with the ball graphics included

  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