Generujesz gitary?

24

Napisz najkrótszy program, który generuje tabulatury gitarowe dla akordów podanych jako wejście.

Aby gitarzyści spośród was nie mieli przewagi i aby uczynić ją deterministyczną (i prawdopodobnie łatwiejszą do kodowania), oto jedyne dozwolone formy akordów:

Major chords:

  E   F   F#  G   G#  A   A#  B   C   C#  D   D#
e 0---1---2---3---4---0---1---2---3---4---5---6---
B 0---1---2---3---4---2---3---4---5---6---7---8---
G 1---2---3---4---5---2---3---4---5---6---7---8---
D 2---3---4---5---6---2---3---4---5---6---7---8---
A 2---3---4---5---6---0---1---2---3---4---5---6---
E 0---1---2---3---4---0---1---2---3---4---5---6---

Minor chords:

  Em  Fm  F#m Gm  G#m Am  A#m Bm  Cm  C#m Dm  D#m
e 0---1---2---3---4---0---1---2---3---4---5---6---
B 0---1---2---3---4---1---2---3---4---5---6---7---
G 0---1---2---3---4---2---3---4---5---6---7---8---
D 2---3---4---5---6---2---3---4---5---6---7---8---
A 2---3---4---5---6---0---1---2---3---4---5---6---
E 0---1---2---3---4---0---1---2---3---4---5---6---

Zauważ, że 5 pierwszych akordów i 7 ostatnich akordów z każdej serii mają różne formy.

Wszystkie akordy są prostymi większymi lub mniejszymi akordami (nr 7 lub inne odmiany).

Powinieneś także zadbać o mieszkania. Przypomnienie:

A# = Bb
C# = Db
D# = Eb
F# = Gb
G# = Ab

B#, Cb, E# and Fb are not used

Dane wyjściowe muszą zawierać pierwszą kolumnę z nazwami przewodów, jak pokazano powyżej. To nie nie muszą zawierać nazwę akordu na górze. Akordy muszą być oddzielone 3- jak pokazano powyżej. Ostatnie 3 -są opcjonalne.

Dane wejściowe to ciąg znaków składający się z nazw akordów oddzielonych spacjami.

Przykładowe dane wejściowe to:

Bm Gb A E G D Em F#

a odpowiednie wyjście to:

e 2---2---0---0---3---5---0---2---
B 3---2---2---0---3---7---0---2---
G 4---3---2---1---4---7---0---3---
D 4---4---2---2---5---7---2---4---
A 2---4---0---2---5---5---2---4---
E 2---2---0---0---3---5---0---2---
Jules Olléon
źródło
... i pytanie poboczne: jaka jest przykładowa piosenka? :)
Jules Olléon
5
Hotel California: P
Matthew Przeczytano
Tak, wygrywasz! :)
Jules Olléon
Fajny pomysł. Chciałbym mieć czas na grę!
Igby Largeman

Odpowiedzi:

9

JavaScript, 297 277 262 235 223 znaków

Brak zwrotów karetki w wersji golfowej jest znaczący; są one tylko po to, aby odpowiedź była czytelna. Średniki są znaczące.

Edycja: zamieniłem zewnętrzną mapna pętlę while i inne zmiany. Wreszcie wewnątrz 2 × wielkości wersji Golfscript (na razie)!

Edycja: Zastąpiłem indexOfmatematyką, zepsułem tablicę odnośników, inne drobne poprawki.

Edit: Inną mapsię fori umieścić w końcowej \nI zostały niepotrzebnie jedzenia. Wreszcie wewnątrz wersji Julesa w języku Python.

i=prompt(o='').split(' ');for(r=6;o+=' EADGBe'[r]+' ',r--;o+='\n')
for(j=0;n=i[j++];o+=(([84,13,52,5][2*/m/.test(n)+x]*8>>2*r&3)+y-7*x)+'---')
y=n.charCodeAt(0),y=(2*y-(y>66)-(y>69)+(n[1]<'$')-(n[1]=='b')+2)%12,x=y>6;alert(o)

Dane wyjściowe nie korzystają już z ---opcjonalnego zakończenia , ponieważ:

e 2---2---0---0---3---5---0---2---
B 3---2---2---0---3---7---0---2---
G 4---3---2---1---4---7---0---3---
D 4---4---2---2---5---7---2---4---
A 2---4---0---2---5---5---2---4---
E 2---2---0---0---3---5---0---2---
DocMax
źródło
Cholera, chyba mam zazdrość o javascript. Ładnie wykonane.
kekekela
7

Golfscript, 136 znaków

[["eBGDAE"{[]+" "+}/]]\" "/{.-2\{"bm#A B C D E F G"?.)!!*(+}/14%.3>-.8>-.7/@109?0>2*+[963 780 882 753]{3base(;}%=\7%{+'---'+}+%}%+zip n*

W pełni 23 znaki (17,5%) dotyczą tych dwóch znaków na początku każdego wiersza wyjściowego.

Przykładowe dane wyjściowe, testowanie przypadków na krawędziach:

$ golfscript.rb tabs.gs <<<"E G# Ab A Db D# Em G#m Abm Am D#m"
e 0---4---4---0---4---6---0---4---4---0---5---
B 0---4---4---2---6---8---0---4---4---1---6---
G 1---5---5---2---6---8---0---4---4---2---7---
D 2---6---6---2---6---8---2---6---6---2---7---
A 2---6---6---0---4---6---2---6---6---0---5---
E 0---4---4---0---4---6---0---4---4---0---5---

Spędziłem na tym tylko około godziny, więc prawdopodobnie można go zmniejszyć przynajmniej o 5 do 10 znaków. Koncepcyjnie okazuje się, że jest całkiem podobne do rozwiązania DocMax: tabela odnośników dla czterech przypadków, następnie zwiększ o przesunięcie i połącz ciągi we właściwej kolejności.

Peter Taylor
źródło
+1: Man I love Golfscript! Kilka razy dzisiaj znalazłem miejsca do przycięcia kodu, ale nie o 50%! Nie mam pod ręką tłumacza: czy zwraca D # dla Eb?
DocMax
BTW, ostatnia nuta w Twojej próbce pasuje do C # m, chociaż wiersz poleceń pokazuje D # m. Literówka czy błąd?
DocMax
@DocMax, błąd. Nie rozumiem, dlaczego wpływa to tylko na D # mi nie D # - debugowanie będzie interesujące. Zmieniam kolejność rzeczy, ponieważ wygodnie jest mieć blok 7 jako pierwszy, więc Eb nie jest tak naprawdę przypadkiem.
Peter Taylor,
Okazuje się, że do ostatniego dołączano \ n, co nie znajdując się w tabeli odnośników zmniejszało wartość o równowartość litery.
Peter Taylor,
4

Po zakodowaniu tego, zdałem sobie sprawę, że mogłem zrobić to znacznie mądrzej ... może zrobię kolejny wpis. Mam nadzieję, że dostanę punkty za bycie najszybszym!

W każdym razie jest 962 znaków Perla.

%c =(B=>{E=>0,F=>1,Gb=>2,G=>3,Ab=>4,A=>2,Bb=>3,B=>4,C=>5,Db=>6,D=>7,Eb=>8,Em=>0,Fm=>1,Gbm=>2,Gm=>3,Abm=>0,Am=>1,Bbm=>2,Bm=>3,Cm=>4,Dbm=>5,Dm=>6,Ebm=>7},G=>{E=>1,F=>2,Gb=>3,G=>4,Ab=>5,A=>2,Bb=>3,B=>4,C=>5,Db=>6,D=>7,Eb=>8,Em=>0,Fm=>1,Gbm=>2,Gm=>3,Abm=>4,Am=>2,Bbm=>3,Bm=>4,Cm=>5,Dbm=>6,Dm=>7,Ebm=>8},D=>{E=>2,F=>3,Gb=>4,G=>5,Ab=>6,A=>2,Bb=>3,B=>4,C=>5,Db=>6,D=>7,Eb=>8,Em=>2,Fm=>3,Gbm=>4,Gm=>5,Abm=>6,Am=>2,Bbm=>3,Bm=>4,Cm=>5,Dbm=>6,Dm=>7,Ebm=>8},A=>{E=>2,F=>3,Gb=>4,G=>5,Ab=>6,A=>0,Bb=>1,B=>2,C=>3,Db=>4,D=>5,Eb=>6,Em=>2,Fm=>3,Gbm=>4,Gm=>5,Abm=>6,Am=>0,Bbm=>1,Bm=>2,Cm=>3,Dbm=>4,Dm=>5,Ebm=>6},E=>{E=>0,F=>1,Gb=>2,G=>3,Ab=>4,A=>0,Bb=>1,B=>2,C=>3,Db=>4,D=>5,Eb=>6,Em=>0,Fm=>1,Gbm=>2,Gm=>3,Abm=>4,Am=>0,Bbm=>1,Bm=>2,Cm=>3,Dbm=>4,Dm=>5,Ebm=>6});
%b=('A#'=>'Bb','C#'=>'Db','D#'=>'Eb','F#'=>'Gb','G#'=>'Ab');
foreach(qw(e B G D A E)){p($_,@ARGV)}
sub p{$s = shift;print "$s ";$s = uc($s);foreach(@_){while(($h,$f)=each(%b)){s/$h/$f/}print "$c{$s}->{$_}---"}print "\n"}

Oto odpowiednie wyjście.

dhrasmus:Desktop standage$ perl guitar Bm Gb A E G D Em F#
e 2---2---0---0---3---5---0---2---
B 3---2---2---0---3---7---0---2---
G 4---3---2---1---4---7---0---3---
D 4---4---2---2---5---7---2---4---
A 2---4---0---2---5---5---2---4---
E 2---2---0---0---3---5---0---2---
Daniel Standage
źródło
4

Ponieważ już podano krótsze rozwiązania (cholera, GolfScript!), Oto moje:

Python, 229 znaków

s=[("E EmF FmF#GbG GmG#AbA AmA#BbB BmC CmC#DbD DmD#Eb".find("%-02s"%s[:2])/4,s[-1]!='m')for s in raw_input().split()]
for c in range(6):
 l='eBGDAE'[c]+' '
 for(i,M)in s:x=i>4;l+=`i-5*x+2*(2<c+x<5)+(M+x)*(c==2-x)`+"---"
 print l

Wydajność:

> echo "Bm Gb A E G D Em F#" | python guitar.py
e 2---2---0---0---3---5---0---2---
B 3---2---2---0---3---7---0---2---
G 4---3---2---1---4---7---0---3---
D 4---4---2---2---5---7---2---4---
A 2---4---0---2---5---5---2---4---
E 2---2---0---0---3---5---0---2---
Jules Olléon
źródło
3

Python, 449 znaków

z=int
f=str
r=range
j=''.join
n='E F F# G G# A A# B C C# D D#'.split()
n+=[x+'m'for x in n]
c=[j([f(z(x)+i)for x in'001220'])for i in r(5)]+[j([f(z(x)+i)for x in'022200'])for i in r(7)]
c+=[x[:2]+f(z(x[2])-1)+x[3:]for x in c[:5]]+[x[0]+f(z(x[1])-1)+x[2:]for x in c[5:]]
a=[c[n.index((chr(ord(i[0])-1)+'#'+i[2:]).replace('@','G')if len(i)-1 and i[1]=='b'else i)]for i in raw_input().split()] 
for i in r(6):print'eBGDAE'[i],j([x[i]+'-'*3 for x in a])
Fernando Martin
źródło
3

C99 - 231 znaków

Akordy są podawane w wierszu poleceń, jeden argument na akord i oczywiście nie ma żadnego rodzaju sprawdzania poprawności wejściowej.

#include<stdio.h>
int main(int c,char**v){for(char*o="e0)B2)G2*D2+A0+E0)",i,m;*o;o+=3,v-=c,puts(""))for(printf("%c ",*o);*++v;printf("%c---",i-(i>2)-i/9+o[1+i/8]-(*o-66-i/8*5?0:m?m+2[*v]>99:0)))m=1[*v],i=(**v*2-4+m/35-m/98*3)%14;}

Przykładowy przebieg:

$ ./a.out Bm Gb A E G D Em F#
e 2---2---0---0---3---5---0---2---
B 3---2---2---0---3---7---0---2---
G 4---3---2---1---4---7---0---3---
D 4---4---2---2---5---7---2---4---
A 2---4---0---2---5---5---2---4---
E 2---2---0---0---3---5---0---2---

Nie grał w golfa

#include<stdio.h>
int main(int c,char**v){
     // o points to three characters per output line:
     //   string name, number for A, adjusted number for E (ASCII code minus 7)
     char* o="e0)B2)G2*D2+A0+E0)",
          i, // chord: A=0, A#=1, ..., G#=13, allowing also 3="E#" and 9="B#"
          m; // second character in chord name
     for (; *o; o+=3) {
          printf("%c ", *o);
          for (; *++v; ) {
               m = 1[*v],
               i = (**v*2-4+m/35-m/98*3)%14; // parse & adjust for sharp, flat
               printf("%c---",
                      i-(i>2)-i/9 // eliminate "E#", "B#"
                      +o[1+i/8] // get the number for a major chord
                      // adjust for minor...
                      -(*o-66-i/8*5
                        ? 0
                        : m ? m+2[*v]>99 : 0));
          }
          v -= c; // rewind argument pointer
          puts("");
     }
}

Niestandardowe C - 206 znaków

Jeśli nie dbamy o specyfikacje językowe, GCC może skompilować następujący jednowierszowy plik do funkcjonalnego pliku binarnego, nawet jeśli miesza deklaracje zmiennych C99 z deklaracją argumentów w stylu K&R (i niejawną deklaracją printf).

main(c,v)char**v;{for(char*o="e0)B2)G2*D2+A0+E0)",i,m;*o;o+=3,v-=c,puts(""))for(printf("%c ",*o);*++v;printf("%c---",i-(i>2)-i/9+o[1+i/8]-(*o-66-i/8*5?0:m?m+2[*v]>99:0)))m=1[*v],i=(**v*2-4+m/35-m/98*3)%14;}
Han
źródło
2

C ++, 432

#include <cmath>
#include <iostream>
F(int c){c-=65;return c*1.6+sin(c/5.+.3);}
T(int a,int s){if(s)return(a=(T(a,s-1)+2)%3)-=(a==1&s>2);return(a<7)*2;}
#define c(a,b) while(*(++j)==a)b;--j; 
#define O std::cout<<
main(int a,char*p[]){
int P=2;for(int i=-1;++i<6;P=2){O p[1][i];O" ";while(P<a){char*j=p[P++];
int f=F(*j);c('#',++f)c('b',--f)
int t=T(f,i)*3.5;if(*(++j)!='m'){--j;t+=(t==3);}
O(f-F(p[1][i])+t+24)%12;O"---";
}O'\n';}}

Zauważ, że wymaga to strojenia gitary jako pierwszego parametru. (Większość niestandardowych ustawień dostarczy ci absurdalnych wyników, ale wydaje mi się, że jesteś zadowolony ze standardowego strojenia.)

W przypadku hotelu California możesz to zrobić $./a.out EBGDAE Cbm Gb Bbb Fb G D Em F# Bm F# G## D## F## C## D##m E##. Wynik:

E 2---2---0---0---3---5---0---2---2---2---5---0---3---5---0---2---
B 3---2---2---0---3---7---0---2---3---2---5---0---3---7---0---2---
G 4---3---2---1---4---7---0---3---4---3---6---1---4---7---0---3---
D 4---4---2---2---5---7---2---4---4---4---7---2---5---7---2---4---
A 2---4---0---2---5---5---2---4---2---4---7---2---5---5---2---4---
E 2---2---0---0---3---5---0---2---2---2---5---0---3---5---0---2---
przestał się obracać w lewo
źródło
Strojenie górnych czterech strun do mniejszych trzecich sprawia, że ​​bardzo łatwo jest grać akord trzy- i czterostrunowy w wielu inwersjach, bez otwartych strun i bez konieczności umieszczania palca „nad” struną bez dotykania go. Używając ciągów DFG # B, sekwencja akordów takich jak „Bbm F Bbm Gb Db Ebm Db F Bbm F F7 Bbm” (Song Mermaid) działa bardzo łatwo. Konieczne jest tylko przesunięcie w górę i w dół o jeden próg. Jest kluczowy krok do połowy, ale to po prostu oznacza przesunięcie progu. Jednak nie zastanawiałem się, co najlepiej zrobić z pozostałymi dwoma łańcuchami.
supercat
@supercat: ciekawe, jutro wypróbuję to na mojej gitarze ...
przestałem obracać się przeciwnie do zegara
Chciałbym usłyszeć, co myślisz. Wziąłem gitarę kilka razy, w odstępie kilku lat, i wciąż się poddawałem, ponieważ palcowanie wydawało się zarówno arbitralne, jak i niezręczne. Potem pomyślałem o tym, jakie strojenie pozwoliłyby na proste palcowanie. Ponieważ akordy w kształcie zamkniętym mają interwały, które wahają się od mniejszej jednej trzeciej do doskonałej czwartej, strojenie strun do mniejszych trzecich oznacza, że ​​każda struna będzie tłumiona w punkcie, który nie jest niższy niż struna poniżej. Jeśli mogę wypróbować gitarę dla leworęcznych, mógłbym wypróbować idealne czwarte z odwróconą kolejnością strun, ponieważ powinno to być podobne.
supercat
W tej chwili strojenie do mniejszych trzecich oznacza, że ​​dla każdej pozycji pierwszego palca na najniższej strunie będą dostępne trzy główne inwersje akordów i trzy mniejsze inwersje akordów. Można także zagrać siódmy akord, umieszczając drugi palec na trzech górnych strunach. W przypadku utworu Mermaid rozpocznij od trzeciego progu i zagraj w F-Bb-DF (palcami 1-3-3-4). Zatem F oznacza FACF (1-2-2-4). Gb jest na progu, z palcami 1-2-2-4 (jak F). Db wraca na dół, 1-3-4-4. Ebm powrócił, 1-2-4-4.
supercat
Dopiero po kilku godzinach dotarłem do momentu, w którym mogłem płynnie zagrać niektóre utwory (w tym wspomnianą piosenkę Syrenka) po wypracowaniu przy pomocy klawiatury odpowiednich nut akordów. Kiedy wypróbowałem ten styl, wydawało mi się to niesamowicie naturalne i bardzo podoba mi się sposób, w jaki można użyć wszystkich trzech inwersji każdego większego i mniejszego akordu. Gdyby ktoś chciał tylko dużych i mniejszych akordów, strojenie takie jak F-Ab-B-Eb-Gb-D teoretycznie mogłoby pozwolić na duże i drobne akordy na sześć palców z łatwymi palcami (1-2-2-3-4-4 lub 1 -1-2-3-3-4), ale bez inwersji.
supercat
2

390 345 340 Postscriptum

Uproszczone do gitarowo-pragmatycznego podejścia (kształt E jest tylko odmianą kształtu A, przesuniętego w dół struny, z jedną zmianą palca). Pożyczkę z zakodowanym ciągiem znaków uzyskałem z innych odpowiedzi.

[/p{print}/x{exch}/e{cvx exec}/d{dup 0
get}/f{forall}(A0#1B2C3D5E7F8G:b;){}forall/m{dup
4 2 copy get 1 sub put}109{m 48}/+{[3 1 roll x{1
index add x}f]}/*{[0 0 2 2 2 0 0]x{load e 48 sub
+}f d 12 gt{-12 +}if d 6 gt{m -7 + 1}{0}ifelse 6
getinterval}>>begin[ARGUMENTS{*}f][(E)(A)(D)(G)(B)(e)]6{[x
e p( )p]x[x{[x e( )cvs p(---)p]}f]x()=}repeat

Poprzednio:

450 442 418 Postscriptum

Naprawiłem również format wyjściowy z tym. (Poprzednie wersje zaczynały się „E ---” zamiast „e”.)

<</i{index}/a{add}/p{pop}/x{exch}/g{getinterval}/r{print}/f{forall}/e{exec}>>begin<<65[0
2 3 5 -5 -4 -2]{1 i 1 a}f p 35{1 a}98{1 sub}109{x dup
4 20 put x}>>begin[ARGUMENTS{[x[0 5 12 17 21 24 29
0]x{load e}f x{1 i a x}f]dup 0 get 0 ge{0}{1}ifelse 7
g[0 -5 -10 -15 -19 -24 -29]0 1 6{2 copy get 3 i 2 i
get a 3 copy put p p}for x p 0 6
g}f][(E)(A)(D)(G)(B)(e)]6{[x cvx e r( )r]x[x{[x cvx
e( )cvs r(---)r]}f]x(\n)r}repeat

Jak go uruchomić: gsnd -q -- tab.ps Bm Gb A E G D Em F\#(ukryj ostrze przed skorupą).

Wersja bez golfa była prawie trudniejsza niż wersja z golfem. Ale starałem się być dokładny. Edycja: jeszcze kilka komentarzy na temat podstępnych bitów.

%!PS
<<    %axioms and operations
/t{2 2 1}    %major tetrachord
/m{t t 2}    %mixolydian mode
/u{2 1 2}    %minor tetrachord
/a{u u}      %aolian mode
/s{m m t}    %2.5-octave mixolydian intervals
/r{3 1 roll}
/${[exch 0 exch{1 index add}forall]}    %running sum: convert (relative)intervals to (abstract)fretstops
/+{[r exch{1 index add exch}forall pop]}    %scale array by scalar
/@{[r{2 copy get r pop}forall pop]}    %select array elements from array of indices
/&{0 1 3 index length 1 sub{    %array2 += array1
    2 copy get 3 index 2 index get add 3 copy put pop pop}for exch pop}
>>begin<<    %map ascii values to scaling functions
65[a]$    %generate fretstops of the A aolian scale to assign scalars to note names
[0 0 0 0 -12 -12 -12]&    %drop E F and G down an octave
{[exch/+ cvx]cvx 1 index 1 add}forall pop    %generate the pairs 'A'->{0 +}, 'B'->{2 +}
35{1 +}     %'#'-> scale up by one
98{-1 +}    %'b'-> scale down by one
109{dup 4 2 copy get 1 sub put}     %'m'-> tweak the 'third' down by one
%generate chord pattern from (string)
/*{[s]$       %generate fretstops of the E mixolydian scale
  [1 4 8 11 13 15 18]    %A-shape figured bass: IV chord of E mixolydian
  -1 +       %convert scale degrees to array indices
  @       %generate chord template by selecting indices from mixolydian scale
  exch{load exec}forall       %execute ascii values, scaling the pattern
  dup 0 get 0 ge{0}{1}ifelse 6 getinterval    %discard first note if it has fallen off the bottom
  [0 -5 -10 -15 -19 -24]&}    %subtract the string offsets
>>begin    %activate definitions
%(A)* pstack()= clear    %[0 0 2 2 2 0]
%(B)* pstack()= clear    %[2 2 4 4 4 2]
%(F#)* pstack()= clear    %[2 4 4 3 2 2]
%(Abm)* pstack()=    %[4 6 6 4 4 4]
[ARGUMENTS{*}forall]    %convert array of strings to array of patterns
[(E)(A)(D)(G)(B)(e)]    %array of string names
6{    %for each "string"
    [exch cvx exec print( )print]    %pop string name and print with space
    exch       %put names behind numbers
    [exch{     %for each "chord"
        [exch cvx exec( )cvs print(---)print]    %pop number, convert, print with trailing hyphens
    }forall]    %zip up chord array for next iteration
    ()=         %print a newline
    exch        %put numbers behind names
}repeat

A co powiesz na House of the Rising Sun jako test?

04:51 PM:~ 0> gsnd -q -- tabb.ps Em G A C Em G B B Em G A C Em B Em B|sed 's/^/    /'
e 0---3---0---3---0---3---2---2---0---3---0---3---0---2---0---2---
B 0---3---2---5---0---3---4---4---0---3---2---5---0---4---0---4---
G 0---4---2---5---0---4---4---4---0---4---2---5---0---4---0---4---
D 2---5---2---5---2---5---4---4---2---5---2---5---2---4---2---4---
A 2---5---0---3---2---5---2---2---2---5---0---3---2---2---2---2---
E 0---3---0---3---0---3---2---2---0---3---0---3---0---2---0---2---
luser droog
źródło
Napisałem komentarz do tego kodu w innej odpowiedzi tutaj .
luser droog