Gerando guias de guitarra?

24

Escreva o programa mais curto que gere guias de guitarra para os acordes dados como entrada.

Para que os guitarristas não tenham uma vantagem, e para torná-la determinística (e provavelmente mais fácil de codificar), aqui estão as únicas formas de acordes autorizadas:

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

Observe que os 5 primeiros acordes e os 7 últimos acordes de cada série têm formas diferentes.

Todos os acordes são simples ou maiores (sem sétima ou outras variações).

Você deve cuidar de apartamentos também. Lembrete:

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

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

A saída deve incluir a primeira coluna com os nomes dos cabos, como mostrado acima. Ele não precisa incluir o nome do acorde na parte superior. Os acordes devem ser separados por 3, -como mostrado acima. Os 3 finais -são opcionais.

Entrada é uma sequência que consiste em nomes de acordes, separados por espaços.

Um exemplo de entrada é:

Bm Gb A E G D Em F#

e a saída correspondente é:

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
fonte
... e questão secundária: qual é o exemplo da música? :)
Jules Olléon
5
Hotel California: P
Matthew Leia
Sim, você venceu! :)
Jules Olléon
Idéia legal. Gostaria de ter tempo para jogar!
Igby Largeman

Respostas:

9

JavaScript, 297 277 262 235 223 caracteres

Nenhum retorno de carro na versão golfed é significativo; eles estão lá apenas para tornar a resposta legível. O ponto e vírgula é significativo.

Editar: Substituiu o exterior mappor um loop while e outras edições. Finalmente, dentro de 2 × o tamanho da versão Golfscript (por enquanto)!

Edit: Substituído o indexOfcom matemática, quebrou a tabela de pesquisa, outras pequenas melhorias.

Edit: Outro mappara fore colocar em uma final \neu estava comendo desnecessariamente. Finalmente dentro da versão Python de Jules.

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)

A saída não aproveita mais o fato de o final ---ser opcional como:

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
fonte
Porra, eu tenho inveja javascript peen eu acho. Bem feito.
kekekela
7

Golfscript, 136 caracteres

[["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*

Totalmente 23 caracteres (17,5%) lidam com esses dois caracteres no início de cada linha de saída.

Exemplo de saída, testando os casos extremos:

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

Eu gastei apenas cerca de uma hora nisso, então provavelmente pode ser reduzido em 5 a 10 caracteres, pelo menos. Conceitualmente, é bastante semelhante à solução da DocMax: tabela de pesquisa para quatro casos, depois incrementa em um deslocamento e une as strings na ordem correta.

Peter Taylor
fonte
+1: Cara, eu amo Golfscript! Várias vezes hoje encontrei lugares para cortar meu código, mas não em 50%! Não tenho um intérprete à mão: ele retorna D # para Eb?
DocMax
BTW, a última nota em seu exemplo corresponde a C # m, embora a linha de comando mostre D # m. Erro de digitação ou erro?
DocMax
@DocMax, bug. Não entendo por que isso afeta apenas o D # me não o D # - isso será interessante para depurar. Reorganizo as coisas porque é conveniente ter o bloco 7 primeiro, então Eb não é realmente um caso de ponta.
Peter Taylor
Acontece que o último estava sendo incluído \ n, o que não estar na tabela de pesquisa estava diminuindo o valor pelo equivalente a uma letra.
Peter Taylor
4

Depois de codificar isso, percebi que poderia ter feito isso de maneira muito mais inteligente ... talvez eu faça outra entrada. Espero conseguir apenas pontos por ser o mais rápido!

De qualquer forma, existem 962 caracteres do Perl.

%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"}

Aqui está a saída correspondente.

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
fonte
4

Como soluções mais curtas já foram fornecidas (maldito GolfScript!), Aqui está a minha:

Python, 229 caracteres

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

Saída:

> 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
fonte
3

Python, 449 caracteres

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
fonte
3

C99 - 231 caracteres

Os acordes são dados na linha de comando, um argumento por acorde e, é claro, não há validação de entrada de nenhum tipo.

#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;}

Exemplo de execução:

$ ./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---

Sem golfe

#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("");
     }
}

C fora do padrão - 206 caracteres

Se não nos importamos com as especificações de linguagem, o GCC pode compilar a seguinte linha em um binário funcional, mesmo que misture declarações de variáveis ​​C99 com uma declaração de argumento de estilo K&R (e uma declaração implícita de 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
fonte
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';}}

Observe que isso precisa do ajuste da guitarra como o primeiro parâmetro. (A maioria das afinações fora do padrão fornecerá resultados ridículos de quebrar os dedos, mas acho que você está satisfeito com a afinação padrão.)

Para o Hotel California, você pode fazer $./a.out EBGDAE Cbm Gb Bbb Fb G D Em F# Bm F# G## D## F## C## D##m E##. Resultado:

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---
deixou de girar contra-relógio
fonte
Ajustar as quatro cordas superiores a terços menores facilita muito a execução de acordes de três e quatro cordas em muitas inversões, sem cordas abertas e sem ter que colocar um dedo sobre uma corda sem tocá-la. Usando as cordas DFG # B, uma sequência de acordes como "Bbm F Bbm Gb Db Ebm Db F Bbm F F7 Bbm" (Canção da sereia) funciona muito facilmente. Só é necessário mudar para cima e para baixo um traste. Há uma troca de teclas em meio passo, mas isso significa apenas mudar de assunto. Ainda não descobrimos o que melhor fazer com as outras duas cordas.
Supercat 19/02
@supercat: interessante, vou tentar fazer isso no meu amanhã guitarra ...
deixou de vez counterclockwis
Eu gostaria de ouvir o que você pensa. Eu peguei um violão algumas vezes, anos depois, e continuei desistindo porque os dedilhados pareciam arbitrários e desajeitados. Então eu comecei a pensar sobre quais afinações permitiriam dedilhados simples. Como os acordes de forma fechada têm intervalos que variam de um terço menor a um quarto perfeito, ajustar cordas a terços menores significa que cada corda será amortecida em um ponto que não seja inferior à corda abaixo. Se eu puder experimentar um violão para canhotos, talvez tente quartas perfeitas com a ordem das cordas invertida, pois deve ser semelhante.
Supercat 19/02
Assim, ajustar para terços menores significa que, para cada posição do primeiro dedo na corda mais baixa, haverá três inversões principais de acordes e três inversões menores de acordes disponíveis. Também se pode tocar um sétimo acorde colocando o segundo dedo nas três cordas superiores. Para Mermaid Song, comece no terceiro traste e toque F-Bb-DF (com os dedos 1-3-3-4). Então F é FACF (1-2-2-4). Gb está preocupado, com os dedos 1-2-2-4 (como F). Db está de volta um problema, 1-3-4-4. Ebm está de volta, 1-2-4-4.
Supercat 19/02
Levei apenas algumas horas para chegar ao ponto em que eu poderia tocar suavemente algumas peças (incluindo a mencionada canção da sereia) depois de trabalhar com a ajuda de um teclado quais deveriam ser as notas de acordes adequadas. Depois de experimentar esse estilo, senti-o incrivelmente natural, e eu realmente gosto da maneira como podemos usar as três inversões de cada acorde maior e menor. Se alguém apenas quisesse acordes maiores e menores, uma afinação como F-Ab-B-Eb-Gb-D poderia teoricamente permitir acordes maiores e menores de seis dedos com dedilhados fáceis (1-2-2-3-4-4 ou 1 -1-2-3-3-4) mas sem as inversões.
Supercat 19/02
2

390 345 340 Postscript

Simplificado para uma abordagem pragmática da guitarra (a forma E é apenas uma variação da forma A, deslocada para baixo de uma corda, com uma mudança de dedo). Emprestou a idéia de cadeia codificada das outras respostas.

[/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

Anteriormente:

450 442 418 Postscript

Corrigi o formato de saída com este também. (As versões anteriores começaram "E ---" em vez de "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

Como executá-lo: gsnd -q -- tab.ps Bm Gb A E G D Em F\#(esconda o afiado da concha).

A versão sem golfe era quase mais difícil do que a versão com golfe. Mas eu tentei ser completo. Edit: mais alguns comentários sobre os truques.

%!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

E quanto à Casa do Sol Nascente como teste?

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
fonte
Escrevi um comentário desse código em outra resposta aqui .
Luser droog