背景

在西方音乐中，每个音符都有一个分配的名称。在每个八度音程中，按以下顺序排列十二个唯一音符：“ CC＃/ Db DD＃/ Eb EFF＃/ Gb GG＃/ Ab AA＃/ Bb B C”，其中最后一个C比第一个高八度。

为了区分不同八度音符之间的区别，在音符名称的末尾附加了一个数字（此挑战仅限于一个数字）。因此，C5是比C4高八度的音符。Bb6高于B5。

一个重要的事实是，B5和C6是彼此相邻的音符，而C0和B9是最低和最高音符。

在任何两个音符之间，存在一个距离，即它们之间的半音数量。Bb4是B4之下的一个半音，它本身是C5之下的一个半音。一个八度音阶中有十二个半音，因此Bb4与A＃3的距离为12，因为它比A＃3高八度音阶（请注意，单个音符最多可以具有两个名称）。

挑战

您面临的挑战是编写尽可能最短的程序，该程序可以从STDIN中获取音符列表，并将间隔更改列表打印到STDOUT。

输入内容将是音符的空格分隔列表。每个音符将由一个大写字母AG，一个可选的b或＃符号以及一个数字组成。您将不必处理E＃/ Fb或B＃/ Cb。输入示例：

C4 D4 E4 F4 G4 A4 B4 C5 C4

输出将是一个用空格分隔的整数列表，这些整数表示每个连续音符之间的距离，并始终以+或-作为前缀，以显示该音符相对于前一个音符是升还是降。输出的数字总是比输入的音符少一个。上述输入的示例输出：

+2 +2 +1 +2 +2 +2 +1 -12

其他一些示例输入：

E5 D#5 E5 B4 E5 F#5 E5 B4
C0 B0 Bb1 A2 G#3 G4 F#5 F6
G4 Ab4 Gb4 A4 F4 A#4

及其相应的输出：

-1 +1 -5 +5 +2 -2 -5
+11 +11 +11 +11 +11 +11 +11
+1 -2 +3 -4 +5

规则与限制

1. 获胜者取决于源代码中的字符数

2. 您的程序应仅包含可打印的ASCII字符

3. 您不得使用任何与音乐或声音相关的内置功能

4. 除此以外，适用标准代码高尔夫规则

GolfScript，61岁

" "/{)12*\{"bC#D EF G A B"?(+}/}%(\{.@-.`\0>{"+"\+}*\}/;]" "*

Haskell，161个字符

f(c:r)=maybe(12*read[c])(+f r).lookup c$zip"bC#D.EF.G.A.B"[-1..]
g n|n<0=show n|1<3='+':show n
h x=zipWith(-)(tail x)x
main=interact$unwords.map g.h.map f.words

Perl，103岁

#!/usr/bin/perl -an
/.((b)|(\D))?/,(($~,$,)=($,,12*$'+ord()%20%7*2+(ord()%7>3)-$-[2]+$-[3]))[0]&&printf'%+d ',$,-$~for@F

C，123个字符

基于leftaboutabout的解决方案，进行了一些改进。

main(c,b,d)
    char*b;
{
    while(d=c,~scanf("%s",b)?c=-~*b*1.6,c%=12,c+=b[~b[1]&16?c+=1-b[1]/40,2:1]*12:0)
        d>1&&printf("%+d ",c-d);
}

我认为值得一提的一些技巧：
1. argv[0]（此处称为b）是指向程序名称的指针，但在此处用作暂存缓冲区。我们只需要4个字节（例如C#2\0），所以我们有足够的空间。
2. c是参数的数量，因此它从1开始（当不带参数运行时）。我们用它来防止在第一轮打印。

可能的问题- c+=b[..c+=..]有点奇怪。我不认为这是未定义的行为，因为这?:是一个序列点，但也许我错了。

C， 241 229 183

F(c){c-=65;return c*1.6+sin(c/5.+.3)+9;}
#define r if(scanf("%s",b)>0){c=F(*b)%12;c+=b[b[1]<36&&++c||b[1]>97&&c--?2:1]*12
main(e,c,d){char b[4];r;}s:d=c;r;printf("%+d ",c-d);goto s;}}

因子303个字符

USING: combinators formatting io kernel math regexp sequences ;
f contents R/ [#-b]+/ all-matching-slices
[ 0 swap [ {
{ [ dup 48 < ] [ drop 1 ] }
{ [ dup 65 < ] [ 48 - 12 * ] }
{ [ dup 98 < ] [ "C-D-EF-G-A-B" index ] }
[ drop -1 ]
} cond + ] each
swap [ over [ - "%+d " printf ] dip ] when* ] each drop

有评论，

! combinators => cond
! formatting => printf
! io => contents
! kernel => swap dup drop over dip when*
! math => < - * +
! regexp => R/ all-matching-slices
! sequences => each
USING: combinators formatting io kernel math regexp sequences ;

f       ! Push false, no previous note value.

! Find notes (as string slices) in standard input. The golfed regexp
! R/ [#-b]+/ matches all notes and no whitespace.
contents R/ [#-b]+/ all-matching-slices

! For each string slice:
[
    0       ! Push 0, initial note value.
    swap    ! Move note slice to top of stack, above note value.

    ! For each Unicode codepoint in note:
    [
        ! Convert the Unicode codepoint to its value in semitones.
        ! For golf, [ 48 ] is shorter than [ CHAR: A ].
        {
            ! Sharp # {35} has 1 semitone.
            { [ dup 48 < ] [ drop 1 ] }
            ! 0-9 {48-57} has 0 to 9 octaves (1 octave = 12 semitones).
            { [ dup 65 < ] [ 48 - 12 * ] }
            ! A-G {65-71} has 0 to 11 semitones.
            { [ dup 98 < ] [ "C-D-EF-G-A-B" index ] }
            ! Flat b {98} has -1 semitone.
            [ drop -1 ]
        } cond

        +       ! Add semitones to cumulative note value.
    ] each

    swap    ! Move previous note value to top of stack.
    ! When there is a previous note value:
    [
        ! Keep current note on stack.
        over [
            ! Compute and print interval.
            - "%+d " printf
        ] dip
    ] when*
    ! Current note replaces previous note at top of stack.
] each

drop    ! Drop previous note, so stack is empty.

对于此脚本，“以空格分隔的列表”在元素之间可以有1个或多个空格，在开头或结尾可以有0个或多个空格。该脚本的确在输出末尾打印了多余的空格，但在输入末尾也接受了多余的空格（或换行符）。

如果我采用更严格的定义，即“以空格分隔的列表”在元素之间恰好有1个空格，在开头或结尾处有0个空格，那么我可以简化contents R/ [#-b]+/ all-matching-slices为contents " " split（使用splitting，而不是regexp）。但是，我需要添加更多代码以防止输出末尾有多余的空间。

如果使用不赞成使用的单词dupd，则可以缩短over [ - "%+d " printf ] dip为dupd - "%+d " printf，节省8个字符。我没有使用过时的词，因为它们“打算很快被删除”。