Musique: qu'y a-t-il dans cet accord?


38

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.

Constellation de pas

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

Constellations de hauteur: trios

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:

Constallations de hauteur: septième accord

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


1
Il pourrait être intéressant d’ajouter une explication incluant les formules des accords en notation entière pour les non musiciens. La notation entière renvoie à tout en demi-tons. Accord majeur (exemple AM): 0,4,7. Accord mineur (exemple C # m): 0,3,7. C diminué (Exemple Co, ou comme vous l'appelez C0) 0,3,6 (notez que la représentation correcte est C Eb Gb, mais pour ce défi, je suppose que nous pouvons supposer que ceci et le CD # F # sont acceptables.) La formule pour un accord augmenté (exemple Db +) vaut 0,4,8 et votre exemple est faux car il ne contient même pas de Db. Comme écrit, il s’agit d’un B + qui équivaut à un D # + ou un G +
Level River St

3
De plus, le code le plus court résultera de l'utilisation de la même forme d'accord pour tous les accords de guitare du même type, interdits. Donc, Ab sera un A barré à la 11ème case. Est-ce correct de mettre un nombre ou devons-nous tirer 11 frettes? Au total, il faut penser à beaucoup de choses. Vous voudrez peut-être simplifier les bonus.
Level River St

1
Hmm .. votre accord augmenté est toujours faux. C # est enharmonique à Db, mais Db+est Db F Ail n'y a pas D ou G # là - dedans. C'est peut-être un peu plus de théorie que nécessaire, les formules étaient la partie importante. Si vous voulez vraiment inclure les huit des sept accords listés dans wikipedia, vous devez spécifier l'entrée. Je suppose que la production artistique de piano et de guitare est flexible.
Level River St

3
Je sens que j'ai appris plus sur la théorie musicale ici que j'en ai appris par les leçons.
Kevin Evans

4
Le problème le plus cool sur ce site!
Ray

Réponses:


5

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

entrez la description de l'image ici

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.

entrez la description de l'image ici

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

Comment le programme est-il censé être utilisé en ligne de commande? (J'ai installé BBC BASIC sur ma machine Ubuntu)
Mathieu Rodic

Wow, je ne savais pas qu'il y avait une version de base de la BBC pour Ubuntu. Je n'arrive pas à en trouver un sur le site d'où provient mon émulateur, et je n'utilise pas Ubuntu. Original BBC Basic n'avait qu'un programme en mémoire à la fois, vous avez donc tapé RUN. Avec l’émulateur que j’utilise, vous devez démarrer l’environnement de l’émulateur pour qu’il s’exécute. Il comporte un éditeur de texte, puis vous cliquez pour l'exécuter, puis lorsque le programme se termine, vous pouvez taper RUN pour l'exécuter à nouveau ou taper des commandes de base individuelles dans l'environnement. Vous pouvez créer un exécutable en ligne de commande avec mon émulateur, mais uniquement si vous achetez la version complète.
Level River St

Si vous souhaitez tester le programme, la meilleure façon de vous aider est de trouver une machine Windows et de télécharger la version exacte que j'utilise. Alternativement, si vous pouviez me dire où vous avez obtenu votre version d'Ubuntu, je pourrais en avoir un peu lu.
Level River St

BBC Basic fonctionne également sous Linux, ils fournissent de nombreuses distributions sur leur page d'accueil en fonction du système d'exploitation hôte. Je n'ai tout simplement pas réussi à faire fonctionner le programme, que ce soit en passant le code ou en le collant dans l'invite ...
Mathieu Rodic

Je viens de télécharger Napoleon Brandy Basic, et il est en effet difficile de commencer! Vous devez enregistrer le code sous forme de fichier texte appelé chords.nap, puis tapez LOAD "chords.nap" à l'invite de commande. Il ajoute des numéros de ligne au code (plus authentique que le BBC Basic d'origine, ajouterait quelques caractères supplémentaires). Ensuite, vous tapez RUN et le programme se bloque sur la ligne contenant l'instruction SOUND, avec le message d'erreur "Fonctionnalité Basic V non prise en charge". a trouvé." Vous pourriez en fait écrire un programme sérieux avec la mise en œuvre de RT Russell si vous le vouliez vraiment. Mais avec Brandy basic, je n'y pensais même pas.
Level River St

8

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

5

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

entrez la description de l'image ici


Je ne peux pas attendre pour le son actuel!
Mathieu Rodic

Les notes pour EM sont correctes (EG # B), mais elles ne sont pas alignées correctement sur votre clavier. Il semblerait que vous soyez sur la bonne voie!
Cameron Tinker

@ CameronTinker Veuillez incliner votre écran de 90 degrés dans le sens inverse des aiguilles d'une montre et regarder à nouveau. Notez que le clavier va de F à E, pas de C à B pour les raisons décrites dans mon post. Choisir F comme "note zéro" interne était un compromis pour les sorties guitare et clavier. Il y a 3 notes noires à gauche, 2 à droite et les notes de sortie sont correctement alignées. L'extension de la division entre B et C clarifierait les choses, mais coûterait environ 20 octets supplémentaires. C'est brutal, mais je pense toujours que mon clavier est plus lisible que celui de Pandubear.
Level River St

Je ne sais pas comment j'ai raté ça! Désolé pour ça. Je suis pianiste et ma première inclination quand j'ai vu que c'était que le clavier n'avait pas l'air correct;).
Cameron Tinker

@MathieuRodic J'ai des sons de l'Arduino maintenant, mais ils sont si pauvres que je ne suis pas sûr de les appeler un accord reconnaissable. Je vais essayer encore une fois, mais je ne comprends pas certaines choses qui se passent avec l’Arduino. Quoi qu'il en soit, je viens de poster une réponse dans BBC Basic avec un clavier et un son qui semble beaucoup mieux. Donc, je mettrai à jour ce post plus tard
Level River St

4

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

2
Utilisez 'C C# D D# E F F# G G# A A# B'.split(' ')au lieu de votre tableau littéral pour enregistrer des octets.
wchargin

2
if('#'in a):j+=1-> if'#'in a:j+=1= 2 caractères en moins pour chaque énoncé. Le passage yà une range()expression enregistre également quelque chose. Bienvenue! (et rappelez-vous que les nouvelles lignes comptent aussi;))
gcq

2
@wch Plus d'octets peuvent être sauvegardés avec 'C C# D D# E F F# G G# A A# B'.split();)
undergroundmonorail

1
Comment as-tu compté ton score? Je pense que vous devez également compter les nouvelles lignes comme un caractère. À propos, comme cette réponse ne fonctionne que dans Python3, je vais modifier votre réponse pour l'indiquer explicitement. En outre, au lieu d’utiliser yle stockage [1,2,4,5,6], pourquoi ne pas simplement sauter la yligne 4 et la remplacer par for i in[1,2,4,5,6]:? Quoi qu'il en soit, bienvenue à codegolf et j'espère que vous vous amuserez ici.
pastebin.com slash 0mr8spkT

1
Vous pouvez également enregistrer 3 caractères supplémentaires en indentant avec un seul espace au lieu de quatre dans la ligne 5.
pastebin.com slash 0mr8spkT

4

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│  │  │  │  │  │  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘

3

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

Le suffixe "h" suit-il l’un des "standards de notation musicale"?
Mathieu Rodic

@MathieuRodic Je suppose que c'est une zone grise, alors je les ai tous frappés à plat. Pas de changement de fonctionnalité. Je ne sais pas pourquoi je ne l'ai pas fait plus tôt.
algorithmshark

2

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.


n[m]==0peut être simplement !n[m]. La même chose s'applique à un autre endroit. Total, vous pouvez facilement couper 6 caractères .
Gaurang Tandon

@GaurangTandon Étant donné que nstring est une chaîne, n[m]==0sera converti 0en "0", il est donc égal à n[m]=="0". "0" == 0est vrai, mais !"0"est faux.
Snack

Je soulignais juste parce que j'ai eu la même sortie quand j'ai entré AM. Je peux me tromper aussi.
Gaurang Tandon

2

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


Vous pouvez gagner quelques octets comme ceci:n,q,a='A A# B C C# D D# E F F# G G#'.split(),[4,4,3,3],input();m,i=ord(a[-1])-42,n.index(a[:-1])
Mathieu Rodic

1

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#_ 
____ 

Bon travail! Bien que je ne vois pas les notes à jouer dans la sortie? Pour CM, on devrait pouvoir lire C E G...
Mathieu Rodic

Oh, j'ai mal interprété la question, je suppose. Voyons si je peux travailler dans ...
pandubear

Fixé! Trop long ...):
pandubear

Vous ne pouvez pas remplacer bool(R)par R|0?
Mathieu Rodic

Non, le fait est que R est une liste et bool(R)vaut 1 (vrai) si non vide, et 0 (faux) si vide. L' |opérateur ne fonctionne pas avec les listes ...
pandubear

1

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}

0

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"]    
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.