Wir schreiben das Jahr 930 und die Gregorianische Kirche hat ein Problem. Sie haben Tausende von Seiten mit Gesangsmusik, aber das Problem ist, dass alle Noten einfach auf einen Stapel geworfen wurden, anstatt über ein echtes Organisationssystem zu verfügen:

^{Bild von User gamerprinter bei Cartographers 'Guild .}

Die Kirche muss alle Noten organisieren, deshalb haben sie einen mittelalterlichen Software-Ingenieur beauftragt, ein Programm zu schreiben, um es für sie zu organisieren. Sie sind der Softwareentwickler, der eingestellt wurde. Bei der Zusammenstellung im Mittelalter wird das Programm jedoch von einem Team langsamer Bibelschreiber auf Papier geschrieben. Um die Zeit zu verkürzen, die das Schreiberteam benötigt, um Ihren Code zu kompilieren, müssen Sie das Programm so klein wie möglich halten.

Die Kirche möchte, dass die Gesangsmusik auf der Grundlage der musikalischen Skala organisiert wird, in der sie geschrieben ist. Alle Gesangsmusik der Kirche ist in dorischen Skalen geschrieben . Ausgehend von den Noten eines bestimmten Musikstücks gibt Ihr Programm die dorische Skala aus, in der es sich befindet. Hier erkläre ich genau, was eine dorische Skala ist. Wenn Sie es bereits wissen, können Sie diesen Abschnitt überspringen.

Es gibt 12 mögliche Noten in jeder Melodie. Hier sind sie in Ordnung:

C C# D D# E F F# G G# A A# B

Ein Halbton (dargestellt mit a S) wird um einen Schritt nach rechts erhöht und umbrochen (ein Halbton von B nach C). Ein Ton (dargestellt mit einem T) besteht aus zwei Halbtönen. Zum Beispiel wäre ein Halbton von F # nach oben G. Ein Ton von F # nach oben wäre G #.

Um eine dorische Skala zu erstellen, gehen wir von einer beliebigen Notiz in der Liste aus und bewegen uns dann in folgendem Muster nach oben, wobei wir die Noten auflisten, auf die wir stoßen:

T, S, T, T, T, S

Ein Beispiel. Ich gehe von A aus. Die Noten meiner dorischen Skala werden:

A
B  (up a tone)
C  (up a semitone)
D  (up a tone)
E  (up a tone)
F# (up a tone)
G  (up a semitone)

Die Skala hat die Noten A, B, C, D, E, F # und G. Da ich von A ausging, werden wir dies die dorische Skala in A nennen . Es gibt also 12 verschiedene dorische Skalen, von denen jede nach der Note benannt ist, mit der sie begonnen haben. Jeder von ihnen verwendet das gleiche Muster von Tönen und Halbtönen, nur ausgehend von einer anderen Position. Wenn meine Erklärung nicht kohärent ist, können Sie auch Wikipedia konsultieren .

Die Eingabe des Programms kann von einer beliebigen Stelle aus erfolgen, die für Ihr Programm geeignet ist (z. B. STDIN, Befehlszeilenargument, raw_input()). Es kann sein, dass es in einer Variablen nicht vorinitialisiert ist. Die Eingabe ist eine Liste von durch Kommas getrennten Noten, die die Melodie des Stücks darstellen. Möglicherweise werden Notizen wiederholt. Die Eingabe wird immer genug unterschiedliche Noten enthalten, um die Tonleiter des Stückes entscheidend bestimmen zu können. Ein Beispiel Input:

B,B,D,E,D,B,A,G#,A,G#,E,D,F#,E,F#,E,F#,G#,A

Die Ausgabe des Programms sollte der String sein Dorian scale in X, wobei X die Startnote der Skala ist. Die Ausgabe der Beispieleingabe:

Dorian scale in B

Vergleicht man dies mit der Dorian-Skala in B ( B C# D E F# G# A), so sieht man, dass alle Noten der Melodie innerhalb dieser Skala liegen. Die Note C # wird in diesem Fall nicht verwendet. Es gibt jedoch genügend Hinweise, um B Dorian eindeutig als den richtigen Schlüssel zu identifizieren. Keine andere dorische Tonleiter passt, denn egal welche andere Tonleiter wir versuchen, es gibt immer mindestens eine Note der Melodie, die nicht zur Tonleiter gehört.

Dies ist Codegolf, daher gewinnt der Eintrag mit der kürzesten Anzahl von Zeichen. Fragen Sie in den Kommentaren, wenn Sie Fragen haben.

CJam - 61

C,q',/f{"FCGDAEB"_5<'#f++:s@m<7<:A-!{"Dorian scale in "A3=}*}

Versuchen Sie es unter http://cjam.aditsu.net/

C 171, 146

i,b;main(int c,char**v){for(;c=v[1][i];)b|=c/65<<c*2%7+v[1][++i]%2*7;for(i=12;i--;)b&(1016056>>i)||printf("Dorian scale in %c%c",65+i*3%7,(i<5)*35);}

Das Parsen von Strings in C ist nicht so einfach, deshalb habe ich mich für einen mathematischeren Ansatz entschieden.

Ich nutze den Kreis der Fünftel. Wenn wir die Noten in der folgenden Reihenfolge anordnen, indem wir 7 Halbtöne gleichzeitig zählen (als "fünfte" bezeichnet), stellen wir fest, dass alle in einer bestimmten Skala zugelassenen Noten einen aufeinanderfolgenden Block von 7 Noten und alle verbotenen Noten bilden Bilden Sie einen fortlaufenden Block mit 5 Noten.

F C G D A E B F# C# G# D# A#

(Es ist ein Kreis, der sich Fam Ende nach hinten dreht .)

Die Position einer natürlichen Note in der obigen Reihenfolge kann wie folgt berechnet werden (ASCII code) * 2 % 7. Wenn das nächste Zeichen ungerade ist (gilt #jedoch nicht für Komma, Leerzeichen oder Null-Byte), addieren wir 7, um es scharf zu machen. Wir speichern eine Bitmap der verwendeten Notizen.

Die Zahl 243(binär 11111000) entspricht den in der Skala von A # Dorian verbotenen Noten. Ich multiplizierte dies mit (1<<12)+1=4097der magischen Zahl 1016056. Dies wird mit der rechten Maustaste verschoben, um zu überprüfen (durch UND-Verknüpfung), ob die Melodie verbotene Noten für jede der 12 Skalen enthält. Wenn die Melodie keine verbotenen Noten enthält, wird die Skala gedruckt.

Denken Sie daran, dass wir für die Ausgabe den Skalennamen in umgekehrter Reihenfolge drucken müssen, um die oben genannten Fünftel zu durchlaufen, da wir die Rechte verschieben.) Die ASCII-Sequenz ADGCFBEADGCFwird von generiert 65+i*3%7. Für die ersten fünf muss zusätzlich ein Scharfes gedruckt werden.

Ungolfed Code

i,b;
main(int c,char**v){
  for(;c=v[1][i];)                          //for each character in first commanline argument v[1]
                                               //if it is a letter (assume uppercase, ASCII 65 or over)
   b|=c/65<<c*2%7+v[1][++i]%2*7;               //convert to position in the circle of fifths. 
                                               //Add 7 if the next character is odd (ASCII'#')
                                               //leftshift 1 by this number and OR this with the contents of b.

  for(i=12;i--;)b&(1016056>>i)||printf         //if melody includes no prohibited notes for the scale i, print
   ("Dorian scale in %c%c",65+i*3%7,(i<5)*35); //the scale letter, and a # (ASCII 35) if required, otherwise an ASCII 0.
}

Ungültiges Eingabeverhalten: Werden nicht genügend Noten zur Verfügung gestellt, um die Skala eindeutig zu bestimmen, werden alle möglichen Skalen ausgegeben. Wenn eine unmögliche Kombination von Noten angegeben wird, wird nichts ausgegeben. Notizen müssen durch ein Komma (oder ein anderes Nicht-Leerzeichen mit einem geraden ASCII-Code <= 64) getrennt werden. Leerzeichen können nicht verwendet werden, da alles, was nach dem ersten Leerzeichen steht, als anderes Argument angesehen wird. ASCII-Codes> 64 werden wie beschrieben als Hinweise interpretiert.

Haskell - 152

w=words
n=w"C C# D D# E F F# G G# A A# B"
f s="Dorian scale in "++[n!!i|i<-[0..11],all(`elem`[(n++n)!!(i+j)|j<-[0,2,3,5,7,9,10]])s]!!0
main=interact$f.w

Ungolfed

type Note = String
type Scale = [Note]

notes :: [Note]
notes = words "C C# D D# E F F# G G# A A# B"

isScale :: Scale -> [Note] -> Bool
isScale scale notes = all (`elem` scale) notes

takeScale :: Int -> Scale
takeScale i = [(notes ++ notes) !! (i + j) | j <- [0, 2, 3, 5, 7, 9, 10]]

findScale :: [Note] -> Note
findScale xs = head [notes !! i | i <- [0..11], isScale (takeScale i) xs]

main = interact (("Dorian scale in "++) . findScale . words)

Python 2 - 177 Zeichen

Es ist nicht so kurz, aber ich finde es die Freude von Python, mehrere geschachtelte for-Loops in einer Zeile zu schreiben, auch wenn Sie nicht Golf spielen. Leider musste ich die Eingabeanweisung in eine separate Zeile stellen, damit sie nicht mehr als einmal ausgeführt wurde.

j=set(raw_input().split(','))
print"Dorian Scale in",[x for x in[["A A# B C C# D D# E F F# G G#".split()[(b+n)%12]for n in[0,2,3,5,7,9,10]]for b in range(12)]if j<set(x)][0][0]

Ich verwende Python 3 nicht, aber ich glaube, dies ist ein seltener Fall, in dem die print-Anweisung keine weiteren Zeichen benötigt. Da printes dort eine Funktion gibt, wäre ich in der Lage, die Notwendigkeit von Klammern durch die Verwendung des *Operators zum Auspacken der Liste auszugleichen, um die letzte zu ersetzen [0].

Rubin - 132

12.times{|i|$*[0].split(?,)-(g=(0..6).map{|j|%w{C C# D D# E F F# G G# A A# B}[-i+=~(58>>j&1)]})==[]?(puts"Dorain scale in "+g[0]):g}

Eingabe über Befehlszeilenargumente.
z.Bruby dorianscale.rb B,B,D,E,D,B,A,G#,A,G#,E,D,F#,E,F#,E,F#,G#,A

Probieren Sie es bei: ideone

Haskell - 140

Nutzen Sie die von @steveverrill eingeführte Circle of Fifths-Eigenschaft. Wenn wir circle0 = words "C G D A E B F# C# G# D# A# F"und lassen circle = circle0 ++ circle0, können wir alle Skalen konstruieren, indem wir 7 aufeinanderfolgende Noten aufnehmen circle.

scales = [take 7 . drop i $ circle | i <- [0..11]]

In jeder auf diese Weise konstruierten Skala scale !! 3ist das vierte Element der Skalenname.

Code

w=words
n=w"C G D A E B F# C# G# D# A# F"
f s="Dorian scale in "++[x!!3|x<-[take 7.drop i$n++n|i<-[0..]],all(`elem`x)s]!!0
main=interact$f.w

Ungolfed

type Note = String
type Scale = [Note]

notes :: [Note]
notes = words "C G D A E B F# C# G# D# A# F"

scales :: [Scale]
scales = [take 7 . drop i $ notes ++ notes | i <- [0..11]]

findScale :: [Note] -> Note
findScale xs = head [scale !! 3 | scale <- scales, all (`elem` scale) xs]

main = interact (("Dorian scale in "++) . findScale . words)

Scala, 130 128 127

print("Dorian scale in "+(".#?".r findAllIn "FCGDAEBF#C#G#D#A#"*2 sliding(7)find{l=>args(0)split','forall(l contains _)}get 3))

Nach der Methode des Quintenkreises. Eingabe von Kommandozeilenargumenten dh

scala dorianscale.scala B,B,D,E,D,B,A,G#,A,G#,E,D,F#,E,F#,E,F#,G#,A