Jest rok 930, a Kościół gregoriański ma problem. Mają tysiące stron śpiewanej muzyki, ale problem polega na tym, że całe nuty zostały po prostu wrzucone na stos, zamiast mieć prawdziwy system organizacji:

^{Zdjęcie użytkownika gamerprinter z Gildii Kartografów .}

Kościół musi uporządkować wszystkie nuty, więc wynajęli średniowiecznego inżyniera oprogramowania, aby napisał program, który je dla nich zorganizuje. Jesteś inżynierem oprogramowania, który został zatrudniony. Jednak proces kompilacji w czasach średniowiecza wymaga zapisania programu na papierze przez zespół powolnych skrybów biblijnych. Aby skrócić czas potrzebny zespołowi skrybów na skompilowanie kodu, musisz zminimalizować program.

Kościół chce, aby muzyka śpiewana była zorganizowana na podstawie skali muzycznej, w której jest napisana. Cała muzyka śpiewana przez Kościół jest napisana w skalach doryckich . Biorąc pod uwagę nuty określonego utworu muzycznego, twój program wyświetli skalę Doriana, w której się znajduje. Tutaj wyjaśnię dokładnie, czym jest skala Doriana. Jeśli już wiesz, możesz pominąć tę sekcję.

W każdej melodii jest 12 możliwych nut. Oto ich kolejność:

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

Półtonowi (przedstawiony za pomocą S) jest zwiększany o jeden krok w prawo, owijając się wokół (a więc półtonowi się z B wróci do C). Tonu (przedstawiony za pomocą T) ma dwa półtony. Na przykład półton w górę od F # byłby G. Tonem w górę od F # byłby G #.

Aby utworzyć skalę Doriana, zaczynamy od dowolnej nuty na liście, a następnie przechodzimy w górę według następującego wzoru, wymieniając nuty, które napotykamy:

T, S, T, T, T, S

Przykład. Zaczynam od A. Nuty mojej skali Doriana stają się:

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)

Skala ma notatki A, B, C, D, E, F # i G. Ponieważ zacząłem od A będziemy nazywają to Dorian skalę w . Istnieje zatem 12 różnych skal Doriana, z których każda nosi nazwę notatki, od której zaczęły. Każdy z nich używa tego samego wzoru tonów i półtonów, zaczynając od innej pozycji. Jeśli moje wyjaśnienie nie jest spójne, możesz również skonsultować się z Wikipedią .

Dane wejściowe programu można podać z dowolnego elementu odpowiedniego dla programu (np. STDIN, argument wiersza poleceń raw_input()). Nie może być wstępnie zainicjalizowany w zmiennej. Daną wejściową będzie lista nut oddzielonych przecinkami, reprezentujących melodię utworu. Mogą się powtarzać notatki. Na wejściu zawsze będzie wystarczająco dużo różnych nut, aby móc zdecydowanie wydedukować skalę utworu. Przykładowe dane wejściowe:

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

Wyjście programu powinno być ciągiem Dorian scale in X, gdzie X jest początkową nutą skali. Dane wyjściowe przykładowego wejścia:

Dorian scale in B

Porównując to ze skalą Doriana w B ( B C# D E F# G# A), widzimy, że wszystkie nuty melodii mieszczą się w tej skali. Uwaga C # nie jest w tym przypadku używana. Istnieją jednak wystarczające uwagi, aby jednoznacznie zidentyfikować B Dorian jako właściwy klucz. Żadna inna skala Doriana nie pasuje, ponieważ niezależnie od innej skali, której próbujemy, zawsze jest co najmniej jedna nuta melodii, która nie należy do skali.

To jest kod golfowy, więc wygrywa pozycja z najmniejszą liczbą znaków. Zapytaj w komentarzach, jeśli masz pytania.

CJam - 61

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

Wypróbuj na 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);}

Analiza łańcuchów w C nie jest taka łatwa, więc wybrałem podejście matematyczne.

Korzystam z Koła Piątych. Jeśli ułożymy nuty w następującej kolejności na podstawie zliczenia 7 półtonów naraz (znanej jako „piąta”), stwierdzimy, że wszystkie nuty dozwolone w dowolnej skali tworzą kolejny blok 7 nut i wszystkie zabronione nuty tworzą kolejny blok 5 nut.

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

(to koło, zawija się Fna końcu).

Położenie nuty naturalnej w powyższej sekwencji można obliczyć jako (ASCII code) * 2 % 7. Następnie, jeśli następny znak jest nieparzysty (dotyczy #przecinka, spacji lub bajtu zerowego), dodajemy 7, aby był ostry. Przechowujemy mapę bitową wykorzystanych notatek.

Liczba 243(binarna 11111000) odpowiada nutom zabronionym w skali A # Dorian. Pomnożyłem to przez (1<<12)+1=4097liczbę magiczną 1016056. Przesunięcie w prawo ma na celu sprawdzenie (przez ANDing), czy melodia zawiera niedozwolone nuty dla każdej z 12 skal z kolei. Jeśli melodia nie zawiera niedozwolonych nut, skala jest drukowana.

Aby uzyskać wynik, musimy wydrukować nazwę skali zakodowaną w odwrotnej kolejności, aby cykl piąty powyżej, pamiętajmy, że cofamy się, ponieważ zmieniamy prawa.) Sekwencja ASCII ADGCFBEADGCFjest generowana przez 65+i*3%7. W przypadku pierwszych pięciu z nich należy również wydrukować ostry.

Nieskluczony kod

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.
}

Nieprawidłowe zachowanie wejściowe: jeśli dostarczona zostanie niewystarczająca ilość notatek, aby jednoznacznie określić skalę, wyświetli ona wszystkie możliwe skale. Jeśli dostarczona zostanie niemożliwa kombinacja nut, nic nie wyda. Notatki muszą być rozdzielane przecinkiem (lub innym znakiem spacji z parzystym kodem ASCII <= 64.) Nie można używać spacji, ponieważ wszystko po pierwszej spacji byłoby traktowane jako inny argument. Kody ASCII> 64 będą interpretowane jako notatki w opisany sposób.

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

Nie golfił

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 znaków

Nie jest to takie krótkie, ale dla Pythona radością jest pisanie wielu zagnieżdżonych pętli dla jednej linii, nawet gdy nie gra w golfa. Niestety musiałem umieścić instrukcję wejściową w osobnym wierszu, aby nie wykonała się więcej niż raz.

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]

Nie używam Pythona 3, ale uważam, że jest to rzadki przypadek, gdy instrukcja print nie potrzebuje więcej znaków. Ponieważ printjest tam funkcja, byłbym w stanie zrównoważyć potrzebę nawiasów za pomocą *operatora rozpakowywania listy w celu zastąpienia ostatniego [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}

Dane wejściowe z argumentów wiersza poleceń.
na przykładruby dorianscale.rb B,B,D,E,D,B,A,G#,A,G#,E,D,F#,E,F#,E,F#,G#,A

Spróbuj na: ideone

Haskell - 140

Skorzystaj z właściwości Circle of Fifths wprowadzonej przez @steveverrill. Jeśli pozwolimy circle0 = words "C G D A E B F# C# G# D# A# F"i circle = circle0 ++ circle0, możemy skonstruować wszystkie skale, biorąc kolejne 7 notatek circle.

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

W każdej skonstruowanej w ten sposób scale !! 3skali czwartym elementem jest nazwa skali.

Kod

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

Nie golfił

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))

Korzystanie z metody koła piątego. Dane wejściowe z argumentów wiersza poleceń tj

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