[Question]
  [
A string is dot-heavy when its morse representation contains more dots than dashes. For example, the letter E is a single dot, which means it is Dot-heavy.
# Input
* The input string will only contain characters in the range of `[a-z]` or `[A-Z]`. You can decide if they should *all* be upper case, or all lower case. `AAA` is fine, `aaa` is fine, `aAa` is not.
* The input string will always be at least 1 character in length.
* You may assume that input strings will never have an equal amount of dots and dashes.
# Output
You should return [Truthy](https://codegolf.meta.stackexchange.com/a/2194/41257) for inputs that contain more dot characters.  
You should return Falsy for inputs that contain more dash characters.  
Edit: I will allow a positive value for dot and a negative value for dash as well.
# Test cases
```
| input | morse representation | result          |
|------------------------------------------------|
| S     | ...                  | Truthy          |
| k     | -.-                  | Falsy           |
| HELLO | .... . .-.. .-.. --- | Truthy          |
| code  | -.-. --- -.. .       | Falsy           |
```
# Reference
![International Morse Code](https://i.stack.imgur.com/35Dsn.png)
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"). Shortest code in bytes wins.
  
[Answer]
# x86-16 machine code, 42 bytes
```
00000000: fc32 e4bb 1c01 ac24 1fd0 e8d7 7206 51b1  .2.....$....r.Q.
00000010: 04d2 e859 240f 2c03 02e0 e2ea c353 4452  ...Y$.,......SDR
00000020: 7412 5130 3146 2452 3100                 t.Q01F$R1.
```
**Listing:**
```
FC          CLD                 ; LODS string functions forward
32 E4       XOR  AH, AH         ; running sum = 0
BB 0119     MOV  BX, OFFSET TBL-1 ; offset data by -1 byte for one-based index 
        LETTER_LOOP: 
AC          LODSB               ; load next char from DS:SI into AL, advance SI 
24 1F       AND  AL, 1FH        ; convert ASCII letter to one-based index 
D0 E8       SHR  AL, 1          ; divide index by 2, CF=1 if odd index 
D7          XLAT                ; look up letter in table 
72 06       JC   ODD            ; odd index use low nibble; even use high
51          PUSH CX             ; save loop counter 
B1 04       MOV  CL, 4          ; set up right shift for 4 bits 
D2 E8       SHR  AL, CL         ; bit shift right 
59          POP  CX             ; restore loop counter 
        ODD: 
24 0F       AND  AL, 0FH        ; isolate low nibble 
2C 03       SUB  AL, 3          ; dash/dot difference remove +3 positive bias 
02 E0       ADD  AH, AL         ; add difference to sum, set result flags 
E2 EA       LOOP LETTER_LOOP    ; loop until end of input 
C3          RET                 ; return to caller
        TBL:
            DB   53H, 44H, 52H, 74H, 12H, 51H
            DB   30H, 31H, 46H, 24H, 52H, 31H, 30H 
```
**Explanation**
Input: string at `DS:SI` (upper or lower case OK).
Output: Truthy if `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. One byte can be saved by converting the input ASCII into a one-based index (`'a' = 1`, etc), however that would offset the table lookup index by one byte, not one nibble. Fortunately for us, the opcode of the previous `RET` instruction is `C3`, so that `3` is used for the `'a' = 1` nibble index.
**Example Output:**
[![enter image description here](https://i.stack.imgur.com/sehx1.png)](https://i.stack.imgur.com/sehx1.png)
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), ~~24~~ 15 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
-9 thanks to Ven
Anonymous tacit prefix function taking uppercase as argument.
```
>/'.-'⍧∊∘⌂morse
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/305fXU9X/VHv8kcdXY86ZjzqacrNLypO/Z/2qG3Co96@R31TPf0fdTUfWm/8qG0ikBcc5AwkQzw8g/@nqQerc6Wpe4MID1cfH38Qw9nfxVUdAA "APL (Dyalog Extended) – Try It Online")
`⌂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)
[Answer]
# [Java (JDK)](http://jdk.java.net/), ~~131~~ ~~124~~ ~~110~~ ~~84~~ 64 bytes
Interestingly, "dot" is dash-heavy and "dash" is dot-heavy.
Takes input in all caps as an `IntStream` (scroll down for a version with an actual `String` for an extra 8 bytes). I've had quite a lot of help golfing this one: Thanks to [Expired Data](https://codegolf.stackexchange.com/users/85908/expired-data) for golfing 20 bytes, to [Neil](https://codegolf.stackexchange.com/users/17602/neil) for golfing 26 bytes, to [Olivier Grégoire](https://codegolf.stackexchange.com/users/16236/olivier-gr%C3%A9goire) for golfing 18 bytes and to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen) for golfing 2 bytes.
Contains 26 unprintable characters inside the double quotes.
```
c->c.map(a->"".charAt(a-65)-4).sum()>0
```
[Try it online!](https://tio.run/##jY5BS8QwFISxTav0V4SeEqHBg3opFhY8uAfxUG/i4W0a19QmKcnrwrL0t9fgYsGbp/cGZr6ZHg5Q9d3Xos3oPNI@ajGhHkRAr8CI67oYp92gJZUDhECfQVt6KrRF5T9AKrq1YVQSnT/tnBsUWNo5xCPbWmx/EFTyev6FBASM5@B0R01EsejRdv/2TsHvA4/klUf1@j3QRVaNFAZGBlVTkpxkWZ5e5UmaJ@SCJNllGjVJSCnkJ/gNRtv9Ha9uuQiTYby5WeqiPQZURrgJxRhLcbBsrRDn0eXjy@sZERjn/J@ZTfv0JzQX8/IN "Java (JDK) – Try It Online")
Ungolfed:
```
c -> // lambda taking input as an IntStream in upper case and returning a boolean
  c.map(a -> "" // map each character's ASCII value to its net dot impact (unprintable characters here)
    .charAt(a - 65) // translate the ASCII code into a zero-based index into the above string (65 is 'A')
    - 4) // unprintables are > 0, this restores the proper values
  .sum() > 0 // add up all the values, positive sum indicates a dot-heavy input string
```
# [Java (JDK)](http://jdk.java.net/), ~~131~~ ~~124~~ ~~110~~ ~~84~~ 72 bytes
For purists; takes input as a `String`. Thanks to [Expired Data](https://codegolf.stackexchange.com/users/85908/expired-data) for golfing 20 bytes, to [Neil](https://codegolf.stackexchange.com/users/17602/neil) for golfing 26 bytes and to [Olivier Grégoire](https://codegolf.stackexchange.com/users/16236/olivier-gr%C3%A9goire) for golfing 10 bytes.
```
s->s.chars().map(a->"".charAt(a-65)-4).sum()>0
```
[Try it online.](https://tio.run/##jY4xa8MwEIWpLbvFv@LwJA0WHZouoYZAh3YoHdytdLjISqrUlox0DoTg3@6KNHju9O7g43vvgEesDu3PPIzbzihQHYYAb2gsnAtjSfsdKg2vNgxakfPnrXOdRgutIzrxhryxe1BiPRVXQyCkGEdnWuij58p8fgH6fRBRu8jALNcTzKGqg1Tf6AMXsseBY1WXLGdZlqd3eZLmCbthSXabxp8lrLywG4rY40pUD0KGseeivp/XRXMKpHvpRpJDLKfO8qVK/i0vn98/SiH@yW6alws8FdP8Cw)
Ungolfed:
```
s -> // lambda taking input as a String in upper case and returning a boolean
  s.chars() // convert to a stream of characters
  .map(a -> "" // map each character's ASCII value to its net dot impact (unprintable characters here)
    .charAt(a - 65) // translate the ASCII code into a zero-based index into the above string (65 is 'A')
    - 4) // unprintables are > 0, this restores the proper values
  .sum() > 0 // add up all the values, positive sum indicates a dot-heavy input string
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 21 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
Oị“ÆġwıMƥ)ɠịṙ{’D¤Æm>4
```
**[Try it online!](https://tio.run/##ATQAy/9qZWxsef//T@G7i@KAnMOGxKF3xLFNxqUpyaDhu4vhuZl74oCZRMKkw4ZtPjT///9DT0RF "Jelly – 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?
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~22~~ 21 bytes
Saved a byte thanks to *Kevin Cruijssen*
```
SA•U(Õþć6Δ
»›I•‡3-O.±
```
[Try it online!](https://tio.run/##yy9OTMpM/W/i9j/Y8VHDolCNw1MP7zvSbnZuCteh3Y8adnkCBR81LDTW9dc7tPG/zv9irmyujNScnHyu5PyUVAA "05AB1E – Try It Online")
**Explanation**
```
•U(Õþć6Δ
»›I•
```
is **35344527512513031462452313** compressed to base 255.
```
S              # split input into list of chars
       ‡       # 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
```
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 47 bytes
```
n=>n.Sum(i=>("[E[LduRgmQSMK"[i%13]>>i%2*3)%8-3)
```
Uses [Level River St's](https://codegolf.stackexchange.com/a/181425/84206) 'magic string'. Be sure to upvote their solution as well!
It's not everyday C# beats Ruby, Python, Javascript, C, Retina, and Perl!
[Try it online!](https://tio.run/##LcZBS8MwFADge35FeFBIpC2bvci2xlNFsSKuEw/VQ0jS9aF7KUk6kLHfXi9@p8/EwkRcHmYyu5gC0jFHSmqoF6oVld18ElgrAX3Tt3beH09v3csz9Jitqy@lMLu9qWR2V1Ry2bLBB6fNKM46cM2R@BOVe6ftwTdkhSy76QeTgE8CKdlHwORaJCfgsrpyjPyyvkKu80Ho8uDfp8kFIeVudQ9Wx7EYnT7/wgasT/@X26Vj3@yxadtXZrx1fw "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 23 bytes
```
9“¡ȷṡẓh)ėḂYF@’ḃ_4ị@OS0<
```
[Try it online!](https://tio.run/##ATcAyP9qZWxsef//OeKAnMKhyLfhuaHhupNoKcSX4biCWUZA4oCZ4biDXzThu4tAT1MwPP///0hFTExP "Jelly – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~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!](https://tio.run/##PczPC4IwHAXwc/srxkDY9t1K6MehYRApCAke6lYdZDLz0IxNuoh/u2lgt8/jPZ6WldbD4JSh@lk47llnGkddFCrulYOIgAQhJF9JySUDCkws@ZiBAblxDxDstg@5WTPlI3cIVT98mrrEFdWN9S2eTvH4ijq0eLvatoaSoMR7HPi7JQIb6pnAninUIzTW@FXUlv7mFSUXMhYTzjPSJMvyOZzyOJkdHy/p3/l1Yj98AQ "C (gcc) – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), ~~73~~ ~~70~~ 69 bytes
```
lambda s:sum(int(`0x21427b563e90d7783540f`[ord(c)%25])-3for c in s)>0
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUaHYqrg0VyMzr0QjwaDCyNDEyDzJ1Mw41dIgxdzcwtjUxCAtITq/KEUjWVPVyDRWU9c4Lb9IIVkhM0@hWNPO4H9BEVCrQpqGerC6Jhec443M8XD18fFHFnD2d3FV1/wPAA "Python 2 – Try It Online")
Uppercase only
-3 bytes, thanks to Erik the Outgolfer
---
Both upper- and lowercase version:
# [Python 2](https://docs.python.org/2/), ~~73~~ 71 bytes
```
lambda s:sum(int(oct(0x1d7255e954b0ccca54cb)[ord(c)%32])-3for c in s)>0
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUaHYqrg0VyMzr0QjP7lEw6DCMMXcyNQ01dLUJMkgOTk50dQkOUkzOr8oRSNZU9XYKFZT1zgtv0ghWSEzT6FY087gf0ERULNCmoZ6sLomF5yTjczxcPXx8UcWSM5PSVXX/A8A "Python 2 – Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~69 68~~ 65 bytes
*-3 bytes thanks to [@l4m2](https://codegolf.stackexchange.com/users/76323/l4m2)*
Expects the input string in uppercase. Returns \$0\$ or \$1\$.
```
s=>!Buffer(s).map(n=>s='30314624523133534452741251'[n%26]-4-~s)<s
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@7/Y1k7RqTQtLbVIo1hTLzexQCPP1q7YVt3YwNjQxMzIxNTI2NDY2NTYBMgyNzE0MjVUj85TNTKL1TXRrSvWtCn@n5yfV5yfk6qXk5@ukaahHqyuqakAAvr6CoZcaJLeSJIG6JIerj4@/iAF2HQ6@7u4gjVj0@niGOwBk8TQ6eIfArEVpPM/AA "JavaScript (Node.js) – Try It Online")
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 20 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
ÉBÜ◙ƒ╣<Hf6─òÉ¼säS╗◄↔
```
[Run and debug it](https://staxlang.xyz/#p=90429a0a9fb93c486636c49590ac738453bb111d&i=S%0AK%0AHELLO%0ACODE&a=1&m=2)
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](https://staxlang.xyz/#c=%2245D.J57KBJa%60%22I%22%09string+literal+with+code+points+[52+53+68+46+74+53+55+75+66+74+97+34+73]%0A%24+++++++++++++++%09flatten+to+string+%2252536846745355756674973473%22%0A%3B+++++++++++++++%09push+input%0A%40+++++++++++++++%09get+string+characters+at+indices+%0A++++++++++++++++%09%28using+input+codepoints+as+indices%3B+lookups+wrap+around%29%0A%3AV++++++++++++++%09arithmetic+mean%0A53%3E+++++++++++++%09is+greater+than+53&i=S%0AK%0AHELLO%0ACODE&m=2)
[Answer]
# [Ruby](https://www.ruby-lang.org/), 64 bytes
```
->s{n=0;s.bytes{|i|n+=("[E[LduRgmQSMK"[i%13].ord>>i%2*3)%8-3};n}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1664Os/WwLpYL6myJLW4uiazJk/bVkMp2jXaJ6U0KD03MNjXWyk6U9XQOFYvvyjFzi5T1UjLWFPVQte41jqv9r9qeXWwgreCh6uPj7@Cs7@La61ebmJBdU1WTYFCdJZOWnRWbGwtl4a9o56efZQmFrn/AA "Ruby – Try It Online")
Uses a 13-byte magic string, 2 numbers `0..7` encoded in each byte. Subtract 3 for a range `-3..4`. 
The ASCII code for `A` (and also `N`) taken modulo 13 is by coincidence, zero.
[Answer]
# GNU sed, 113 bytes
Accepts lower-case inputs, one per line. Output is 1 for dot-heavy or 0 for dash-heavy. Since the question didn't specify the output for exactly balanced lines, I produce an empty line in that case.
```
s/[acnpxz]//g
y/bdfgjklqruvwy/ieitmtimeeitm/
:e
s/h/ii/
s/s/ie/
s/i/ee/
s/o/mt/
s/m/tt/
s/et\|te//
te
/e/c1
/t/c0
```
1. First, remove the letters which are themselves balanced.
2. Replace unbalanced letters with their equivalents (e.g. Q is `--·-`, so its net contribution is `--`, i.e. M).
3. Expand these equivalents into the corresponding count of E or T.
4. Remove paired E and T
5. If we have an E remaining, we're dot-heavy; if we have a T remaining, we're dash-heavy; otherwise (nothing remaining) evenly balanced.
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 51 bytes
```
T`L`35344527412513031462452313
.
$*<>>>
+`<>|><
^<
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7wPyTBJ8HY1NjExNTI3MTQyNTQ2MDY0MTMCMg3NjTm0uNS0bKxs7Pj0k6wsauxs@HiirP5/z@Yy5vLw9XHx5/L2d/FFQA "Retina 0.8.2 – 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.
[Answer]
# [Bash](https://www.gnu.org/software/bash/)+coreutils,  64 60 bytes
```
tr a-z 35344526512513031462452313|sed s/./\&z-+/g|dc -eIK?^p
```
[Try it online!](https://tio.run/##S0oszvj/v6RIIVG3SsHY1NjExNTIzNTQyNTQ2MDY0MTMCMg3NjSuKU5NUSjW19OPUavS1dZPr0lJVtBN9fS2jyv4/z8jNScnHwA "Bash – 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
```
[Answer]
# [R](https://www.r-project.org/),  74  70 bytes
```
f=utf8ToInt;sum(f("42433250265364746315325464")[f(scan(,''))-96]-52)<0
```
input should be lower case, returns TRUE or FALSE
[Try it online](https://tio.run/##K/qfZptWmpdckpmfp1GhWV2cnJhnowsX0dPT06yuqAUqKi1JswjJ98wrsS4uzdVI01AyMTIxNjYyNTAyMzU2MzE3MTM2NAXyTcxMlDSj0zRABmnoqKtraupamsXqmhpp2hj8r@UCaixW0gRR2RAqIzUnJ19J8z8A)
[Answer]
# TI-BASIC (TI-84), 111 bytes
```
:Ans→Str1:"ABCDEFGHIJKLMNOPQRSTUVWXYZ→Str2:"35344527512513031462452312→Str3:0<sum(seq(expr(sub(Str3,inString(Str2,sub(Str1,X,1)),1)),X,1,length(Str1))-3
```
I used the same string for determining dot-heaviness as some of the other answers.  
Program returns truthy (`1`) if the input string is dot-heavy, falsy (`0`) if not.  
Input string must be in all-caps.  
Input is stored in `Ans`. Output is stored in `Ans` and is automatically printed out when the program completes.
**Ungolfed:**
```
:Ans→Str1
:"ABCDEFGHIJKLMNOPQRSTUVWXYZ→Str2 
:"35344527512513031462452312→Str3
:0<sum(seq(expr(sub(Str3,inString(Str2,sub(Str1,X,1)),1)),X,1,length(Str1))-3
```
**Example:**
```
"HELLO
HELLO
prgmCDGF3
           1
"CODE
CODE
prgmCDGF3
           0
```
**Explanation:**  
(TI-BASIC doesn't have comments, assume that `;` indicates a commment)
```
:Ans→Str1                          ;store the input into Str1
:"ABCDEFGHIJKLMNOPQRSTUVWXYZ→Str2  ;store the uppercase alphabet into Str2
:"35344527512513031462452312→Str3  ;store dot-dash+3 for each letter into Str3
:0<sum(seq(expr(sub(Str3,inString(Str2,sub(Str1,X,1)),1)),X,1,length(Str1))-3 ;full logic
   sum(                                                                       ;sum the elements of
       seq(                                                               )    ;the list evaluated by
                sub(                                    )                       ;the substring of
                    Str3,                                                        ;Str3
                         inString(                  ),                           ;at the index of
                                       sub(        )                              ;the substring of
                                           Str1,                                   ;Str1
                                                X,                                 ;starting at X
                                                  1                                ;of length 1
                                  Str2,                                           ;in Str2
                                                      1                          ;of length 1
           expr(                                        ),                       ;converted to an integer
                                                          X,                    ;using X as the increment variable
                                                            1,                  ;starting at 1
                                                              length(Str1)      ;ending at the length of Str1
                                                                           -3   ;then subtract 3 from all elements in the list
  0<                                                                           ;then check if the sum is greater than 0
                                                                               ;implicitly output the result
```
---
**Note:** The byte count of a program is evaluated using the value in **[MEM]**>**[2]**>**[7]** (124 bytes) then subtracting the length of the program's name, `CDGF3`, (5 bytes) and an extra 8 bytes used for storing the program:
124 - 5 - 8 = 111 bytes
[Answer]
# [Thunno 2](https://github.com/Thunno/Thunno2), 21 [bytes](https://github.com/Thunno/Thunno2/blob/main/docs/codepage.md)
```
Ạ»œfḅ“ƈ©OMṾȤØ»ṆdN3-Sʂ
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m728JKM0Ly_faMGCpaUlaboWN9Uf7lpwaPfRyWkPd7Q-aphzrOPQSn_fhzv3nVhyeMah3Q93tqX4GesGn2paUpyUXAzVtGBpRmpOTj6EAwA)
Port of Emigna's 05AB1E answer.
#### Explanation
```
Ạ»œfḅ“ƈ©OMṾȤØ»ṆdN3-Sʂ  # Implicit input
Ạ                      # Push the lowercase alphabet
 »œfḅ“ƈ©OMṾȤØ»         # Push compressed integer 35344527512513031462452313
              Ṇ        # Transliterate the input string (^^ --> ^)
               dN      # Convert to a list of digits
                 3-    # Subtract 3 from each
                   S   # Sum the list
                    ʂ  # Sign of the sum
                       # Implicit output
```
[Answer]
# [Morsecco](https://codegolf.meta.stackexchange.com/a/26119/72726) 175 bytes
morsecco has a small advantage here: it knows morse code by nature. Do `. - .-.` to `R`ead the stdin (special address `-`), `-.- .-` to `K`onvert from `·T`ext, `-.- --` to `K`onvert to `M`orse and you already have the morse transcript. But then the work begins!
```
. - .-. -.- .- -.- -- . . - .
-- - -.-. - - - . . -... -.. --.. --.
- .- . . - . -.-. . - .. .- - . -- --.. --.
. - .- - .. .- - . - - .-.. --.. --.
- .- --.
- .- -.-. - ---
```
One funny golfing trick in the third line (handling of space or dash): `C`oncatening a dot in front of the character turns the space into a null `.` , but the dash into a minus 1 (`.-`), so this value can simply be added to the total count.
The `Output is simply the first character of the count, which happens to be a dot for negative numbers and a dash for positive numbers, so the output is the character with less occurrences.
[Answer]
# [Perl 5](https://www.perl.org/) `-pF`, 53 bytes
```
$p+=y/a-z/35344526512513031462452313/r-3for@F;$_=$p>0
```
[Try it online!](https://tio.run/##DcexCoAgEADQn3EL0/M8lzCa3PqGCCoIIg9zqY/v6m2P13KQiOIm3mbWj0FC78kFAkeAFsEH9x8BTdG45TKkTk1RcW9FllzfzHXP5yV6pNaCFc3pAw "Perl 5 – Try It Online")
[Answer]
# [Factor](https://factorcode.org/), 66 bytes
```
: f ( s -- ? ) >morse [ [ 45 = ] count ] [ [ 46 = ] count ] bi < ;
```
[Try it online!](https://tio.run/##VYw9D4IwGIR3fsWFSQec1KH4MRiDJARJiJNhqPUlEoTi2zLw6ysRFnPDXZ7cXSmV1exueZxGApJZDgaGPj21igxq4pbeaKR9odFsCB2TtUPHVWsRenEqkGWnyAmUWMAgCHDEEoepfB@13mCPAkr346KY0PYPPSrsEDo/98eTlefXs1/OSXKds9JP@kX3BQ "Factor – Try It Online")
[Answer]
# 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,2,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 Heavy\n";
    }
    else
    {
        std::cout << "Dash Heavy or Neutral\n";
    }
    return 0;
}
```
assumes all lowercase
[Answer]
**c (118 characters)**
returns a positive value for over-dot-ness and negative value for over-dash-ness
```
int n(char* c){int v=25124858,d=3541434,i=0,o=0;for(;c[i]!=0;i++)o=(1&(v>(c[i]-65)))>0?(1&(d>>(c[i]-65)))>0?o+1:o-1:o;return o;}
```
un-golfed
```
int n(char* c)
{
  // Bitwise alpha map: 
  // more dots = 1
  // more dashes or equal = 0
  int d=3541434;  
  // validation bit map.
  // dot/dash heavy = 1
  // even = 0
  int v=25124858;
  int i=0,o=0;
  for(;c[i]!=0;i++)   // iterate through all values
  {
    // There is no way to make this pretty
    // I did my best.
    // If the little endian validation bit corresponding
    // to the capitol letter ascii value - 65 = 0,
    // the output does not increment or decrement.
    // If the value is one it increases or decreases based
    // on the value of the d bitmap.
    o=(1& ( v > (c[I] - 65))) > 0 ?
      (1 & (d >> (c[I] - 65))) > 0 ?
        o + 1 :
        o - 1 :
      o;
  }
  return o;
}
```
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), 22 bytes
```
{▄="Yⁿ∩┐↑rⁿ¼~<↔"$▒3-§+
```
[Try it online!](https://tio.run/##y00syUjPz0n7/7/60bQWW6XIR437H3WsfDRlwqO2iUVAzqE9dTaP2qYoqTyaNslY99By7f//1YvVudSzgTgjNScnH0gn56ekqv8HAA "MathGolf – Try It Online")
Uses the same method as many other answers, where `ⁿ∩┐↑rⁿ¼~<↔"` represents the magic number `35344527512513031462452313`.
[Answer]
# Python 2, ~~90~~ 86 bytes
```
import morse
s=''.join(morse.string_to_morse(input()))
print s.count('.')>s.count('-')
```
worked on my local with the [morse](https://pypi.org/project/morse/) library.
-4 bytes. Thanks for the tip @JoKing!
Also, it's 1 byte more if it's in Python 3.
# Python 3, 87 bytes
```
import morse
s=''.join(morse.string_to_morse(input()))
print(s.count('.')>s.count('-'))
```
Though the question assumes the number of '.'s and '-'s will not be equal; in case they are equal, this code will return True.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 19 bytes
```
n»¨g±„ẇ⟇PNĖṡø»Ŀ3-∑±
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJuwrvCqGfCseKAnuG6h+Kfh1BOxJbhuaHDuMK7xL8zLeKIkcKxIiwiIiwiayJd)
Saying the same joke but ~~louder~~ shorter is fun :p
Ports 05AB1E
## Explained
```
n»¨g±„ẇ⟇PNĖṡø»Ŀ3-∑±
n                     # Lowercase alphabet
 »¨g±„ẇ⟇PNĖṡø»        # 35344527512513031462452313
              Ŀ       # transliterate
               3-     # - 3
                 ∑±   # sign of sum
```
[Answer]
# [Nibbles](http://golfscript.com/nibbles/index.html), 16.5 bytes (33 nibbles)
```
+.$-=$`D8 3 2954b0ccca54cb75c957
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m708LzMpKSe1eMGCpaUlaboWNxW09VR0bVUSXCwUjBWMLE1NkgySk5MTTU2Sk8xNky1NzSHqoMrXRivFKGWk5uTkxygpxUIFAQ)
Approach based on [Emigna's O5AB1E answer](https://codegolf.stackexchange.com/a/181340/95126).
Input is lowercase. Outputs the dot-dash sum: positive values are truthy in Nibbles, negative values (as well as zero) are falsy.  
To directly compare to the [Vyxal](https://codegolf.stackexchange.com/a/261553/95126), [Thunno](https://codegolf.stackexchange.com/a/261545/95126), [O5AB1E](https://codegolf.stackexchange.com/a/181340/95126) etc. answers, add 2 nibbles (+1 byte; prefix  ``$`) to output the sign of the sum, although this isn't necessary here due to Nibbles' truthy/falsy convention.
```
      `D    2954b0ccca54cb75c957    # interpret hex 2954b0ccca54cb75c957
        8                           # in base 8
                                    # (digits: 51251303146245231335344527)
 .$                                 # now map over the input
    =$                              # getting the digit at the modular index
                                    # of each input codepoint 
   -      3                         # subtract 3 from each
+                                   # and sum the result
```
[Answer]
# C++, 76 bytes
This assumes the input is in ASCII (or any encoding that's compatible for letters, e.g. UTF-8 or ISO-8859.1). Input may be in either case.
```
[](auto s,int&i){i=0;for(int c:s)i+="DDFDEEECHFBCFBDADBEGCEFCDBD"[c&31]-68;}
```
It's a function that accepts a string and and integer reference. The integer gets assigned a positive number (truthy) for dot-heavy input or a negative number (falsey) for dot-light input. Balanced input returns zero.
The magic string encodes the weight of each of `A`..`Z`, offset by `D` (i.e. D represents a Morse-balanced letter). That's the `68` we subtract from each value.
I did attempt encoding two Morse symbols per char in the magic string, but the cost of unpacking was too great.
### Test program:
```
auto f = [](auto s,int&i){i=0;for(int c:s)i+="DDFDEEECHFBCFBDADBEGCEFCDBD"[c&31]-68;};
#include <iostream>
#include <string>
int main(int argc, char **argv)
{
    int i;
    while (*++argv) {
        std::string s{*argv};
        f(s, i);
        std::cout << s << ": " << i << '\n';
    }
}
```
### Output:
```
./181318 S k HELLO code
S: 3
k: -1
HELLO: 6
code: -1
```
[Answer]
# GNU [sed](https://www.gnu.org/software/sed/) `-E`, 112 bytes
An approach could not differ more from the existing `sed` solution, but beating it by only one byte! This one builds a map from +4 dots to +3 dashes then two `s` commands taking turns in moving one of their side down until one of them has no moves left:
```
s/^/H S IFLV EDRU :_GKWT_JQYM_O!/
:1
s/((\S)\S* (.).*)\2/\1\3/
T-
s/((.)_[^_]*([^_]).*!.*)\3/\1\2/
t1
c.
q
:-
c-
```
[Try it online!](https://tio.run/##Hcq9DsIgFEDh/T4F3YAEbmg3Vov1N41SNUZahmqMS6uhvr4oLmc5X7hdxX14xxiwwwWxZDnfHIkp9weifbU@NX61O299nSFoBQEpdZY5ywmVTHLmcnTKFQiN@E/J/KXzLaepP5AlUySTI0wKegkv0AJ6EeOsLs1nfE6PcQhRmC8 "sed – Try It Online")
[Answer]
# [Scala 3](https://www.scala-lang.org/), 91 bytes
A port of [@Level River St's Ruby answer](https://codegolf.stackexchange.com/a/181425/110802) in Scala.
---
Golfed version. [Attempt This Online!](https://ato.pxeger.com/run?1=lVDLSsNAFN33Ky5DS2bUBDWb0jIDVQNKU4oNbgxdjGkSE9JJmJlWSsiXuOlGN4L_079x0lRw64X74hzOPdz3TxXxgrtfIbJF-calQMvDonzJ40jDjGcC6h7AKk5gbRbMZapGMJGS78JAy0ykSzKCJ5FpoIZpqFteQDIC3KGUPQhNDPax0Yk9PISKsnrLJQh6OVZOGuubnY6Vk5Qy5tFrnVEmzinGKPRCf7VZpOvHYDZFDq-qYoezwZVLHF0aTcbMdn3mEjIY2i5pxqI5nfgGE36mNEYBugA0bcu95_vzdrid33mI_N6DGnKgrAfHqIxjXQisUD8Hm0G_TnBOGkSOeNM7NmxNLNAlWM_Wf2SM6-4jf_TaPLne77v-Aw)
```
s=>{var n=0;s.getBytes.foreach{i=>n+=(("[E[LduRgmQSMK".apply(i%13).toInt>>(i%2*3))%8-3)};n}
```
Ungolfed version. [Attempt This Online!](https://ato.pxeger.com/run?1=lVHBTsJAEI1XvuJlg-muWqJyISQ0QSXRUEKUeLHhsJa2bANb011UQvgSL1z04h_xNW7bVeDoYXfm5b15uzPz8aVCPuPN74C4MnvjuSTjzedCx25re7TNntMo1BhwIbGqAZMoxtwAyvNEtdHNc74MRjoXMhmzNh6l0OiUSuCVzxAbRI2wkjB0PEsWdA5p6HOLVSOJ9NVSR6oRZ3nEwylWEKbC8pWhkJPo3VQJHOOieUCpqYi1pS5xgkM2nJr3OiBBL_Ani4dkfj8a9Akt_difUuLUfJgW4obO7qSG51XGzLi24KL5K17bKGsVKoMvlKZkRM5A-sV12_P9YZFcD296hO11lu46ezGz0TNJFamncD3UVzFN2ZqwfWfqdB3oDM6T8x8b04Wd_c6vOOtqxXbTGxt_AA)
```
object Main {
  def main(args: Array[String]): Unit = {
    val f = (s: String) => {
      var n = 0
      s.getBytes.foreach { i =>
        val index = i % 13
        val shift = i % 2 * 3
        val char = "[E[LduRgmQSMK"(index)
        n += ((char.toInt >> shift) % 8 - 3)
      }
      n
    }
    List("S", "K", "HELLO", "CODE").foreach { j =>
      println(s"$j -> ${f(j)}")
    }
    ('A' to 'Z').foreach { j =>
      println(s"$j -> ${f(j.toString)}")
    }
  }
}
```
]