1class Tone:
  2    tones = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
  3
  4    def __init__(self, name):
  5        self.name = name
  6
  7    def __str__(self):
  8        return self.name
  9
 10    def __add__(self, other):
 11        if isinstance(other, Tone):
 12            return Chord(self, other)
 13        elif isinstance(other, Interval):
 14            curr_index = (Tone.tones.index(self.name) + other.semitones) % 12
 15            return Tone(Tone.tones[curr_index])
 16        
 17    def __sub__(self, other):
 18        if isinstance(other, Tone):
 19            distance = (Tone.tones.index(self.name) - Tone.tones.index(other.name)) % 12
 20            return Interval(distance)
 21        
 22        elif isinstance(other, Interval):
 23            curr_index = (Tone.tones.index(self.name) - other.semitones) % 12
 24            return Tone(Tone.tones[curr_index])
 25
 26
 27class Interval:
 28    INTERVAL_NAMES = {
 29        0: "unison", 1: "minor 2nd", 2: "major 2nd", 3: "minor 3rd",
 30        4: "major 3rd", 5: "perfect 4th", 6: "diminished 5th",
 31        7: "perfect 5th", 8: "minor 6th", 9: "major 6th",
 32        10: "minor 7th", 11: "major 7th"
 33    }
 34
 35    def __init__(self, semitones):
 36        self.semitones = semitones % 12
 37
 38    def __str__(self):
 39        return self.INTERVAL_NAMES[self.semitones]
 40
 41    def __add__(self, other):
 42        if isinstance(other, Interval):
 43            new_semitones = (self.semitones + other.semitones) % 12
 44            return Interval(new_semitones)
 45        else:
 46            raise TypeError("Invalid operation")
 47
 48
 49class Chord:
 50    def __init__(self, root_tone, *tones):
 51        unique_tones = {root_tone, *tones}
 52
 53        if len(unique_tones) < 2:
 54            raise TypeError("Cannot have a chord made of only 1 unique tone")
 55        
 56        self.root_tone = root_tone
 57        self.tones = unique_tones
 58
 59        start_index = Tone.tones.index(root_tone.name)
 60        sorted_tones = sorted(unique_tones, key=lambda t: (Tone.tones * 2).index(t.name, start_index))
 61        
 62        self.tones = [Tone(t.name) for t in sorted_tones]
 63
 64    def __str__(self):
 65        return "-".join(str(tone) for tone in self.tones)
 66    
 67    #Find distance between two tones
 68    def semitone_distance(self, tone1, tone2):
 69        return (Tone.tones.index(tone2.name) - Tone.tones.index(tone1.name)) % 12
 70    
 71    def is_minor(self):
 72        for tone in self.tones:
 73            if tone != self.root_tone:
 74                distance = self.semitone_distance(self.root_tone, tone)
 75                if Interval (distance).__str__() == "minor 3rd":
 76                    return True
 77        return False
 78    
 79    def is_major(self):
 80        for tone in self.tones:
 81            if tone != self.root_tone:
 82                distance = self.semitone_distance(self.root_tone, tone)
 83                if Interval(distance).__str__() == "major 3rd":
 84                    return True
 85        return False
 86    
 87    def is_power_chord(self):
 88        if not self.is_major and not self.is_minor:
 89            return True
 90        return False 
 91
 92    def __sub__(self, other):
 93        if isinstance(other, Tone):
 94            if other.name not in [tone.name for tone in self.tones]:
 95                raise TypeError(f"Cannot remove tone {other} from chord {self}")
 96            
 97        new_tones = [tone for tone in self.tones if tone.name != other.name]
 98
 99        if len(new_tones) == 1:
100            raise TypeError("Cannot have a chord made of only 1 unique tone")
101        
102        new_root_tone = new_tones[0]
103
104        return Chord(new_root_tone, *new_tones)
105    
106    def __add__(self, other):
107        if isinstance(other, Chord):
108            combined_tones = list(self.tones)  
109            for tone in other.tones:
110                if tone not in combined_tones:
111                    combined_tones.append(tone)  
112            new_root_tone = combined_tones[0]
113            unique_tones = []
114            for tone in combined_tones:
115                if tone not in unique_tones:
116                    unique_tones.append(tone)
117            return Chord(new_root_tone, *unique_tones)
118        elif isinstance(other, Tone):
119            combined_tones = list(self.tones)
120            if other not in combined_tones:
121                combined_tones.append(other)
122            new_root_tone = combined_tones[0]
123            return Chord(new_root_tone, *combined_tones)
124    
125    def transposed(self, interval):
126        if not isinstance(interval, Interval):
127            raise TypeError("Interval is expected")
128
129        transposed_tones = [
130            Tone(Tone.tones[(Tone.tones.index(tone.name) + interval.semitones) % 12])
131            for tone in self.tones
132        ]
133        return Chord(transposed_tones[0], *transposed_tones[1:])