Виведіть список музичних нот

27

Це завдання просте: Напишіть програму чи функцію, яка виводить список усіх музичних нот (використовуючи англійські імена нот) від A до G♯.

На всіх нотах без імені, що складаються з однієї літери (тобто чорних нот на музичній клавіатурі), має бути надруковано їхнє ім’я двічі, один раз, як різка ноти, один раз як площина однієї. Гострі або плоскі ноти, які можна описати однією буквою, як-от B♯ (C) або F ♭ (E), не повинні виводитися.

Ось приклад результату:

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

Технічні умови

  • Програма або функція не повинні приймати жодного вводу.

  • Примітки можуть бути надруковані в будь-якому порядку та в будь-якому списку, дозволеному нашими стандартними правилами вводу / виводу

  • Гострі та плоскі символи Unicode (♯ / ♭) можуть бути замінені на b і#

  • Як завжди, стандартні лазівки заборонені.

  • Оскільки це код-гольф , виграє найменша програма в байтах.

code-golf  kolmogorov-complexity 
— TheOnlyMrCat
джерело
3
— Джонатан Аллан
1
Чи можемо ми випустити "C "замість "C"?
— Арнольд
1
@Arnauld так ви можете
— TheOnlyMrCat
7
До речі, B # існує в музичній нотації; наприклад, у підписі ключа для клавіші C #, де він виконує роль провідного тону.
— Каз
2
Я не знаю, здається, Cb тут відсутній;)
— AJFaraday

Відповіді:

13

Malbolge , 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 1 = 39 байт

Підпрограма, що приймає вихідний вказівник у R4 і записує нотатки туди, розділені пробілами. У прикладі коду ми пишемо безпосередньо на екран.

Шістнадцятковий дамп (лише рутина)

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 кодується з 10-бітовим значенням, відомим як "DECLE". Ця процедура триває 31 DECLE, починаючи з $ 4820 і закінчуючи $ 483E (включно).

— Арнольд
джерело
9

Python 3 , 50 байт

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

Спробуйте в Інтернеті!

Пітон 2: 48 байт

Цей код можна скорегувати таким чином, щоб він включав B # та Cb, без додаткових байтів. Цього можна досягти, замінивши 5на 6.

Крім того, він (нарешті) коротший, ніж просто виведення простої рядки:

Python 3 , 51 байт

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

Спробуйте в Інтернеті!

Python 2: 50 байт

— Джице
джерело
2
Це дуже творче рішення
— TheOnlyMrCat
7

05AB1E , 16 15 13 байт

Au…b #âŽ7×bûÏ

-2 байти завдяки @maxb .

Спробуйте в Інтернеті.

Виводиться як список, де однозначні ноти мають пробіл.

Пояснення:

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 байт вихідного коду, кожен з символів Unicode представляє байт вихідного коду - див. сторінку коду, пов'язану словом bytesу заголовку.
— Джонатан Аллан
5

Сітківка 0,8,2 , 33 байти


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

Спробуйте в Інтернеті! Пояснення:


ABCDEFG

Вставте назви базових нот.

.
 $&b $& $&#

Розгорніть кожну примітку, щоб вона включала плоскі та гострі версії.

 [BE]#...

Видаліть B#, E#а також примітки, що слідують за ними ( Cbі Eb).

— Ніл
джерело
5

Perl 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

Japt , 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

Рубін , 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) щоразу.

Це призводить до поданого наказу листа про ноти, в якому кожна нота на п'ять градусів включно (відома як "п'ята") вище попередньої. Наприклад F->CєFGABC

— Рівень річки Св
джерело
Мені подобається, що ти піднімаєшся на п’яті. Приємно.
— Уейн Конрад
2

Zsh , 36 байт

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

Більш потворне рішення, але воно економить два символи. (F)приєднується до списку //[BE]#???в нових рядках та видаляє потрібні нам частини рядка.

Спробуйте в Інтернеті!

Zsh , 38 байт

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

Мені завжди подобається, коли Зш б'є Перла (сподіваюсь, я не надто швидко розмовляю ...).

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

Спробуйте в Інтернеті!

— GammaFunction
джерело
1

Брахілог , 36 байт

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

Спробуйте в Інтернеті!

Наразі я перебуваю в процесі жорстокого примусового індексу набору потужностей, який дозволив би мені позбутися ⟨h₅ct₁₄⟩⟨h₁₂ct₅⟩(і в розширенні ↺, оскільки вихід не повинен бути в тому ж порядку, як прикладний вихід), але він займає досить в той час як ... можливо, я повинен відкласти хвилину, щоб фактично розібратися в тому, які списки підрядів створюються, і обчислити індекс таким чином ...

— Непов'язані рядки
джерело
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#

Спробуйте в Інтернеті!

— Ніч2
джерело
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 (ймовірно, інші 8-бітові варіанти Commodore BASIC) - 52 токенізованих байків BASIC

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

Натискання CTRLклавіші плюс Nна клавіатурі C64 переходить у «діловий режим» набору символів для великих та малих символів. Ми можемо роздрукувати це в рядку в один байт / маркер; і оскільки у нас є 40 стовпців, пробіл від G до G # не потрібно.

У цьому випадку нам не потрібно закривати рядок, оскільки це не багатошаровий рядок з :роздільником.

Як це виглядає на екрані Commodore C64 (і сумісних), показано нижче.

Коммодор 64 музичні ноти

— Шон Беберс
джерело
0

мозковий ебать , 255 115 байт

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

Спробуйте в Інтернеті!

— Кшиштоф Шевчик
джерело
1
Я б підтримав це, але це неправильно. Немає чорної ноти між B і C, або між E і F. Тому ви не повинні виводити. B #, Cb, E # або Fb. Крім того, я не бачу нічого в специфікації про те, що це нормально, щоб використовувати малі регістри.
— Рівень річки Св.
@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.Це здається мені досить зрозумілим, і я не бачу жодної історії редагування на ОП на екрані.
— Рівень р. Св.
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#'
— БредК
джерело
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 - це просто проста фентезійна машина на базі 8-розрядного процесора Z80. Програма завантажується в пам'яті 0x0000, а решта пам'яті заповнюється нулями. Виведення відбувається за допомогою виклику 0x8000, який виведе значення регістру А як символу.

Програма починається з даних, які будуть оброблятися, загалом 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:

Ось як розшифровує це процесор:

    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.

Ці дані одночасно зчитуються двома байтами в пару регістрів DE. Покажчик стека використовується для вказівки на наступний елемент. Він починається з 0, і оскільки Z80 використовує повний низхідний стек, будь-які спливаючі вікна прочитають наступну пару даних - всі операції зі стеком є ​​16-бітними.

Зовнішній цикл реалізований лічильником зменшення в регістрі B, для якого Z80 забезпечує спеціальну підтримку у вигляді djnzінструкції:

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

Поточний лист зберігається в реєстрі А. Оскільки приріст добре підходить до початку циклу, ми завантажуємо його менше, ніж фактичне початкове значення 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
джерело
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.