Atualmente, o Python é a principal linguagem de programação que mais cresce. É o idioma mais procurado pelo terceiro ano consecutivo, o que significa que os desenvolvedores que ainda não o utilizam dizem querer aprender. ^[1]

A razão para a popularidade do Python são suas muitas versões. ^{[citação necessário]} Na verdade, existem 116 versões do Python, incluindo duas versões de desenvolvimento.

Sua tarefa é produzir / imprimir uma lista de todas as versões do Python, na ordem que você desejar e no formato que você desejar. Você não pode usar nenhuma função interna que tenha essas informações armazenadas.

Você é livre para escolher o formato de saída, mas cada versão devem ser identificadas na medida padrão: 1.1, 2.3.0, 2.7.10e assim por diante.

A lista completa ² de versões do Python, separadas por vírgula, é mostrada abaixo:

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

ou pelas principais versões:

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

O desafio é um desafio de saída fixo e muito próximo de um desafio de kolmogorov , exceto que o formato de saída é opcional.

_{² A lista é retirada do site oficial do Python, aqui e aqui . Existem algumas versões que não estão incluídas, como 0.9.0.. 0.9.9e 1.5.1p1. Você deve usar a lista acima, mesmo se encontrar versões que não estão incluídas. Eu decidi ficar com as listas oficiais, pois caso contrário alguém provavelmente encontraria uma 2.1.0.1.2versão ou algo assim.}

JavaScript (ES6),  128 125  124 bytes

Guardado 1 bytes graças a @ OlivierGrégoire

Produz cada versão em uma linha separada. Ordenado da versão principal mais alta para a mais baixa e da revisão mais baixa para a mais alta.

f=(r=v=28)=>v?r<parseInt('0111131000244655ah002678b8940'[v],36)?(1+v/10).toFixed(1)+(r|v>22?'.'+r:'')+`
`+f(r+1):f(+!v--):''

Experimente online!

Quão?

As versões principal e secundária são mantidas na variável :$v \in [0..27]$

• maior = $\lfloor v/10+1\rfloor$
• $v \bmod 10$

A revisão é realizada na variável . O valor máximo de depende de é armazenado em uma tabela de pesquisa codificada na Base-36. Qualquer nesta tabela significa que esta versão não foi lançada.$r\ge0$$r$$v$$0$

Além disso, usamos o teste para saber se a revisão deve ser incluída mesmo quando é (iniciando no Python 3.3.0).$v>22$$0$

C # (compilador interativo do Visual C #) , 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));

Contém muitos não imprimíveis, cujos códigos são mostrados entre colchetes. Este é um programa completo. Os bytes nulos são substituídos por \0s no link TIO, pois meu dispositivo não pode copiá-los e colá-los.

Guardou um byte graças a @OlivierGregoire.

Experimente online! (Obrigado a @OlivierGregoire por implantar os bytes nulos)

Explicação

Cada caractere na sequência representa quantas versões secundárias na posição principal. Por exemplo, o caractere no índice 5 ( ETX) tem um valor ASCII de três e corresponde à versão principal 1.5.xque possui três versões secundárias. O programa pega o valor ascii do caractere atual e faz o loop várias vezes, imprimindo as versões secundárias antes de passar para a próxima versão principal.

Para algumas versões, existem lacunas nas próximas versões. Para corrigir isso, a cadeia contém bytes nulos, para que o programa faça um loop zero vezes quando os encontrar.

A sequência não imprimível contém estes valores de caracteres:

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

Pitão, 52 bytes

.emj\.+W|d>k18,h/k8%k8dbxLG"abbbbdbaceegffkrcghilije

Experimente online aqui .

Saída é uma lista aninhada, com elementos agrupados por versão principal e secundária. Há uma lista vazia no início da saída e outra depois 1.6. A saída total é a seguinte:

[[], ['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']]

Se isso não for aceitável, acrescente .nao código a saída como uma lista nivelada, a um custo de 2 bytes.

Java (JDK) , 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);}

Experimente online!

As versões são impressas da mais alta para a mais baixa.

Créditos

• -1 byte graças a Kevin Cruijssen
• -3 bytes graças à incorporação da ignorância

Retina , 105 bytes

11* 111131   244655TS  2678E894
L$`.
$&_$.`
T
10
E
11
S
17
.+_
*
Lv$`_+(.)(.)
$1.$2.$.%`
,16`(...)\.0
$1

Experimente online! Basicamente baseado na solução da @ Arnauld. Explicação:

11* 111131   244655TS  2678E894

Insira a sequência que consiste em 11 espaços seguidos pelos caracteres fornecidos.

L$`.
$&_$.`

Para cada caractere, liste o sufixo com a _e seu número da coluna.

T
10
E
11
S
17

Converta as três letras em valores numéricos.

.+_
*

Converta os valores numéricos em unário.

Lv$`_+(.)(.)
$1.$2.$.%`

Para cada valor até o valor especificado, use-o como sufixo para o número da versão, extraindo o maior e o menor do número da coluna.

,16`(...)\.0
$1

Exclua o sufixo zero para as 16 primeiras versões que possuem um.

Geléia , 51 bytes

+⁵D;ⱮḶ}j€”.
“øṄƇịɱ⁽Ɱj>⁶7,Ẉ¢’b18Ė0ị$Ƈç/€ḣ3$€1¦€17R¤¦

Experimente online!

Um link niládico que gera uma lista de listas de .números inteiros separados, agrupados por versão principal. No TIO, há algum código de rodapé para imprimi-las lindamente.

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]

Eu queria experimentar isso na minha linguagem cerebral.

Ele imprime cada versão python necessária para o desafio, delimitada por novas linhas.

Aqui está uma pequena explicação.

[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