In der Musiktheorie ist ein Intervall die Differenz zwischen zwei Tonhöhen. Jede Tonhöhe wird durch die Anzahl der Halbschritte (Der Unterschied zwischen C und C #) oder der ganzen Schritte (Der Unterschied zwischen C und D) definiert. Ein ganzer Schritt entspricht zwei Halbschritten. Hier ist eine Liste aller Standardintervalle und der Anzahl der Halbschritte, die sie darstellen:

0     Perfect Unison
2     Major Second
4     Major Third
5     Perfect Fourth
7     Perfect Fifth
9     Major Sixth
11    Major Seventh
12    Perfect Octave

Es gibt 3 Variationen der Standardintervalle: geringfügig , verringert und erweitert .

• Ein kleines Intervall ist einen halben Schritt niedriger als ein großes Intervall, aber kein perfektes Intervall. Sie haben also eine kleine Sekunde (1), eine kleine dritte (3), eine kleine sechste (8) und eine kleine siebte (10). Es gibt kein Moll-Viertel, Moll-Fünftel, Moll-Unisono oder Moll-Oktave, da dies alles perfekte Intervalle sind.

• Ein verkürztes Intervall ist einen halben Schritt niedriger als ein kleines oder perfektes Intervall. Es gibt eine verminderte Sekunde (0), eine verminderte dritte (2), eine verminderte vierte (4), eine verminderte fünfte (6), eine verminderte sechste (7), eine verminderte siebte (9) und eine verminderte Oktave (11).

• Ein erweitertes Intervall ist einen halben Schritt höher als ein Hauptintervall oder ein perfektes Intervall. Wir haben Augmented Unison (1), Augmented Second (3), Augmented Third (5), Augmented Fourth (6), Augmented Fifth (8), Augmented Sixth (10) und Augmented Seven (12).

Die Herausforderung:

Sie müssen ein Programm oder eine Funktion schreiben, die mehrere halbe oder ganze Schritte ausführt und dann eine der gültigen englischen Beschreibungen dieses Intervalls druckt . Es spielt keine Rolle, welche Beschreibung Sie auswählen, solange sie genau mit der E / A-Tabelle übereinstimmt. Sie können dies als eine Zeichenfolge nehmen

"5w" == 5 whole steps
"3h" == 3 half steps

oder als Zahl und Zeichenfolge / Zeichen.

5, "w" == 5 whole steps
3, "h" == 3 half steps.

Sie können davon ausgehen, dass jeder Eingang zwischen 0 und 12 Halbschritten liegt.

IO-Tabelle

Hier ist eine vollständige Liste, in der die Anzahl der Halbschritte allen zulässigen Ausgaben zugeordnet ist.

0       Perfect unison, Diminished second   
1       Minor second, Augmented unison  
2       Major second, Diminished third  
3       Minor third, Augmented second   
4       Major third, Diminished fourth  
5       Perfect fourth, Augmented third     
6       Diminished fifth, Augmented fourth  
7       Perfect fifth, Diminished sixth 
8       Minor sixth, Augmented fifth        
9       Major sixth, Diminished seventh 
10      Minor seventh, Augmented sixth      
11      Major seventh, Diminished octave    
12      Perfect octave, Augmented seventh   

Hier sind einige Beispiel-E / A:

5w      Minor Seventh
5h      Augmented Third
12h     Perfect Octave
12w     UNDEFINED
1w      Diminished third
2h      Major Second

Ruby, Rev B 138 Bytes

->n,s{i=12-n-n*(s<=>?h)
[a='Augmented','Major','Minor',d='Diminished',a,'Perfect',d][i%7]+' '+%w{seventh fifth third unison}[i%7/4+i/7*2]}

5 Bytes werden durch Nichtwiederholung gespeichert Augmented/Diminished. 1 Byte durch Verwendung von gespeichert ?h.

Ruby, Rev. A 144 Bytes

->n,s{i=12-n-n*(s<=>'h')
%w{Augmented Major Minor Diminished Augmented Perfect Diminished}[i%7]+' '+%w{seventh fifth third unison}[i%7/4+i/7*2]}

Die Idee ist, die Anzahl der Grundintervalle zu minimieren (siebtes fünftes Drittel und nur unisono) und die Tatsache auszunutzen, dass siebte und fünfte eine analoge Beziehung zu der zwischen Dritteln und Unisons haben.

Es gibt vier Arten von siebten / dritten und drei Arten von fünften / unisono, so dass die Indexvariable iauf 12 minus der Anzahl der Halbschritte gesetzt wird, so dass der erste Term des Ausdrucks i%7/4 + i/7*2den Typ des Basisintervalls korrekt auswählt.

ungolfed im Testprogramm

f=->n,s{                 #n = number of steps. s= step size, w or h
  i=12-n-n*(s<=>'h')     # i=12-n. If s is later in the alphabet than 'h' subtract again for whole steps
  %w{Augmented Major Minor Diminished Augmented Perfect Diminished}[i%7]+
  ' '+%w{seventh fifth third unison}[i%7/4+i/7*2]
}

-1.upto(12){|j|
puts f[j,'h']
}  

0.upto(6){|j|
puts f[j,'w']
}

Ausgabe

Diminished unison
Perfect unison
Augmented unison
Diminished third
Minor third
Major third
Augmented third
Diminished fifth
Perfect fifth
Augmented fifth
Diminished seventh
Minor seventh
Major seventh
Augmented seventh

Perfect unison
Diminished third
Major third
Diminished fifth
Augmented fifth
Minor seventh
Augmented seventh

Undefinierte Verhaltenseingaben: Die Funktion gibt die richtige Antwort diminished unionfür -1 Halbschritte aus, schlägt jedoch für Eingaben über 12 fehl. Beispielsweise werden perfect unison14 Halbschritte ausgegeben, da der Algorithmus auf einem Zyklus von 14 statt 12 basiert.

Python 2, 149 Bytes

def f(n,c):n*=1+(c>'h');print(n-6)%13%2*"Diminished"or"Augmented",'octave seventh sixth fifth fourth third second unison'.split()[71056674174>>3*n&7]

Zunächst werden ganze Schritte in halbe Schritte umgewandelt.

Dann wird Diminishedvs Augmentedgedruckt. Diese wechseln sich für benachbarte naußer dem ab n=5und n=6ergeben dasselbe, was erreicht wird, indem sie zuerst über eine Grenze modulo eine ungerade Zahl gesetzt werden.

Schließlich wird die Entfernung gedruckt und über eine Drei-Bit-Nachschlagetabelle berechnet. Das ist kürzer als das int('6746543230210'[n]).

Python 2.7, 155 Bytes

s='second unison third fourth sixth fifth seventh octave Diminished Augmented'.split()
def f(n,c):x=0xDE9CB87561430>>[4,8][c>'h']*n;print s[x%2+8],s[x/2%8]

Netzhaut, 153 Bytes

\ d +
$ *
(. *) w | h
$ 1 $ 1
^ 1 * $
$ .0
^ 11
Verminderte $ 0
^ \ d
Augmented $ 0
10 | 7
sechste
11
Oktave
12 | 9
siebte
8
fünfte
4 | 6
vierte
5 | 2
dritte
1
Einklang
\ d
zweite

Die eingegebene Nummer wird zuerst in unär konvertiert und dann verdoppelt, wenn sie gefolgt wird w. Alle Buchstaben werden entfernt, wobei nur die unäre Nummer übrig bleibt. Diese Zahl wird dann wieder in eine Dezimalzahl umgewandelt. Schließlich wird etwas Suchen und Ersetzen angewendet, um die endgültige Ausgabe zu erstellen.

Beispielläufe:

6w => 111111w => 111111111111 => 12 => Augmented 12 => Augmented 7th
7h => 1111111h => 1111111 => 7 => Vermindert 7 => Vermindert Sechster
3w => 111w => 111111 => 6 => Augmented 6 => Augmented Fourth
0h => h => => 0 => Vermindert 0 => Verminderte Sekunde

Probieren Sie es online aus!

Vitsy , 166 Bytes

Nun, das kann definitiv weiter gespielt werden.

WW2M1+*a+mZ
'dehsinimiD'
'roniM'
'rojaM'
'tcefreP'
'detnemguA'
'dnoces '
'htruof '
'htxis '
'evatco '
6m1m
6m2m
6m3m
6m5m
7m1m
7m4m
7m5m
8m1m
8m2m
8m3m
8m5m
9m1m
9m4m

Dies funktioniert, indem die minimal mögliche Anzahl von Elementen definiert und diese Elemente dann über die Methodensyntax aufgerufen werden.

Probieren Sie es online aus!

Javascript 189 Bytes

a=>(n='sutsftfxFvxov'[N=parseInt(a)*(a.slice(-1)>'v'?2:1)])&&((N>5?N+1:N)%2?'Augmented ':'Dimished ')+'unison,second,third,fourth,fifth,sixth,seventh,octave'.split`,`['ustfFxvo'.indexOf(n)]



 F=
  a=>
    (n='sutsftfxFvxov' //using the right side of the possible answers
                       //set n = the letter representing
                       //unison, first, second ...

       //set N to 12 for 12h, but 24 for 12w
       [N=parseInt(a)*(a.slice(-1)>'v'?2:1)])

  &&   //if we were out of range (12w) we'll return undefined


    (
      (N>5?N+1:N)%2?  //get Aug or Dim (right side goes)
                      //DADADAADADADA
                      //     ^^ makes this a pain
       'Augmented ':'Dimished '
     )
     +
            //turn n (which is u for unison, x for sixth, etc
            //into it's full name
       'unison,second,third,fourth,fifth,sixth,seventh,octave'
         .split`,`
     ['ustfFxvo'.indexOf(a)]

Java, 225 224 Bytes

Es muss einen besseren Weg geben, diese Saiten zu packen, aber ich habe keine Ideen.

(i,s)->{String A="Augmented",M="Major",m="Minor",P="Perfect",D="Diminished",d=" Second",f=" Fourth",a=" Sixth",C=" Octave";String[]o=new String[]{D+d,m+d,M+d,A+d,P+f,A+f,D+a,m+a,M+a,A+a,D+C,P+C};i*=s=='w'?2:1;return o[i-1];}

Eingerückt:

static BiFunction<Integer, Character, String> interval = (i,s) -> {
    String A="Augmented",M="Major",m="Minor",P="Perfect",D="Diminished",
            d=" Second",f=" Fourth",a=" Sixth",C=" Octave";
    String[] o = new String[] {D+d,m+d,M+d,A+d,P+f,A+f,D+a,m+a,M+a,A+a,D+C,P+C};
    i *= s=='w' ? 2 : 1;
    return o[i-1];
};