이 작업은 간단합니다. 모든 음표 목록 (영어 음표 이름 사용)을 A ♭에서 G♯까지 출력하는 프로그램이나 기능을 작성하십시오.

한 글자로 구성된 이름이없는 모든 음표 (예 : 뮤지컬 키보드의 검은 색 음표)는 한 번의 음표로 한 번, 평지로 한 번, 이름이 두 번 인쇄되어야합니다. B♯ (C) 또는 F ♭ (E)와 같이 한 글자로 설명 할 수있는 날카 롭거나 납작한 음표는 출력하지 않아야합니다.

다음은 출력 예입니다.

Ab, A, A#, Bb, B, C, C#, Db, D, D#, Eb, E, F, F#, Gb, G, G#

명세서

프로그램이나 기능은 입력을 받아서는 안됩니다.
노트는 표준 I / O 규칙에 따라 허용되는 모든 순서와 순서로 인쇄 될 수 있습니다.
날카 롭고 편평한 유니 코드 기호 (♯ / ♭)는 b 및#
항상 그렇듯이 표준 허점 은 금지되어 있습니다.
이것이 code-golf 이므로 바이트 단위의 가장 작은 프로그램이 승리합니다.

code-golf kolmogorov-complexity

— TheOnlyMrCat
소스

3

말레 볼제 , 482 (370) 353 바이트

R1 : 사이에 쉼표가 제거되었습니다 (챌린지에 필요하지 않음)

R2 : 몇 바이트를 면도

('<;_#!=6Z|{8xUwvt,PrqonKmk)"FhCUTdb?`+<;:[Z7YtVU2T|/g-O+i(gJrHc#EC~B{@zZxw:tt'r5Qo"!l/K-hUfe?bP``_Lo~[}|X2VCTR3Q+N`_^9+7Hji3ffdAc~w|u;]\wpon4VUSSQ.PONcb(JI^]#DCYX|@?>=<:u9NMRKo32MFj.C,Ae)>'<%:^"!~5:3WxwwuRts0q(Lnml)"Fhgfe"y?a`_zyxq7YXWlUj0RgfkjMb(JI^c\[Z~BAV?T=Rv987Mq44310FEi-,G@)>b&%#"8=6Z{{yyw/Sut1*)('Km$k(!Efe{zyx>`uz]r8ZXnm3TTih.PkNchg`&HFF[DY}Az

온라인으로 사용해보십시오!

— 크 르지 스토 프 슈체 치크
소스

12

CP-1610 어셈블리 ( Intellivision ), 31 DECLE ¹ = 39 바이트

R4 에서 출력 포인터를 가져 와서 공백으로 구분하여 메모를 작성 하는 루틴 . 예제 코드에서는 화면에 직접 씁니다.

16 진 덤프 (루틴 만)

275 001 2BD 03C 048 1DB 2B8 012 044 2A9 2BA 108 078 201 003 262
261 263 2FA 008 37A 140 225 00B 089 22C 011 2B7 018 210 000

전체 소스

                ROMW    10              ; use 10-bit ROM width
                ORG     $4800           ; map this program at $4800

                ;; ------------------------------------------------------------- ;;
                ;;  test code                                                    ;;
                ;; ------------------------------------------------------------- ;;
4800            SDBD                    ; set up an interrupt service routine
4801            MVII    #isr,     R0    ; to do some minimal STIC initialization
4804            MVO     R0,       $100
4806            SWAP    R0
4807            MVO     R0,       $101

4809            EIS                     ; enable interrupts

480A            MVII    #$200,    R4    ; R4 = backtab pointer
480C            CALL    notes           ; invoke our routine

480F            DECR    R7              ; loop forever

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

4810            MVO     R0,       $0020 ; enable display

4812            CLRR    R0
4813            MVO     R0,       $0030 ; no horizontal delay
4815            MVO     R0,       $0031 ; no vertical delay
4817            MVO     R0,       $0032 ; no border extension
4819            MVII    #$D,      R0
481B            MVO     R0,       $0028 ; light-blue background
481D            MVO     R0,       $002C ; light-blue border

481F            JR      R5              ; return from ISR

                ENDP

                ;; ------------------------------------------------------------- ;;
                ;;  routine                                                      ;;
                ;; ------------------------------------------------------------- ;;
      notes     PROC

4820            PSHR    R5              ; save return address

4821            SDBD                    ; R5 = pointer to @@chr
4822            MVII    #@@chr,   R5
4825            CLRR    R3              ; R3 = 0 (space)
4826            MVII    #$12,     R0    ; R0 = bitmask = $12
4828            SWAP    R0,       2     ; extend it to $1212

4829  @@loop    MVI@    R5,       R1    ; R1 = next symbol
482A            MVII    #('A'-32)*8, R2 ; R2 = 'A' character

482C  @@note    SARC    R0              ; right shift the bitmask
482D            BC      @@next          ; skip this note if the carry is set

482F            MVO@    R2,       R4    ; append the note
4830            MVO@    R1,       R4    ; append the symbol
4831            MVO@    R3,       R4    ; append a space

4832  @@next    ADDI    #8,       R2    ; advance to the next note
4834            CMPI    #('H'-32)*8, R2 ; is it now a 'H'?
4836            BLT     @@note          ; if not, process the inner loop

4838            TSTR    R1              ; was the symbol a space?
4839            BNEQ    @@loop          ; if not, process the outer loop

483B            PULR    R7              ; return

483C  @@chr     DECLE   ('#'-32)*8      ; '#'
483D            DECLE   ('b'-32)*8      ; 'b'
483E            DECLE   0               ; space

                ENDP

산출

^{jzIntv의 스크린 샷}

_{1. CP-1610 opcode는 'DECLE'로 알려진 10 비트 값으로 인코딩됩니다. 이 루틴의 길이는 $ 4820에서 $ 483E (포함)로 끝나는 31 DECLE입니다.}

— 아르나 울드
소스

9

파이썬 3 , 50 바이트

print(*map(''.join,zip(3*'ADGBCEF',7*' '+5*'#b')))

온라인으로 사용해보십시오!

파이썬 2:48 바이트

이 코드는 추가 바이트없이 B # 및 Cb를 포함하도록 조정할 수 있습니다. 로 대체 5하면 6됩니다.

또한 일반 문자열을 출력하는 것보다 (최종적으로) 짧습니다.

파이썬 3 , 51 바이트

exit('Ab A A# Bb B C C# Db D D# Eb E F F# Gb G G#')

온라인으로 사용해보십시오!

파이썬 2:50 바이트

— 지테
소스

2

이것은 매우 창의적인 솔루션입니다

— TheOnlyMrCat

7

05AB1E , 16 15 13 바이트

Au…b #âŽ7×bûÏ

@maxb 덕분에 -2 바이트 .

온라인으로 사용해보십시오.

단일 문자 메모에 후행 공백이있는 목록으로 출력합니다.

설명:

Au             # Push the lowercase alphabet, and uppercase it
  …b #         # Push string "b #"
      â        # Take the cartesian product of both strings to create all possible pairs:
               #  ["Ab","A ","A#","Bb","B ","B#",...,"Zb","Z ","Z#"]
       Ž7×     # Push compressed integer 1999
          b    # Convert it to a binary string "11111001111"
           û   # Palindromize it to "111110011111110011111"
            Ï  # Only leave the notes in the list at the truthy values (1), (the trailing
               # items beyond the length of this binary string are also discarded)
               # (after which the result is output implicitly)

내이 05AB1E 팁을 참조하십시오 (섹션 얼마나 큰 정수를 압축하는 방법을? ) 이유를 이해하는 Ž7×것입니다 1999.

Ž7×또는 ₄·<동일한 바이트 수에 대해 (1000, 이중, 1 씩 감소) 일 수 있습니다.

— 케빈 크루이 센
소스

3

은 7£정말 필요? 그것없이 잘 작동하는 것 같습니다.

— maxb

6

젤리 , 18? * 20 바이트

ØAḣ7µp⁾b#Żs6ḣ€4ẎḊ;W€

문자 목록을 반환하는 모나 딕 링크.

* _{(a) 문자 목록과 (b) 문자의 혼합 목록이 허용되는 경우 후행 W€을 18로 제거하십시오 .}

온라인으로 사용해보십시오!

방법?

ØAḣ7µp⁾b#Żs6ḣ€4ẎḊ;W€ - Link: no argument
ØA                   - list of characters     [A-Z]
  ḣ7                 - head to 7              "ABCDEFG"
    µ                - new monadic link (call that X)
      ⁾b#            - list of characters     "b#"
     p               - Cartesian product      ["Ab","A#","Bb","B#","Cb","C#","Db","D#","Eb","E#","Fb","F#","Gb","G#"]
         Ż           - prepend a zero       [0,"Ab","A#","Bb","B#","Cb","C#","Db","D#","Eb","E#","Fb","F#","Gb","G#"]
          s6         - split into sixes    [[0,"Ab","A#","Bb","B#","Cb"],["C#","Db","D#","Eb","E#","Fb"],["F#","Gb","G#"]]
            ḣ€4      - head each to 4      [[0,"Ab","A#","Bb"],["C#","Db","D#","Eb"],["F#","Gb","G#"]]
               Ẏ     - tighten              [0,"Ab","A#","Bb","C#","Db","D#","Eb","F#","Gb","G#"]
                Ḋ    - dequeue                ["Ab","A#","Bb","C#","Db","D#","Eb","F#","Gb","G#"]
                  W€ - wrap each (of X)       ["A","B","C","D","E","F","G"]
                 ;   - concatenate            ["Ab","A#","Bb","C#","Db","D#","Eb","F#","Gb","G#","A","B","C","D","E","F","G"]

— 조나단 앨런
소스

@mirabilos 이것은 20 바이트의 소스 코드이며, 유니 코드 문자는 각각 소스 코드의 바이트를 나타냅니다 - bytes헤더 의 단어 로 연결된 코드 페이지를 참조하십시오 .

— Jonathan Allan

5

레티 나 0.8.2 , 33 바이트


ABCDEFG
.
 $&b $& $&#
 [BE]#...

온라인으로 사용해보십시오! 설명:


ABCDEFG

기본 노트 이름을 삽입하십시오.

.
 $&b $& $&#

평평하고 날카로운 버전을 포함하도록 각 메모를 확장하십시오.

 [BE]#...

삭제 B#, E#그들 (다음 또한 노트 Cb와 Eb).

— 닐
소스

5

펄 6 , 41 바이트

{S:g/[E|B]\#...//}o{'A'..'G'X~'b #'.comb}

온라인으로 사용해보십시오!

음표와 샤프 / 플랫의 단순한 교차 곱에 이어 잘못된 음표가 제거됩니다. 이것은 문자열을 생성하는 익명 코드 블록입니다.

Ab A  A# Bb B   C  C# Db D  D# Eb E   F  F# Gb G  G#

— 조 킹
소스

4

R , 50 바이트

cat("Ab,A,A#,Bb,B,C,C#,Db,D,D#,Eb,E,F,F#,Gb,G,G#")

온라인으로 사용해보십시오!

지루한 답변.

R , 60 바이트

cat(outer(LETTERS[1:7],c("#","","b"),paste0)[-c(2,5,17,20)])

온라인으로 사용해보십시오!

— 주세페
소스

1

예제 출력도 생략 - 나는 중복 노트의 예제의 목록을 총망라하는 것은 아닙니다 생각 Cb하고 E#.

— 관련없는 문자열

4

숯 , 21 바이트

Φ⪪⭆…α⁷⭆b #⁺ιλ²§↨⊖⊘φ²κ

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

    α                   Predefined variable uppercase alphabet
   … ⁷                  First 7 letters i.e. `ABCEDFG`
  ⭆                     Map over characters and join
       b #              Literal string `b #`
      ⭆                 Map over characters and join
          ⁺ιλ           Concatenate outer and inner characters
 ⪪           ²          Split back into substrings of length 2
Φ                       Filter where nonzero
                  φ     Predefined variable 1000
                 ⊘      Halved i.e. 500
                ⊖       Decremented i.e 499
               ↨   ²    Converted to base 2 i.e. [1, 1, 1, 1, 1, 0, 0, 1, 1]
              §     κ   Cyclically indexed by outer index
                        Implicitly print matching values on separate lines

— 닐
소스

3

apt , 23 22 바이트

;B¯7
ï"b #" fÏÄ %9%8<6

시도 해봐

;B          Alphabet
  ¯7        First seven characters ("ABCDEFG")
            Assign to U
ï"b #"       Cartesian product with "b #" ("Ab,A ,A#,Bb,B ,B#,Cb,C ,C#,Db,D ,D#,Eb,E ,E#,Fb,F ,F#,Gb,G ,G#")
f           Filter:
 ÏÄ           Is index + 1
   %9%8       Mod 9 Mod 8
     <6       Less than 6
            End filter ("Ab,A ,A#,Bb,B ,C ,C#,Db,D ,D#,Eb,E ,F ,F#,Gb,G ,G#")

— 무지의 구체화
소스

코드에 포함되어 <6있지만 <5설명에 있습니다.

— TheOnlyMrCat

@TheOnlyMrCat 편집

— 무지의 구현

2

dzaima / APL REPL, 38 28 25 바이트

(⊤2056111)⌿,' b#'∘.,⍨7↑⎕A

온라인으로 사용해보십시오!

— 자 지마
소스

을 제거 할 수 있다고 생각합니다 ⎕←.

— Outgolfer Erik

@EriktheOutgolfer 흠 그래, 내가 REPL로 전환하면

— dzaima

아 맞다, 나는 {}LOL 을 세는 것을 잊었다 .

— Outgolfer Erik

2

Stax , 17 15 바이트

║♠+I▬┌ó£ΔφΔ`╗╨Å

실행 및 디버깅

보너스 프로그램 : 멋진 기호 인쇄

— 재귀
소스

2

루비 , 43 바이트

p (2..18).map{|i|"FCGDAEB"[i%7]+"b #"[i/7]}

온라인으로 사용해보십시오!

범위를 사용하면 0..20모든 평면, 모든 자연 및 모든 샤프가 포함 된 배열이 인쇄됩니다. 원치 않는 것은 Fb Cb E# B#범위를 사용하여 생략됩니다2..18

노트는 https://en.wikipedia.org/wiki/Circle_of_fifths 에 따라 또는 매번 7 개의 반음 (거의 정확히 1.5의 주파수 비율)으로 오름차순으로 인쇄됩니다 .

이로 인해 각 주문이 이전보다 5도 ( "제 5"라고 함)가 포함 된 주문 순서가 정해집니다. 예를 들어 F->C입니다FGABC

— 레벨 리버 스트리트
소스

나는 당신이 5 분의 1을 오르는 것을 좋아합니다. 좋은.

— 웨인 콘래드

2

brainfuck , 106 바이트

+++[[-<+>>++<]>]<<[-<->]++<<++<,+<-<[->+>+<<]<+[>>>>>+>-[<.<<<.>.[<]]>[>]<+[---<.<.<.[<]]>[>]<++<.<<.<<<-]

온라인으로 사용해보십시오!

캐리지 리턴으로 구분 된 각 노트를 출력합니다.

— 조 킹
소스

2

Zsh , 36 바이트

<<<${${(F):-{A..G}{b,,#}}//[BE]#???}

추악한 해결책이지만 두 문자를 절약합니다. (F)개행 목록에 합류하고 //[BE]#???필요한 문자열 부분을 제거합니다.

온라인으로 사용해보십시오!

Zsh , 38 바이트

<<<${${:-{A..G}{b,,#}}:#([BE]#|[CF]b)}

Zsh가 Perl을 이길 때 나는 항상 그것을 즐긴다.

<<<${${:-{A..G}{b,,#}}:#([BE]#|[CF]b)}
     ${:-             }                 # empty-fallback, basically an anonymous parameter expansion
         {A..G}{b,,#}                   # Cross product range A-G with b,(nothing),#
   ${                 :#             }  # Remove matching elements
                        ([BE]#|[CF]b)   # B#, E#, Cb, Fb
<<<                                     # Print to stdout

온라인으로 사용해보십시오!

— 감마 기능
소스

1

젤리 , 21 바이트

ØAḣ7;p¥⁾b#“¿€×Ø‘œPẎẎ€

온라인으로 사용해보십시오!

— 아웃 골퍼 에릭
소스

1

Brachylog , 36 바이트

"#b"ẹ,Ẹ↺;Ṇh₇ᵗ↔{∋ᵐc}ᶠ⟨h₅ct₁₄⟩⟨h₁₂ct₅⟩

온라인으로 사용해보십시오!

나는의 과정에있어 짐승 - 강제 나를 제거 할 것 파워 셋 지수 ⟨h₅ct₁₄⟩⟨h₁₂ct₅⟩(그리고 확장에 의해 ↺출력이 출력 예와 같은 순서로 할 필요가 없기 때문에 등),하지만 꽤을 복용 어쩌면 ... 어쩌면 잠시 시간을내어 실제로 서브리스트가 생성되는 순서를 해결하고 인덱스를 계산해야합니다 ...

— 관련없는 문자열
소스

1

캔버스 , 23 바이트

Ｚ７ｍ｛#＋¹¹b＋］｛“╷!↕„２┬²＠？Ｐ

여기 사용해보십시오!

출력에 추가 줄 바꿈이있는 22 바이트

— 자 지마
소스

1

PHP , 65 바이트

루프로 목록을 만듭니다. 항목은 _후행 구분 기호로 구분됩니다.

for(;$l=ABCDEFG[$i++];)echo$l._.[$a="$l#_",$a.$b=$l.b_,$b][$i%3];

온라인으로 사용해보십시오!

PHP , 43 바이트

PHP는 내부 <?php및 ?>태그 가 아닌 경우 그대로 출력 합니다.

Ab,A,A#,Bb,B,C,C#,Db,D,D#,Eb,E,F,F#,Gb,G,G#

온라인으로 사용해보십시오!

— Night2
소스

1

Pyth , 23 21 바이트

s<R7c.>*<r1G7"b #"2 9

온라인으로 사용해보십시오!

s<R7c.>*<r1G7"b #"2 9   Implicit: G=lowercase alphabet
         r1G            Convert G to upper case
        <   7           First 7 characters
       *     "b #"      Cartesian product with "b #"
     .>           2     Rotate the above 2 places to the right
    c               9   Chop into pieces of length 9
 <R7                    Trim each to length 7
s                       Flatten, implicit print

편집 : 2 바이트를 저장하기 위해 부분 재 작성, 이전 버전 : s%2c*<r1G7"b #"xLG"fhoq 온라인으로보십시오!

— 속여
소스

1

Commodore C64 / TheC64 Mini (아마도 다른 Commodore 8 비트 BASIC 변형)-52 개의 토큰 화 된 BASIC 바이트

 0?"{CTRL+N}Ab A A# Bb B C C# Db D D# Eb E F F# Gb GG#

C64 키보드 에서 CTRL키 플러스 N를 누르면 대문자 / 소문자 문자 세트의 '비즈니스 모드'로 들어갑니다. 우리는 이것을 1 바이트 / 토큰의 문자열로 인쇄 할 수 있습니다. 40 개의 열이 있으므로 G에서 G #까지의 공간이 필요하지 않습니다.

이 경우 문자열은 :구분 기호가 있는 다중 문이 아니므로 문자열을 닫을 필요가 없습니다 .

Commodore C64 (및 호환 가능) 화면에서 어떻게 보이는지 아래에 나와 있습니다.

— 숀 비버
소스

1

케그 , 43 바이트

압축 된 문자열입니다.

AbAA\#BbBCC\#DbDD\#EbEFF\#GbGG\#(:H<[ $]')'

TIO

— 에이
소스

0

APL (Dyalog Unicode) , 45 바이트

2↓(,¨⎕A)⎕R', &'⊢'AbAA#BbBCC#DbDD#EbEFF#GbGG#'

온라인으로 사용해보십시오!

⎕Rlphabet의 ,각 문자와 일치하는 문자열의 각 요소 앞에 추가 ⎕A하고 첫 두 문자 인을 삭제하는 간단한 eplace 조작 ,입니다.

— 살레
소스

0

Brainfuck, 214 바이트

>>>>++++++++[<++++<++++<++++++++++++<++++++++>>>>-]<<+++<++<+.>.>>.<<<.>>>.<<<.>>.>.<<<+.>.>>.<<<.>>>.<<<+.>>>.<<<.>>.>.<<<+.>.>>.<<<.>>>.<<<.>>.>.<<<+.>.>>.<<<.>>>.<<<+.>>>.<<<.>>.>.<<<+.>.>>.<<<.>>>.<<<.>>.>.<<<+

온라인으로 사용해보십시오!

— 재커리 코튼
소스

0

자바 스크립트 (Node.js) , 84 바이트

_=>[...'ABCDEFG'].map((n,i)=>`${i%3!=2?n+'b,':''}${n}${i%3!=1?`,${n}#`:''}`).join`,`

온라인으로 사용해보십시오!

문자열을 반환하면 (아래 그림 참조) 36 바이트가 짧아 지지만 그 재미는 어디에 있습니까?

_=>'Ab,A,A#,Bb,B,C,C#,Db,D,D#,Eb,E,F,F#,Gb,G,G#'

— 디르크
소스

0

brainfuck , 255 115 바이트

--[----->+<]>-----[<+>>+>+<<-]>>+<<<-[->+++<]>+++[->>>+>+<
<<<]>>>>--->+++++++[-<<<<.>.>>.<<<.>>>.<<<.>>.>.<<<+>>>>]

온라인으로 사용해보십시오!

— 크 르지 스토 프 슈체 치크
소스

1

나는 이것을 공언하지만 잘못되었습니다. B와 C 사이 또는 E와 F 사이에 검은 색 메모가 없으므로 출력하지 않아도됩니다. B #, Cb, E # 또는 Fb. 또한 소문자를 사용해도 괜찮다는 사양에 대해서는 아무것도 보지 못했습니다.

— Level River St

@LevelRiverSt 도전은 우리가 B와 C & E와 F 사이에 메모가 없다고 언급하지 않았습니다

— Krzysztof Szewczyk

All notes without a name consisting of a single letter (i.e. black notes on a musical keyboard) should have their name printed twice, once as the sharp of a note, once as the flat of one. Sharp or flat notes that can be described with a single letter, like B♯ (C) or F♭ (E) should not be outputted.

그것은 나에게 꽤 분명해 보이고 내 화면의 OP에 편집 내역이 표시되지 않습니다.

— Level River St

0

배쉬 5 , 42 바이트

x=`echo {A..G}{b,,#}`;echo ${x//[BE]#???/}

산출:

Ab A A# Bb B C C# Db D D# Eb E F F# Gb G G#

— 토르스텐
소스

0

펄 5 , 47 41 바이트

say for'AbA#DbD#GbG#BbEbC#F#'=~/../g,A..G

온라인으로 사용해보십시오!

— Xcali
소스

0

T-SQL, 124 바이트

SELECT value+a
FROM STRING_SPLIT('A-B-C-D-E-F-G','-')
    ,(VALUES('b'),(''),('#'))b(a)
WHERE value+a NOT IN ('B#','E#','Cb','Fb')

줄 바꿈은 표시 목적으로 만 사용됩니다.

사소한 버전 (50 바이트) 보다 길지만 훨씬 더 흥미 롭습니다 .

PRINT'Ab,A,A#,Bb,B,C,C#,Db,D,D#,Eb,E,F,F#,Gb,G,G#'

— BradC
소스

0

Z80Golf , 31 29 바이트

00000000: 9d5b dc6d df7f 0603 3e40 d13c cb3a 3008  .[.m....>@.<.:0.
00000010: fff5 7b2f ffaf fff1 20f1 10ec 76         ..{/.... ...v

온라인으로 사용해보십시오!

설명 :

Z80Golf는 Z80 8 비트 CPU 기반의 단순한 판타지 머신입니다. 프로그램은 메모리 위치에로드되고 0x0000나머지 메모리는 0으로 채워집니다. 0x8000레지스터 A의 값을 문자로 출력 하는를 호출하여 출력을 수행 합니다.

프로그램은 처리 될 데이터 (총 6 바이트)로 시작합니다. 각 바이트 쌍은 메모 접미사와이 메모와 결합 할 수있는 문자를 제어하는 비트 마스크를 지정합니다. 바이트를 저장하기 위해 접미사 문자는 반전됩니다 ( xor 0xff)-부작용없이 명령어로 데이터를 실행할 수 있으므로이 데이터를 건너 뛰는 점프를 제거 할 수 있습니다.

               ;    GFEDCBA
    db 0xff^'b', 0b01011011 ; Ab Bb Db Eb Gb
    db 0xff^'#', 0b01101101 ; A# C# D# F# G#
    db 0xff^' ', 0b01111111 ; A  B  C  D  E  F  G
skip_data:

이것은 CPU가 이것을 해독하는 방법입니다.

    sbc a, l  ; a subtraction with carry on registers we don't care about
    ld e, e   ; put the E register back into itself. This instruction is useless
              ; but still exists to make the encoding regular.
    call c, 0xdf6d ; if the carry flag is set, call a function. The carry flag isn't set
              ; because of the initial register values (all zeroes) when the sbc above
              ; was executed
    ld a, a   ; as above, put A back into itself.

이 데이터는 한 번에 2 바이트 씩 DE 레지스터 쌍으로 읽습니다. 스택 포인터는 다음 요소를 가리키는 데 사용됩니다. 0부터 시작하고 Z80은 전체 내림차순 스택을 사용하므로 모든 팝은 다음 데이터 쌍을 읽습니다. 모든 스택 작업은 16 비트입니다.

외부 루프는 B 레지스터의 감소 카운터로 구현되며 Z80은 djnz명령 형식으로 특별한 지원을 제공합니다 .

    ld b, 3
process_pair:
    ...
    djnz process_pair
    halt

현재 문자는 A 레지스터에 유지됩니다. 증가분은 루프의 시작 부분에 잘 맞기 때문에 실제 시작 값보다 하나 적은 값을로드합니다 A.

process_pair:
    ld a, 'A'-1
    pop de ; D = bitmask, E = suffix character
process_note:
    inc a
    srl d ; put the current bitmask bit in the carry flag
          ; also sets the zero flag if this is the last note in the pair
    jr nc, skip
    ; Print the note. Note that we need to preserve the zero flag to check it in the
    ; loop condition later.
    rst $38 ; Short encoding of call $0038.
            ; Because the program is so short, the memory in the 0038..8000 range
            ; is filled with zeroes, which happens to be the encoding for a no-op.
            ; The execution will therefore fall-through to the character-print hook.
    push af ; Save the letter on the stack (which will be just to the left of the
            ; unprocessed data) to free up A for printing other characters.
            ; (only 16-bit register pairs can be saved, so we also push the flags)
    ld a, e
    cpl     ; Undo the inversion used to make the execution fall-through the data.
            ; Done again each iteration because it takes less bytes to operate
            ; on the A register.
    rst $38 ; Print the suffix.
    xor a   ; Standard assembly practice of setting a register to zero by XORing it
            ; with itself. Saves a byte over a simple `ld a, 0`.
    rst $38 ; Print a null byte as a separator.
    pop af  ; Restore the current letter from the stack.
skip:
    jr nz, process_note ; If the zero flag (last changed at the srl d) is not set,
                        ; loop once again
    djnz process_pair
    halt

— 니 제제 콥
소스

음표 목록 출력

명세서

말레 볼제 , 482 (370) 353 바이트

CP-1610 어셈블리 ( Intellivision ), 31 DECLE 1 = 39 바이트

16 진 덤프 (루틴 만)

전체 소스

산출

파이썬 3 , 50 바이트

파이썬 3 , 51 바이트

05AB1E , 16 15 13 바이트

젤리 , 18? * 20 바이트

방법?

레티 나 0.8.2 , 33 바이트

펄 6 , 41 바이트

R , 50 바이트

R , 60 바이트

숯 , 21 바이트

apt , 23 22 바이트

dzaima / APL REPL, 38 28 25 바이트

Stax , 17 15 바이트

루비 , 43 바이트

brainfuck , 106 바이트

Zsh , 36 바이트

Zsh , 38 바이트

젤리 , 21 바이트

Brachylog , 36 바이트

캔버스 , 23 바이트

PHP , 65 바이트

PHP , 43 바이트

Pyth , 23 21 바이트

Commodore C64 / TheC64 Mini (아마도 다른 Commodore 8 비트 BASIC 변형)-52 개의 토큰 화 된 BASIC 바이트

케그 , 43 바이트

APL (Dyalog Unicode) , 45 바이트

Brainfuck, 214 바이트

자바 스크립트 (Node.js) , 84 바이트

brainfuck , 255 115 바이트

배쉬 5 , 42 바이트

펄 5 , 47 41 바이트

T-SQL, 124 바이트

Z80Golf , 31 29 바이트

CP-1610 어셈블리 ( Intellivision ), 31 DECLE ¹ = 39 바이트