[Question]
  [
The French [spell out numbers](https://codegolf.stackexchange.com/q/35435/31516) in a peculiar way. 
* **1-16** are "normal"
* **17-19** are spelled out **10+7. 10+8, 10+9**.
* **20-69** are "normal" (OK, OK! Not really, but they are in this challenge)
* **70-79** are **60+10, 60+11 ... 60+10+7, 60+10+8, 60+10+9**.
* **80-99** are **4\*20, 4\*20+1, 4\*20+2 ... 4\*20+16, 4\*20+10+7, 4\*20+10+8, 4\*20+10+9**
**Challenge:**
Take a positive integer in the range **[1,100]**, and output it the "French way". You must output it exactly as it's shown below, with `*` and `+`, so `97` is `4*20+10+7`, not `[4 20 10 7]` or something else.
Test cases:
```
1  - 1
.. - ..
16 - 16
17 - 10+7
18 - 10+8
19 - 10+9
20 - 20
21 - 21
.. - ..
69 - 69
70 - 60+10
71 - 60+11
72 - 60+12
77 - 60+10+7
78 - 60+10+8
79 - 60+10+9
80 - 4*20
81 - 4*20+1
82 - 4*20+2
.. - ..
90 - 4*20+10
91 - 4*20+11
96 - 4*20+16
97 - 4*20+10+7
98 - 4*20+10+8
99 - 4*20+10+9
100 - 100
```
  
[Answer]
## Excel, ~~153~~ 149 Bytes
```
=IF(OR(A1<17,A1>99,AND(A1>19,A1<70)),A1,IF(A1<20,"10+"&A1-10,IF(A1<80,"60","4*20")&IF(A1=80,,IF(MOD(A1,20)>16,"+10+"&MOD(A1,20)-10,"+"&MOD(A1,20)))))
```
I'm sure this could be better, I struggled to find an efficient way to account for #80.
edit: Consolidated the 'Normal' cases better to save 4 bytes. #80 still sucks.
Can't find a specific answer on here, not sure the rules of code-golf tbh. Can I use multiple cells in Excel, and add the byte count of each?
ie. For an input in cell A1
A2: 11 Bytes
```
=MOD(A1,20)
```
A3 (result): 125 Bytes
```
=IF(OR(A1<17,A1>99,AND(A1>19,A1<70)),A1,IF(A1<20,"10+"&A1-10,IF(A1<80,"60","4*20")&IF(A1=80,,IF(A2>16,"+10+"&A2-10,"+"&A2))))
```
For a total of 136?
[Answer]
# [Retina](https://github.com/m-ender/retina), ~~52~~ 48 bytes
*4 bytes saved thanks to Neil*
```
^7\B
60+1
^9\B
81
^8\B
4*20+
1(?=7|8|9)
10+
\+0
```
[Try it online!](https://tio.run/nexus/retina#@x9nHuPEZWagbcgVZwlkWQBpCyBtomVkoM1lqGFva15jUWOpyWUI5MZoG3D9/29qAAA "Retina – TIO Nexus") or [verify all inputs](https://tio.run/nexus/retina#4zI0MFDRUgSSXIpcKnoJh7ZxOSbEGXCpargn/I8zj3HiMjPQNuSKswSyLIC0BZA20TIy0OYy1LC3Na@xqLHU5DIEcmO0Dbj@/wcA) (provided by Neil)
**Explanation**
```
^7\B
60+1
^9\B
81
^8\B
4*20+
```
First we handle the translation of 70, 80, and 90. In these first 3 stages, a 7 at the start with another character following it is replaced by `60+1`. Similarly, `9` is replaced by `81`, and `8` by `4*20+1`. The replacement of `9` is essentially changing it to "eighty-ten" and such, so that the `8` is then handled by the next replacement, which saves bytes over writing `4*20+1` twice.
```
1(?=7|8|9)
10+
```
This handles the cases of `17`, `18`, and `19`, by replacing the `1` in each with `10+`.
```
\+0
```
Finally, there should never be a `+0` at the end, so delete it if it's there.
[Answer]
# [Python 2](https://docs.python.org/2/), 98 bytes
```
f=lambda x:[`x`*(x%100<70),'10+'+`x-10`][16<x<20]or['60+'+f(x-60),'4*20'+x/81*('+'+f(x-80))][x/80]
```
[Try it online!](https://tio.run/nexus/python2#LcpNCsIwEEDhtZ5iNpK/FmeKxFLiSUIgEY0UairBxdw@tuD2fa/l25Le90cCnnzkqCWfCNFdUXWC0AgTuSeMwZN17AYMa/XC7pAl93bfLnpAYfg8kpbiDyMqFfzWMLS8VmCYC9RUXk9JHSGp6Xj41Ll8YbtV@wE "Python 2 – TIO Nexus")
[Answer]
## JavaScript (ES6), ~~73~~ 71 bytes
```
f=n=>n>16&n<20?'10+'+n%10:n<70|n>99?n:n%20?f(n-n%20)+'+'+f(n%20):'4*20'
```
Bonus version that prints the numbers as they are actually spelled for an extra 2 bytes:
```
f=n=>n<17|n>99?n:n<20?'10+'+n%10:n%20?f(n-n%20)+'+'+f(n%20):n-80?n:'4*20'
```
[Answer]
# R, 110 bytes
```
i=scan()
r=i%%10;paste0(ifelse(i>16&i<20,"10+",ifelse(i>69&i<80,"60+10+",ifelse(i>16&i<20,"4*20+",i-r/10))),r)
```
[Answer]
# PHP, 99 bytes (I wanna be happy version)
a straight port of [ETHproductions´ JS](https://codegolf.stackexchange.com/a/117757/55735), 4 bytes golfed. Prints the numbers as asked for by the OP.
```
function f($n){return$n<17|$n>19?$n>60&$n<100?($m=$n%20)?f($n-$m)."+".f($m):'4*20':$n:"10+".$n%10;}
```
**breakdown**
```
function f($n){return
    $n<17|$n>19
        ?$n>69&$n<100
            ?($m=$n%20)
                ?f($n-$m)."+".f($m) # 70..79, 81..99
                :'4*20'             # 80
            :$n                     # 1..16, 20..69
        :"10+".$n%10                # 17..19
    ;
}
```
## I wanna be right version, ~~114~~ 98 bytes
new approach inspired by [ETHproductions](https://codegolf.stackexchange.com/a/117757/55735), prints the numbers as they are actually spelled out.
```
function f($n){return$n>16&$n<100?$n-80?($m=$n%($n>60?20:10))?f($n-$m)."+".f($m):$n-$m:'4*20':$n;}
```
[try it online](http://sandbox.onlinephpfunctions.com/code/e4e481bc0233ab113ed757eac563da136ca1a9d5).
**breakdown**
```
function f($n){return
    $n>16&$n<100
        ?$n-80
            ?($m=$n%($n>60?20:10))
                ?f($n-$m)."+".f($m) # $n%$m>0
                :$n-$m              # 10,20,30,40,50,60
            :'4*20'                 # 80
        :$n                         # 1..16, 100
;}
```
[Answer]
# Python 2, ~~130~~ 108 bytes
*22 bytes saved thanks to @mathjunkie*
```
f=lambda x:79<x<100and('4*20'+('+'+f(x-80))*(x>80))or 69<x<100and'60+'+f(x-60)or 16<x<20and'10+'+`x-10`or`x`
```
[Try it online!](https://tio.run/nexus/python2#RcpBCsIwEEDRvaeY3UwaCjNFopa2Z0mkRgKaSnAxt4@NCK7@4v0a50d4XtcAOp4uk07CHPJKeOwGRkto0UbS/szGdKRL61bA/Vd0/HscNxK30/AVaeK1F/Zb8epr3D1BylBCvt9IWMx4gFdJ@Q2Rkqkf)
[Answer]
## Batch, ~~220~~ 217 bytes
```
@set/pn=
@set s=
@if %n% gtr 99 goto g
@if %n% gtr 79 set s=+4*20&set/an-=80
@if %n% gtr 69 set s=+60&set/an-=60
@if %n% gtr 16 if %n% lss 20 set s=%s%+10&set/an-=10
:g
@if %n% gtr 0 set s=%s%+%n%
@echo %s:~1%
```
Takes input on STDIN. Generating and removing the leading `+` saves 1 byte over special-casing 80. Edit: Saved 3 bytes thanks to @ConorO'Brien.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 55 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
⁹
’,ṃ60Ṁ€
⁹%80“4*20”,
Dj⁾0+µ¹e?“×ØŒ‘
%ȷ2:“FP‘S‘ŀḟ0Ç€j”+
```
**[Try it online!](https://tio.run/nexus/jelly#@/@ocSfXo4aZOg93NpsZPNzZ8KhpDRdQTNXC4FHDHBMtIyA1V4fLJetR4z4D7UNbD@1MtQdKHJ5@eMbRSY8aZnCpnthuZAUUcQsA8oKB@GjDwx3zDQ63Aw3KAurV/v//v6UlAA)** or see a [test suite](https://tio.run/nexus/jelly#@/@ocSfXo4aZOg93NpsZPNzZ8KhpDRdQTNXC4FHDHBMtIyA1V4fLJetR4z4D7UNbD@1MtQdKHJ5@eMbRSY8aZnCpnthuZAUUcQsA8oKB@GjDwx3zDQ63Aw3KAurV/m9oYBAE5kb@BwA)
*No doubt there is a shorter way!*
### How?
```
+ - Link 1, helper for 1-69&100: number s=0, number n
⁹ - link's right argument, n
’,ṃ60Ṁ€ - Link 2, helper for 70-79: number s=1, number n
’       - decrement s -> 0
 ,      - pair -> [0,n]
  ṃ60   - base decompress (vectorises) using [1,2,...60]  effectively -> [60,[1,n%60]]
     Ṁ€ - maximum for €ach effectively -> [60,n%60]
⁹%80“4*20”, - Link 3, helper for 80-99: number s=2, number n
⁹           - link's right argument, n
 %80        - mod 80
    “4*20”  - literal ['4','*','2','0']
          , - pair -> [['4','*','2','0'],n]
Dj⁾0+µ¹e?“×ØŒ‘ - Link 4, reformat 17-19: element v (may be char list or number)
        ?      - if
       e       - v exists in
         “×ØŒ‘ - literal [17,18,19]
               - then:
D              -   convert to decimal list  e.g. [1,7]
  ⁾0+          -   literal ['0','+']
 j             -   join                          [1,'0','+',7]
     µ         - else:
      ¹        -   identity, v
%ȷ2:“FP‘S‘ŀḟ0Ç€j”+ - Main link: number n in [1,100]
 ȷ2                - literal 100
%                  - mod (convert 100 to 0)
    “FP‘           - literal [70,80]
   :               - integer division (vectorises)
        S          - sum (0 for 1-69&100; 1 for 70-79; 2 for 80-99)
         ‘         - increment (...1, 2 or 3)
          ŀ        - call link at index (1, 2 or 3) as a dyad(sum, n)
           ḟ0      - filter out zeros (remove 0 from 4*20+0)
             Ç€    - call the last link (4) as a monad for each
                ”+ - literal '+'
               j   - join
```
[Answer]
# Pyth, ~~61~~ 56 bytes
```
L?}b}17 19++T\+eb|bk?}/QTr6T.s+?<Q80"60+""4*20+"y%Q20\+y
```
[Test it online!](http://pyth.herokuapp.com/?code=L%3F%7Db%7D17+19%2B%2BT%5C%2Beb%7Cbk%3F%7D%2FQTr6T.s%2B%3F%3CQ80%2260%2B%22%224%2a20%2B%22y%25Q20%5C%2By&test_suite=1&test_suite_input=1%0A2%0A3%0A4%0A5%0A6%0A7%0A8%0A9%0A10%0A11%0A12%0A13%0A14%0A15%0A16%0A17%0A18%0A19%0A20%0A21%0A22%0A23%0A24%0A25%0A26%0A27%0A28%0A29%0A30%0A31%0A32%0A33%0A34%0A35%0A36%0A37%0A38%0A39%0A40%0A41%0A42%0A43%0A44%0A45%0A46%0A47%0A48%0A49%0A50%0A51%0A52%0A53%0A54%0A55%0A56%0A57%0A58%0A59%0A60%0A61%0A62%0A63%0A64%0A65%0A66%0A67%0A68%0A69%0A70%0A71%0A72%0A73%0A74%0A75%0A76%0A77%0A78%0A79%0A80%0A81%0A82%0A83%0A84%0A85%0A86%0A87%0A88%0A89%0A90%0A91%0A92%0A93%0A94%0A95%0A96%0A97%0A98%0A99%0A100&debug=0)
Thanks to Leaky Nun for a 5 byte improvement!
Explanation:
```
                     | Implicit: Q=eval(input())
L                    | Define y(b):
 ?}b}17 19           |  If b is in the inclusive range from 17 to 19:
          ++T\+eb    |   Return "10+" + (last digit of b)
                 |b  |  Else: if b!=0: return b
                   k |   Else: return an empty string (Leaves a trailing '+' for case 80)
_____________________|________________
?}/QTr6T                              | If 70<=Q<100:
          +                           |  Concatenate the next two expressions:
           ?<Q80                      |   If Q<80:
                "60+"                 |    Evaluate to "60+"
                     "4*20+"          |    Else: Evaluate to "4*20+"
                            y%Q20     |   y(Q%20)
        .s                       \+   |  Strip off trailing '+', if present (for case 80)
                                   y  | Else: return y(Q)
                                   (Q)| Trailing Q is implicitly added
```
[Answer]
## Python3, 127 bytes
```
m,r=map,range;l=[*r(1,17),*m("10+{}".format,(7,8,9))];f=[0,*l,*r(20,61),*m("60+{}".format,l),"4*20",*m("4*20+{}".format,l),100]
```
Each array element contains its representation:
```
for i in range(1,101):
    print(i, f[i])
```
The code does not actually create a function, just an array -- I don't know if that's allowed. Otherwise, I'd have to make this 139 bytes by adding `f=[...].__getitem__`.
[Answer]
# Java 7, ~~97~~ ~~96~~ 109 bytes
```
String c(int i){return i>16&i<20?"10+"+(i-10):i%100<70?i+"":i<80?"60+"+c(i-60):"4*20"+(i<81?"":"+"+c(i-80));}
```
+13 bytes for bug-fixing case `80`.. :(
**Explanation:**
```
String c(int i){      // Method with integer parameter and String return-type
  return i>16&i<20?   //  If 17..19:
    "10+"+(i-10)      //   Return "10+" + `i`-10
   :i%100<70?         //  Else if 1..16; 20..69; 100:
    i+""              //   Return `i`
   :i<80?             //  Else if 70..79:
    "60+"+c(i-60)     //   Return "60+" + recursive-call with `i`-60
   :                  //  Else (80..99):
    "4*20"+           //   Return "4*20" +
     (i<81?           //   If 80:
      ""              //    nothing
     :                //   Else (81..99)
      "+"+c(i-80));   //    recursive-call with `i`-80
}                     // End of method
```
**Test code:**
[Try it here.](https://tio.run/nexus/java-openjdk#LY7NCsJADITvPsWwoHRdlKxILbraJ/DkUTzU@kOgbqXdCiJ99ppaD2ECM8k3eZHVNfafEVCHLHCO7hAq9nfkEfsA1p/qGprKg3c2nrBbUKosGWUinlnSax5bIreilI1Sa3aJ@HHvy/0sloBaThfUx11iU4mov5eQ1pu2A57NuRDuH/8q@YJHxj4aehxPyHRfD7iVFYZS2MJuRJwokWzGaAwh4PCuw/UxL5swf8qHUPhIeAL7@e2on7b7Ag)
```
class M{
  static String c(int i){return i>16&i<20?"10+"+(i-10):i%100<70?i+"":i<80?"60+"+c(i-60):"4*20"+(i<81?"":"+"+c(i-80));}
  public static void main(String[] a){
    for (int i = 1; i <= 100; i++) {
      System.out.println(c(i));
    }
  }
}
```
]