[Question]
  [
Time for another Pyth practice. I present here 8 problem statements with a Pyth solution each. These solutions are written by a Pyth beginner. He is quite happy about these solutions, since they are a lot shorter than his Python answers. Your task however is to show him better. Create equivalent but shorter programs.
This is a challenge about the the tricks and optimizations that can be used when golfing in Pyth. Pyth golfers may recognize many of the tricks involved, that lead to shorter solutions. However some problems will require some unusual approaches that are rarely used. Some of the tricks I've actually never seen in the wild. But no solution requires any bugs or strange behavior, that was not intentional by the designer(s) of Pyth. All answers must be valid for the most recent Pyth commit ([2b1562b](https://github.com/isaacg1/pyth/commit/2b1562bbe275d2bec3bb4e9432b89771338f221a)) as of this question's posting. You can use the [Pyth interpreter](http://pyth.herokuapp.com) for testing. It is up-to-date right now and I don't expect any big changes in Pyth, that will invalidate optimal solutions or make shorter solutions possible. The online interpreter also features the new Character Reference. Since it is pretty new, you can (should) also use [the old docs](https://github.com/isaacg1/pyth/blob/5a30b8e87ac1c3f72845f5f10536ac370c2a7919/doc.txt), in case something is incorrect or missing. 
**Goal:** The reference solutions total 81 bytes. Your goal is to beat that by as much as possible. The submission that solves all 8 problems with the smallest total number of bytes wins. Tiebreaker is the submission date.
Of course only submissions are valid, which contain solutions for all 8 problems. You can use the reference implementation, if you can't improve the score of one (or more) particular problem. 
Your solutions must print the exact same output as the reference solutions. Except for an optional trailing newline. 
Since this is a Pyth practice, only programs written in the language Pyth are allowed. 
**Answering:** Please spoiler your entire answer, except for your total score. It is intended that you do not look at other people's answers before submitting your own. You can create spoilers by putting >! in front of every line, like:
```
>! Problem 1: V9m?>dNd0S9 (11 bytes)
>! Problem 2: VTN)VGN (7 bytes)
>! ...
```
I hope I haven't chosen too difficult or too trivial problems. Hoping for a lots of participators and for everyone to gain a few new insights into Pyth. **Happy golfing!**
### Problem 1:
Create the following 9x9 matrix and print it:
```
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 0, 3, 4, 5, 6, 7, 8, 9]
[0, 0, 0, 4, 5, 6, 7, 8, 9]
[0, 0, 0, 0, 5, 6, 7, 8, 9]
[0, 0, 0, 0, 0, 6, 7, 8, 9]
[0, 0, 0, 0, 0, 0, 7, 8, 9]
[0, 0, 0, 0, 0, 0, 0, 8, 9]
[0, 0, 0, 0, 0, 0, 0, 0, 9]
```
Reference solution ([Link](http://pyth.herokuapp.com/?code=V9m%3F%3EdNd0S9&debug=0)):
```
V9m?>dNd0S9 (11 bytes)
```
### Problem 2:
Print all digits and all letters on separate lines:
```
0
...
9
a
...
z
```
Reference solution ([Link](http://pyth.herokuapp.com/?code=VTN%29VGN&debug=0)):
```
VTN)VGN (7 bytes)
```
### Problem 3:
Find the lexicographically smallest palindrome, that is lexicographically bigger or equal than an input string containing lowercase letters and is of the same than the input string. 
```
a -> a
abc -> aca
adcb -> adda
```
Reference solution ([Link](http://pyth.herokuapp.com/?code=hf%26gTzqT_T%5EGlz&input=abc&test_suite=1&test_suite_input=a%0Aabc%0Aadcb&debug=0)):
```
hf&gTzqT_T^Glz (14 bytes)
```
### Problem 4:
Check, if a number is in the range [0, input number). This should also work for floats. 
```
4, 6 -> True
5.5, 6 -> True
6, 6 -> False
6, 6.1 -> True
```
Reference solution ([Link](http://pyth.herokuapp.com/?code=%26gQ0%3CQE&input=4%0A6&test_suite=1&test_suite_input=-0.1%0A3%0A4%0A6%0A5.5%0A6%0A6%0A6%0A7.1%0A6%0A6%0A6.1&debug=0&input_size=2)):
```
&gQ0<QE (7 bytes)
```
The reference format is `to be tested value<newline>end value`. You can choose a different input format however. Important is only, that you accomplish the problem statement and produce the correct results. 
### Problem 5:
Parse an input string of the format "\d+[a-zA-Z]+". Notice that the number really has to be a number, not a string containing digits. 
```
'123Test' -> [123, 'Test']
```
Reference solution ([Link](http://pyth.herokuapp.com/?code=A.ggk%5CAz%2CsGH&input=123Hallo&test_suite=1&test_suite_input=123Hallo%0A0a%0A101Test&debug=0)):
```
A.ggk\Az,sGH (12 bytes)
```
### Problem 6:
Compute the sum of numbers, that are separated by one or multiple commas. You can assume that there is at least one number in the string. 
```
11,2,,,3,5,,8 -> 29
```
Reference solution ([Link](http://pyth.herokuapp.com/?code=svM%3Az%22%2C%2B%223&input=11%2C2%2C%2C%2C3%2C5%2C%2C8&test_suite=1&test_suite_input=11%2C2%2C%2C%2C3%2C5%2C%2C8%0A5%2C1%2C2%0A4%2C%2C%2C%2C%2C%2C2&debug=0)):
```
svM:z",+"3 (10 bytes)
```
### Problem 7:
Read positive integers from the input until you get the number 0. Print the sum of all numbers. 
Reference solution ([Link](http://pyth.herokuapp.com/?code=WJE%3D%2BZJ%29Z&input=1%0A2%0A3%0A0%0A5&debug=0)):
```
WJE=+ZJ)Z (9 bytes)
```
### Problem 8:
Sum up all elements of a square matrix, except the ones of the main diagonal (left upper corner to right bottom corner).
Reference solution ([Link](http://pyth.herokuapp.com/?code=-ssQs.e%40bkQ&input=[[1%2C%202%2C%203]%2C%20[2%2C%203%2C%204]%2C%20[3%2C%204%2C%205]]&debug=0)):
```
-ssQs.e@bkQ (11 bytes)
```
  
[Answer]
# ~~59~~ ~~58~~ 56 bytes
Problem 1: 
> 
>  `j.tmLdS9Z` (9 bytes)
> 
> 
> 
Problem 2:
> 
>  `MTjG` (5 bytes) (The first character is a newline)
> 
> 
> 
Problem 3:
> 
>  `h.f_IZ1z` (8 bytes)
> 
> 
> 
Problem 4:
> 
>  `%IQE` (4 bytes)
> 
> 
> 
Problem 5:
> 
>  `,J.vz-zJ` (8 bytes)
> 
> 
> 
Problem 6:
> 
>  `srXz\,d7` (8 bytes)
> 
> 
> 
Problem 7:
> 
>  `u+GE0` (5 bytes)
> 
> 
> 
Problem 8:
> 
>  `ss.DR~hZQ` (9 bytes)
> 
> 
> 
[Answer]
# 66 bytes
> 
>  1. 10 bytes: `V9+mZN}hN9`  
> 
>  2. 6 bytes: `jUT)jG`  
> 
>  3. 8 bytes: `h.f_IZ1z`  
> 
>  4. (reference implementation) 7 bytes: `&gQ0<QE`  
> 
>  5. 11 bytes: `,sK-rzZG-zK`  
> 
>  6. 7 bytes: `ssMcz\,`  
> 
>  7. 8 bytes: `s<.Qx.QZ`  
> 
>  8. 9 bytes: `ss.eXbkZQ`
> 
> 
> 
[Answer]
## ~~68~~ ~~67~~ ~~66~~ 65 bytes
Task 1
> 
>  10 bytes: `V9m*d>dNS9`
> 
> 
> 
Task 2
> 
>  5 bytes: `\nMTjG`, where `\n` is a newline
> 
> 
> 
Task 3
> 
>  9 bytes: `h.fqZ_Z1z`
> 
> 
> 
Task 4
> 
>  5 bytes: `qQ%QE`
> 
> 
> 
Task 5
> 
>  Reference solution, 12 bytes: `A.ggk\Az,sGH`
> 
> 
> 
Task 6
> 
>  7 bytes: `ssMcz\,`
> 
> 
> 
Task 7
> 
>  8 bytes: `s<.Qx.Q0`
> 
> 
> 
Task 8
> 
>  9 bytes: `ss.DVQUlQ`
> 
> 
> 
[Answer]
# 54 bytes
Here are the intended solutions. Except for task 8 all solutions were found.
> 
>  1. j.tmLdS9Z (9 bytes) using map for left-map, transpose and fill with zeros  
> 
>  2. \nMTjG (5 bytes) use newlines for map  
> 
>  3. h.f\_IZ1z (8 bytes) generate the possible strings with .f  
> 
>  4. %IQE (4 bytes) found a usecase, where the invariant operator needs 2 parameters  
> 
>  5. ,J.vz-zJ (8 bytes) .v evaluates only the first statement of a string and ignores the rest  
> 
>  6. ssMcz\, (7 bytes) s"" = 0  
> 
>  7. u+GE0 (5 bytes) reduce until it reaches a know number  
> 
>  8. ss.DVQUQ (8 bytes) delete the diagonal using vectorization
> 
> 
> 
[Answer]
# ~~60 59~~ 57 bytes
> 
>  1. **[9 bytes](https://pyth.herokuapp.com/?code=j.tmRdS9Z&debug=0)**: `j.tmRdS9Z`
> 
> 
> 
---
> 
>  2. **[6 bytes](https://pyth.herokuapp.com/?code=jbUTjG&debug=0)**: `jbUTjG`
> 
> 
> 
---
> 
>  3. **[8 bytes](https://pyth.herokuapp.com/?code=h.f_IZ1z&input=adcb&debug=0)**: `h.f_IZ1z`
> 
> 
> 
---
> 
>  4. **[4 bytes](https://pyth.herokuapp.com/?code=%7DsEU&input=6%0A5.5&test_suite=1&test_suite_input=6%0A4%0A%0A6%0A5.5%0A%0A6%0A6%0A%0A6.1%0A6%0A&debug=0&input_size=3)**: `}sEU`
> 
> 
> 
---
> 
>  5. **[8 bytes](https://pyth.herokuapp.com/?code=%2CK.vz-zK&input=123Test&debug=0&input_size=3)**: `,K.vz-zK`
> 
> 
> 
---
> 
>  6. **[7 bytes](https://pyth.herokuapp.com/?code=ssMcz%5C%2C&input=11%2C2%2C%2C%2C3%2C5%2C%2C8&debug=0&input_size=3)**: `ssMcz\,`
> 
> 
> 
---
> 
>  7. **[8 bytes](https://pyth.herokuapp.com/?code=s%3CFxB.Q0&input=1%0A2%0A3%0A0%0A5&debug=0&input_size=3)**: `s<FxB.Q0`
> 
> 
> 
---
> 
>  8. **[~~11 10~~ 7 bytes](https://pyth.herokuapp.com/?code=ssm.DFdCUB&input=%5B%5B1%2C+2%2C+3%5D%2C+%5B2%2C+3%2C+4%5D%2C+%5B3%2C+4%2C+5%5D%5D&debug=0&input_size=3)**: `ss.DVQU`
>  Previous version: `ss.e+<bk>bh`
> 
> 
> 
Note that I developed this solutions **completely** independently of other answers, although I am quite late to the party.
]