[Question]
  [
Python is the fastest-growing major programming language today. It is the most wanted language for the third year in a row, meaning that developers who do not yet use it say they want to learn it.[[1]](https://insights.stackoverflow.com/survey/2019#key-results)
The reason for Python's popularity is its many versions.[citation needed] There are in fact 116 versions of Python, including two development versions.
Your task is to output/print a list of all the Python versions, in whatever order you like, and on whatever format you like. You may not use any built-in functions that have this information stored.
You are free to choose the output format, but each version must be identified on the standard way: `1.1`, `2.3.0`, `2.7.10` and so on.
The complete list2 of Python versions, comma-separated is shown below:
```
1.1, 1.2, 1.3, 1.4, 1.5, 1.5.1, 1.5.2, 1.6, 2.0, 2.0.1, 2.1, 2.1.1, 2.1.2, 2.1.3, 2.2, 2.2.1, 2.2.2, 2.2.3, 2.3, 2.3.1, 2.3.2, 2.3.3, 2.3.4, 2.3.5, 2.4, 2.4.1, 2.4.2, 2.4.3, 2.4.4, 2.5, 2.5.1, 2.5.2, 2.5.3, 2.5.4, 2.6, 2.6.1, 2.6.2, 2.6.3, 2.6.4, 2.6.5, 2.6.6, 2.6.7, 2.6.8, 2.6.9, 2.7, 2.7.1, 2.7.2, 2.7.3, 2.7.4, 2.7.5, 2.7.6, 2.7.7, 2.7.8, 2.7.9, 2.7.10, 2.7.11, 2.7.12, 2.7.13, 2.7.14, 2.7.15, 2.7.16, 3.0, 3.0.1, 3.1, 3.1.1, 3.1.2, 3.1.3, 3.1.4, 3.1.5, 3.2 , 3.2.1, 3.2.2, 3.2.3, 3.2.4, 3.2.5, 3.2.6, 3.3.0, 3.3.1, 3.3.2, 3.3.3, 3.3.4, 3.3.5, 3.3.6, 3.3.7, 3.4.0, 3.4.1, 3.4.2, 3.4.3, 3.4.4, 3.4.5, 3.4.6, 3.4.7, 3.4.8, 3.4.9, 3.4.10, 3.5.0, 3.5.1, 3.5.2, 3.5.3, 3.5.4, 3.5.5, 3.5.6, 3.5.7, 3.6.0, 3.6.1, 3.6.2, 3.6.3, 3.6.4, 3.6.5, 3.6.6, 3.6.7, 3.6.8, 3.7.0, 3.7.1, 3.7.2, 3.7.3
```
or by major versions:
```
1.1
1.2
1.3
1.4
1.5, 1.5.1, 1.5.2
1.6
2.0, 2.0.1
2.1, 2.1.1, 2.1.2, 2.1.3
2.2, 2.2.1, 2.2.2, 2.2.3
2.3, 2.3.1, 2.3.2, 2.3.3, 2.3.4, 2.3.5
2.4, 2.4.1, 2.4.2, 2.4.3, 2.4.4
2.5, 2.5.1, 2.5.2, 2.5.3, 2.5.4
2.6, 2.6.1, 2.6.2, 2.6.3, 2.6.4, 2.6.5, 2.6.6, 2.6.7, 2.6.8, 2.6.9
2.7, 2.7.1, 2.7.2, 2.7.3, 2.7.4, 2.7.5, 2.7.6, 2.7.7, 2.7.8, 2.7.9, 2.7.10, 2.7.11, 2.7.12, 2.7.13, 2.7.14, 2.7.15, 2.7.16
3.0, 3.0.1
3.1, 3.1.1, 3.1.2, 3.1.3, 3.1.4, 3.1.5
3.2, 3.2.1, 3.2.2, 3.2.3, 3.2.4, 3.2.5, 3.2.6
3.3.0, 3.3.1, 3.3.2, 3.3.3, 3.3.4, 3.3.5, 3.3.6, 3.3.7
3.4.0, 3.4.1, 3.4.2, 3.4.3, 3.4.4, 3.4.5, 3.4.6, 3.4.7, 3.4.8, 3.4.9, 3.4.10 
3.5.0, 3.5.1, 3.5.2, 3.5.3, 3.5.4, 3.5.5, 3.5.6, 3.5.7
3.6.0, 3.6.1, 3.6.2, 3.6.3, 3.6.4, 3.6.5, 3.6.6, 3.6.7, 3.6.8
3.7.0, 3.7.1, 3.7.2, 3.7.3
```
The challenge is a fixed output challenge, and very close to a [kolmogorov-challenge](/questions/tagged/kolmogorov-challenge "show questions tagged 'kolmogorov-challenge'"), except that the output format is optional.
2The list is taken from the official Python website, [here](https://www.python.org/download/releases/) and [here](https://www.python.org/doc/versions/). There are some versions that aren't included, such as `0.9.0` .. `0.9.9` and `1.5.1p1`. You must use the list above, even if you find versions that aren't included. I've decided to stick with the official lists, since otherwise someone would probably find a `2.1.0.1.2` version or something like that.
  
[Answer]
# JavaScript (ES6), ~~128 125~~ 124 bytes
*Saved 1 bytes thanks to @OlivierGrégoire*
Outputs each version on a separate line. Ordered from highest to lowest major version, and from lowest to highest revision.
```
f=(r=v=28)=>v?r<parseInt('0111131000244655ah002678b8940'[v],36)?(1+v/10).toFixed(1)+(r|v>22?'.'+r:'')+`
`+f(r+1):f(+!v--):''
```
[Try it online!](https://tio.run/##DchLDoIwFEDRubtw1PdSi235iMTCzMQ1GBMqtIohlBTSOHDvlTs6uR8d9NL5YV7Z5HoTo1XgVVCyRFWHxl9m7Rdzm1YgXGylgnMus6zIc/3eVJzKZ3nOOLmHxyEtsAFBw1FwTFZ3Hb6mB4EU/C/UUjYkIdRXhCBtdy214KnAygLdB8Zw@7Fz0@JGk4zuBRYQ4x8 "JavaScript (Node.js) – Try It Online")
### How?
The major and minor versions are held in the variable \$v \in [0..27]\$:
* major = \$\lfloor v/10+1\rfloor\$
* minor = \$v \bmod 10\$
The revision is held in the variable \$r\ge0\$. The maximum value of \$r\$ depends on \$v\$ and is stored in a lookup table encoded in Base-36. Any \$0\$ in this table means that this version was not released at all.
Besides, we use the test \$v>22\$ to know whether the revision should be included even when it's \$0\$ (starting with Python 3.3.0).
[Answer]
# Pyth, 52 bytes
```
.emj\.+W|d>k18,h/k8%k8dbxLG"abbbbdbaceegffkrcghilije
```
Try it online [here](https://pyth.herokuapp.com/?code=.emj%5C.%2BW%7Cd%3Ek18%2Ch%2Fk8%25k8dbxLG%22abbbbdbaceegffkrcghilije&debug=0).
Output is a nested list, with elements grouped by major and minor version. There is an empty list at the start of the output, and another one after `1.6`. Full output is as follows:
```
[[], ['1.1'], ['1.2'], ['1.3'], ['1.4'], ['1.5', '1.5.1', '1.5.2'], ['1.6'], [], ['2.0', '2.0.1'], ['2.1', '2.1.1', '2.1.2', '2.1.3'], ['2.2', '2.2.1', '2.2.2', '2.2.3'], ['2.3', '2.3.1', '2.3.2', '2.3.3', '2.3.4', '2.3.5'], ['2.4', '2.4.1', '2.4.2', '2.4.3', '2.4.4'], ['2.5', '2.5.1', '2.5.2', '2.5.3', '2.5.4'], ['2.6', '2.6.1', '2.6.2', '2.6.3', '2.6.4', '2.6.5', '2.6.6', '2.6.7', '2.6.8', '2.6.9'], ['2.7', '2.7.1', '2.7.2', '2.7.3', '2.7.4', '2.7.5', '2.7.6', '2.7.7', '2.7.8', '2.7.9', '2.7.10', '2.7.11', '2.7.12', '2.7.13', '2.7.14', '2.7.15', '2.7.16'], ['3.0', '3.0.1'], ['3.1', '3.1.1', '3.1.2', '3.1.3', '3.1.4', '3.1.5'], ['3.2', '3.2.1', '3.2.2', '3.2.3', '3.2.4', '3.2.5', '3.2.6'], ['3.3.0', '3.3.1', '3.3.2', '3.3.3', '3.3.4', '3.3.5', '3.3.6', '3.3.7'], ['3.4.0', '3.4.1', '3.4.2', '3.4.3', '3.4.4', '3.4.5', '3.4.6', '3.4.7', '3.4.8', '3.4.9', '3.4.10'], ['3.5.0', '3.5.1', '3.5.2', '3.5.3', '3.5.4', '3.5.5', '3.5.6', '3.5.7'], ['3.6.0', '3.6.1', '3.6.2', '3.6.3', '3.6.4', '3.6.5', '3.6.6', '3.6.7', '3.6.8'], ['3.7.0', '3.7.1', '3.7.2', '3.7.3']]
```
If this isn't acceptable, prepend `.n` to the code to have output as a flattened list, at a cost of 2 bytes.
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 109 bytes
```
for(int j,k=1;;k++)for(j=@" [SOH][SOH][SOH][SOH][ETX][SOH][NUL][NUL][NUL][STX][EOT][EOT][ACK][ENQ][ENQ]
[DC1][NUL][NUL][STX][ACK][BEL][BS][VT][BS][TAB][EOT]"[k];j-->0;)Print($"{k*.1+1:N1}"+(j<1&k<17?"":"."+j));
```
Contains many unprintables, whose codes are shown in the brackets. This is a full program. The null bytes are replaced by `\0`s in the TIO link, since my device can't copy and paste them.
Saved one byte thanks to @OlivierGregoire.
[Try it online! (Thanks to @OlivierGregoire for implanting the null bytes)](https://tio.run/##Sy7WTS7O/P8/Lb9IIzOvRCFLJ9vW0No6W1tbEySUZaukwAgEzIwMDAxMLCxsrKwxeYJAJhs7BzcHJ4tSdHasdZaurp2BtWZAEdAADRWl6mwtPUNtQys/w1olbY0sG0O1bBtDc3slJSslPSXtLE1N6///AQ "C# (Visual C# Interactive Compiler) – Try It Online")
# Explanation
Each character in the string represents how many minor versions in the major position. For example, the character at index 5(`ETX`) has an ASCII value of three, and corresponds to the major version `1.5.x` which has three minor versions. The program takes the ascii value of the current character and loops that many times, printing the minor versions before moving on to the next major version. 
For some versions, there are gaps to the next versions. To fix that, the string contains null bytes, so that the program loops zero times when it encounters those.
The unprintable string contains these character values:
```
1,1,1,1,3,1,0,0,0,2,4,4,6,5,5,10,17,0,0,2,6,7,8,11,8,9,4
```
[Answer]
# [Java (JDK)](http://jdk.java.net/), 134 bytes
```
v->{for(int a=0,b;;)for(b="0111131000244655:A002678;894".charAt(++a)-48;b-->0;)System.out.printf("%.1f%s ",a*.1+1,b<1&a<23?"":"."+b);}
```
[Try it online!](https://tio.run/##HU5BboMwELznFZalVLiAZSckpTFQRT33FKmXqoe1g1NTMAibSFXE26mTuezMzs5qGrhC2px/F9WCc@gDjEW3FULDJFujkPPgw7j25oy64EUnPxp7@fpGMF4ceZwi1IQndPKmpXqyypve0vfeuqmrx@IzRCuky@WaVjfdj5GxHkHJEikEuWtZYsYDtpwxtsmy/W53OAa2f8lF/pphqn5gPPoojoGkWS5kmlZMkNOf83VH@8nTIVTyOsJryvXaIZzAM@UxT2TBn6DYbN8wPmCKY0nEvIhHY01BqXrwkZ3altx382pe/gE "Java (JDK) – Try It Online")
The versions are printed from the highest to the lowest.
## Credits
* -1 byte thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen)
* -3 bytes thanks to [Embodiment of Ignorance](https://codegolf.stackexchange.com/users/84206/embodiment-of-ignorance)
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 105 bytes
```
11* 111131   244655TS  2678E894
L$`.
$&_$.`
T
10
E
11
S
17
.+_
*
Lv$`_+(.)(.)
$1.$2.$.%`
,16`(...)\.0
$1
```
[Try it online!](https://tio.run/##DYu7DoMwEAT7/QoXF8RLK44YAx9ARwclki9FijQpoii/79xqitFI@3l@X@@HlgLVNqjvriGEMcY0TefhluZlW9aIXYyQKgsNJ3TA5hcc0BnsMlrsP7Hc1WwciFJGCm@GXpPVJJuLg/dS/g "Retina – Try It Online") Loosely based on @Arnauld's solution. Explanation:
```
11* 111131   244655TS  2678E894
```
Insert the string consisting of 11 spaces followed by the given characters.
```
L$`.
$&_$.`
```
For each character, list it suffixed with a `_` and its column number.
```
T
10
E
11
S
17
```
Convert the three letters to numeric values.
```
.+_
*
```
Convert the numeric values to unary.
```
Lv$`_+(.)(.)
$1.$2.$.%`
```
For each value up to the given value, use that as the suffix for the version number, extracting the major and minor from the column number.
```
,16`(...)\.0
$1
```
Delete the zero suffix for the first 16 versions that have one.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 51 bytes
```
+⁵D;ⱮḶ}j€”.
“øṄƇịɱ⁽Ɱj>⁶7,Ẉ¢’b18Ė0ị$Ƈç/€ḣ3$€1¦€17R¤¦
```
[Try it online!](https://tio.run/##y0rNyan8/1/7UeNWF@tHG9c93LGtNutR05pHDXP1uB41zDm84@HOlmPtD3d3n9z4qHEvUEWW3aPGbeY6D3d1HFr0qGFmkqHFkWkGQHmVY@2Hl@sDtT7csdhYBUgbHloGIs2DDi05tOz/oUXeQF7kfwA "Jelly – Try It Online")
A niladic link that outputs a list of lists of `.`-separated integers, grouped by major version. On TIO, there’s some footer code to print these prettily. 
[Answer]
# [33](https://github.com/TheOnlyMrCat/33), 484 bytes
```
"1."es[lz1azpois4m]"1.5"pi"1.5."z1apoiapoi"1.6"pi"2.0"pip".1"pizcz"2.1"''pie"."e''es[lz1azpois3m]"2.2"''pie"."et''es[lz1azpois3m]"2.3"''pie"."et''es[lz1azpois5m]"2.4"''pie"."et''es[lz1azpois4m]"2.5"''pie"."et''es[lz1azpois4m]"2.6"''pie"."et''es[lz1azpois9m]"2.7"''pie"."et''es[lz1azpois16m]"3.0"pip".1"pi"3.1"''pie"."et''es[lz1azpois5m]"3.2"''pie"."et''es[lz1azpois6m]"3.3."''es[lzpoi1azs8m]"3.4."''es[lzpoi1azs11m]"3.5."''es[lzpoi1azs8m]"3.6."''es[lzpoi1azs9m]"3.7."''es[lzpoi1azs4m]
```
I wanted to give this a go in my brainf\*ck-style language.
It prints each python version required for the challenge, delimited by newlines.
Here's a small explanation.
```
[lz1azpois4m] | Imitates a for loop starting at 1
[  1az    4m] | For i in range 1 through 4
      p       | - Print the string declared previously (1.5., 3.4., etc.)
       o      | - Print the current value of i
        i     | - Print a newline
[lzpoi1azs8m] | Imitates a for loop starting at 0
[     1az 8m] | For i in range 0 through 7
   poi        | Print the version
```
]