Contribution

Le symbole de tout accord triadique (voir http://en.wikipedia.org/wiki/Chord_(music)#Triads ).

Sortie

Les notes constituant l'accord donné.

Exemples

Entrée: AM sortie:A C# E

Entrée: C#m sortie:C# E G#

Entrée: Db+ sortie:C# F A

Entrée: C0 sortie:C D# F#

Bonus

-50 si vous pouvez également composer avec des accords septième

-150 pour jouer le son de l'accord

-150 pour utiliser des caractères imprimables pour montrer comment jouer l'accord sur un piano; exemple pour AM:

┌─┬─┬┬─┬─┬─┬─┬┬─┲┱─┬─┬─┲━┱┬─┲━┱─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ┃┃ │ │ ┃ ┃│ ┃ ┃ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ┃┃ │ │ ┃ ┃│ ┃ ┃ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ┃┃ │ │ ┃ ┃│ ┃ ┃ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┲┛┗┱┘ │ ┗┯┛└┲┛ ┃ └┬┘└┬┘└┬┘ │
│  │  │  │  │  ┃  ┃  │  │  ┃  ┃  │  │  │  │
└──┴──┴──┴──┴──┺━━┹──┴──┴──┺━━┹──┴──┴──┴──┘

-100 pour l'utilisation de caractères imprimables pour montrer comment jouer l'accord sur une guitare; exemple pour AM:

x   o   o   o   o   o
┌───┬───┬───┬───┬───┐
│   │   │   │   │   │
├───┼───┼───┼───┼───┤
│   │   │   │   │   │
├───┼───┼───┼───┼───┤
│   │   █   █   █   │
├───┼───┼───┼───┼───┤
│   │   │   │   │   │

(voir https://en.wikipedia.org/wiki/Box-drawing_character )

Règles

• Le résultat doit être un programme ou un script en ligne de commande.

• L'entrée et la sortie peuvent être sous n'importe quelle forme, dans la mesure où elles respectent une norme de notation musicale.

• Une représentation de guitare ou de piano est considérée comme valide si et seulement si elle contient les trois notes (triadiques) ou quatre (septième) requises et rien d’autre. La même note peut être présente plusieurs fois dans l'accord.

• Les bibliothèques externes ne sont pas autorisées, sauf pour la génération de son (dans ce cas #include, les importdirectives , ... ne sont pas ajoutées au nombre de caractères).

• C'est le code golf, le code le plus court gagne!

Un peu de théorie musicale ...

Dans la musique tonale occidentale moderne, chaque octave est composée de douze notes successives, souvent notées:

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

Ou:

La La# Si Do Do# Re Re# Mi Fa Fa# Sol Sol#

Dans ce système, nous considérons que deux notes successives (par exemple, Aet A#, ou Eet F) sont séparées par un demi-ton. En outre, les notes sont en quelque sorte "en boucle": ce qui suit immédiatement G#est A.

Un accord est constitué de quelques notes (2, 3, 4, parfois plus) qui "sonnent bien ensemble". Par exemple, les accords triadiques contiennent trois notes différentes et les accords du septième, quatre notes différentes.

Définissons les quatre accords triadiques comme suit :

• Triade majeure : contient la racine de l'accord (dans cette question, la note donnée en entrée), le tiers majeur de la racine (4 demi-tons plus haut que la racine) et le cinquième parfait pour la racine (7 demi-tons plus haut que la racine ) cela peut être symbolisé 0-4-7

• Triade mineure , symbolisée 0-3-7

• Triade augmentée , symbolisée 0-4-8

• Triade diminuée , symbolisée 0-3-6

Ainsi , par exemple, si vous voulez faire une triade majeure C , noté C, CM, Cmaj, vous aurez besoin de trois a noté:

• 0: la racine , dans ce cas unC
• 4: le tiers mineur , 4 demi-tons plus haut que la racine; c'est unE
• 7: le cinquième parfait , 7 demi-tons plus haut que la racine: aG

C'est ce que 0-4-7, 0-3-7, 0-4-8et les 0-3-6notations utilisées ci - dessus moyenne! Pour les septièmes accords, utilisez le modèle suivant:

C'est tout pour aujourd'hui! Maintenant, étonnez-moi avec un code incroyable ... Si vous avez des questions, ajoutez quelques commentaires ci-dessous.

BBC BASIC

Emulator sur bbcbasic.co.uk

Rev 1, 340 - 150 clavier - 150 en cours de jeu = 40

Voici la dernière version, dans laquelle j'ai réussi à inclure les améliorations suivantes tout en n'allongeant que de quelques caractères supplémentaires.

L'entrée peut être modifiée facilement à l'écran avant d'appuyer sur retour touche (J'utilisais auparavant GET $ pour obtenir des pressions uniques, car BBC Basic ne vous permet pas d'accéder à un seul caractère d'une chaîne comme si la chaîne était un tableau. fonction encombrante de MID $ pour extraire une chaîne d'un caractère à l'intérieur de la chaîne.

Les deux côtés du clavier sont affichés, ainsi que la ligne complète entre E et F.

Pour compenser les caractères ajoutés par ce qui précède, j'ai réorganisé le programme afin d'éliminer les instructions d'impression inutiles et j'ai supprimé des espaces qui, à première vue, semblaient ne pas pouvoir être supprimés. IN BBC Basic, toutes les fonctions intégrées sont des mots réservés. Vous pouvez leur attribuer un nom de variable sans espace entre eux. Les noms de variables ne sont pas autorisés à commencer par un mot réservé. Afin de rendre le programme moins compliqué à lire, j'ai changé toutes les variables en minuscules.

Bien que la présentation soit bien meilleure, le programme suivant est déjà entièrement joué au golf.(Voir la correction ci-dessous.) En général, les nouvelles lignes et les deux points sont interchangeables, sauf lorsqu'une instruction IF est utilisée. Dans ce cas, toutes les instructions de la même ligne (séparées par des deux points) seront exécutées conditionnellement. Les instructions après la nouvelle ligne ne sont pas contrôlées par le SI et seront toujours exécutées.

Programme rev 1 340 caractères

  a$="C#D#EF#G#A#B0Mm+"
  INPUTx$
  r=INSTR(a$,LEFT$(x$,1))-1
  c=INSTR(a$,MID$(x$,2,1))
  IFc=2c=INSTR(a$,MID$(x$,3)):r=r+1
  t=(r+4-c MOD2)MOD12
  f=(r+c DIV2)MOD12
  v=1
  FORn=-1TO11
  c=1-(n<0ORn=4ORn=11)*5
  b$=MID$(a$,n+1,1)
  IFb$="#"c=11:b$=MID$(a$,n,1)+b$
  c$=MID$("   _______--|__",c,5)
  IFr=n ORt=n ORf=n c$=c$+b$:SOUNDv,-15,100+n*4,99:v=v+1
  PRINTc$
  NEXT

CORRECTION: BBC BASIC pour Windows de RT Russell vous permet d’éliminer certaines nouvelles lignes et deux points, ce qui ramène le total à 327, voir ci-dessous. En outre, il marque les mots-clés en caractères uniques avant de les enregistrer, ce qui les ramène à 279.

  a$="C#D#EF#G#A#B0Mm+"INPUTx$
  r=INSTR(a$,LEFT$(x$,1))-1c=INSTR(a$,MID$(x$,2,1))IFc=2c=INSTR(a$,MID$(x$,3))r=r+1
  t=(r+4-c MOD2)MOD12f=(r+c DIV2)MOD12v=1FORn=-1TO11c=1-(n<0ORn=4ORn=11)*5b$=MID$(a$,n+1,1)IFb$="#"c=11b$=MID$(a$,n,1)+b$
  c$=MID$("   _______--|__",c,5)IFr=n ORt=n ORf=n c$=c$+b$SOUNDv,-15,100+n*4,99v=v+1
  PRINTc$
  NEXT

Sortie rev 1

Rev 0, 337 - 150 clavier - 150 en cours de jeu = 37

A$="C#D#EF#G#A#B0Mm+":X$=GET$:R=INSTR(A$,X$)-1:X$=GET$:IF X$="#"R=R+1:X$=GET$
C=INSTR(A$,X$):T=(R+4-C MOD2)MOD12:F=(R+C DIV2)MOD12:V=1:PRINT"______"
FORN=0 TO 11
C=1-(N=4)*12:B$=MID$(A$,N+1,1): IF B$="#" C=7: B$=MID$(A$,N,1)+B$
PRINT MID$("    __---|________",C,6);:IF(R-N)*(T-N)*(F-N)=0 PRINT B$;:SOUND V,-15,100+N*4,99:V=V+1
PRINT
NEXT

C'est un concept similaire à ma réponse Arduino, mais j'ai toujours su que je pouvais battre ce nombre d'octets avec BBC Basic. Ne reconnaît que les dièses, mais considère que B # est invalide, vous devez mettre C. Ceci pourrait être résolu si cela était vraiment considéré comme important.

J'ai abandonné l'idée de la guitare et me suis concentré sur l'amélioration du clavier. Il va maintenant de C à B, et j'ai ajouté dans la partie gauche du clavier et la ligne entre E et F. Cela coûte 28 caractères. Le côté droit ne serait pas beaucoup plus.

Voici un exemple de sortie, un accord atténué A # (qui produit un son assez bizarre dans cette inversion) et un accord majeur en sol. Notez que l'entrée n'est pas renvoyée à l'écran. Conformément à la réponse Arduino, tournez l'écran dans le sens contraire des aiguilles d'une montre pour afficher.

Version non-golfée

A$="C#D#EF#G#A#B0Mm+"                              :REM Note names and chord type names fit very conveniently in the same string.
X$=GET$                                            :REM Get a character 
R=INSTR(A$,X$)-1                                   :REM Root note = position of that char in A$. INSTR starts counting at 1, but we want 0, so subtract.
X$=GET$                                            :REM If the root note is natural, the next character will be the chord type. But...
IF X$="#"R=R+1:X$=GET$                             :REM If this char is # we need to increment the root, and get another char for chord type. 
C=INSTR(A$,X$)                                     :REM C encodes for chord type
T=(R+4-C MOD2)MOD12                                :REM even C means major third, odd C means minor third
F=(R+C DIV2)MOD12                                  :REM "Mm" gives C=14,15 meaning C DIV2=7 (perfect fifth.) C=13,16 give diminished and augmented: 6,8.
V=1                                                :REM V is the sound channel number ("voice")                             
PRINT"______"                                      :REM left side of keyboard for cosmetic reasons
FORN=0 TO 11                                       :REM at the start of each iteration initialise C to 1, to point to the 4 spaces/2 underscores in the string below for drawing white notes. 
  C=1-(N=4)*12                                     :REM if the note is E, add 12 so it points to the 6 underscores to draw the line between E and F. 
  B$=MID$(A$,N+1,1)                                :REM load B$ with the name of the current note.
  IF B$="#" C=7: B$=MID$(A$,N,1)+B$                :REM if the character encountered is a sharp, update C to point the characters for drawing a sharp. Find the previous character in A$ and join it to the beginning of B$ to complete the note name.
  PRINT MID$("    __---|________",C,6);            :REM print the key (6 characters.)
  IF(R-N)*(T-N)*(F-N)=0 PRINT B$;:SOUND V,-15,100+N*4,99:V=V+1  :REM if N is equal to R,T or F, print the note name beside the key, play the note and increment the channel number for the next note.  
  PRINT                                            :REM print a carriage return. It may be possible to golf this line out.
NEXT

Comme vous pouvez le constater, je n'ai pas du tout essayé de jouer au golf. Je suis un geek de la musique, et ma bête noire est que les gens écrivent des choses en utilisant de mauvais enharmonics (par exemple, en disant qu'un accord diminué en C est CD # F # au lieu de C Eb Gb), j'ai donc écrit ce programme qui obtient les enharmonies droite. Pour ce faire, chaque note est représentée par le nombre de quintes parfaites supérieures à F.

Pour ce que cela vaut, si vous voulez distinguer les harmoniques, tout intervalle musical peut être bien représenté dans un programme informatique sous la forme d’un nombre de quintes parfait et d’un nombre d’octaves. Une quatrième augmentée, par exemple, correspond à 6 quintes parfaites et à -3 octaves, et une cinquième diminuée correspond à -6 quintes parfaites et 4 octaves.

Haskell, 441 caractères

import Data.List

notes = "FCGDAEB"

fromNum x = [notes !! (mod x 7)] ++ if x < 0 then replicate (-(div x 7)) 'b' else replicate (div x 7) '#'

toNum (x:xs) = y + 7 * if isPrefixOf "b" xs then -length xs else length xs
    where Just y = elemIndex x notes

chord xs = unwords . map (fromNum . \x -> toNum (init xs) + x) $ case last xs of 'A' -> [0,4,8]; 'M' -> [0,4,1]; 'm' -> [0,-3,1]; 'd' -> [0,-3,-6]

main = getLine >>= putStrLn . chord

Quelques exemples d'invocations:

jaspers:junk tswett$ ./chord
AM
A C# E
jaspers:junk tswett$ ./chord
C#m
C# E G#
jaspers:junk tswett$ ./chord
DbA
Db F A
jaspers:junk tswett$ ./chord
Cd
C Eb Gb
jaspers:junk tswett$ ./chord
A#M
A# C## E#
jaspers:junk tswett$ ./chord
Dbm
Db Fb Ab

Arduino

Les entrées / sorties sont envoyées à / reçues de l’Arduino via un port COM. Un utilisateur peut interagir avec cela via un terminal ou le moniteur série de l'IDE Arduino. Comme vous l'avez peut-être deviné grâce à mon choix de plate-forme, j'ai l'intention d'inclure le jeu réel de l'accord (même si je ne l'ai pas encore fait.)

J'ai réussi à m'attaquer au bonus clavier et j'ai essayé de m'attaquer à la guitare, avec un succès limité.

La boîte à accords arrive à 130 octets, ce qui est trop long pour en valoir la peine. J'ai donc essayé d'une autre manière, en imprimant simplement le style de tabulation des numéros de frette. Il s’agit actuellement de 81 octets pour un bonus de 81-100 = -19. Si cette approche est jugée valide, je peux essayer de l’améliorer.

Les accords utilisés sont toutes des formes de type D avec la racine sur la 2ème corde, la cinquième sur la 3ème et la troisième sur les 1ère et 4ème cordes. Les 5ème et 6ème cordes ne sont pas utilisées et je la marque avec un X à droite du cadre des accords (la gauche serait plus habituelle, mais des exemples marqués à droite peuvent être trouvés.)

Parce que le programme considère que F est la note la plus basse (pour la compatibilité avec le clavier tout en évitant les frettes excessivement hautes avec cette forme d'accord), l'accord le plus élevé est un Mi (avec la racine sur la 17ème frette.) Voir l'exemple de sortie.

Le clavier a plus de succès en termes de golf. Il fonctionne à partir de FE plutôt que CB pour les raisons décrites ci-dessus. Vous devez l'afficher en tournant l'écran de 90% dans le sens inverse des aiguilles d'une montre, pour voir clairement les contours des notes noires et la démarcation entre les notes blanches ---. La ligne entre B et C pourrait être étendue de ____quelques octets supplémentaires.

Je vais essayer de jouer les notes ensuite. Ce sera intéressant car, bien que je pense que l’Arduino Uno a 3 timers internes, vous ne pouvez jouer qu’une note à la fois à l’aide de la commande de son intégrée. Il existe une fonction de bibliothèque externe qui utilise tous les minuteries matérielles (ce qui gâchera la série, mais elle ne sera de toute façon pas nécessaire à ce stade.) Sinon, je peux essayer de produire les tonalités en mode softare.

Si je réussis avec cela, je vais jouer au golf, mais je ne pense pas que ce sera le vainqueur final.

Code non-liquéfié

String p="F#G#A#BC#D#E -Mm+",y,d[]=
{"    ","---|"},n="\n";

void setup() {
  Serial.begin(9600);
  Serial.setTimeout(99999);
}

void loop(){
  char x[9]; int r,t,f,i,c=1;
  Serial.readBytesUntil(13,x,9);
  Serial.println(x);  
  r=p.indexOf(x[0]);
  if (x[1]==35|x[1]==98){c=2;r+=x[1]==35?1:-1;}
  f=p.indexOf(x[c])/2;
  t=4-p.indexOf(x[c])%2;

  //chord box
  y=n;for(i=24;i--;)y+=d[1]+(i%4?"":" \n");
  y[89]=y[107]='X'; y[t*4-10]=y[t*4+52]=y[f*4+14]=y[28]='O';
  Serial.print("\t "+String(r+6)+y);

  f+=r;t+=r;

  //tab style
  Serial.println(String(t+1)+n+String(r+6)+n
  +String(f-2)+n+String(t+3)+"\nX\nX\n");

  f%=12;t%=12;

  //piano
  for(i=0;i<12;i++){
    c=0;
    y=String(p[i]);
    if(y=="#") {c=1;y=p[i-1]+y;}      
    Serial.println(d[c]+"__"+((r-i&&t-i&&f-i)?"":y));
  }  
}

Exemple de sortie Plus l'espacement entre les lignes de texte est faible, meilleur sera l'apparence. Par conséquent, ça a l'air génial quand je suis en train de modifier le post, mais horrible dans la case grise après avoir posté. Au lieu de cela, j'ai posté une capture d'écran du moniteur série Arduino qui présente un espacement des lignes intermédiaire (et donc une qualité d'affichage).

Python3 - 315 caractères

Première fois en codegolf! Ne supporte que les accords mineurs, majeurs, diminués et augmentés pour le moment.

z=["C","C#","D","D#","E","F","F#","G","G#","A","A#","B"];y=[1,2,4,5,6]
def q(a):print(z[a%12])
a=input();k=(ord(a[0])+3)%7;j=k;m=4;s=0;f=7;
for i in y:
    if(k>=i):j+=1
if('#'in a):j+=1
if('b'in a):j-=1
if('m'in a or'0'in a):m=3
if('+'in a or"aug"in a):f=8
if('0'in a or"dim"in a):f=6;m=3
if('ma'in a):m=4
q(j);q(j+m);q(j+f);

Python 506 (Unicode en 1 caractère) -150 (son) -150 (clavier) = 206

Pour jouer du son, il utilise pygame.midi. Notez que la pygame.midi.get_default_output_id()méthode ne fonctionne pas très bien. Vous pouvez donc essayer de modifier la ligne o=Output(get_default_output_id())en o=Output(1), o=Output(2)etc. La valeur correcte est généralement comprise entre 0 et 5.

c=input()
s='C D EF G A B'.index(c[0])+{'#':1,'b':-1,'':0}[c[1:-1]]
m='0mM+'.index(c[-1])
t=s+3+m//2
R=[list(x)for x in['┌─'+'─┬─'*13+'─┐']+['│'+'  │'*14]*5+['└─'+'─┴─'*13+'─┘']]
i=3
for d in[3,6,3,3,6]*2:q=slice(i-1,i+2);R[0][q]='┬─┬';R[1][q]=R[2][q]=R[3][q]='│ │';R[4][q]='└┬┘';i+=d
X=[2]+[1,2,1,2,3,1,2,1,2,1,2,3]*2
from pygame.midi import*
init()
o=Output(get_default_output_id())
for s in[s,t,t+3+m%2]:R[[5,3][s%12 in[1,3,6,8,10]]][sum(X[:s+1])]='o';o.note_on(s+60,127,1)
for r in R:print(''.join(r))

Résultats

goooolf> python chords2.py
CM
┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┬─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
│ o│  │ o│  │ o│  │  │  │  │  │  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘
goooolf> python chords2.py
Cm
┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┬─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││o│ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
│ o│  │  │  │ o│  │  │  │  │  │  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘
goooolf> python chords2.py
Dm
┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┬─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
│  │ o│  │ o│  │ o│  │  │  │  │  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘
goooolf> python chords2.py
D+
┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┬─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │o││ ││o│ │ │ ││ │ │ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
│  │ o│  │  │  │  │  │  │  │  │  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘
G+
┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┬─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││o│ │ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
│  │  │  │  │ o│  │ o│  │  │  │  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘
goooolf> python chords2.py
Am
┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┬─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
│  │  │  │  │  │ o│  │ o│  │ o│  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘
goooolf> python chords2.py
C#0
┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┬─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │o││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
│  │  │ o│  │ o│  │  │  │  │  │  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘
goooolf> python chords2.py
EbM
┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┬─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││ │ │ │ ││ ││ │ │ │ ││ │ │ │ ││ ││ │ │
│ │ ││o│ │ │ ││ ││o│ │ │ ││ │ │ │ ││ ││ │ │
│ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
│  │  │  │  │ o│  │  │  │  │  │  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘

J - 82 caractères

Autonome, lit depuis l'entrée de la console. Si vous avez besoin de stdin, changez la finale 1en a 3. Ne réclamant aucun bonus, et ne couvrant que les triades.

+/&(0 3 6++/\_3{.#:'0mM+'i.{:e)&.((,~C`Db`D`Eb`E`F`Gb`G`Ab`A`Bb`B)i.;:)}:e=.1!:1]1

Au lieu d'une note aiguë, C#vous devez par exemple utiliser le nom à plat équivalent Db. (Corriger cela gonflerait le code de plus d'un peu.) Les quatre types d'accords sont 0pour diminuer, mpour mineur, Mpour majeur et +pour augmenté.

La logique est la suivante: nous utilisons le dernier caractère pour ajouter un décalage à la base 0-3-6, qui sélectionne le type de troisième et cinquième. Pendant ce temps, nous utilisons la note pour trouver où dans l’échelle tirer les notes. Les ;:deux rendent la note compatible avec l'indexation dans la gamme au début, puis &.transforment (par ) les notes extraites en une chaîne séparée par des espaces.

Exemple d'utilisation:

   +/&(0 3 6++/\_3{.#:'0mM+'i.{:e)&.((,~C`Db`D`Eb`E`F`Gb`G`Ab`A`Bb`B)i.;:)}:e=.1!:1]1
AM
A Ch E
   +/&(0 3 6++/\_3{.#:'0mM+'i.{:e)&.((,~C`Db`D`Eb`E`F`Gb`G`Ab`A`Bb`B)i.;:)}:e=.1!:1]1
Ab0
Ab B D
   +/&(0 3 6++/\_3{.#:'0mM+'i.{:e)&.((,~C`Db`D`Eb`E`F`Gb`G`Ab`A`Bb`B)i.;:)}:e=.1!:1]1
B+
B Eb G
   +/&(0 3 6++/\_3{.#:'0mM+'i.{:e)&.((,~C`Db`D`Eb`E`F`Gb`G`Ab`A`Bb`B)i.;:)}:e=.1!:1]1
Em
E G B

Javascript, 224 caractères

n=prompt();a="A0A#0B0C0C#0D0D#0E0F0F#0G0G#".split(0);x=1;r=a.indexOf(n[0]);n[1]=="#"&&(r++,x++);n[1]=="b"&&(r--,x++);s=r+4;l=r+7;(n[x]=="m"||n[x]==0)&&s++;s%=12;n[x]=="+"&&l++;n[x]==0&&l--;l%=12;alert(a[r]+" "+a[s]+" "+a[l])

Ceci est mon premier code de golf. Je pense que cela peut être plus court, mais je ne trouve aucun octet à sauvegarder.

Supports principaux, mpour mineur, 0pour une diminution, +pour augmentèrent, ou 37 octets pour plus dim, aug.

Python ( 143 134 caractères)

n,a='A A# B C C# D D# E F F# G G#'.split(),input();m,i=ord(a[-1])-42,n.index(a[:-1])
print(n[i],n[(i+4-m//2)%12],n[(i-4+(-m//2))%12]) 

Mon premier défi de golf :), je ne sais pas si quelques octets supplémentaires peuvent être supprimés.
La notation utilisée ici est * août / + maj /, min / - dim
Je mérite un point bonus pour avoir la constante 42 dans le code: P

Python 3: 257 - 150 = 107

Juste 25 caractères trop long pour battre la solution J! Tant pis. Il y a quelques bonnes idées ici, je pense.

I='AaBCcDdEFfGg'*2
Q='0123456789.,'*2
K="""-1#_2
-,#_0
-9#_.
____8
-6#_7
-4#_5
____3"""
r,*R,q=input()
r=I.find(r)+bool(R)
p=str.replace
for x in[0]+[8,4,7,3,6]['+Mm0'.find(q):][:2]:K=p(K,Q[x+r],I[x+r].upper())
for x in Q:K=p(K,x,' ')
print(p(K,' #','  '))

La saisie ressemble aux exemples, bien que vous deviez utiliser des noms nets au lieu de noms simples. (par exemple, Gb doit être F #)

La sortie est une seule octave de piano, vue d'en haut et à gauche, avec des noms de notes superposés. Devrait être juste un petit effort d'imagination.

$ echo C#m | python3 chords.py
-  _ 
-G#_ 
-  _ 
____ 
-  _E
-C#_ 
____ 

Scala 537 caractères - 50

import java.util.Scanner
object C extends App{
val c=Map("M"->145,"m"->137,"+"->273,"0"->73,"7"->1169,"M7"->2193,"m7"->1161,"Mm7"->2185,"+7"->1297,"+M7"->2321,"07"->585,"7b5"->1097)
val n=List("A","A#","B","C","C#","D","D#","E","F","F#","G","G#")
val o=List("","Bb","Cb","B#","Db","","Eb","Fb","E#","Gb","","Ab")
val s=new Scanner(System.in).nextLine
val v=s indexWhere{c=>c!='#'&&c!='b'&&(c<'A'||c>'G')}
val (u,m)=s splitAt v
val x=n.indexOf(u)max o.indexOf(u)
val k=c(m)
for(i<-0 to 11)if((k&(1<<i))!=0)print(n((i+x)%12)+" ")
println}

Haskell, 273 caractères

n(s,a)="CCDDEFFGGAABB"!!(s+1-a):["b#"!!a|" b b  b b b "!!s/=' ']
t p=[(s,a)|s<-[11,10..0],a<-[0,1],n(s,a)==p]!!0
m(s,d)=n(mod s 12,d-3)
c q=[n(a,x),m(a+d,d),m(a+d+e,e)]where
 (a,x)=t$init q;f=lookup(last q).zip"0mM+";Just d=f[3,3,4,4];Just e=f[3,4,3,4]
main=print.c=<<getLine

Résultats

C0 ->["C","Eb","Gb"]   Cm ->["C","Eb","G"]    CM ->["C","E","G"]     C+ ->["C","E","G#"]    
C#0->["C#","F","G"]    C#m->["C#","F","G#"]   C#M->["C#","F","Ab"]   C#+->["C#","F","A"]    
D0 ->["D","F","Ab"]    Dm ->["D","F","A"]     DM ->["D","F#","A"]    D+ ->["D","F#","A#"]   
D#0->["D#","Gb","A"]   D#m->["D#","Gb","A#"]  D#M->["D#","G","Bb"]   D#+->["D#","G","B"]    
E0 ->["E","G","Bb"]    Em ->["E","G","B"]     EM ->["E","G#","B"]    E+ ->["E","G#","C"]    
F0 ->["F","Ab","B"]    Fm ->["F","Ab","C"]    FM ->["F","A","C"]     F+ ->["F","A","C#"]    
F#0->["F#","A","C"]    F#m->["F#","A","C#"]   F#M->["F#","A#","Db"]  F#+->["F#","A#","D"]   
G0 ->["G","Bb","Db"]   Gm ->["G","Bb","D"]    GM ->["G","B","D"]     G+ ->["G","B","D#"]    
G#0->["G#","B","D"]    G#m->["G#","B","D#"]   G#M->["G#","C","Eb"]   G#+->["G#","C","E"]    
A0 ->["A","C","Eb"]    Am ->["A","C","E"]     AM ->["A","C#","F"]    A+ ->["A","C#","F"]    
A#0->["A#","Db","F"]   A#m->["A#","Db","F"]   A#M->["A#","D","F"]    A#+->["A#","D","F#"]   
B0 ->["B","D","F"]     Bm ->["B","D","F#"]    BM ->["B","D#","Gb"]   B+ ->["B","D#","G"]