[Question]
  [
Your input is an array of integers in the range `[-1,4]`. An array element of `-1` means that there might be a bomb in that position. A non-negative element means that there is not a bomb in that position and also the numeric value tells how many bombs there are **within distance 2**.
For example, if we have the following array:
`[1,2,-1,-1,4,-1,-1,-1,1]` it's possible to infer that every `-1` except the last one contains a bomb.
Your task is to take indicate which `-1` **for sure doesn't** contain a bomb by outputting it's index (0 or 1 based). There is always at least one guranteed bombfree square (and thus the input length is at least two). You can use another number instead of `-1` to represent an unknown square. If there are multiple possibilities output at least one of them. Shortest code wins.
To reiterate, you **have to be certain** that the index you output **cannot contain a mine**. If you were clearing mines IRL, you probably would also like to know that you won't accidentally step on one.
# Test cases
```
[-1,0] -> 0
[0,1,-1,-1] -> 2
[-1,-1,-1,0] -> 1 or 2
[1,-1,-1,-1,2] -> 1
[-1,2,-1,-1,4,-1,-1] -> 0
[-1,-1,3,-1,-1,2,2,-1] -> 3
[2,-1,-1,-1,2,-1,-1,-1,2] -> 3 or 5
[-1,-1,1,-1,-1,-1,-1,1,0] -> 6
[-1,-1,1,-1,-1,2,-1,-1,2,-1,-1,2,-1,1] -> 0 or 1
```
  
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~55~~ ~~48~~ 47 bytes
```
≔⌕Ａθ±¹ηＦＥＸ²ＬηΦη﹪÷ιＸ²μ²Ｆ⬤θ∨‹κ⁰⁼κＬΦι›³↔⁻μλ≔⁻ηιηＩη
```
[Try it online!](https://tio.run/##TU/LbgIxDLz3K3x0JCOV5chpRUtViaXcEYeUTTdWTVKSLP38kIUU1fLBj/HM@Gh1OHotObcx8uBwza5vRfBMsDWDTgbnShFYtXz68gGw0z@4878mYEOwMW5IFu2EWLOkMrUEne9H8fju0gtfuDfIBI@T04RtVAm48VWtj4AbEyN@EzwXwOt51HLrqkRlL0xvweipXBC0n9HLWCx27MaIJwJRfwH1n/uquOL6xS6wS7jSMU2@lznv9w3N5jX/l4dDnl3kCg "Charcoal – Try It Online") Link is to verbose version of code. Outputs all possible bombfree positions. Explanation:
```
≔⌕Ａθ±¹η
```
Create a list of all the positions of `-1`s in the input.
```
ＦＥＸ²ＬηΦη﹪÷ιＸ²μ²
```
Create all possible mine layouts and loop over them.
```
Ｆ⬤θ∨‹κ⁰⁼κＬΦι›³↔⁻μλ
```
If for all non-negative values there are the correct number of mines within a distance of 2, then...
```
≔⁻ηιη
```
... remove the positions that might have a mine.
```
Ｉη
```
Output the positions that didn't have a mine.
[Answer]
# [Pari/GP](http://pari.math.u-bordeaux.fr/), 110 bytes
```
a->forvec(v=[[k=0,1]|i<-s=a],i=1;[t+1|t<-a,polcoef(Polrev(v)*Pol([1,1,5,1,1]),i++)!=t]||s+=v);[k|t<-s,t<0*k++]
```
[Try it online!](https://tio.run/##bY5BCsMgEEWvYrvSOIIGukrMGboXFxJikYRGjAiF3D3VpoXQFv4w7/EZGG@CYze/WSQ3wzo7hzT0OEmlRslB6NW1bJFGg5OiUZGKNbbMgJ@nfh4svs5TGBJOpMqElQABlzxCE3CUkpOMel0XKhNp1FhOF4gtr0ZK9Wa8nx7YINYhH9w9ZjwXOSOLDSGAlGICuM6QPwFWUoS9ea8@klMXrw/@Ve14OHgZ/63qf1toTbYn "Pari/GP – Try It Online")
1-indexed.
Ungolfed:
```
{ a ->                              /* Define a function with argument a: */
    s = a;                          /* Let s = a. */
    forvec(v = [[0, 1] | i <- a],   /* Let v loops over all binary vectors with length #a. */
        if(                         /* If */
            prod(i = 1, #a,         /* for all i in range 1..#a */
                a[i] == -1 ||       /* a[i] is -1 or */
                polcoef(            /* the coefficient of x^(i + 1) in */
                    Polrev(v)       /* the polynomial with coefficients v */
                    * Pol([1 ,1, 5, 1, 1]),     /* times (1 + x + 5*x^2 + x^3 + x^4) */
                    i + 1
                ) == a[i]           /* equals a[i] */
            ),
            s += v                  /* Then add v to s */
        )
    );
    [k | k <- [1..#a], s[k] == -1]  /* Find all k in range 1..#a such that s[k] is -1 */
}
```
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 102 bytes
```
Position[#+Total@Cases[{0,1}~Tuples~Tr[1^#],v_/;MatchQ[ListConvolve[{1,1,5,1,1},v,3,0],#/.-1->_]],-1]&
```
[Try it online!](https://tio.run/##bY3NCsIwEIRfJRDw4sZ2K57EUuhVoUJvIUqQSgNtI03spcRXj6k/ICrMsvMxO2wrbV210qqT9Gey8YU2yirdcTovtZVNlktTGT7GgO5WXi9NZW5lz/FABQzHaL2T9lTv@VYZm@tu0M1Q8REBYRUGHQywhFgAjRYMWXoUAhiKmS961VlOCUvJmVMhyIxEGRlHhhA7INO7cBg0AXv5Z/SGoGTi5IO/oqf9KDwo/o2Sfxud83c "Wolfram Language (Mathematica) – Try It Online")
A port of my [PARI/GP answer](https://codegolf.stackexchange.com/a/243314/9288). 1-indexed.
[Answer]
# JavaScript (ES6), 127 bytes
The output is 0-indexed.
```
a=>a.findIndex((v,i)=>!~v&[...Array(1<<a.length)].every((_,k)=>a.some((v,j)=>~v*(g=x=>x+3?g(x-1)-(!~a[x+=j]&k>>x|x==i):v)(2))))
```
[Try it online!](https://tio.run/##hZDRaoMwFIbv@xT2ppysJjUp20VpMna5ZxAZoUartWbEElIYvrpLVgalFT0cCOfi@/6TU0sru4Opvi@41bkaCj5ILiQpqjb/bHPlAGxcIS6WvV2lhJAPY@QV6H4vSaPa8nJEGVFWmSvAV3xCge30WQWs9lNvX6Dkjgu33r6X4DBFGJa9TN2a19nqJIT7cZxXaGcRMORrOOi2040ijS6hgBTTOMkQimZrs4mSxQOcxDTGoecMHmaL5@Rbz@V7mEbaPBv@Bb7ZpCMYHmF2B096PLwN8a/jH7hb4m9KRg1v0zAbe29XDXcP8XT4BQ "JavaScript (Node.js) – Try It Online")
---
# JavaScript (ES6), 118 bytes
Slightly shorter but stack-overflows on the last test case.
```
a=>a.findIndex((v,i)=>!~v&(h=k=>k>>a.length||a.some((v,j)=>~v*(g=x=>x+3?g(x-1)-(!~a[x+=j]&k>>x|x==i):v)(2))&h(-~k))())
```
[Try it online!](https://tio.run/##hY/LasMwEEX3@QpnY2Yay/GDZhEYdd1vCFmIWH5XKrYRWhj/uisnFEISYnE3QnPOHdXCiP7SVb8DUzqTc06zIC7CvFLZt8qkBTBBhcS3k/GhpIZ4w917K1UxlOMowl7/yGWodkOT@YCCLHG7S78KsCxGBttJnOyO6rPvSDtaogqPBiFB9EtgU4MIiPNFq163Mmx1ATmcWBxEZ0Rv9ez3XrR5gKMgDtiSNYODk81z8y1r/Q6OPd09G/4FLslbx2J4hJM7@K3HwelS//n6A3dLXG/RS8Nh/gM "JavaScript (Node.js) – Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 112 bytes
```
a=>eval("for(i=k=-1;j=4*--i;~a[k]|i>>k&!a.some(v=>((j&9)+(j/2&9))*9/8&7^v|(j/=2)&2&&~v)&&(i=2**a.length,k++))k")
```
[Try it online!](https://tio.run/##hZDfCoIwFIfvewrrYuyoU7f@E/NFomDULJ250NhV9Oq2FUGU6Dhw2OD7fmenEEY0hzq/3kilj7LNeCt4Ko0o8STTNc654oRuCj7zCck3D7FVu3uepgqNRdToi8SGpxgXaA0BLmJmO/jreIWWe3O3D5wBYgg9DCBkZcz3RVTK6nQ7hyoIANQE2oOuGl3KqNQnnOEtoWGyA/AGTxx7yegHTkIaEldDBguz0X/yu4byLUw9Xf8bPgJbrNfhDL8w@4J7PRaeuvh59we@hnjdkk7Doh9mXf29Vbd3F0/bJw "JavaScript (Node.js) – Try It Online")
```
// for each cell `k`
// for each possible mine placement `i`
// convert `i` to binary, the nth lsb  means nth cell is a mine
for(i=k=0;++i<2**a.length;)
  if(
    // Current cell is not unknown, or
    ~a[k]|
    // current mine placement have a mine on position `k`, and
    i>>k&
    // it is a valid mine placement
    !a.some(v=>
      // (mine count is incorrect or current is mine) and current is not -1
      ((j&9)+(j/2&9))*9/8&7^v|(j/=2)&2&&~v,j=i*4)
  // we try next `k`
  )i=0,k++;
```
[Answer]
# [Python](https://www.python.org) NumPy, 127 bytes
```
lambda L:where(L<-sum((T:=r_[:1<<(l:=len(L))]>>(a:=c_[:l])&1)*~any(((5//-~abs(a-a.T<<1)@T).T-L)*~L,1),1))[0]
from numpy import*
```
[Attempt This Online!](https://ato.pxeger.com/run?1=bVBBasMwEKRXXfsBkUOzCpJjOSQUY4c-wMfcXFOUxiYCWTa20-JL-oH-oJdAaf_UvqaS5UIIgUXLzuzsDPr4rvtuX-nTZxE_fh26gt3_vClRbncCJ-HrPm9ySCLWHkqATRg3T2nIowhUGKtcQ0JItl6DCONnQ6iM3HEyOwrdA8ByPmdHsW1BMOFtooiThw3xNiwxGwnlxBRJ_QwVTVVifSjrHsuyrppuNsZ4dyNu-xYVVYMVltoOXtvtpPaaXOyU1HkLJEQYY0krHGPltbWSHUwwW-MJGQgDm9z5i1AgSWahWUUNWIoaLEqrUTTFxmZKBlXdSN2BOUoLoyIu0-n35jZlnPqZPe-jlFMz2WcAFhYILGRqMXZmIccvUcquLvBxwbcBVij16cgMaDDIXDlnbveC0X70cARKg3PfC3phdcv_c2fqYXK3V5d0cK2f5eXIfc4f)
### Old [Python](https://www.python.org) NumPy, 134 bytes (@alephalpha)
```
def f(L):t=len(L);T=c_[:1<<t]>>r_[:t]&1;return where(L<-sum(T[~any((T@triu(tril(L**0,2),-2)+4*T-L)*(L+1),1)],0))[0]
from numpy import*
```
[Attempt This Online!](https://ato.pxeger.com/run?1=bU9LbsMgFNxziqcsGnAgMu5HVX7qAbz0DlmV1WAFCWML41bedNlVb9BNNu0pepHcpmA7UhRVQvBmhhmGr5-md4faHI_fnSvZ4-ljL0socUpWbqul8cM62748ixXfbFy-21k_uvyGr610nTXwdpBW4nTD2q7CmXgvTI9x9uSs6rDfNE6jKKYJoSwhi7soYymJcLrghHKS05gQEeeotHUFpquaHlTV1NZFU5vPEULbt6isLWhQJoBl6_bKLK0s9loZ2WKyQgCgaA1b0Mu20crhGbAdzMggeNo3l6-FxorkgYpq6smqaHBgaT2Z5uCfmZPB1VhlHPahtPQuMnY6nn4F4zTOQ3qMREw5ZWENRIIEm_B0hYdAT59Zv5JRQCK54K7l2-C7P8dduAc0Zj9cy8l_59gsDnkcjZ_4Aw)
### Old [Python](https://www.python.org) NumPy, 141 bytes
```
def f(L):m=L<0;t=sum(m);T=c_[:1<<t]>>r_[:t]&1;v=any((T@triu(tril(L**0,2),-2)[m]-L)*~m,1);return where(m)[0][~any(T[~v],0)]
from numpy import*
```
[Attempt This Online!](https://ato.pxeger.com/run?1=bU9BasMwELzrFUsOjWTkILu0lDgOfYCPuQlRTGMTgSUZWU7xJS9oX9BLLu0r-pH8ppLtQCgFIWlmNLOjz-92cAejz-ev3tXx0-VjX9VQ44KsVV5sWObyrldYkWyXv77wdbLZOLHdWn914i7JjnmpB4x3z87KHvutwUUUMZoSGqeEKxEXJDopmpDMVq63Gt4Ola18IGeCn4J5x09HQRkRqLZGge5VO4BUrbEumku9TxC6oUO1sdCA1AGsOreXemWrct9IXXWYrBEASGogh2bVtY10eAHxFhZkFDztq1fHssHSD_RUZKgnVdniwFIzm5bgxyzJ6Gqt1A77UFp7F5k6nS8_PE4oEyGdIc5oQuOwRiJFPJ7x_CQJgZ6-sn6lk4B4esP9le-D7-Ead-Me0ZT9-FdO_zunZizkJWj6xC8)
### Old [Python](https://www.python.org) NumPy, 149 bytes
```
def f(L):m=L<0;M=triu(tril(L**0),-2);t=sum(m);T=c_[:1<<t]>>r_[:t]&1;v=any((T@(M^M.T)[m]-L)*~m,1);return where(m)[0][~any(T[~v],0)]
from numpy import*
```
[Attempt This Online!](https://ato.pxeger.com/run?1=bU9BasMwELzrFUsOjWRkI7u0lDgOfYBz8024xTQ2EViykeUUX_KCXnvqJZf2Ff1IflPJdiCEwiJpZndmR18_7WD2jTqdvntT-U_nz11ZQYVTspJJumbxNjFa9NgeNU49jxHqRyQ2SddLLEmcJW-vfBWu1ybfbLR9mvwujA9JoQaMs2e8fdkGGeEy91PiHSUNSaxL02sF7_tSl9aCs5wf3XjGj4ecMpKjSjcSVC_bAYRsG228OdzHBKEbOlQ1GmoQyoGgMzuhAl0Wu1qossNkhQBA0AYSqIOurYXBC_A3sCBjw9I2bHkoaizsQkt5DbWkLFrsWNrMoiXYNUsyqlotlMHWlFZWRaZMp_Mv90PKcufOEGc0pL6rkYgQ92c8j4TO0NIX1lY0NRCPrrjb9r3TPVzsrtQjmrwfb9vRf_eUjDm_EE2f-AM)
Brute-force approach using matrix algebra. Takes a numpy array and returns the indices (0-based) of all safe squares.
Matrix `T` contains all patterns of bombs at -1 positions as columns. `triu(tril...` is essentially an adjacency matrix capturing the geometry of hint/bomb squares. By multiplying T with this matrix we get for each pattern in `T` the corresponding pattern of hints it would generate. A square is safe if each pattern of bombs where it is set creates a pattern of hints that is not the given one.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 38 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
®Qƶ0K<ÐUæʒXðrKǝ₂S.øü5ʒÅsd}εÅsy®¢Q}P}˜K
```
Outputs all possible results.
Inspired by [*@Neil*'s Charcoal answer](https://codegolf.stackexchange.com/a/243297/52210).
[Try it online](https://tio.run/##yy9OTMpM/f//0LrAY9sMvG0OTwg9vOzUpIjDG4q8j8991NQUrHd4x@E9pqcmHW4tTqk9txVIVR5ad2hRYG1A7ek53v//RxvqGOnoGoKQCZQGIsNYAA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfaVL2P9D6wKPbTPwtjk8IfTwslOTIg9viKj0Pj73UVNTsN7hHYf3mJ6adLi1OKX23FYgVXlo3aFFgbUBtafneP/X@R8dbahjpKNrCEImUBqIDGN1FKKBtAGINtCBCkMFIQgsZYjQYgSVRTMNoccYphCsBCRuhKQb0yCQMxCiYJ4BppQRNtowNhYA) or [try it online with added debug-lines](https://tio.run/##XVLBahRBEL3nK4q9qLC7JoKXEAlBiYQ9aBKFgATSO13jFOnpnnT3ZJmDl4Bng2e95OAxeEnw4GkHFBTyEf7IWt09YzbCHLq7qt579eYZJ6aEi8VgR1e1X4fB5pP59ebK4Dl6EErB/dXRVDiUD4C0pAwdmBxGazA15dSF9vnl7o/r1clGGntlqVKUCY9Afgz73lgEoxEyUzUMAafCkpgqhKODozEEFl8gVGaG1vGFwYU2/GTjRCBoz1@3X54l@G1Snku@IPdvZn0Ftsk6DxZLc4pcNA6ZR9UsNremjFpHvXxF3MrkAfrm6qCZvEvQsIeVEhlGPf2CQXG4UzBnFEeF7xh6wBn5AlwVRmUtXcLdab82Pz/30FtScq0sG1AoJOm3D70VpPgAlWDtQ15aBiINmcVgHi9ilaiq0HJSk/Z1pdB34H/OzvbH7bf2@@Oe4IVWDRwjVlHt0gDM2Mq0U0lSsu/snEaKDot@T9DG3q6QSH59bN87edgRPC0wO4ac21BkRbBakL4rDiiPPKI0tfbLMQmceFILBd4sSUk8N1fM08wv5xe7d8kYjvw9B97Wvmgidwjkf268TDNbecoFQh4jMkxno5SZRZu7sMR/6ECwJwrzmPf2Q5ctJbxHncIV2kLx96dU3OuzhWXKVIC/dSEmgzdeTtqQvSf2itFMbbnZ1SpiToaLxZtHw9Fa9y0fD/8C).
**Explanation:**
```
®Qƶ0K<        # Get a list of (0-based) indices of the -1s:
              # (05AB1E unfortunately lacks a builtin for this..)
®Q            #  Check for each value in the (implicit) input-list if its equal to -1
  ƶ           #  Multiply each (0 or 1) check by its 1-based index
   0K         #  Remove all 0s
     <        #  Decrease the 1-based indices to 0-based indices
Ð             # Triplicate this list of bomb-indices
 U            # Pop and store one of them in variable `X`
 æ            # Pop another one and get its powerset
  ʒ           # Filter this powerset by:
              #  (implicitly push the current powerset-list)
   X          #  Push list `X` with the bomb-indices
    ð         #  Push a space character
     r        #  Reverse so the stack-order goes to space, `X`, powerset-list
      K       #  Remove the values of the powerset-list from bomb-indices list `X`
       ǝ      #  Replace those bombs with spaces in the (implicit) input-list,
              #  to mark those bombs as duds
        ₂S.ø  #  Surround this list with leading/trailing [2,6]
              #  (any leading/trailing pair that isn't -1 would be fine here)
   ü5         #  Pop and push all overlapping quintuplets
     ʒ        #  Filter this list of quintuplets by, keeping those where:
      Ås      #   The middle item
        d     #   is a non-negative integer (so neither a -1 bomb nor " " dud)
     }ε       #  After the inner filter: map over the remaining quintuplets
       Ås     #   Check if the middle item
            Q #   is equal to
         y®¢  #   the amount of -1 bombs
      }P      #  After the map: check if all were truthy by taking the product
  }˜          # After the filter: flatten the list of powersets that were truthy
    K         # Remove those from the bomb-indices list we've triplicated at the start
              # (after which the result is output implicitly)
```
[Answer]
# Python3, 580 bytes:
```
def r(d,p,v):
 d,c=eval(str(d)),[]
 for i in p:
  if 0<=i and i<len(d)and d[i]<0:d[i]=v;c+=[1]
 return c and[d]
def f(d,c=0):
 def g(d,c,o,u):
  if o==1:
   for i in r(d,[c-1],u)+r(d,[c+1],u):yield from f([*i],c+1)
   return
  for i in r(d,[c-2,c-1],u)+r(d,[c+1,c+2],u):yield from f([*i],c+1)
 if len(d)==c:yield d;return
 if d[c]in[2,1,0]:yield from g(d,c,d[c],[-2,-3][d[c]==0])
 else:yield from f(d,c+1)
def F(d):
 v={}
 for i in f(d):
  if -3 in i:return i.index(-3)
  for j,k in enumerate(i):
   if k==-2:v[j]=v.get(j,0)+1
 return min(v,key=lambda x:v[x])if v else d.index(-1)
```
[Try it online!](https://tio.run/##fVHLboMwELzzFT7axY54XCoSX/MTlg8Um9QJGEQISlT12@kukDRJH5Ile2dnZ3bX7aV/b3z62nbjaGxJOmp4yweWBcTwQtohr@ixB5QxrnRAyqYjjjhPWmAQV5JoIx3JvSFuU1kPPHwb5fQmyvCSw7oIpYqhtrP9qfOkQLoyOkC/kqJNNPlBuMOQN/zEFvlGyhif38bYoSpErIEUzkE4BdnF2cqQsmtqkFUvTnPIMCyenYOfKgl/VoKa5F81aGoeVMpiIZn11QCSRhXaeZXwmEf6XmWeDdNcgbFItcJAykiDrK2O9tHTzIa4li3YwRYG@fF59wXljKKpSBFw2bJit3Le2DMVKVuG3vMDMqw/1bbLe0vdVIq1BylFkg1qD3@12tme7nnEwvj2X7XzdOAHe5FVXr@ZnJyBfNYMSoepbWKudjEb2875nm6pEjg/Y8ENiGAjAs8DKhbwiXxF4SQPieQu8Rdnxu4kpij6h5P8dmOj4xc)
[Answer]
# Python 3, ~~408~~404 bytes
```
e=enumerate
def v(m):
 for i,u in e(m):
  if u>-1 and m[max(0,i-2):i+3].count(-2)>u:return 0
 return 1
def p(m):
 for i,u in e(m):
  if u>0 and m[max(0,i-2):i+3].count(-2)<u:return 1
 return 0
def b(m):
 r=[]
 for i,u in e(m):
  if u==-1:t=m.copy();t[i]=-2;r+=b(t)if p(t)else[t]if v(t)else[]
 return r
def s(m):
 t=b(m)
 for i,u in e(m):
  if u==-1:
   n=1
   for u in t:
    if u[i]==-2:n=0
   if n:return i
```
[Try it online!](https://tio.run/##hZPBatwwEIbveophc6jF2sH2kh6cKlBKcy5tbo4IzlomgrXWyHJInn4rjSTbu9AtGGyN/vlm5pc8fJq3o9qdToIJNfVCN0aQVnTwnvS0ItAdNch0AqlA@AjIDqaHrIBGtdDXffOR5KnMSlrJ7Y7f7o@TMoldPkyVFmbSCnIC4atA9HAdnf@P/G0mFzM5R/Kr52hW83/yGcuKyrDe8obPhN6bWnKWlfd6y14TQ6Xrz1BxGEVtuHRGhBWfi2ksNnqoYa7q9XL2GxQr3MvJUGQwihrXgW2hUiwnPqTihPJkxGhe9s0oRmBQY05SZ0Wa8xTqnNM0hPK0SDP3uHi5xLMQ9glF6rbgBmwbZVBEQeY2nWZJLldbF6pdeockC7o7K7XC4Qrrfr1s6BJ79sYZ7ECc@k4LwgkZmtGb8KQnQbpGHibtTeHEmw/OKzyAeJWTxT3q/R60tLdo86ye1ZNTu70KNrCF0ehEUooq8TGIvRGtpTuCtQTDWuyFfMfwiGh3AGdY8zNkLszIohfK3wG2KCM@KGU3R3CoyPGDrFg4yA87CPxyHrWbMIS9tVe0j9bBWYuKaPBjYzPncHT6thkGoVrrESHuL0H1manfDwd/BP66DrGZpZEg/HPsxVrZylZ9MZiwWbsUS9PTXw "Python 3 – Try It Online")
Saved 4 bytes with suggestion from [Neil](https://codegolf.stackexchange.com/users/17602/neil)
]