[Question]
  [
## Overview
The *sharpness* of a word is the sum of the sharpness of each of its letters, using the following rules:
**Sharp letters**
* `A`, and `V` each have a sharpness of **1**
* `N` and `Z` each have a sharpness of **2**
* `M` and `W` each have a sharpness of **3**
**Dull letters**
* `C` and `U` each have a sharpness of **-1**
* `S` has a sharpness of **-2**
* `O` has a sharpness of **-3**
**All other letters** have a sharpness of **0**.
### Example
The word `SAUCE` has a sharpness of **-3** since the `A` contributes 1, the `U` and `C` each contribute -1 and the `S` contributes -2.
The word `MAZE` has a sharpness of **6** since the `M` contributes 3, the `Z` contributes 2, and the `A` contributes 1.
## Task
Given as input a string containing only uppercase letters\*, determine the sharpness of that string.
\*If you wish, you may instead take the input as a string containing only lowercase letters. Other common input formats are also acceptable (eg. a list of characters, a list of codepoints, etc.)
## Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'")!
## Test Cases
```
CODE => -4
GOLF => -3
SAUCE => -3
CATS => -2
MOON => -1
NONSENSE => -1
ZUCKERBERG => 0
STRING => 0
CHALLENGE => 2
NAIL => 3
CARNIVAL => 4
COMPLIMENT => 4
WAVE => 5
UNKNOWN => 5
MAZE => 6
```
**Extra test cases (Provided by [@Surculose Sputum](https://codegolf.stackexchange.com/users/92237/surculose-sputum))**
```
MIZZENMASTMAN => 17
PNEUMONOULTRAMICROSCOPICSILICOVOLCANOCONIOSIS => -26
MANAGEMENT => 12
CONSCIOUSNESS => -13
```
  
[Answer]
# [Python 2](https://docs.python.org/2/), 53 bytes
```
lambda s:sum(3-"MWCUNZS_AVO".find(c)/2*4%7for c in s)
```
[Try it online!](https://tio.run/##VY99a8IwEMb/z6cIwrAd6tbqJggdZFnmgs2dNG2FMpBOLRZ8w1Zkn76rsdsQAnl@zz13lxy@y/V@51aZ91lt0u3XMqXFqDhtrX63pWY8gkTPWYytXpbvltbCfnDvB3fDbH@kC5rvaGFX53W@WVFnRGo@nMoO3Z/K@qYePabnufEsu1ccNnlptan3Qts2@c/ku9K6Qu0ejjXejiE0LYrVsaSZZXybel5T6lDrJtr5y9gVxzdx2dUdkDH670b2iWYRF43mLNRGukQhgpEOAQQt6tNgEvGJCF5FML4Yj0SHgYRG8w/m@wLGJusSYNK/qMvkAGTMDA0IRzX1pRIQXnnGYtPxRCKYAM7gCoolxn4mSiaJAMV0qJgpOkMyBREpBIz8MGBK8gA1x6nkWvqSY4w@Z4AcQaKWza/qQQzYWPxudtz6KaC5xEiD0NeU0/8B "Python 2 – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 21 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
“CSO“ANM“U“VZX”iⱮ€§ḅ-
```
A monadic Link accepting a list of characters which yields an integer.
**[Try it online!](https://tio.run/##y0rNyan8//9RwxznYH8g6ejnCyRDgTgsKuJRw9zMRxvXPWpac2j5wx2tuv///w/wcw319ffzD/UJCXL09XQO8g929g/wdA729PF09g/z93F29PN39vfz9A/2DAYA "Jelly – Try It Online")**
### How?
```
“CSO“ANM“U“VZX”iⱮ€§ḅ- - Link: list of characters, W
“CSO“ANM“U“VZX”       - list of lists of characters = [['C','S','O'],['A','N','M'],['U'],['V','Z','X']]
                 €    - for each (L in those four lists):
                Ɱ     -   map across (c in W) with:
               i      -     first (1-based) index (of c in L) or 0 if not found
                  §   - sum each resulting list
                    - - literal minus one
                   ḅ  - convert (the list of four sums) from base (-1)
```
[Answer]
# [Python 2](https://docs.python.org/2/), 52 bytes
```
lambda s:sum(3-"MCNSAO_WUZ_V".find(c)*4%7for c in s)
```
[Try it online!](https://tio.run/##VY9xa8IwEMX/z6cIg2E7VNbqJggdZFnmgs2dNK1CGYhTiwWtYiuyT9@1abchBPJ@797dJafvYnfM3DLxPsv96vC1WdF8nF8O1qB3pzhohstFFC/nd/0kzTbW2n4Y3o@S45muaZrR3C6vu3S/pc6YVHy6FF16vBTVTT16Xl2XxrPsfn7ap4XVod4L7djkP5NmhdVA5Z7OFd6OIXSV59tzQRPL@Db1vLbUpdZNtPuXsUuOb6Le1RuSCfrvRg6IZhEXreYs1Ea6RCGCkQ4BBC2q02Ic8akIXkUwqY1HosNAQqv5B/N9AROTdQkw6deqnhyAnDNDQ8JRzXypBIQNL9jcdDyRCKaAC2hAsdjYz0TJOBagmA4VM0VnRGYgIoWAkR8GTEkeoOY4k1xLX3Kco88ZIEeQqGX7q2oQAzYRv5sdt3oKaC4x0iB0k3IGPw "Python 2 – Try It Online")
Improvement on @xnor's answer.
```
M C N S A O _ W U Z _ V ?  c
0 1 2 3 4 5 6 0 1 2 3 4 6  "...".find mod 7
0 4 1 5 2 6 3 0 4 1 5 2 3  "...".find*4 mod 7
3-1 2-2 1-3 0 3-1 2-2 1 0  (3-"...".find*4 mod 7)
```
\*4 is to map -1 (failed find) onto 0
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~61~~ 53 bytes
A lookup table based on the ASCII code of each letter.
Takes input as a list of codepoints.
```
a=>a.map(c=>t+='50363133463254'[(c^98)%22]-3|0,t=0)|t
```
[Try it online!](https://tio.run/##jZFba8JAEIXf/RWhUIykRk2ibR8ibLfbdHF3VrKJgmIhpNoLVsWEPvnf06i5NaXgMG8fZ@bMmc/gO4jC/ccubm@2r8tkZSeBPQz0r2CnhvYw1uxmv2sOzJ5pWgPT6FvNuRq@3N@1rg1j0TYP3ZvY7rYOcRIvo1ixlUixh0q43UTb9VJfb9/UlTrXdT1anCeeqB6@B3ucbkOx2kqr0TiK1SssHslVSymq01HaVsYcwZ7qzMyYRD6uCqsMI0/WdUbGuBBQZ72MgQBJ0s55lc18PCLuA3GdM02Z0s29eC4Fp5xaZfgZMUbAyYemTMu9AKKs5kUrb3CBThCreNGsIjM@ZpQT8AovBZuiST1PrZ8xH0YgpuX5VcbR7I9ukD@J09mMAEfS4@hXev/WUd67zeRjID4XIHzmuYhT7AqJxZhiSRnFYiIYRiCwACokPT/u9LFBYQ2QQ8pzL9xuFGmBxFT4EoiUl5pv98zkBw "JavaScript (Node.js) – Try It Online")
### How?
By XOR'ing the ASCII code with **98** and applying a modulo **22**, we gather the characters with a non-zero sharpness into the range **[0..13]**. This results in a lookup table of **14** entries.
If the result of the formula is out of range, we get `undefined - 3 | 0`, which is **0**.
```
 char. | code | XOR 98 | MOD 22 | sharpness
-------+------+--------+--------+-----------
  'A'  |  65  |   35   |   13   |    +1
  'B'  |  66  |   32   |   10   | 
  'C'  |  67  |   33   |   11   |    -1
  'D'  |  68  |   38   |   16   | 
  'E'  |  69  |   39   |   17   | 
  'F'  |  70  |   36   |   14   | 
  'G'  |  71  |   37   |   15   | 
  'H'  |  72  |   42   |   20   | 
  'I'  |  73  |   43   |   21   | 
  'J'  |  74  |   40   |   18   | 
  'K'  |  75  |   41   |   19   | 
  'L'  |  76  |   46   |    2   | 
  'M'  |  77  |   47   |    3   |    +3
  'N'  |  78  |   44   |    0   |    +2
  'O'  |  79  |   45   |    1   |    -3
  'P'  |  80  |   50   |    6   | 
  'Q'  |  81  |   51   |    7   | 
  'R'  |  82  |   48   |    4   | 
  'S'  |  83  |   49   |    5   |    -2
  'T'  |  84  |   54   |   10   | 
  'U'  |  85  |   55   |   11   |    -1
  'V'  |  86  |   52   |    8   |    +1
  'W'  |  87  |   53   |    9   |    +3
  'X'  |  88  |   58   |   14   | 
  'Y'  |  89  |   59   |   15   | 
  'Z'  |  90  |   56   |   12   |    +2
```
[Answer]
# APL+WIN, ~~42~~ 38 bytes.
Prompts for string:
```
   +/(2/¯3+⍎¨'4562103')['AVNZMWCUS O '⍳⎕]
```
[Try it online! Courtesy of Dyalog Classic](https://tio.run/##PY/BSsNAEIbveYreViml2qj3cVzj0N2Zks0mEPEQKhUhoNCTL6BeWrz4Dt48@AZ9lLxIumSDMIfvn/n/GaZ5bWePb0378jRbt812@7zuu/23Nd37V5p0nx@bfjo/WcwPv@m02@0PP@ri8mpxfpaq03sFJde2Qu8mMlHd7i8EH/qQ6TeJQrnRKgmQibkdwIHH2EIo3ABWhAdgYadDDaL2uNT5tc6zmCty4oh4B8ZozqKPgcy4L2cqYRRiV4as5mKQFZTR7XnJUsVzFurYtFTXmi24wkIcrVh7KyzeFDlYwlwcyorQkSGUUgwCCwqTOBqfAIZM/x8MM4ck3rF2wXAE "APL (Dyalog Classic) – Try It Online")
Explanation:
```
⍎¨'4562103' Split number as a string into individual digits and convert to integers
2/¯3+ Subtract 3 to give the non-zero letter values and double up each value 
['AVNZMWCUS O '⍳⎕] Find the index position of non-zero letters that occur in the input. 
If a letter is not in list it is given an index of length of list + 1
+/ Sum the values corresponding to the indices of non-zero letters in string
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 31 [bytes](https://github.com/abrudz/SBCS)
```
-/1⊥¨4|(↓4 3⍴'ANMCSOVZWU  ')⍳¨⊂
```
[Try it online!](https://tio.run/##FcsxCsIwFIDh3VN0iw5FpL1AeAQNNHmlr6ngJkhdCroKTgodCi2KeAShm4OeoEd5F4l1@YcP/u2xCnenbXXYex/OF9y8hj4@T7l@xEHE7VdIa4Cw2KxdEIgZt5@h5@biS65v3HbcXId3xPWduydlMDZfafKlMNLKpTLK5mJSCkBLoNGRVUR/SK1yBi26JM@k0ZAhAaYaSCcasMAEpMXx0kiaxA8 "APL (Dyalog Unicode) – Try It Online")
Tacit function.
### How it works
```
-/1⊥¨4|(↓4 3⍴'ANMCSOVZWU  ')⍳¨⊂  ⍝ Input: string S
       (↓4 3⍴'ANMCSOVZWU  ')     ⍝ 'ANM' 'CSO' 'VZW' 'U  '
                            ⍳¨⊂  ⍝ Find the index of each char in S in each of above
                                 ⍝ Index is 1-based, not found gives 4
     4|  ⍝ Modulo 4; convert 4 to 0
  1⊥¨    ⍝ Sum of each row
-/       ⍝ Alternating sum; (ANM score)-(CSO score)+(VZW score)-(U score)
```
[Answer]
# C(GCC) ~~84~~ ~~73~~ 72 bytes
*-11 bytes thanks to ceilingcat*
```
t;f(char*s){for(t=0;*s;t+=""[*s++-65]-4);s=t;}
```
(note that StackExchange strips some non-printing characters)
[Try it online!](https://tio.run/##Vc9ra8IwFAZgNqtCf0UWKG21grvoB0MYXZe5YpuOegO3fSi13QTnxGQwEH97l3iJaykNfU7ynpO09ZGmRcFRbqWfyabB7G3@vbE4bqMGQ7yJYVWraKenXrsQ30utUq1rWg2@Nliz2ep23lt3NmKYo13BM8aPSQ5YrDjIftdZyrO5vdXlb5Lyn2QJMMgtZqM9rRPGBJwqWB1B@nojNuQWNFgPGHNgpFgulsHstxV0DifvAZQrBD0A82SxFH6IUnUTm6JoXpmOinaA6A70nb6f4CtZrCwbbPX99NCLHolIkZc6Sj8KnqTcKhm6Y4@UyXNHQyk3SsIoolKuldCIDol4yzobewMSP5C4L7x97jGKfVom79kNAkL7MuDch7p@IOD/KDH1J67E8yW8KHwJ/JDQUYmn7kSmdRSM6YBGU1qy0J3JTV0Bu@IP "C (gcc) – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), ~~62~~ 60 bytes
-2 bytes thanks to @Neil!
```
lambda w:sum('AVNZMW'.find(c)/2-'CUS_O'.find(c)/2for c in w)
```
[Try it online!](https://tio.run/##TY9ha8IwEIa/51cc/RKFbgM/Cg6yLKvF5G40TQtlMFylWNAq6ij79V0Thw4O3jcv91zujj@X7aGbDc3iY9it91@bNfTz8/d@wkWBlSn5Y9N2m0k9fZo9cOnsJ/1LmsMJamg76KfDzXOy0v3BcwZwPLXdBeoY@OKZx9CMJGMhZMxDvYciSa8qiiFKSL95tcLJEEiRW6@GCL0ioVVjeV85uVLZi8qSgORZisHJpdBaYRKaUKT6OijDtBBXT@Zdp0Zh7l@lKEKnwxVSGX4xolLRffv@vv146i8 "Python 2 – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 61 bytes
Input is taken as a byte-string \$ s \$.
```
lambda s:sum(b''[c-65]-4for c in s)
```
[Try it online!](https://tio.run/##NY9ra8IwFIbZrAr5Fflm@0Gx3gaCgyzLumBzjjStgs4PtVYUvGErY7@@60VDCM97zvueJNe/dH8597Pd5Cc7hqfNNqTJOLmfzE2rbtSM52o2XvLz1ajVm4bRaK2i9mi4bg92lxuN6OFMEyv73R@OMbXHhEZhEtNJXr7eU9PqJNfjITVbdPJOWxahYZLEt5TuzMK26q478Tm6bGPTsuikCKVVw15bGcdPUcTaA@Kg@1Vin2gWcPFgznxdYo8oRCjRJoCgRb4fchnwqfA@hOcUhS7Rvifhwfybua4Ap/T2CDDpFlRM9kDOWakGhKOauVIJ8Cu9YPMyMSQBTAEXUAnFlmV5RJRcLgUopn3Fyqb9RmYgAoWAget7TEnuoeY4k1xLV3Kco8sZIEeQqOXjV/kgBswRz5vtXv4U0FxioEHoymX3/wE "Python 3 – Try It Online")
We use a lookup table, where each element maps to the *sharpness* of a given letter. Note the `-4`, to display the negative *sharpness*.
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), ~~61~~ 60 bytes
```
M|W
N#
N|Z
##
O
S-
S
--
T`VAUC`##-
+`\w|-#|#-
^(-)?.*
$1$.&
```
[Try it online!](https://tio.run/##HY7BSgQxEETv9RtZZVWy4BdIG9sYNule0skMDCLjwYMXDyJ4mX8fg1CHR1FV1PfHz@fX@351jOtethniINsC56AwD4P3aOtEPazOedytr7@bd9tAvB39zcPpFof7w@l634M@MaLmZ9hIMwI1Q1EViIrxEJYezlwfuUZYq0kiwgvlzBIZQimPTpU00QAtl5wKS8NME6PLWXQWFFoYJS0LSyFrhQQX4V5UtOdWqaRQ1YJeUrCUU9BJcyDRoJLU0jhEQpH/h4dnIWk3YbM/ "Retina 0.8.2 – Try It Online") Link includes test cases. Edit: Saved 1 byte thanks to @mathjunkie. Explanation:
```
M|W
N#
N|Z
##
O
S-
S
--
T`VAUC`##-
```
Turn sharp letters into the appropriate number of `#` (sharp... geddit? any non-word non-magic non-`-` character would have worked) signs and dull letters into the appropriate number of `-` (because they have negative sharpness) signs.
```
+`\w|-#|#-
```
Delete other letters and all matching pairs of `#` and `-` signs.
```
^(-)?.*
$1$.&
```
Output the number of signs remaining, prefixed by the first one if it's a `-`. Since the regex matches a zero-length string, I have to ensure it only matches once.
[Answer]
# [Javascript (Node.js)](https://nodejs.org/), 115 bytes
```
let s=0;for(let b='w'+w,c=a=>Math.ceil(10*3**(4/~'OSCUAVNZMW'.indexOf(a[0])))-4||-1;b=b.slice(1);s+=9>c(b)?c(b):0);
```
[Try it online!](https://tio.run/##HZBRa8JAEITf71fkQcid1lSpL63Ecj2v6WFuV3KJQtqCMcaaEoyYUAtq/7qNwjIMA7N8zHfyk1TpPt/V3W25yi5pua1qa47B2FiutRA4lsRD/5UYHglJBA8N0YhAAMHI5kgciYkMXmTgERMGCjwi3rjvS/AkAa78phOAmvHGoJ76SksIyZzPJIlgAjgHonksiVZxLEFzE2oOZAoy0ggY@WHAtRIBGoFTJYzylcAZ@oIDCgSFRjVAHLgnb4@bzAiFkQFpzMKpdkVeU/tjazPirMu9TNINPVjuyDpeiqy2Krc3bGJ69UvXPtidw13qJu5IJ/XGSbO8oP1e@6HdpoP7P7uBiPgMYj23nXy7yn5xTZP33idjrDs4nbr94dJdOlWRpxnts2HVcR9HKV2y56s89djwNm9ZZE5RftFF63g4X1Fax@q8YOTMLv8)
This puts all the characters in a string, 'OSCUAVNZMW', and uses a formula to map the character index to the "sharpness" of each letter. The formula is:
\$f\left(x\right)=ceil\left(10\cdot3^{\frac{4}{x}}-4\right)\$
Where \$f(x)\$ is the sharpness, and \$x\$ is the negative index of the character + 1. Sounds convoluted, but there's a reason: the index is modified to make Javascript's `string.indexOf()` return 0 instead of -1.
This formula does result in 0 instead of -1 for U. However, using Javascript's `||` functionality in variable assignment, we can just default zero values to -1 instead.
Also, this is my first code golf, advice appreciated!
[Answer]
# [Java (JDK)](http://jdk.java.net/), 56 bytes
```
s->s.map(c->("XXAVNZMWOOSSCU".indexOf(c)/2+3)%7-3).sum()
```
[Try it online!](https://tio.run/##bU5da9swFH3PrxCBgL01HqwPg3YLqJrqiVr3BstOiksfNCfunMUfWHJoGf3tmuLtZaygi@49595zzkGf9PKw@@nqpu8GSw5@jkZbH6N317P/sGpsS1t37ZukscNeN2eqPGpjiNR1S37NCOnH78e6JMZq679TV@9I47lA2aFunx4eiR6eTDitEpJ1orW3f30@@15NsitSkS/OLFcmanQflMtVML@/pxso5BZRKZbPo7rd7Z@xCsrww8f3l@Hi0/IyjMzYBKG7nrSrbiDBSQ/E7o29@seWEPVi7L6JutFGvc9lq2C@MFdksVu084vp4oJUke774ws1PldwhqLyhx5MEIbhH4fX2blenWP4lbsYk1unaM64YzRTTiKCAwTF/XNFzu54esPT2KksFRA79o0mCYeYO6Ai8TcpiA31Dcp1IiSHzG3phrsc7gC34CQtuJOiKDhIqjJJwa2B5xIB8yRLqRQsRcVwLZgSiWC4wYRRQIYgUAkfiAKN@STsMcUE5gq4Ur8B "Java (JDK) – Try It Online")
[Answer]
# [Javascript (Babel Node)](https://developer.mozilla.org/en-US/docs/Web/JavaScript), 131 bytes
```
d=>(s=0,[...d].map(c=>{s+=/[AV]/.test(c)?1:(/[NZ]/.test(c)?2:(/[MW]/.test(c)?3:(/[CU]/.test(c)?-1:(c=='S'?-2:(c=='O'?-3:0)))))}),s)
```
[Try it online!](https://tio.run/##TctBC4IwGMbxj@NGOUtvwhQZHQa6V1waJB7W1CgspUmX6LOb0sXn9OcHz129ldGv2zDaF3VpOvvZ183U0qmmATJ0ty0JIXVFHmpAmgYfs6FOGRWVQ8bGjEjjcO8jpxTnlbiLJKeVeIuwfCX2fNOUWtIKbfefMKfn7/CyL94aPOn@afquIV1/RS2yUnHIExCQx8csSjjLQDJIOZM85gwKiFkkgIHgILm0MJ5@)
This is my first code golfing. I hope I'm doing it right.
I'll be glad to get some js golfing tips (before exploring new golfing languages) and overall golfing tips.
[Answer]
## Javascript (ES6), 65 characters
```
x=>x.map(l=>s-=~(z='RosLucyEvanzmw'.indexOf(l))?~(z/2)+4:0,s=0)|s
```
## Javascript (ES6), 67 characters
```
x=>x.reduce((s,l)=>~(z='RosLucyEvanzmw'.indexOf(l))?s-~(z/2)-4:s,0)
```
Takes an array of lowercase characters as input.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), ~~20~~ 19 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
ô≈X╙R┤╠Φyf∙H¡»₧ßc≡╡
```
[Run and debug it](https://staxlang.xyz/#p=93f758d352b4cce87966f948adaf9ee163f0b5&i=%22CODE%22%0A%22GOLF%22%0A%22SAUCE%22%0A%22CATS%22%0A%22MOON%22%0A%22NONSENSE%22%0A%22ZUCKERBERG%22%0A%22STRING%22%0A%22CHALLENGE%22%0A%22NAIL%22%0A%22CARNIVAL%22%0A%22COMPLIMENT%22%0A%22WAVE%22%0A%22UNKNOWN%22%0A%22MAZE%22&a=1&m=2)
[Answer]
# [Keg](https://github.com/JonoCode9374/Keg), 42 bytes
```
?⑷¦A1|V1|N2|Z2|M3|W3|C1±|U1±|S2±|O3±║_0™⑸⅀
```
Unfortunately, TIO doesn't have the latest version of the interpreter on its servers, so y'all can't try it online.
Quite literally, this maps over each character in the input, assigns it a value based on the sharpness table, and sums the stack.
[Answer]
# [Zsh](https://www.zsh.org/), 73 bytes
```
a=(O S CU : AV NZ MW)
for c (${(s[])1})(((x=a[(I)*$c*])&&(r+=x-4)))
<<<$r
```
[Try it online!](https://tio.run/##HY/BagJBEETv/RVzWGTG4CGQU9BDp9PZDM50y/bOCiseRJTcAq4HSci3b1ahDkXBK6p@hq/x7IOH4XR1i9t4WHl15qi4V4edk97lbYDz98Udna9@/bDbh@e/4L2/rQ47H8O8Os73YTbzl6fVbfESQoDlclldxgAP7Hoars4DkL4z1Jo@wLAQA2FrkFUFRMV4EvSF1ty8cVODtU2UGugTU2KpGQRjmphGYoeT0bxJMbO0sMWOochadCuQsWfIse9ZMlqbUWAjXLKKltQ2mCM1aqSbSBZTJO00EYqSSlSL0yAUrPlRPGVGUYsJmwHc77jq/mb8Bw "Zsh – Try It Online")
Get the last `(I)`ndex of the glob `*$char*` (with `(I)`, it is zero if not found). If it is non-zero, add to `$r`.
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, 48 bytes
```
$_=y/AV//+2*y/NZ//+3*y/MW//-y/CUSO//-y/SO//-y;O;
```
[Try it online!](https://tio.run/##Lcw9C8IwEAbgPb@ig5NSov1wkQoxxlqa3EnSD@ji5CAUW9Slf97YpoWDe97j7vrHu42tXd2TgbKK0k2wHig0I8IRqqbUHygvDTrM7YAHazmehZccPT8iKcqLY0gMK7lYzFlhHAOiEMFxRwDBiLGW2JQ8F/okdDoNtsQUOoPF/MqkFJC63YAAy@Sk6bOGrGIuRYSjuslMCSjmXLPKXcSkhBywhjko1rjx/tf132f3@li/b/8 "Perl 5 – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~25~~ 24 bytes
```
ＩΣＥＳ⁻÷⌕AVNZMWι²÷⌕UCSSOι²
```
[Try it online!](https://tio.run/##VY3BCoMwEER/RTxtwX5BT7K0sJBkxa0WegsW2kBMRWN/Pw16aecwMDMPZnjZeXhbn1IzuxAB7RJB1hG0nYDCtEaJeXjCoSq0C@sCjc92ceEBZW10WRUuT3vu77ct5@KHQuE/qtuZTaf8a86dZsOdura1JmxZkBtCIUXIPSusDSMbYiFJx4//Ag "Charcoal – Try It Online") Link is to verbose version of code. Edit: Saved 1 byte by porting @ovs' answer. Explanation:
```
   Ｓ                        Input string
  Ｅ                         Map over characters
             ι              Current character
      ⌕                     Find position in
       AVNZMW               Literal string `AVNZMW`
     ÷        ²             Integer divide by literal `2`
    ⁻                       Minus
                      ι     Current character
                ⌕           Find position in
                 UCSSO      Literal string `UCSSO`
               ÷       ²    Integer divide by literal `2`
 Σ                          Take the sum
Ｉ                           Cast to string
                            Implicitly print
```
The halved `Find` results in one less than the sharpness/dullness, but the other find returns `-1` in that case, thus correcting the value.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~39~~ ~~38~~ ~~36~~ ~~34~~ ~~33~~ 28 bytes
```
lε.•3и½:∍äaŠ•sk>4%„Ý§uyåi(]O
```
[Try it online!](https://tio.run/##AUMAvP9vc2FiaWX//2zOtS7igKIz0LjCvTriiI3DpGHFoOKAonNrPjQl4oCew53Cp3V5w6VpKF1P//9DT05TQ0lPVVNORVNT "05AB1E – Try It Online") or [Verify all test cases (as arranged by @sporeball)](https://tio.run/##LY6xSgNBEIZfJSwIFtEmVhYJ42Q9h@zOHLu3FzhJEcEiKFgEhSsCKW18BEVE8QkEG5sctuIz3Iucu4cw8P//x8/M3KyXF6vLju7qiRocjAdqUk@765@Pw3b7Mvr93H0dt/cPzevy@zmC9dX4aK/dPjWPu/fbunlb7W820g27c4Uy1WqoMjGnUTwETBGh8FGsCEdhYa/jRFsFnGl3ol2W2oUjTgbPwBjNWWowkOk3OKYSeis2N2Q1FzHMoUytwDOWeVpuoUrAUlVptuALCwnnrIMVlmAKB5bQiUfJCT0ZQinFILCgMImn/lVgyPT/kcg9kgTP2nu1@AM) 
*-5 thanks to @Kevin*
## Explained
```
Original: lε.•3и½:∍äaŠ•sk>4%„Ý§uyåi(]O
Uncompressed: lε"anm vzw cso u"sk>4%"cosu"yåi(]O
l               | Take the implicit input and lowercase it.
ε               | Map the following to this input to find the sharpness of each letter:
"anm vzw cso u" |   Push the string "anm vzw cso u", representing the sharpness of each
                |   letter. They are arranged in a way such the index of the character
                |   is retrivable via mathematical caluclation.
                |
sk              |   Swap this string, and the mapping item, and find the index of the
                |   item within the big string
                |
>4%             |   Increment the value, and then modulo 4 it in order to find the "raw"
                |   sharpness of the string. The result will be in the range [0, 3]
                |
"cosu"          |   Now comes the part where we determine if the sharpness needs to be
                |   negated or not. First, we push a string containing all letters that
                |   have negative sharpness
                |
yå              |   We now push the letter being mapped, and test to see if it is in the
                |   aforementioned string
                |
i(]             |   If it is in the string, negate the sharpness value. After that,
                |   close the if-statement and the loop
                |
O               | Summate the stack and implicitly output the total sharpness.
```
## [05AB1E](https://github.com/Adriandmen/05AB1E), 22 bytes
```
.•7ùZ9£nDн•#εXlSk>}O®β
```
[Try it online!](https://tio.run/##LU49SwNBEP0rYW2jrdgkjJPxHLI7c@zsXsKJhYKFKFoIQgrB36K9hWBhYRP74G/wj5y7hzDwPni8N/cPF5fXVwM/buZusj@buPkmDwe/zy@H35/90fb1bvHzVdTe7mN9azezJ92@7d6H6XDmUBfkpq5Rf1LAIGOVCMkKBFUpICpG5QrtMy4pHlNsajpFlkrwFLwnaWpCgP3YEIU7GKmG1nMgSUWsoKupLEvRVS0P0FcjcN@TBLAUoNqtUA4qmn2KEBijGmrLaOwZtVOPIIoqrMbjqyDQ0P9I8Q1ZswmZufM/ "05AB1E – Try It Online")
A port of the Jelly answer suggested by @Kevin.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 28 bytes
```
J"MNA CSOWZV U"sm-3%xJd7@#JQ
```
[Try it online!](https://tio.run/##K6gsyfj/30vJ189RwTnYPzwqTCFUqThX11i1wivF3EHZK/D/fyVn/zBPFyUA "Pyth – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 70 bytes
```
->s{'OAVNZMWCUS'.chars.zip(1226655440.digits).sum{s.count(_1)*(_2-3)}}
```
[Try it online!](https://tio.run/##TZBNT4NAEIbv/RV7A0zZtBS4oVnXFUlh1vCZQDjUmipNlaaUgwK/nbIGIslcnicz70zmUr/99AerV@@rRuIkhtRLaBRIeP@5u1T4tzjLa00zTcPQ9RV@Lz6Ka6Xgqv5q2mJ5bCu8L@vvq1wod/JR3Shd159RtkAokyh/YtISqXq@/GObu8@CNyMHJKJsLigJA8HayB7nIHg9MnAI2FBzl0Z0y/xH5tuDXU3Joe/AXNAX4roMbDE6pQNx3AH/l/vgxESo6WDKvVfX8RiEM5mQWKQYI0awBZ7AzHgkFQ1mvsjx7nR6QA0aPoXKFh2yIkeWhUrU9Tc "Ruby – Try It Online") (3 bytes longer because TIO doesn't suppoort ruby 2.7 `_1` syntax)
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~88~~ 87 bytes
Saved a byte thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)!!! 
```
char*t="O_S_CU__AVNZMW",*i;v;f(char*s){for(v=0;*s;v+=i?i-t-6>>1:0)i=index(t,*s++);v=v;}
```
[Try it online!](https://tio.run/##TVFta9swEP6eX3EYAnZss6RpOzbPGZqmZaKWFCw7ASchFNfZbFhaImPCQn57JskpDO64t@fuHunK8FdZXq/l7@fjqI0dsZM7nO92aMkLtnKCUR110d61ZeWd969Ht4vH0UhFnR/XX@uwDR9ns8nnsVfH9eGlOrltMFK@70Vd3EWX65/n@uB65wH0CyrVqvU2PjtYfCdOAM5cJD@MlSjHNoFRJo1lQnBjueCSaDF@keMnkn4j6dy2ZCnl1sM/UZIQPrcgjmjSD0o5XaLeF2yRUEZ4ZqIVWlpkzp@4WNktDBU2xWhREM6QzBgyhQGAs@AkZ4KLPMlSxChOhcRiQbGkCcViKRKMuMCCUyFpTx1xNCfv23RFYipyyYmUziUaQH1ooTq9VWVrviK8DyCc3vRO66TXsRWd0Pl7Kw9WHgOYfDRQ41j81Ay1/wvH9RZiODubE7nbnD5hrQ@GxH/x1HLQhwTXEGn0NaGBL6Dqv9Xr3rUn8j7cIjvVi8D3Gw/0FS13pVfcgOtm6@lp8HbUhb3rDHVtBsMXGKrNwQneMYEKNDUVx7dnN1vbdhlcrv8A "C (gcc) – Try It Online")
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + GNU utilities, ~~100~~ \$\cdots\$ ~~92~~ 91 bytes
```
sed 's/[AV]/+1/g
s/[NZ]/+2/g
s/[MW]/+3/g
s/[CU]/-1/g
s/S/-2/g
s/O/-3/g
s/[A-Z]//g'<<<0$1|bc
```
[Try it online!](https://tio.run/##LY9BS8NAEIXv@RVzKESRsFaPFmFcx7h0d6ZkswlEerBN0/aSQKt4UH97XBqHOXy8eW@Y2byfD2P32W8/jkMP3dU1fI/nXQvpWb1htVY3c7VPInMT@W5iV0e@n1iHtcomj1fZZBCV/U8xizG1TxeLxe1s/rPZjr9JN5zgazi1cOxByzNBLvYFPAZNoLH04EQYWNhTbGiCXlLxREUOviwM56Bf0VrinIDR2Jgp2FQYQdzKGkdcQo0VQeAlS83gsCFwpmmIHfrSIcOKKThhCbYs0BldiNeyMtoba7RUYjWyaGEj3sSDkDGny@KoeW0keCbvH6AdEoi12x4GyHqYXf5Ks0dIL3o3KUk79LvxDw "Bash – Try It Online")
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), 205 bytes
```
int u(String s){if(s.length()>0){int n=0;switch(s.charAt(0)){case'M':case'W':n++;case'N':case'Z':n++;case'A':case'V':n+=4;case'O':n--;case'S':n--;case'C':case'U':n--;}return n+u(s.substring(1));}return 0;}
```
[Try it online!](https://tio.run/##TY9fb4IwFMWf8VPc8CINk7BkTxJNOsacEcoi/klc9oCIisNqaNEshM/u2oKLCeGe/u7p6b2H@BL3TueUHjY/t3O5zrMEkjxmDII4o1B1OlpLGY@5KJdTtoGj6BkRLzK6@/qGuNgxpKyausRgADS9qgQDOQL/W3nKuGxXoLvhm6c/gT4K/XdZIzx3FXDxLJI1CEMiKwlJ5IlP6tXcnXjTV286Uldm0zFRyv3Avu@RkTCJ5zRNJ3jsN2FTMl7gRofBpz8OPDKTpyVeqMg5mZBwqV4K8MrToXbkJttTAe2KamroN8MjmR/9Mp4erVPJrbNw8JwaymOCDoOh@JnArFIxhGRc3bkJG5T3RIaqbGswK0/pju8NNLQFEAY6sB12zXiyF81kHxeYGzZCVRKztBt0@6ouu31qmo7SpGWrB4ZbtpBs8NLAUBx6vUZHD9ptzfOG1UXKy4ICNUsxASvXTA1sPIs97j3bqW/17Q8 "Java (OpenJDK 8) – Try It Online")
[Answer]
# T-SQL, 133 bytes
Added some line changes to make it readable
```
SELECT
SUM(iif('P'=type,nullif(substring(
translate(@,'AVNZMWCUSO','4455662210'),
number,1),substring(@,number,1))-3,0))
FROM spt_values
```
**[Try it online](https://data.stackexchange.com/stackoverflow/query/1246790/determine-the-sharpness-of-a-word)**
[Answer]
# [Add++](https://github.com/cairdcoinheringaahing/AddPlusPlus), 49 bytes
```
D,k,@,"MCNSAO_WUZ_V"$€=12Rz€¦*bM-1+4*7%3$_
L,€kBs
```
[Try it online!](https://tio.run/##bZHBSsNAEIbP9ilCqJeagklrCxbF6XaNS3dnyk42hVxKS29VKHhTvPgwnnwKH8UXiWkSITEuC7t8/zD/zr/b/f54zPNFcAjuAt8IZKDN2mWb1O9/v3/ehJF9Kc6vj8HODMOL8WB6Pupvejoo4GH@nOvr4PVx@7Tbb73wrdfr1/fo1he0kP7ZzBuOmzQmfV/SUZMyOCG7WEDCJY2a1BBhScMmRUKWxfa9jpQ5sZR2Lm1cipct58Qq/IeLB9BaYlz1a/kjKF3SP2@1qFKolHE7CLPSykhMutoa0srhqkkdLpHW2BUMZFX5pBW1UVkm0QAnBopoTmvmhdNmyQqlM4TkdGLBKGGJBa2UYKWVoJS0ACRBqIgVVxlGk7Y1QizrKX4tovacyEKRY5TMddHpK0b5Dw "Add++ – Try It Online")
An implementation of [xnor's formula](https://codegolf.stackexchange.com/a/205536/66833), go upvote that.
## How it works
The second line defines the main function which runs the helper function `k` over `€`ach character in the input, then sums the result.
`k` works as follows:
```
D,k,@,"MCNSAO_WUZ_V"$€=12Rz€¦*bM-1+4*7%3$_ ; Monadic function, takes a single character **s**
					   ;    and returns the sharpness of **s**
					   ; For example, **s** = 'C'		 		STACK = ['C']
      "MCNSAO_WUZ_V"			   ; Push this string 			 		STACK = ['C' 'MCNSAO_WUZ_V']
                    $€=			   ; Check each character for equality with **s**		STACK = [[0 1 0 0 0 0 0 0 0 0 0 0]]
		       12R		   ; Push [1 2 3 4 5 6 7 8 9 10 11 12]			STACK = [[0 1 0 0 0 0 0 0 0 0 0 0] [1 2 3 4 5 6 7 8 9 10 11 12]]
			  z		   ; Zip arrays						STACK = [[[0 1] [1 2] [0 3] [0 4] [0 5] [0 6] [0 7] [0 8] [0 9] [0 10] [0 11] [0 12]]]
			   €¦*		   ; Product of each					STACK = [[0 2 0 0 0 0 0 0 0 0 0 0]]
			      bM	   ; Maximum (call the result **r**)			STACK = [2]
				-1+4*7%3$_ ; Push 3 - ((**r** - 1) * 4 % 7)				STACK = [-1]
```
[Answer]
# [Perl 5](https://www.perl.org/) + `-pF`, 39 bytes
```
$\+=y/OSUBANMCBVZW/0-62-6/&&$_-3for@F}{
```
[Try it online!](https://tio.run/##K0gtyjH9/18lRtu2Ut8/ONTJ0c/X2SksKlzfQNfMSNdMX01NJV7XOC2/yMGttvr//wA/11Bffz//UJ@QIEdfT@cg/2Bn/wBP52BPH09n/zB/H2dHP39nfz9P/2DP4H/5BSWZ@XnF/3UL3AA "Perl 5 – Try It Online")
## Explanation
For each character in the input (stored in `@F` via `-F`) we add to `$\` (defaults to `''`, implicitly output as the last argument for calls to `print`, which is triggered as part of `-p`) the value of `$_-3`, if we have `tr`anslated (`y///` is a synonym for `tr///`) any char in `$_` (the current char taken from `for@F`) using `OSUBANM` to `0-6` and `CBVZW` to `2-6`.
[Answer]
# SimpleTemplate, 118 bytes
Yes, not short at all. :(  
My language has absolutely no way what-so-ever of creating an array with keys and values defined, so, everything has to be generated.
```
{@setA 1,1,2,2,3,3,-1,-1,-2,-3}{@setL"AVNZMWCUSO"}{@eachL}{@setA.[_]A.[__]}{@/}{@eachargv.0}{@incbyA.[_]R}{@/}{@echoR}
```
This simply outputs the sharpness of the word.
---
**Ungolfed**
The code above is just a mess! Here's a readable version:
```
{@set rates 1,1,2,2,3,3,-1,-1,-2,-3}
{@set letters "AVNZMWCUSO"}
{@each letters as letter key i}
    {@set rates.[letter] rates.[i]}
{@/}
{@set result 0}
{@each argv.0 as char}
    {@inc by rates.[char] result}
{@/}
{@echo result}
```
Should be fairly easy to understand.
The `{@inc by rates.[char] result}` will increment the `result` by `rates.[char]` (similar to `result += rates[char]` on other languages).
---
You can try this on <http://sandbox.onlinephpfunctions.com/code/54adfe0b61fe1a12f3be085d0e058123a7842627>  
There you have the golfed version, ungolfed and a function implementation (the `{@echo result}` is replaced with `{@return result}`).
]