帮我弹小号

14

该喇叭是有阀管乐器仪器，一般在投B♭。当演奏者振动嘴唇以置换乐器内部的空气时，将发出声音。这种振动是通过以一种特定的方式张口而获得的，这种方式被称为“囊袋”。嘴唇更紧或更松的不同囊袋会产生不同的音高。

此外，小号中的每个气门也会改变乐器的音高。按下时，阀门会关闭乐器管内的路径，使空气流经更长的路径，从而降低原始声音的音调。为了应对这一挑战，我们将考虑标准B♭喇叭，其中第一个阀门将螺距降低整步，第二个阀门将螺距降低半步，第三个阀门将螺距降低一个和一个。半步。

挑战

您面临的挑战是创建一个程序或函数，给定两个输入embouchure和valves，确定要弹奏的音符的音高。

出于此挑战的目的，注释将遵循以下顺序：

B♭, B, C, C♯, D, E♭, E, F, F♯, G, G♯, A.

规则

  • 可以通过任何合理的方法进行输入/输出。
  • 标准漏洞。
  • 您可以使用b和#代替♭和♯，如果你想。
  • 的输入valves可以作为低压阀列表（1, 3）或布尔值列表（1, 0, 1）的形式。
  • 这是代码高尔夫球，因此每种语言中最短的代码将获胜。

测试用例：

Valves 在这些测试用例中以布尔值列表的形式给出，其中0表示被压低，1表示被压低。

Embouchure:    Valves:   Output:
B♭             0 0 0     B♭
B♭             0 1 0     A
B♭             1 0 1     F
C♯             0 0 1     B♭
C♯             1 1 1     G
E♭             1 0 0     C♯
G              0 1 1     E♭
G♯             1 0 0     F♯
G♯             0 0 1     F
G              1 0 0     F
F♯             1 0 0     E
D              1 0 1     A
A              1 1 1     E♭
E              1 1 0     C♯
E              0 0 1     C♯

免责声明：我还不是一个音乐家，所以我对在测试用例上可能做出的任何屠杀深表歉意。更正表示赞赏。

code-golf  music 
— J·萨莱
source
2
这里的打击乐手。等待，等等，这就是您拼凑包裹的方式。一直以为它以a ;-)
— 开头
1
@vasilescur你是对的。我将修复这些错误并查看其他可能的错误。感谢您的注意。
— J.Sallé18年
1
作为一个长期吹小号的人，我真的对Embouchure的测量感到困惑……例如，什么是C＃Embouchure？
— bentl
1
应该F# 100不是E吗？
— Level River St
2
@bendl没有这样的事情。C#不按下任何气门就不能在小号上弹奏。只是特定的注释（B♭-F-B♭-D-F-A♭-B♭...），是的泛音系列B♭。尽管如此，即使它不能反映真实的工具，也可以很好地定义挑战。
— 克里斯（Chris

Answers:

4

蟒蛇 3 2， 125 119 81个字节

lambda e,f,s,t,n=2*'A G# G F# F E Eb D C# C B Bb'.split():n[n.index(e)+2*f+s+3*t]

在线尝试！

感谢乔纳森·艾伦节省了很多字节。

我的原始解决方案（在Python 3中）：

n=2*'Bb B C C# D Eb E F F# G G# A'.split()
e,f,s,t=str(input()).split()
print(n[n.index(e,9)-2*int(f)-int(s)-3*int(t)])

在线尝试！

@HyperNeutrino节省了6个字节。

说明

首先，我做了一系列笔记，但长度加倍，因此我不必担心从Bb到循环A。

然后，以以下格式输入输入（例如）：

Bb 1 0 1

然后，我使用n.index(e,9)（找到该起始符的索引，9以确保我在（doubled）列表的中间很好地开始。我用表达式计算所需的偏移量：

2*int(f) - int(s) - 3*int(t)

f第一个阀在哪里，s第二个阀在哪里，t第三个阀在哪里。

最后，它只是通过从起始索引中减去偏移量来简单地打印在列表中找到的注释。

— 血管性
source
3
用空格分隔可节省一些字节。"<some string>".split()默认情况下按空格分割
— HyperNeutrino，
通过移至Python 2（避免str和int强制转换并允许评估的输入）并反转音符并向前偏移（避免,9在index通话中使用，可以节省30个字节。在线尝试！
— Jonathan Allan，
...以及另外8个开始运行的功能（可在Python 2或3中运行）在线尝试！
— 乔纳森·艾伦，
@JonathanAllan我从您的改进中学到了一些Python高尔夫技巧。非常感谢！
— vasilescur
...实际上，您可以按原始顺序使用列表，而无需重复并减去值，因为负索引永远不会超出范围（最负的'Bb', 1, 1, 1索引-6是E根据需要将您带到索引位置）-这就是TFeld所具有的自从完成。
— 乔纳森·艾伦
3

Wolfram语言（Mathematica），100字节（工作中的喇叭为134）

l="Bb,B,C,C#,D,Eb,E,F,F#,G,G#,A"~StringSplit~",";f=l[[Mod[#&@@#&@@l~Position~#-2#2-#3-3#4-1,12]+1]]&

在线尝试！

非常简单。

l="Bb,B,C,C#,D,Eb,E,F,F#,G,G#,A"~StringSplit~",";f=EmitSound@SoundNote[l[[Mod[#&@@#&@@l~Position~#-2#2-#3-3#4-1,12]+1]],1,"Trumpet"]&

34字节成本的更好输出。

— 柯玉甘
source
等等... Mathematica具有音频输出？？？邪恶！
— 泰特斯
当然Mathematica具有内置的音频输出。这是黄金。
— J.Sallé18年
2

果冻， 37  36 字节

ØAḣ7;⁾#b“®JXrẊỤȥ’ṃnŒl$œṗ$Ḋ©i_⁸æ.J¤ị®

双向链接接受阀门作为s的列表1或0s作为s的列表[second, first, third]（在左侧表示），将embouchure（字符）作为字符的列表在右侧（返回字符列表）。

在线尝试！

怎么样？

ØAḣ7;⁾#b“®JXrẊỤȥ’ṃnŒl$œṗ$Ḋ©i_⁸æ.J¤ị® - Link: list of integers, V; list of characters, E
ØA                                   - yield uppercase alphabet
  ḣ7                                 - head to index 7 = "ABCDEFG"
     ⁾#b                             - literal list of characters = "#b"
    ;                                - concatenate = "ABCDEFG#b"
        “®JXrẊỤȥ’                    - literal integer = 2270857278734171
                 ṃ                   - base decompress (i.e. convert to base 9 using the 'digits' "bABCDEFG#")
                                     -                 = "ABbBCC#DEbEFF#GG#"
                        $            - last two links as a monad:
                     $               -   last two links as a monad:
                   Œl                -     to lower case = "abbbcc#debeff#gg#"
                  n                  -     not equal? (vectorises) = [1,1,0,1,1,1,0,1,1,0,1,1,1,0,1,1,0]
                      œṗ             -   partition at truthy indices = [[],"A","Bb","B","C","C#","D","Eb","E","F","F#","G","G#"]
                         Ḋ           - dequeue = ["A","Bb","B","C","C#","D","Eb","E","F","F#","G","G#"]
                          ©          - copy to register and yield
                           i         - first index of E in there
                                 ¤   - nilad followed by links as a nilad:
                             ⁸       -   chain's left argument, V
                                J    -   range of length [1,2,3]
                              æ.     -   dot product (i.e. 1*second + 2*first + 3*third)
                            _        - subtract
                                   ® - recall from register
                                  ị  - index into (1-based and modular)
— 乔纳森·艾伦
source
1

Javascript 96字节

遵循@vasilescur的想法，这是js中的实现

(a,b,c,d,_="B♭,B,C,C♯,D,E♭,E,F,F♯,G,G♯,A".split`,`)=>(l=_.concat(_))[l.indexOf(a,9)-(2*b+c+3*d)]


a=(a,b,c,d,_="B♭,B,C,C♯,D,E♭,E,F,F♯,G,G♯,A".split`,`)=>(l=_.concat(_))[l.indexOf(a,9)-(2*b+c+3*d)]
console.log(a('B♭',0,0,0))
console.log(a('B♭',0,1,0))
console.log(a('B♭',1,0,1))
console.log(a('C♯',0,0,1))
console.log(a('C♯',1,1,1))
console.log(a('E♭',1,0,0))
console.log(a('G',0,1,1))
console.log(a('G♯',1,0,0))
console.log(a('G♯',0,0,1))
console.log(a('G',1,0,0))
console.log(a('F♯',1,0,0))
console.log(a('D',1,0,1))
console.log(a('A',1,1,1))
console.log(a('E',1,1,0))
console.log(a('E',0,0,1))
展开摘要

— 路易斯·费利佩·德·耶稣·穆诺兹
source
少3个字节；）顺便说一句，公寓和小旅馆应该算作3个字节，不是吗？
— Shieru Asakoto
哦NVM（我没有看到，b而#被允许），但你需要使用b和#，而不是单位和锐器。
— Shieru Asakoto
1

批处理，188字节

@set n=%1
@set/aC=0,D=2,Eb=3,E=4,F=5,G=7,A=9,Bb=10,B=11,n=(%n:#=+1%+12-%2*2-%3-%4*3)%%12
@for %%n in (C.0 C#.1 D.2 Eb.3 E.4 F.5 F#.6 G.7 G#.8 A.9 Bb.10 B.11)do @if %%~xn==.%n% echo %%~nn

使用#和b：这表示Eb和Bb是合法的变量名称；#通过对进行字符串替换来处理+1。然后，将自动评估字符串替换的结果，然后在列表中查找结果之前考虑阀门。

— 尼尔
source
1

Stax，32 个字节

τ┤=Yº○!AÄΔâß₧←╥╟ö'ÄD├æñßf╧å▬tó÷╖

在线运行和调试

它带有一个注释名称和一个低压阀列表。它建立一个音符名称数组，然后计算总气门间隔，并在该数组中的偏移处获取音符。

"AbABbBCC#DEbEFF#G" just a literal
{VA#}(Y             partition at capital letters and store in y
,]I                 get the index of the input note
,2R:t               swap 1s and 2s in valve list
{-F                 subtract valve list from note index
y@                  look up result from note array

运行这个

— 递归的
source
0

Perl6 / Rakudo 73个字符

从技术上讲，这是83个字节，因为我输入了Unicode字符，但是将它们替换为ASCII等效项将得到73个字节。

作为{code block}带有这样的参数的$^a是带签名的lambda ($a, $b, $c, $d)。

{$_=2*$^b+$^c+3*$^d;'AG♯GF♯FEE♭DC♯CBB♭'x 2~~/$^a(\w\W?)**{$_}/~~/\w\W?$/}

叫它：

say { ... }("D", 1, 0, 1)
>> A

打高尔夫球

sub f($a, $b, $c, $d) {
   my $totalShift = 2*$b + $c + 3*$d;
   my $doubledScale = 'AG♯GF♯FEE♭DC♯CBB♭' x 2;
   my $matchEmbOnward = $doubledScale ~~ / $^a (\w\W?)**{$totalShift} /;
   my $matchFinalNote = $marchEmbOnward ~~ / \w \W? $ /;
   return $matchFinalNote;
}

在这里，我们'...' x 2使用xinfix运算符将字符串加倍，然后使用smartmatch运算符搜索n笔记，然后搜索n笔记-regex '...' ~~ /.../取决于\w\W?其上是一个单词char还是一个非单词char。

我们正在寻找via的n个实例(\w\W?)**{$_}，其中我们已经计算了$_从params $b到的n = $d。这样便产生了从便签到最终便笺的匹配，我们只想要最后一个便笺，所以我们将其与另一个匹配~~ /\w\W?$/。

$_first 的计算对于允许$^b在块上隐式创建参数是必需的。

76个字符

使用数组而不是字符串匹配的替代方法是另外3个字符：

{$_=<B♭ B C C♯ D E♭ E F F♯ G G♯ A>;.[((.first: $^a,:k)-2*$^b-$^c-3*$^d)%12]}

在列表中找到凭证 @arr.first: $^a, :k，使用可以返回找到的元素的索引（键）:k。

设置数组$_（作为一个对象）可以让我们使用.first，并.[ ]在其上没有花费太多的字符。

— 菲尔·H
source
0

C（gcc），155个字节

char r[][12]={"bb","b","c","c#","d","eb","e","f","f#","g","g#","a"};u;v(z,y,x,w)char*z;{for(;u<12;u++)if(!strcmp(z,r[u]))break;u=u-2*y-x-3*w;u=u<0?12+u:u;}

在线尝试！

简单的方法。

阀门输入为0.1。

徽章输入必须为小写。有趣的是，strcmpi()如果不包含string.h，就不会找到TiO ，而mingw-gcc则允许它带有标准-Wimplicit-function-declaration警告。

— 瓦兹特
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.