Python 2, 84 83 74 67 bytes

lambda n:4*(n>99)+2-n%~9/9-0x55561aaaab/4**(n%100)%4+`n`.count('7')

Thanks to @xnor for golfing off 9 16 bytes!

Try it online!

Python 2, 79 bytes

lambda n:4*(n>99)+([-1]+10*[1]+[3,1]+7*[2]+8*([2]+9*[3]))[n%100]+`n`.count('7')

Straightforward, but longer.

Try it online!

Perl 5 -p, 53 bytes

$_=4*/.../+2*/[^0].$/+!/0$/+y/7//-/1[^1]$/-/12$/-/00/

Try it online!

How

-p commandline flag reads input into $_



$_=4*/.../     # Hundreds place has minimum of 4 sylables (__ HUN-DRED AND),

               # match fails on number <100, and would add 0 here

  +2*/[^0].$/  # Tens place has two syllables if not 0 (__-TY or __TEEN),

               # match fails on numbers <10, and would add 0

  +!/0$/       # Ones place has one syllable if not 0 (__)

               # -- Now adjust for special cases --

  +y/7//       # add a syllable for every 7 present

  -/1[^1]$/    # remove a syllable for 10-19, except 11

  -/12$/       # remove another syllable for 12

  -/00/        # remove the syllable for AND if it's an even hundred



-p commandline flag outputs contents of $_

JavaScript (ES6), 89 bytes

n=>(s='01111112111312222322',n>99&&+s[n/100|0]+3-!(n%=100))+~~(s[n]||+s[n/10|0]-~s[n%10])

Try it online!

Python 2, 112 108 bytes

f=lambda n:n>99and f(n/100)+3+f(n%100)-(n%100<1)or n>19and f(n/10)-~f(n%10)or int("01111112111312222322"[n])

Try it online!

_{-4 bytes, thanks to Shaggy}

JavaScript, 86 84 bytes

A tweaked port of TFeld's Python solution.

f=n=>n>99?f(n/100)+3+f(n%=100)-!n:n>19?f(n/10)-~f(n%10):+"01111112111312222322"[n|0]

Try it online

2 bytes saved thanks to Arnauld

Wolfram Language 101 115 Bytes

s=StringSplit;Length[Join@@(WordData[#,"Hyphenation"]&/@Join@@s/@

s[IntegerName@#,"-"])]+Boole[#>100&&#~Mod~100!=0]&

Explanation

(substituting StringSplit for s)

Length[Join@@(WordData[#,"Hyphenation"]&/@Join@@

StringSplit/@ StringSplit[IntegerName@#,"-"])]+Boole[#>100&&#~Mod~100!=0]&

IntegerName renders the number in American English (i.e. without "and" included in numbers greater than 100.) E.g. 777-> "seven hundred seventy-seven.

StringSplit[IntegerName@#,"-"] removes any hyphens in the rendering.

StringSplit/@ splits the rendering into words.

Join@@ leaves a simple list of words, without embedded list (in the case that a hyphen appeared).

WordData[#,"Hyphenation"] breaks up a single word into its syllables.

Join@@ leaves a simple list of syllables in all of the words.

Length counts the syllables

+Boole[#>100&&#~Mod~100!=0] adds 1 to the syllable count for those numbers greater than 100 (because of the additional "and" employed in the British English rendering), excluding integral multiples of 100.

Java 11, 105 102 bytes

n->(""+"".repeat(8)).charAt(n%100)+(n+"").split("7",9).length-(n>99?2:6)

Contains loads of unprintable characters.

-3 bytes thanks @OlivierGrégoire.

Try it online.

Explanation:

n->               // Method with integer as both parameter and return-type

  (""

                  //  Push string with ASCII-value digits 46666666666867777777

 +"".repeat(8))

                  //  Appended with 8 times a string with ASCII-value digits 7888888888

   .charAt(n%100) //  Take the (input modulo-100)'th character of this string (as integer)

  +(n+"").split("7",9).length

                  //  Count the amount of 7s in the input + 1

  -(n>99?         //  And if the input is larger than 99:

     2            //   Subtract 2 (-1 for the 7s+1 count; -5 to map the ASCII-digits to:

                  //               4 → -1; 6 → 1; 7 → 2; 8 → 3;

                  //               and +4 for the inputs above 99)

    :             //  Else:

     6)           //   Subtract 6 (-1 for the 7s+1 count and -5 to map the ASCII-digits to:

                  //               4 → -1; 6 → 1; 7 → 2; 8 → 3)

05AB1E, 34 31 bytes

т%U7¢I€Ā`Iт@3*X_(X20@X12Q(X11QO

Try it online or verify all [1,999] test cases.

Explanation:

With all checks mentioned it will result in 1 for truthy and 0 for falsey.

т%         # Take modulo-100 of the (implicit) input

           #  i.e. 710 → 10

  U        # Pop and store it in variable `X`

7¢         # Count the amount of 7s in the (implicit) input

           #  i.e. 710 → 1

I€Ā        # Trutify each digit in the input (0 if 0; 1 otherwise)

   `       # And push all of the mapped values to the stack

           #  i.e. 710 → [1,1,0]

Iт@        # Check if the input is larger than or equal to 100

           #  i.e. 710 → 1 (truthy)

   3*      # Multiply that result by 3 (for 'hund-red and')

           #  i.e. 1 → 3

X_         # Check if variable `X` is 0

           #  i.e. 10 → 0 (falsey)

  (        # And negate that (to remove 'and' when #00)

           #  i.e. 0 → 0

X20@       # Check if variable `X` is larger than or equal to 20 (for '-ty')

           #  i.e. 10 → 0 (falsey)

X12Q       # Check if variable `X` is exactly 12

           #  i.e. 10 → 0 (falsey)

    (      # And negate that (to remove 'teen')

           #  i.e. 0 → 0

X11Q       # Check if variable `X` is exactly 11 (for 'el-ev-en' minus 'one one')

           #  i.e. 10 → 0 (falsey)

O          # Sum everything on the stack (and output implicitly)

           #  i.e. [1,1,1,0,3,0,0,0,0] → 6

Charcoal, 39 31 bytes

Ｉ⁻⁺↨Ｅ謬Ｉι²№θ7Ｉ§⁺”)∨∧⌈a¡↶”×0⁸⁰Ｎ

Try it online! Link is to verbose version of code. Explanation:

Ｉ⁻⁺

Calculate adjustments to the number of syllables and output the result as a string.

↨Ｅ謬Ｉι²

Start by changing each non-zero digit to 1 and then decoding as base 2. This gives the correct answer for most inputs.

№θ7

Add 1 for each 7.

Ｉ§⁺”)∨∧⌈a¡↶”×0⁸⁰Ｎ

Take the literal string 10000000001021111111 and append 80 zeros, then cyclically index by the input, and subtract that digit.

Jelly, 28 25 23 bytes

9ḊŻ;2+⁵Żċ%ȷ2$ạDṠḄƊ+Dċ7Ɗ

Try it online!

How it works

9ḊŻ;2+⁵Żċ%ȷ2$ạDṠḄƊ+Dċ7Ɗ  Main link. Argument: n (integer in [1, ..., 999])



9                        Set the return value to 9.

 Ḋ                       Dequeue; yield [2, 3, 4, 5, 6, 7, 8, 9].

  Ż                      Zero; yield [0, 2, 3, 4, 5, 6, 7, 8, 9].

   ;2                    Concat 2, yield [0, 2, 3, 4, 5, 6, 7, 8, 9, 2].

     +⁵                  Add 10; yield [10, 12, 13, 14, 15, 16, 17, 18, 19, 12].

       Ż                 Zero; yield [0, 10, 12, 13, 14, 15, 16, 17, 18, 19, 12].

         %ȷ2$            Yield n % 1e2.

        ċ                Count the occurrences of the modulus in the array.

                 Ɗ       Combine the three links to the left into a monadic chain.

              D            Decimal; convert n to its array of digits in base 10.

               Ṡ             Take the sign of each decimal digit (0 or 1).

                Ḅ            Convert the array of signs from base 2 to integer.

             ạ           Compute the abs. difference of the results to both sides.

                      Ɗ  Combine the three links to the left into a monadic chain.

                   D       Decimal; convert n to its array of digits in base 10.

                    ċ7     Count the number of 7's.

PHP, 190 158 145 141 137 bytes

<?for($j=$p=0;$p<strlen($i=$argv[1]);)$j+=str_split($i)[$p++]>0;echo$j+substr_count($i,7)+3*($i>99)-!($i%=100)+($i>19)-($i==12)+($i==11);

Try it online!

A port of Kevin Cruijssen's solution (unfortunately it doesn't have the same brevity in PHP :) )

-32 45 thanks to Shaggy!

-3 thanks to Kevin Crujissen!

05AB1E, 24 bytes

Port of Dennis' jelly answer

8L>Ć¾šT+¾šsт%¢sSĀJCαs7¢+

Try it online!
or as a Test suite

Explanation

8L>                       # push range [2 ... 9]

   Ć                      # enclose, append head

    ¾š                    # prepend 0

      T+                  # add 10 to each

        ¾š                # prepend 0

          sт%¢            # count occurrences of input % 100 in this list

              sS          # push input split into a list of digits

                Ā         # truthify, check each if greater than 0

                 JC       # convert from base-2 to base-10

                   α      # absolute difference

                    s7¢+  # add the amount of 7's in the input

05AB1E, 26 bytes

€ĀJCI7¢•Ž¢Γ}Þ±6u•¾80׫Iè(O

Port of @Neil's Charcoal answer, so make sure to upvote him as well if you like this answer!

Try it online or verify all test cases.

Compressed integer •Ž¢Γ}Þ±6u• can alternatively be •8JA•b2TÌǝ for the same byte-count.

Explanation:

€Ā                   # Trutify every digit in the (implicit) input

                     # (0 remains 0; everything else becomes 1)

  J                  # Join it together to a single string

   C                 # Convert from binary to integer

I7¢                  # Count the amount of 7s in the input

•Ž¢Γ}Þ±6u•           # Push compressed integer 10000000001021111111

          ¾80׫      # Append 80 "0"s

               Iè    # Index the integer (with automatic wraparound) into it

                 (   # Negate the result

O                    # Sum all values on the stack (and output implicitly)

See this 05AB1E answer of mine (section How to compress large integers?) to understand why •Ž¢Γ}Þ±6u• is 10000000001021111111.