Jelly, 23 bytes

9“¡ȷṡẓh)ėḂYF@’ḃ_4ị@OS0<

Try it online!

C (gcc), 84 82 81 79 75 bytes

Assumes all caps.

r;f(char*s){for(r=0;*s;r+="+-+,,-*/--*-)+(+),.*,-*+)+"[*s++%65]-43);s=r>0;}

Try it online!

Java (JDK), 131 124 110 84 bytes

Interestingly, "dot" is dash-heavy and "dash" is dot-heavy.

Assumes all caps. Thanks to Expired Data for golfing 20 bytes and to Neil for golfing another 26 bytes!

c->{int s=0;for(int a:c)s+="35344527512513031462452313".charAt(a-65)-51;return s>0;}

Try it online!

Ungolfed:

c -> { // lambda taking an array of char as input and returning a boolean

  int s = 0; // keep track of the net total of dots

  for(int a : c) // look at each character's ASCII value

    s += "35344527512513031462452313".charAt(a - 65) - 51; // add the net dot impact of each letter to the total; 65 is ASCII code for 'A'; 48 is ASCII code for '0'; to save bytes, there are no negative values in the list - subtracting 3 rectifies that => -48 - 3 = -51

  return s > 0; // if the total is positive, the string is dot-heavy

}

Retina 0.8.2, 51 bytes

T`L`35344527412513031462452313

.

$*<>>>

+`<>|><



^<

Try it online! Link includes test cases. Only accepts upper case (+6 bytes for mixed case). Shamelessly stealing @Arnauld's string but I was going to use the same algorithm anyway. Explanation:

T`L`35344527412513031462452313

.

Change each letter into the difference in numbers of dots and dashes, plus three, so O=0 and H=7.

$*<>>>

Represent the difference as that number of <s and three >s. (Sadly I can't use dots because they're special in regex.)

+`<>|><

Remove matched pairs of <s and >s.

^<

Check whether there are still any dots left.

Bash+coreutils,  64 60 bytes

tr a-z 35344526512513031462452313|sed s/./&z-+/g|dc -eIK?^p

Try it online!

Takes a string in lowercase, outputs zero for falsy, nonzero for truthy

Explanation

Uses tr and sed to create a dc program that looks like (for the example input 'hello'):

IK6z-+4z-+5z-+5z-+0z-+^p



IK     Push 10, then 0 to the stack

6z-+  Push 6 (three more than the dots minus dashes in 'h'), subtract 3, and accumulate

...    Do the same for all other letters, so the stack now has the total dots minus dashes

^      Raise 10 to this power - precision is zero so this turns negative/positive to falsy/truthy

p      Print result

APL (Dyalog Extended), 24 bytes^SBCS

Anonymous tacit prefix function taking uppercase as argument.

⎕CY'dfns'

>/'.-'⍧∊∘morse

Try it online!

⎕CY'dfns' copy in the dfns library

morse convert to list of Morse strings
∘ then
∊ ϵnlist (flatten)
'.-'⍧ count the number of dots and dashes in that
>/ more dots than dashes? (lit. greater-than reduction)

05AB1E, 22 bytes

εA•U(Õþć6Δ

»›I•‡3-}O.±

Try it online!

Explanation

•U(Õþć6Δ

»›I•

is 35344527512513031462452313 compressed to base 255.

ε         }     # apply to each char in input

       ‡        # transliterate

 A              # the lowercase alphabet

  •...•         # with the digits from the compressed string

        3-      # subtract 3 from each              

           O    # then sum the result

            .±  # and take the sign

Jelly, 21 bytes

Oị“ÆġwıMƥ)ɠịṙ{’D¤Æm>4

Try it online!

How?

Oị“ÆġwıMƥ)ɠịṙ{’D¤Æm>4 - Link: list of characters ([A-Z]), S

                ¤     - nilad followed by link(s) as a nilad:

  “ÆġwıMƥ)ɠịṙ{’       -   base 250 integer = 14257356342446455638623624

               D      -   to decimal digits

                      -   -- that is the number of dots less the number of dashes plus 4

                      -      ... for each of OPQRSTUVWXYZABCDEFGHIJKLMN

O                     - ordinals of S   e.g. "ATHROUGHZ" -> [65,84,72,82,79,85,71,72,90]

 ị                    - index into (1-indexed & modular, so O gets the 79%26 = 1st item

                      -                                  or A gets the 65%26 = 13th item

                 Æm   - arithmetic mean

                   >4 - greater than 4?

IBM PC DOS, 8088 assembly, 54 35 bytes

-19 bytes using the difference method

ac2c 41d0 d8d7 7206 51b1 04d2 e859 240f 2c03 02e0 e2ea 3534 4527 4125 1303 1462 4523 13

Unassembled:

; compare dashes and dots in a morse code string

; input:

;   I: pointer to input string (default SI)

;   IL: length of input string (default CX)

;   TBL: pointer to data table (default BX)

; output:

;   Sign/OF flags: Dot-heavy: SF == OF (JGE), Dash-heavy: SF != OF (JL)

MORSE_DD    MACRO   I, IL, TBL

            LOCAL   LOOP_LETTER, ODD

        IFDIFI <I>,<SI>     ; skip if S is already SI

    MOV  SI, I              ; load string into SI 

        ENDIF

        IFDIFI <IL>,<CX>    ; skip if IL is already CX

    MOV  CX, IL             ; set up loop counter

        ENDIF

        IFDIFI <TBL>,<BX>   ; skip if TBL is already BX

    MOV  BX, OFFSET TBL     ; load letter table into BX

        ENDIF

LOOP_LETTER:

    LODSB                   ; load next char from DS:SI into AL, advance SI

    ;AND  AL, 0DFH           ; uppercase the input letter (+2 bytes)

    SUB  AL, 'A'            ; convert letter to zero-based index

    RCR  AL, 1              ; divide index by 2, set CF if odd index

    XLAT                    ; lookup letter in table

    JC   ODD                ; if odd index use low nibble; if even use high nibble

    PUSH CX                 ; save loop counter (since SHR can only take CL on 8088)

    MOV  CL, 4              ; set up right shift for 4 bits

    SHR  AL, CL             ; shift right

    POP  CX                 ; restore loop counter

ODD:

    AND  AL, 0FH            ; mask low nibble

    SUB  AL, 3              ; unbias dash/dot difference +3 positive

    ADD  AH, AL             ; add letter difference to sum (set result flags)

    LOOP LOOP_LETTER

        ENDM



TBL DB 035H, 034H, 045H, 027H, 041H, 025H, 013H, 003H, 014H, 062H, 045H, 023H, 013H

Explanation

Implemented in Intel/MASM syntax as a MACRO (basically a function), using only 8088 compatible instructions. Input as uppercase string (or +2 bytes to allow mixed-case), output Truthy/Falsy result is SF == OF (use JG or JL to test).

The letter difference table values are stored as binary nibbles, so only takes 13 bytes in total.

Original (54 bytes):

; compare dashes and dots in a Morse code string

; input:

;   I: pointer to input string (default SI)

;   IL: length of input string (default CX)

;   TBL: pointer to data table

; output:

;   Carry Flag: CF=1 (CY) if dot-heavy, CF=0 (NC) if dash-heavy

MORSE_DD    MACRO   I, IL, TBL

            LOCAL   LOOP_LETTER

        IFDIFI <I>,<SI>     ; skip if S is already SI

    MOV  SI, I              ; load string into SI 

        ENDIF

        IFDIFI <IL>,<CX>    ; skip if IL is already CX

    MOV  CX, IL             ; set up loop counter

        ENDIF

    MOV  BX, OFFSET TBL     ; load score table into BX

    XOR  DX, DX             ; clear DX to hold total score

LOOP_LETTER:

    LODSB                   ; load next char from DS:SI into AL, advance SI

    ;AND  AL, 0DFH           ; uppercase the input letter (+2 bytes)

    SUB  AL, 'A'            ; convert letter to zero-based index

    XLAT                    ; lookup letter in table

    MOV  AH, AL             ; examine dot nibble

    AND  AH, 0FH            ; mask off dash nibble

    ADD  DH, AH             ; add letter dot count to total

    PUSH CX                 ; save loop counter (since SHR can only take CL)

    MOV  CL, 4              ; set up right shift for 4 bits

    SHR  AL, CL             ; shift right

    POP  CX                 ; restore loop counter

    ADD  DL, AL             ; add letter dash count to total

    LOOP LOOP_LETTER

    CMP  DL, DH             ; if dot-heavy CF=1, if dash-heavy CF=0

        ENDM



; data table A-Z: MSN = count of dash, LSN = count of dot

TBL DB 011H, 013H, 022H, 012H, 001H, 013H, 021H, 004H, 002H 

    DB 031H, 021H, 013H, 020H, 011H, 030H, 022H, 031H, 012H

    DB 003H, 010H, 012H, 013H, 021H, 022H, 031H, 022H

Explanation

Implemented in Intel/MASM syntax as a MACRO (basically a function), using only 8088 compatible instructions. Input as string, output Truthy/Falsy result in Carry Flag. Score table contains the number of dashes and dots per letter.

Input is upper case. Add 2 bytes to take lower or mixed case.

Example Test Program (as IBM PC DOS standalone COM executable)

    SHR  SI, 1              ; point SI to DOS PSP

    LODSW                   ; load arg length into AL, advance SI to 82H

    MOV  CL, AL             ; set up loop counter in CH

    DEC  CX                 ; remove leading space from letter count



    MORSE_DD SI, CX, TBL    ; execute above function, result is in CF



    MOV  DX, OFFSET F       ; default output to "Falsy" string

    JA   DISP_OUT           ; if CF=0, result is falsy, skip to output

    MOV  DX, OFFSET T       ; otherwise CF=1, set output to "Truthy" string

DISP_OUT:

    MOV  AH, 09H            ; DOS API display string function

    INT  21H

    RET



T   DB "Truthy$"

F   DB "Falsy$"

Example Output:

Download test program DD.COM

Or Try it Online!
I'm not aware of an online TIO to direct link to a DOS executable, however you can use this with just a few steps:

1. Download DD.COM as a ZIP file
   


2. Go to https://virtualconsoles.com/online-emulators/DOS/
   


3. Upload the ZIP file you just downloaded, click Start


4. Type DD Hello or DD code to your heart's content

JavaScript (Node.js),  69  68 bytes

Expects the input string in uppercase. Returns $0$ or $1$.

s=>Buffer(s).map(n=>s+='30314624523133534452741251'[n%26]-3,s=0)|s>0

Try it online!

Python 2, 73 bytes

lambda s:sum(int('035344527512513031462452313'[ord(c)%32])-3for c in s)>0

Try it online!

Perl 5 -pF, 53 bytes

$p+=y/a-z/35344526512513031462452313/r-3for@F;$_=$p>0

Try it online!

C# (Visual C# Interactive Compiler), 49 bytes

n=>n.Sum(c=>""[c-65]-4)

Contains a lot of unprintables. Returns a positive integer for dot-heavy, and negative for dash-heavy.

Try it online!

C++ (compiled with Visual Studio 2017) 171bytes

int f(string i){const char*c="1322131421130102123023121211210120032121323101112232";int j=0,h[2]={0};while(j<sizeof(i)/28)*h+=c[i[j]-97],h[1]+=c[i[j++]-71];return*h>h[1];}

if we take the main program that exists for test purposes into account as well its more.

this is the ungolfed "tidy" variant

#include "stdafx.h"

int main()

{

    const int dotCount = {1,3,2,22,1,3,1,4,2,1,1,3,0,1,0,2,1,2,3,0,2,3,1,2,1,2};

    const int dashCount = {1,1,2,1,0,1,2,0,0,3,2,1,2,1,3,2,3,1,0,1,1,1,2,2,3,2};

    std::cout << "Enter String:n";

    std::string input;

    std::cin >> input;

    int inputsHeavyness[2] = { 0 };

    for(int i = 0;i < sizeof(input)/sizeof(std::string);i++)

    {

        inputsHeavyness[0] += dotCount[input[i] - 'a'];

        inputsHeavyness[1] += dashCount[input[i] - 'a'];

    }

    if (inputsHeavyness[0] > inputsHeavyness[1])

    {

        std::cout << "Dot Heavyn";

    }

    else

    {

        std::cout << "Dash Heavy or Neutraln";

    }

    return 0;

}

Stax, 20 bytes

ÉBÜ◙ƒ╣<Hf6─òɼsäS╗◄↔

Run and debug it

Unpacked, ungolfed, and commented, it looks like this.

"45D.J57KBJa`"I"    string literal with code points [52 53 68 46 74 53 55 75 66 74 97 34 73]

$                   flatten to string "52536846745355756674973473"

;                   push input

@                   get string characters at indices 

                    (using input codepoints as indices; lookups wrap around)

:V                  arithmetic mean

53>                 is greater than 53

Run this one