Diese Aufgabe ist einfach: Schreiben Sie ein Programm oder eine Funktion, die die Liste aller Noten (unter Verwendung englischer Notennamen) von A ♭ bis G♯ ausgibt.

Bei allen Noten ohne Namen, die aus einem einzelnen Buchstaben bestehen (dh schwarzen Noten auf einer Musiktastatur), sollte der Name zweimal gedruckt werden, einmal als Schärfe einer Note, einmal als Ebene einer Note. Scharfe oder flache Noten, die mit einem Buchstaben wie B♯ (C) oder F F (E) beschrieben werden können, sollten nicht ausgegeben werden.

Hier ist ein Beispiel für die Ausgabe:

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

Spezifikationen

Das Programm oder die Funktion darf keine Eingabe annehmen.
Die Notizen können in beliebiger Reihenfolge und in einer Liste gedruckt werden, die nach unseren Standard-E / A-Regeln zulässig ist
Die scharfen und flachen Unicode-Symbole (♯ / ♭) können durch b und ersetzt werden#
Standardlücken sind wie immer verboten.
Da es sich um Code-Golf , das kleinste Programm, in Bytes, gewinnt.

code-golf kolmogorov-complexity

— TheOnlyMrCat
quelle

3

1

Mai geben wir "C "statt "C"?

— Arnauld

1

@ Arnauld ja, Sie können

— TheOnlyMrCat

7

Übrigens existiert B # in der Musiknotation; Es ist zum Beispiel in der Schlüsselsignatur für die Taste von C #, wo es als Leitton dient.

— Kaz

2

Ich weiß nicht, es fühlt sich an, als ob Cb hier fehlt;)

— AJFaraday

13

Malbolge , 482 370 353 Bytes

R1: Entfernte Kommas dazwischen (wie von der Challenge nicht benötigt)

R2: Rasiere ein paar Bytes ab

('<;_#!=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

Probieren Sie es online!

— Krzysztof Szewczyk
quelle

12

CP-1610- Baugruppe ( Intellivision ), 31 DECLEs ¹ = 39 Byte

Eine Routine, die einen Ausgabezeiger in R4 nimmt und die Notizen dort durch Leerzeichen getrennt schreibt. Im Beispielcode schreiben wir direkt auf den Bildschirm.

Hex-Dump (nur Routine)

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

Volle Quelle

                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

Ausgabe

^{Screenshot von jzIntv}

_{1. Ein CP-1610-Opcode wird mit einem 10-Bit-Wert codiert, der als "DECLE" bezeichnet wird. Diese Routine ist 31 DECLE lang und beginnt bei 4820 US-Dollar und endet bei 483 US-Dollar (im Lieferumfang enthalten).}

— Arnauld
quelle

9

Python 3 , 50 Bytes

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

Probieren Sie es online!

Python 2: 48 Bytes

Dieser Code kann so angepasst werden, dass er B # und Cb enthält, ohne dass zusätzliche Bytes anfallen. Dies kann durch Ersetzen 5durch erreicht werden 6.

Außerdem ist es (endlich) kürzer als nur die einfache Zeichenfolge auszugeben:

Python 3 , 51 Bytes

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

Probieren Sie es online!

Python 2: 50 Bytes

— Jitse
quelle

2

Dies ist eine sehr kreative Lösung

— TheOnlyMrCat

7

05AB1E , 16 15 13 Bytes

Au…b #âŽ7×bûÏ

-2 Bytes dank @maxb .

Probieren Sie es online aus.

Ausgabe als Liste, wobei die einzelnen Zeichen mit einem Leerzeichen am Ende versehen sind.

Erläuterung:

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)

Sehen Sie sich meinen Tipp 05AB1E (Abschnitt Wie komprimiere ich große ganze Zahlen? ) An, um zu verstehen, warum dies so Ž7×ist 1999.

Ž7×könnte alternativ ₄·<(1000, doppelt, um 1 verringert) für die gleiche Byteanzahl sein.

— Kevin Cruijssen
quelle

3

Ist das 7£wirklich nötig? Scheint ohne gut zu laufen.

— 15.

6

Jelly , 18 × 20 Bytes

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

Ein monadischer Link, der eine Liste von Zeichenlisten zurückgibt.

* _{Wenn eine gemischte Liste von (a) Zeichenlisten und (b) Zeichen akzeptabel ist, entfernen Sie das Nachstellen W€für 18.}

Probieren Sie es online!

Wie?

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

— Jonathan Allan
quelle

@mirabilos diese 20 Bytes des Quellcodes ist, die Unicode - Zeichen jeweils repräsentieren ein Byte des Quellcodes - siehe die Codepage mit dem Wort verknüpft bytesin der Kopfzeile.

— Jonathan Allan

5

Retina 0.8.2 , 33 Bytes


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

Probieren Sie es online! Erläuterung:


ABCDEFG

Fügen Sie die Basisnotennamen ein.

.
 $&b $& $&#

Erweitern Sie jede Note um flache und scharfe Versionen.

 [BE]#...

Löschen B#, E#und auch die Noten nach ihnen ( Cbund Eb).

— Neil
quelle

5

Perl 6 , 41 Bytes

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

Probieren Sie es online!

Einfaches Kreuzprodukt der Noten und der Scharfen / Flächen, gefolgt vom Entfernen der zusätzlichen ungültigen Noten. Dies ist ein anonymer Codeblock, der die Zeichenfolge erzeugt:

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

— Scherzen
quelle

4

R , 50 Bytes

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

Probieren Sie es online!

Langweilige Antwort.

R , 60 Bytes

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

Probieren Sie es online!

— Giuseppe
quelle

1

Ich denke, die Liste der Beispiele für redundante Noten ist nicht erschöpfend - die Beispielausgabe lässt auch Cbund aus E#.

— Unabhängiger String

4

Holzkohle , 21 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

    α                   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

— Neil
quelle

3

Japt , 23 22 Bytes

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

Versuch es

;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#")

— Verkörperung der Ignoranz
quelle

Ihr Code enthält, <6aber es ist <5in der Erklärung.

— TheOnlyMrCat

@TheOnlyMrCat Bearbeitet

— Verkörperung der Ignoranz

2

dzaima / APL REPL, 38 28 25 Bytes

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

Probieren Sie es online!

— dzaima
quelle

Ich denke, dass Sie das entfernen können ⎕←.

— Erik der Outgolfer

@EriktheOutgolfer hmm ja, wenn ich um

— dzaima

Oh richtig, ich habe vergessen, die {}LOL zu zählen .

— Erik der Outgolfer

2

Stax , 17 15 Bytes

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

Führen Sie es aus und debuggen Sie es

Bonusprogramm: Drucken Sie die ausgefallenen Symbole aus

— rekursiv
quelle

2

Ruby , 43 Bytes

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

Probieren Sie es online!

Mit diesem Bereich 0..20würde ein Array gedruckt, das alle Ebenen, alle natürlichen Elemente und alle scharfen Elemente enthält. Die unerwünschten Fb Cb E# B#werden durch die Verwendung des Bereichs weggelassen2..18

Die Noten werden in der Reihenfolge https://en.wikipedia.org/wiki/Circle_of_fifths ausgedruckt, dh jeweils um 7 Halbtöne aufsteigend (ein Frequenzverhältnis von fast genau 1,5).

Dies führt zu der angegebenen Reihenfolge der Notenbuchstaben, in der jede Note fünf Grad (als "fünfte" bezeichnet) über der vorherigen Note liegt. Zum Beispiel F->CistFGABC

— Level River St
quelle

Ich mag es, dass du um Fünftel aufsteigst. Nett.

— Wayne Conrad

2

Brainfuck , 106 Bytes

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

Probieren Sie es online!

Gibt jede Note getrennt durch Wagenrücklauf aus.

— Scherzen
quelle

2

Zsh , 36 Bytes

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

Eine hässlichere Lösung, die jedoch zwei Zeichen speichert. (F)Verbindet eine Liste mit Zeilenumbrüchen und //[BE]#???entfernt die Teile der Zeichenfolge, die wir benötigen.

Probieren Sie es online!

Zsh , 38 Bytes

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

Ich genieße es immer, wenn Zsh Perl schlägt (hoffentlich spreche ich nicht zu früh ...).

<<<${${:-{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

Probieren Sie es online!

— GammaFunktion
quelle

1

Jelly , 21 Bytes

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

Probieren Sie es online!

— Erik der Outgolfer
quelle

1

Brachylog , 36 Bytes

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

Probieren Sie es online!

Ich bin gerade dabei, den Powerset-Index zu erzwingen, der es mir ermöglichen würde, ihn zu entfernen ⟨h₅ct₁₄⟩⟨h₁₂ct₅⟩(und zwar ↺, da die Ausgabe nicht in der gleichen Reihenfolge wie die Beispielausgabe erfolgen muss), aber es dauert ziemlich lange während ... vielleicht sollte ich eine Minute beiseite legen, um herauszufinden, in welcher Reihenfolge Unterlisten generiert werden, und den Index auf diese Weise berechnen ...

— Unabhängige Zeichenfolge
quelle

1

Canvas , 23 Byte

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

Probieren Sie es hier aus!

22 Bytes mit zusätzlichen Zeilenumbrüchen in der Ausgabe

— dzaima
quelle

1

PHP , 65 Bytes

Erstellt die Liste mit einer Schleife. Elemente werden durch _ein nachstehendes Trennzeichen getrennt.

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

Probieren Sie es online!

PHP , 43 Bytes

PHP gibt alles so aus, wie es ist, wenn es nicht in <?phpund ?>Tags ist.

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

Probieren Sie es online!

— Night2
quelle

1

Pyth , 23 21 Bytes

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

Probieren Sie es online!

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

Bearbeiten: Teilweises Umschreiben, um 2 Bytes zu sparen, Vorgängerversion: s%2c*<r1G7"b #"xLG"fhoq Online ausprobieren!

— Sok
quelle

1

Commodore C64 / TheC64 Mini (wahrscheinlich andere Commodore 8-Bit-BASIC-Varianten) - 52 tokenisierte BASIC-Bytes

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

Durch Drücken der CTRLPlus-Taste Nauf der C64-Tastatur wird der Zeichensatz für Groß- / Kleinschreibung in den Geschäftsmodus versetzt. Wir können dies in einer Zeichenfolge in einem Byte / Token ausdrucken; und da wir 40 Spalten haben, ist der Raum von G zu G # nicht erforderlich.

In diesem Fall muss die Zeichenfolge nicht geschlossen werden, da es sich nicht um eine Zeile mit mehreren Anweisungen und einem :Trennzeichen handelt.

Wie dies auf einem Commodore C64 (und kompatiblen) Bildschirm aussieht, wird unten gezeigt.

— Shaun Bebbers
quelle

1

Fass , 43 Bytes

Die Zeichenfolge, komprimiert.

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

TIO

— EIN
quelle

0

APL (Dyalog Unicode) , 45 Byte

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

Probieren Sie es online!

Einfache ⎕REplace-Operation, ,bei der jedem Element in der Zeichenfolge, das mit jedem Buchstaben im Buchstaben ⎕Aübereinstimmt, vorangestellt wird und die ersten beiden Zeichen gelöscht werden ,.

— J. Sallé
quelle

0

Brainfuck, 214 Bytes

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

Probieren Sie es online!

— Zachary Cotton
quelle

0

JavaScript (Node.js) , 84 Byte

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

Probieren Sie es online!

Nur die Zeichenfolge (wie unten gezeigt) zurückzugeben, wäre um 36 Byte kürzer, aber wo ist der Spaß dabei?

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

— T. Dirks
quelle

0

Brainfuck , 255 115 Bytes

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

Probieren Sie es online!

— Krzysztof Szewczyk
quelle

1

Ich würde das gutheißen, aber es ist falsch. Es gibt keine schwarzen Noten zwischen B und C oder zwischen E und F. Sie sollten also nicht ausgeben. B #, Cb, E # oder Fb. Außerdem sehe ich in der Spezifikation nichts darüber, dass es in Ordnung ist, Kleinbuchstaben zu verwenden.

— Level River St

@LevelRiverSt die Herausforderung hat nirgendwo angegeben, dass wir keine Notizen zwischen B und C & E und F haben

— 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.

Das scheint mir ziemlich klar zu sein und ich sehe keinen Bearbeitungsverlauf auf dem OP auf meinem Bildschirm.

— Level River St

0

Bash 5 , 42 Bytes

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

Ausgabe:

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

— Thorsten
quelle

0

Perl 5 , 47 41 Bytes

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

Probieren Sie es online!

— Xcali
quelle

0

T-SQL, 124 Bytes

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

Zeilenumbrüche dienen nur zu Anzeigezwecken.

Länger aber viel interessanter als die Trivialversion (50 Bytes) :

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

— BradC
quelle

0

Z80Golf , 31 29 Bytes

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

Probieren Sie es online!

Erklärung :

Z80Golf ist nur eine einfache Fantasy-Maschine, die auf der 8-Bit-CPU Z80 basiert. Das Programm wird an der Speicherstelle geladen 0x0000und der Rest des Speichers wird mit Nullen gefüllt. Die Ausgabe erfolgt durch einen Aufruf 0x8000, der den Wert von Register A als Zeichen ausgibt.

Das Programm startet mit den zu verarbeitenden Daten, insgesamt 6 Bytes. Jedes Bytepaar gibt ein Notensuffix und eine Bitmaske an, die steuert, welcher der Buchstaben mit dieser Notiz kombiniert werden kann. Um Bytes zu sparen, wird das Suffix-Zeichen invertiert ( xor 0xff). Dadurch können die Daten als Anweisungen mit geringen Nebenwirkungen ausgeführt werden, sodass ein Sprung entfernt werden kann, der diese Daten überspringt:

               ;    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:

So dekodiert die CPU das:

    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.

Diese Daten werden jeweils zwei Bytes in das DE-Registerpaar eingelesen. Der Stapelzeiger zeigt auf das nächste Element. Sie beginnt bei 0, und da der Z80 einen vollständigen, absteigenden Stapel verwendet, lesen alle Pops das nächste Datenpaar - alle Stapeloperationen sind 16-Bit-Operationen.

Die äußere Schleife ist mit einem Dekrementierungszähler im B-Register implementiert, für den der Z80 eine besondere Unterstützung in Form der djnzAnweisung bietet :

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

Der aktuelle Buchstabe wird im A-Register gespeichert. Da das Inkrement am Anfang der Schleife gut passt, laden wir eines weniger als den tatsächlichen Startwert von 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

— NieDzejkob
quelle

Die Liste der Noten ausgeben

Spezifikationen

Malbolge , 482 370 353 Bytes

CP-1610- Baugruppe ( Intellivision ), 31 DECLEs 1 = 39 Byte

Hex-Dump (nur Routine)

Volle Quelle

Ausgabe

Python 3 , 50 Bytes

Python 3 , 51 Bytes

05AB1E , 16 15 13 Bytes

Jelly , 18 × 20 Bytes

Wie?

Retina 0.8.2 , 33 Bytes

Perl 6 , 41 Bytes

R , 50 Bytes

R , 60 Bytes

Holzkohle , 21 Bytes

Japt , 23 22 Bytes

dzaima / APL REPL, 38 28 25 Bytes

Stax , 17 15 Bytes

Ruby , 43 Bytes

Brainfuck , 106 Bytes

Zsh , 36 Bytes

Zsh , 38 Bytes

Jelly , 21 Bytes

Brachylog , 36 Bytes

Canvas , 23 Byte

PHP , 65 Bytes

PHP , 43 Bytes

Pyth , 23 21 Bytes

Commodore C64 / TheC64 Mini (wahrscheinlich andere Commodore 8-Bit-BASIC-Varianten) - 52 tokenisierte BASIC-Bytes

Fass , 43 Bytes

APL (Dyalog Unicode) , 45 Byte

Brainfuck, 214 Bytes

JavaScript (Node.js) , 84 Byte

Brainfuck , 255 115 Bytes

Bash 5 , 42 Bytes

Perl 5 , 47 41 Bytes

T-SQL, 124 Bytes

Z80Golf , 31 29 Bytes

CP-1610- Baugruppe ( Intellivision ), 31 DECLEs ¹ = 39 Byte