Perl 6, 76 65 63 59 bytes

-4 bytes thanks to Phil H

{221222==[~] (.skip Z-$_)X%12}o*>>.&{13*.ord+>3+?/#/-?/b/}

Try it online!

Explanation

*>>.&{ ... }  # Map notes to integers

  13*.ord     # 13 * ASCII code:  A=845 B=858 C=871 D=884 E=897 F=910 G=923

  +>3         # Right shift by 3: A=105 B=107 C=108 D=110 E=112 F=113 G=115

              # Subtracting 105 would yield A=0 B=2 C=3 D=5 E=7 F=8 G=10

              # but isn't necessary because we only need differences

  +?/#/      # Add 1 for '#'

  -?/b/       # Subtract 1 for 'b'



{                           }o  # Compose with block

            (.skip Z-$_)        # Pairwise difference

                        X%12    # modulo 12

         [~]  # Join

 221222==     # Equals 221222

Node.js v10.9.0, 78 76 71 69 bytes

a=>!a.some(n=>(a-(a=~([x,y]=Buffer(n),x/.6)-~y%61)+48)%12-2+!i--,i=3)

Try it online!

How?

Each note $n$ is converted to a negative number in $[-118,-71]$ with:

[x, y] = Buffer(n) // split n into two ASCII codes x and y

~(x / .6)          // base value, using the ASCII code of the 1st character

- ~y % 61          // +36 if the 2nd character is a '#' (ASCII code 35)

                   // +38 if the 2nd character is a 'b' (ASCII code 98)

                   // +1  if the 2nd character is undefined

Which gives:

  n   | x  | x / 0.6 | ~(x / 0.6) | -~y % 61 | sum

------+----+---------+------------+----------+------

 "Ab" | 65 | 108.333 |    -109    |    38    |  -71

 "A"  | 65 | 108.333 |    -109    |     1    | -108

 "A#" | 65 | 108.333 |    -109    |    36    |  -73

 "Bb" | 66 | 110.000 |    -111    |    38    |  -73

 "B"  | 66 | 110.000 |    -111    |     1    | -110

 "B#" | 66 | 110.000 |    -111    |    36    |  -75

 "Cb" | 67 | 111.667 |    -112    |    38    |  -74

 "C"  | 67 | 111.667 |    -112    |     1    | -111

 "C#" | 67 | 111.667 |    -112    |    36    |  -76

 "Db" | 68 | 113.333 |    -114    |    38    |  -76

 "D"  | 68 | 113.333 |    -114    |     1    | -113

 "D#" | 68 | 113.333 |    -114    |    36    |  -78

 "Eb" | 69 | 115.000 |    -116    |    38    |  -78

 "E"  | 69 | 115.000 |    -116    |     1    | -115

 "E#" | 69 | 115.000 |    -116    |    36    |  -80

 "Fb" | 70 | 116.667 |    -117    |    38    |  -79

 "F"  | 70 | 116.667 |    -117    |     1    | -116

 "F#" | 70 | 116.667 |    -117    |    36    |  -81

 "Gb" | 71 | 118.333 |    -119    |    38    |  -81

 "G"  | 71 | 118.333 |    -119    |     1    | -118

 "G#" | 71 | 118.333 |    -119    |    36    |  -83

We compute the pairwise differences modulo $12$ between these values.

The lowest possible difference between 2 notes is $-47$, so it's enough to add $4times12=48$ before applying the modulo to make sure that we get a positive result.

Because we apply a modulo $12$, the offset produced by a '#' is actually $36 bmod 12 = 0$ semitone, while the offset produced by a 'b' is $38 bmod 12 = 2$ semitones.

We are reusing the input variable $a$ to store the previous value, so the first iteration just generates $text{NaN}$.

For a major scale, we should get $[ text{NaN}, 2, 2, 1, 2, 2, 2 ]$.

We use the counter $i$ to compare the 4th value with $1$ rather than $2$.

JavaScript (Node.js), 150 131 125 bytes

l=>(l=l.map(x=>'C0D0EF0G0A0B'.search(x[0])+(x[1]=='#'|-(x[1]=='b')))).slice(1).map((n,i)=>(b=n-l[i])<0?2:b)+""=='2,2,1,2,2,2'

Try it online!

-19 bytes thanks to Luis felipe
-6 bytes thanks to Shaggy

Ungolfed:

function isMajor(l) {

    // Get tone index of each entry

    let array = l.map(function (x) {

        // Use this to get indices of each note, using 0s as spacers for sharp keys

        let tones = 'C0D0EF0G0A0B';

        // Get the index of the letter component. EG D = 2, F = 5

        let tone = tones.search(x[0]);

        // Add 1 semitone if note is sharp

        // Use bool to number coercion to make this shorter

        tone += x[1] == '#' | -(x[1]=='b');

    });

    // Calculate deltas

    let deltas = array.slice(1).map(function (n,i) {

        // If delta is negative, replace it with 2

        // This accounts for octaves

        if (n - array[i] < 0) return 2;

        // Otherwise return the delta

        return n - array[i];

    });

    // Pseudo array-comparison

    return deltas+"" == '2,2,1,2,2,2';

}

Dart, 198 197 196 189 bytes

f(l){var i=0,j='',k,n=l.map((m){k=m.runes.first*2-130;k-=k>3?k>9?2:1:0;return m.length<2?k:m[1]=='#'?k+1:m[1]=='b'?k-1:k;}).toList();for(;++i<7;j+='${(n[i]-n[i-1])%12}');return'221222'==j;}

Try it online!

Loose port of the old Perl 6 answer https://codegolf.stackexchange.com/a/175522/64722

f(l){

  var i=0,j='',k,

  n=l.map((m){

    k=m.runes.first*2-130;

    k-=k>3?k>9?2:1:0;

    return m.length<2?k:m[1]=='#'?k+1:m[1]=='b'?k-1:k;

  }).toList();

  for(;++i<7;j+='${(n[i]-n[i-1])%12}');

  return'221222'==j;

}

• -1 byte by using ternary operators for #/b


• -1 byte by using ifs instead of ternaries for the scale shifts


• -7 bytes thanks to @Kevin Cruijssen

Old version :

Dart, 210 bytes

f(l){var i=0,k=0,n={'C':0,'D':2,'E':4,'F':5,'G':7,'A':9,'B':11,'b':-1,'#':1},j='',y=[0,0];for(;++i<7;j+='${(y[0]-y[1])%12}')for(k=0;k<2;k++)y[k]=n[l[i-k][0]]+(l[i-k].length>1?n[l[i-k][1]]:0);return'221222'==j;}

Try it online!

Ungolfed:

f(l){

  var i=0,k=0,n={'C':0,'D':2,'E':4,'F':5,'G':7,'A':9,'B':11,'b':-1,'#':1},j='',y=[0,0];

  for(;++i<7;j+='${(y[0]-y[1])%12}')

    for(k=0;k<2;k++)

      y[k]=n[l[i-k][0]]+(l[i-k].length>1?n[l[i-k][1]]:0);



  return'221222'==j;

}

A whole step is 2, a quarter is 1. Mod 12 in case you jump to a higher octave.
Iterates through all notes and computes the difference between the ith note and the i-1th note.
Concatenates the result and should expect 221222 (2 whole, 1 half, 3 wholes).

• -2 bytes by not assigning 0 to k


• -4 bytes by using j as a String and not a List


• -6 bytes thanks to @Kevin Cruijssen by removing unnecessary clutter in loops

C (gcc), -DA=a[i] + 183 = 191 bytes

f(int*a){char s[9],b[9],h=0,i=0,j=0,d;for(;A;A==35?b[i-h++-1]++:A^98?(b[i-h]=A*13>>3):b[i-h++-1]--,i++);for(;j<7;d=(b[j]-b[j-1])%12,d=d<0?d+12:d,s[j++-1]=d+48);a=!strcmp(s,"221222");}

Try it online!

Based on the Perl answer.

Takes input as a wide string.

Ungolfed:

int f(int *a){

	char s[9], b[9];

	int h, i, j;

	h = 0;

        for(i = 0; a[i] != NULL; i++){

		if(a[i] == '#'){

			b[i-h-1] += 1;

			h++;

		}

		else if(a[i] == 'b'){

			b[i-1-h] -= 1;

			h++;

		}

		else{

			b[i-h] = (a[i] * 13) >> 3;

		}

	}

	for(j = 1; j < 7; j++){

		int d = (b[j] - b[j-1]) % 12;

		d = d < 0? d + 12: d;

		s[j-1] = d + '0';

	}

	return strcmp(s, "221222") == 0;

}

Python 3, 175 136 134 114 112 bytes

def f(t):r=[ord(x[0])//.6+ord(x[1:]or'"')%13-8for x in t];return[(y-x)%12for x,y in zip(r,r[1:])]==[2,2,1,2,2,2]

Try it online!

An one-liner Python 3 implementation.

Thanks to @Arnauld for idea of calculate tones using division and modulo.

Thanks to @Jo King for -39 bytes.

[Python] 269 202 bytes

Improvements from Jo King:

p=lambda z:"A BC D EF G".index(z[0])+"b #".index(z[1:]or' ')-1

def d(i,j):f=abs(p(i)-p(j));return min(f,12-f)

q=input().replace(' ','').split(',')

print([d(q[i],q[i+1])for i in range(6)]==[2,2,1,2,2,2])

Try it!

Ungolfed, with test driver:

tone = "A BC D EF G"   # tones in "piano" layout

adj = "b #"            # accidentals



def note_pos(note):

    if len(note) == 1:

        note += ' '

    n,a = note

    return tone.index(n) + adj[a]



def note_diff(i, j):

    x, y = note_pos(i), note_pos(j)

    diff = abs(x-y)

    return min(diff, 12-diff)



def is_scale(str):

    seq = str.replace(' ','').split(',')

    div = [note_diff(seq[i], seq[i+1]) for i in (0,1,2,3,4,5)]

    return div == [2,2,1,2,2,2]



case = [

("C, D, E, F, G, A, B", True),

("C#, D#, E#, F#, G#, A#, B#", True),

("Db, Eb, F, Gb, Ab, Bb, C", True),

("D, E, Gb, G, A, Cb, C#", True),

("Eb, E#, G, G#, Bb, B#, D", True),



("C, D#, E, F, G, A, B", False),

("Db, Eb, F, Gb, Ab, B, C", False),

("G#, E, F, A, B, D#, C", False),

("C#, C#, E#, F#, G#, A#, B#", False),

("Eb, E#, Gb, G#, Bb, B#, D", False),

]



for test, result in case:

    print(test + ' '*(30-len(test)), result, 't',

          "valid" if is_scale(test) == result else "ERROR")

Ruby, 109 bytes

->s{(0..11).any?{|t|s.map{|n|(w="Cef;DXg<E=Fhi>G j8A d9B:")[(w.index(""<<n.sum%107)/2-t)%12]}*''=='CfDX<=h'}}

Try it online!

[Wolfram Language (Mathematica) + Music` package], 114 bytes

I love music and found this interesting, but I was out playing real golf when this code golf opportunity came down the pike so my submission is a little tardy.

I figured I'd try this a totally different way, utilizing some actual music knowledge. It turns out the music package of Mathematica knows the fundamental frequency of the named notes. First I convert the input string into sequence of named notes. Next, I take the ratios of each successive note and double any that are less than 2 (to account for octave shift). Then I compare these ratios to the ratios of the Ionian scale which has roughly a 6% frequency difference between half notes and 12% between full notes.

More than half of the bytes spent here are to convert the input into named symbols.

.06{2,2,1,2,2,2}+1==Round[Ratios[Symbol[#~~"0"]&/@StringReplace[# ,{"b"->"flat","#"->"sharp"}]]/.x_/;x<1->2x,.01]&

Try it online!