트럼펫은 일반적으로 투구 밸브 형 기명 악기 악기입니다 B♭. 플레이어가 입술을 진동시켜 악기 내부의 공기를 대체 할 때 소리가납니다. 이 진동은 입으로 불리는 특정한 방식으로 입을 설정함으로써 획득됩니다. 입술이 더 꽉 조여진 다양한 엠보싱은 다른 피치를 만들어냅니다.

또한 트럼펫의 각 밸브도 악기의 피치를 변경합니다. 눌려지면 밸브가 악기 튜브 내부의 경로를 닫아 공기가 더 긴 경로를 통과하도록하여 원래 사운드의 피치를 낮 춥니 다. 이 과제 B♭를 위해 첫 번째 밸브가 피치를 전체 단계만큼 낮추고, 두 번째는 피치를 반 단계 낮추고, 세 번째는 피치를 1 씩 낮추는 표준 트럼펫을 고려합니다 . 반 단계.

도전

내 과제는 두 입력 주어진하는 프로그램이나 함수를 생성하는 것 embouchure및 valves, 재생되는 음의 피치를 결정한다.

이 도전의 목적을 위해, 노트는 순서를 따릅니다 :

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

규칙

• 합리적인 방법으로 I / O를 수행 / 제공 할 수 있습니다 .
• 표준 허점이 적용됩니다.
• 당신이 사용할 수있는 b및 #대신 ♭하고 ♯당신이하고자하는 경우.
• valves감압 밸브 목록 ( 1, 3) 또는 부울 목록 ( 1, 0, 1)으로 입력 할 수 있습니다 .
• 이것은 code-golf 이므로 각 언어에서 가장 짧은 코드가 승리합니다.

테스트 사례 :

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♯

면책 조항 : 나는 아직 음악가는별로 없기 때문에 테스트 케이스에서 도살 한 것에 대해 사과드립니다. 정정 부탁드립니다.

파이썬 삼 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]

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

Jonathan Allan 덕분에 많은 바이트를 절약했습니다.

내 원래 솔루션 ( 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확인 나는 (두 배) 목록의 중간에서 잘 시작 있는지 확인하기 위해이 나는 식으로 원하는 오프셋을 계산합니다. :

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

f첫 번째 밸브는 어디에 s있고 두 번째 밸브 t는 세 번째 밸브 입니다.

마지막으로 시작 색인에서 오프셋을 빼서 목록에서 찾은 메모를 인쇄합니다.

Wolfram Language (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 바이트의 비용으로 더 나은 출력.

젤리 ,  37  36 바이트

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

밸브를 1s 또는 0s의 목록으로 [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)

루비 , 71 바이트

->e,(b,c,d){a=%w{Bb B C C# D Eb E F F# G G# A};a[a.index(e)-b*2-c-d*3]}

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

70 자, 80 바이트

->e,(b,c,d){a="B♭BCC♯DE♭EFF♯GG♯A".scan /.\W?/;a[a.index(e)-b*2-c-d*3]}

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

자바 스크립트 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))

배치, 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. 그런 다음 스트링 교체 결과가 자동으로 평가되고 결과가 목록에서 조회되기 전에 밸브가 고려됩니다.

스탁스 , 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

이것을 실행

파이썬 2 , 84 79 바이트

lambda e,a,b,c,s='Bb B C C# D Eb E F F# G G# A'.split():s[s.index(e)-2*a-b-3*c]

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

C (gcc) , 92 86 82 바이트

*r=L"扢bc⍣d扥ef⍦g⍧a",*u;v(z,y,x,w)short*z;{u=wcschr(r,*z);u-=2*y+x+3*w;u+=(u<r)*12;}

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

@Vazt의 구현 에서 채택되었습니다 .

Perl6 / Rakudo 73 자

기술적으로 이것은 유니 코드 문자를 넣었 기 때문에 83 바이트이지만 ASCII 문자로 바꾸면 73 바이트가됩니다.

이와 {code block}같은 매개 변수 $^a로 시그니처가있는 람다 ($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은 Using x어귀에 의해 n은 smartmatch 연산자를 사용하여 노트 다음을 위해 다음 검색, 중위 연산자 '...' ~~ /.../-의 정규식 경첩 \w\W?어쩌면 다음 단어가 아닌 문자 단어의 문자를 인을.

우리는 그 via의 n 개의 인스턴스를 찾고 (\w\W?)**{$_}, 여기서 이미 $_params에서 n 까지 n = 을 계산 $b했습니다 $d. 이렇게하면 embouchure 노트에서 결과 노트와 일치하는 결과를 얻을 수 ~~ /\w\W?$/있습니다.

$_첫 번째 계산은 허용해야합니다.$^b블록에서 암시 적 매개 변수 작성 .

76 자

문자열 일치 대신 배열을 사용하는 대안은 3 문자 더입니다.

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

목록에서 embouchure를 @arr.first: $^a, :k찾으려면을 사용하여 찾은 요소의 색인 (키)을 반환합니다 :k.

에 배열 설정 $_(객체로하는 것은) 우리가 사용할 수 있도록 .first하고 .[ ]너무 많은 문자를 지출하지 않고 그것을.

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입니다.

대사 입력은 소문자 여야합니다. 흥미롭게도 TiO는 strcmpi()을 포함 하지 않으면 찾을 수 없지만 string.hmingw-gcc는 표준 -Wimplicit-function-declaration경고로 허용합니다 .