Inspirada por esta pergunta no SO , sua tarefa é produzir um programa válido em (pelo menos) duas versões principais do idioma escolhido que produzem resultados diferentes.

Regras

• Qualquer idioma que tenha mais de uma versão principal pode ser usado.
  • Para os propósitos deste desafio, eu sugeriria que uma "versão principal" é onde o primeiro número no número da versão é alterado.
    • PHP 4 e PHP 5 são diferentes, PHP 5.3 e PHP 5.4 não.
  • No entanto, como eu não conheço o esquema de versão para todos os idiomas, se você puder argumentar bem o seu caso, tenho certeza de que a comunidade determinará se você foi justo ao determinar a "versão principal".
• O código deve ser compilado e executado com os mesmos sinalizadores e entrada sempre
  • Exceto para alterar a versão do idioma, se for pertinente
• Erros não contam como saída e as respostas que produzem erros são desqualificadas (em vez de a saída de erro ser apenas ignorada)
• O programa não deve receber outra entrada além da necessária para executá-lo.
• Para cada versão fornecida, a saída deve sempre ser a mesma
• A intenção é que a alteração seja consequência de uma alteração na especificação do idioma, em vez da especificação da VM ou dos metadados ambientais

Pontuação

• pontuação do tipo código-golfe para comprimento, portanto, +1para cada caractere / byte
• -1para cada diferença de caractere no comprimento da saída.
  • por exemplo, saídas da Versão 1 abcde(5 caracteres), saídas da Versão 2 123abc(6 caracteres) =-1

Outras regras

• As exceções padrão se aplicam - sem programas externos, solicitações da Web etc.
• Seu programa deve terminar (dentro de 2 segundos)
• Menor pontuação ganha.

Pontuação "Melhor"

Mantenha suas respostas originais, no interesse da justiça, marcarei o vencedor com base nas regras originais.

Como minha pontuação original é fundamentalmente quebrada, por que não marcar novamente / tentar novamente com o seguinte sistema de pontuação:

• pontuação do tipo código-golfe para comprimento, portanto, +1para cada caractere / byte
• +1para cada diferença de caractere no comprimento da saída
  • abcdee 123456->+1
• -1para cada diferença de caractere exclusivo na saída (limitado ao comprimento da saída mais curta)
  • abcdee 123456->-5
  • 12345e 123456->-1
  • 12345e 123455->0
• Pontuações mais próximas de zero vitória
• No caso de um segundo desempate, a pontuação simples do código-golfe vence.

Resposta revisada para um sistema de pontuação "melhor"

C89 / C99, Pontuação: 0

Meu programa tem 52 caracteres e usa o mesmo mecanismo da resposta original para obter resultados diferentes. Isso funciona porque o C89 não trata //como um comentário:

i=32;main(){putchar(i+++0//**/
+52)&&i<84&&main();}

Os resultados:

$ ./diff2c89
 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRS
$ ./diff2c99
TUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~⌂Çüéâäàåç
$ ./diff2c99 | wc
      0       1      52
$ ./diff2c89 | wc
      0       1      52
$ wc diff2.c
      1       2      52 diff2.c

Resposta antiga:

C89 / C99, Pontuação: -Infinito?

Não tenho certeza se este programa não quebra as regras, mas não importa. Este programa explora o fato de que em C89 //não é um comentário válido, mas /* ... */é.

Usando o truque de comentário, outra função é executada. No C89, a função é impressa apenas "trolololol..."até a pilha estourar (para que ela termine em 2 segundos).

f1(){printf("ol");f1();}
f2(){printf("oll");}
main(){
    printf("tr");
    void (*f[])() = {f1,f2};
    f[0 //* trollololol */
      +1]();
}

C99

$ ./diffc99
troll

C89

$ ./diffc89
trolololololololololololololololololololololololololololololololololololololololololo
lolololololololololololololololololololololololololololololololololololololololololol
ololololololololololololololololololololololololol ....

Python - 10 pontos a menos que a próxima melhor resposta

print(range(100))

No Python 2, isso imprimirá a lista inteira de números inteiros de 0 a 99.

No Python 3, rangeé um gerador e, portanto, imprime apenas "intervalo (0,100)".

Como eu nunca encontrei um limite de tamanho para números em Python, posso substituir esses 100 por um número muito maior (2 ** 1000, por exemplo) e acabar com uma diferença praticamente infinita na saída.

Editado para refletir o fato de que, embora eu possa obter uma pontuação infinitamente baixa para qualquer finalidade prática, não consigo alcançar o infinito real com um programa que termina em menos de 2 segundos

Para o sistema de pontuação do desempate atualizado, eu enviaria:

print(range(4))

Saída:

Python 2: [0, 1, 2, 3]

Python 3: range(0, 4)

A primeira impressão possui 5 caracteres únicos ( [123]), a segunda impressão possui 8 caracteres únicos ( range(4)), a diferença no tamanho da saída é 1, o código possui 15 caracteres, a menor saída é de 11 caracteres ... essas regras são bastante confusas, mas Eu acho que isso me leva a uma pontuação final de 15 + 1 min (11,5 + 8) = 5.

Python - 0 pontos

Não faço ideia de como isso funciona: P Apenas tropeçou nele enquanto tentava código aleatório.

int

No Python 3, é <class 'int'>e no Python 2, é <type 'int'>(usando o console interativo)
Pontuação "Better": 3 (comprimento) + 1 (diferenciação de caracteres) - 4 (caracteres exclusivos)

Python mais antigo 1 - 7 pontos

print()

Muito obrigado ao @grc por esta versão e por me ajudar a subtrair quatro pontos!

No Python 2, essa declaração é interpretada como a print ()que imprime a tupla vazia ().
No Python 3, o printé uma função e resulta em nada sendo impresso.
Pontuação "Melhor": 7 (comprimento) + 2 (diferenças de caracteres) - 2 (caracteres únicos)

Python mais antigo 2 - 13 pontos:

print(1,2)

Pontuação "Melhor": 12 (comprimento) + 2 (diferenças de caracteres o / p) - 1 (caracteres únicos o / p)

Eu sei que isso não vai ganhar, mas ainda deu uma resposta, pois esta é minha primeira tentativa em Python :)

C #

Também alterei os algoritmos de inferência de tipo de método genérico entre C # 2, 3 e 4. Por exemplo:

using System;
class C
{
  static int M<T>(T x, T y) { return 1; }
  static int M(object x, object y) { return 2; }
  static void Main() 
  {
    Console.WriteLine(M(1, new int?()));
  }
}

No método C # 2, a inferência de tipo diz que T não pode ser ambos inte int?, portanto, produz 2. No método C # 3, a inferência de tipo diz "o melhor compromisso entre inte int?é int?" e, portanto, escolhe M<int?>e produz 1.

Ruby, 4 caracteres + 0 de diferença de comprimento de caractere - 3 diferença de caractere exclusivo = pontuação 1

p ?d

No Ruby 1.9, ele será impresso "d". No 1.8, ele imprime 100.

Explicação: ?destá "d"em 1.9 e 100(o código ASCII para d) em 1.8. p xé equivalente a puts x.inspect. *é repetição e multiplicação de cordas.

Versão "otimizada" para pontuação antiga:

Ruby, 8 caracteres - 999999989 diferença de caracteres = pontuação de -999999981

p ?!*1e9

Imprime 33000000000.0para 1,8 e "!!!!!!... !!!"para 1,9. ( ?!está 33em 1.8 e "!"em 1.9 e *é a repetição e multiplicação de cordas).

Realmente, você pode ir o quanto quiser com a multiplicação, isso depende apenas da velocidade do seu computador.

Bash - -∞ (até limites práticos)

Efetivamente, por mais memória que você tenha. Por exemplo, com cerca de 10 GB:

echo {0..999999999}

Bash 2: não suporta intervalos na expansão de chaves, portanto, imprime {0..999999999} .

Festança 3:

Qualquer idioma - -∞ (até limites práticos)

Você terá isso em praticamente qualquer idioma, mesmo que acabe sendo um pouco mais complexo. Assim que você pode criar dois valores diferentes, pode escrever um código que produz uma saída arbitrariamente diferente. Um método de pontuação melhor ignoraria as diferenças na saída.

version = … # some arbitrarily weird stuff
if version = 2:
    while not timed_out():
        print "version2"

C #

O código a seguir produziria a saída diferente para o C # 5.0 e versões anteriores do C #

using System;
using System.Collections.Generic;

namespace TestConsoleAppClosure
{
    class Program
    {
        static void Main(string[] args)
        {
            var actions = new List<Action>();
            List<int> list = new List<int> { 10, 20, 30, 40 };
            foreach (var item in list)
            {
                  actions.Add(() => Console.WriteLine(item));
            }
            foreach (var act in actions) act();
        }
    }
}

Saída: C # 5.0

10
20
30
40

Saída: C # 4.0

40
40
40
40

O motivo é explicado no blog por Eric Lippert

Fechando a variável de loop considerada prejudicial

Python, -14 pontos (diferença de comprimento de 3 a 17 caracteres = -14)

2/3

Saídas Python 2: 0

Saídas Python 3: 0.6666666666666666

Versão com melhor pontuação, 5 pontos (diferença de comprimento de 3 + 2 caracteres = 5)

3/2

Saídas Python 2: 1

Saídas Python 3: 1.5

C #

Eu adicionei covariância e contravariância ao C # 4, então os programas da forma:

using System;
using System.Collections.Generic;
class C
{
  static void Main() 
  {
    Console.WriteLine((new List<string>()) is IEnumerable<object>);
  }
}

Produziria falseem C # 2 e 3 etrue em C # 4.

No entanto, pode-se argumentar que isso não conta, porque a biblioteca que contém a definição de IEnumerable<T>também teve que mudar.

C ++ 98/11 - Pontuação "Melhor" (115 caracteres - 115 diferenças únicas de caracteres na saída = pontuação 0)

Uma versão ligeiramente editada para obedecer às novas regras de pontuação

Golfe:

#include<cstdio>
#define u8 "\x0B"
int main(){int i=116;char c[i];c[--i]=0;while(i-->0)c[i]=u8"\x7E"[0]+i;puts(c);}

Versão não destruída:

#include <cstdio>
#define u8 "\x0B"
int main() {
    int i = 116;
    char c[i];
    c[--i] = 0;

    while(i-- > 0)
        c[i] = u8"\x7E"[0] + i;

    puts(c);
}

A nova solução não difere muito da antiga. Na nova solução, a saída no C ++ 11 e no C ++ 98 tem 116 caracteres igualmente longos, mas o único caractere que eles têm em comum é o novo caractere de linha acrescentado pela função put.

Para C ++ 98 o u8em u8"\x7E"[0]ainda vai ser substituída, mas agora com "\x0B". Portanto, o valor resultante após o pré-processamento será "\x0B""\x7E"[0]. As duas seqüências serão concatenadas "\x0B\x7E"e o operador subscrito acessará o primeiro elemento; nesse caso, o caractere com o valor 11 na codificação de caracteres. Além disso, o valor de iserá adicionado, que inicialmente é 114. Portanto, o caractere com o valor 125 será gravado na matriz resultante. Como ivai para zero, todos os valores de 125 a 11 serão gravados na matriz e putsimprimirão todos os caracteres com os valores de 11 a 125, além da nova linha à direita.

Em C ++ 11 u8"\x7E"[0]será interpretada como uma string UTF-8 que consiste no caractere único com o valor hexadecimal 7E. O operador subscrito agora acessará esse caractere e o valor de iserá adicionado a ele, resultando no valor decimal 241 durante a primeira iteração. Enquanto ivai para zero, todos os valores abaixo de 126 serão gravados na matriz eputs imprimirão os caracteres com os valores de 126 a 241, além da nova linha à direita.

Dependendo do conjunto de caracteres usado, isso produzirá resultados diferentes, pois a maioria dos conjuntos de caracteres tem apenas os primeiros 128 caracteres em comum.

Para ISO-8859-2, a saída seria a seguinte:

C ++ 98:

C ++ 11:

C ++ (106 caracteres - 107 diferença na saída = pontuação -1) (REGRAS ANTIGAS)

Golfe:

#include<cstdio>
#define u8 "f"
int main(){int i=108;char c[i];c[--i]=0;while(i-->0)c[i]=u8""[0];puts(c);}

Versão não destruída:

#include <cstdio>
#define u8 "f"

int main() {
    int i = 108;
    char c[i];
    c[--i] = 0;

    while(i-- > 0)
            c[i] = u8""[0];

    puts(c);
}

Compilado com g++ -std=c++98 main.cppeg++ -std=c++11 main.cpp .

Na verdade você pode substituir 108 por qualquer número positivo no intervalo inteiro para obter pontuações negativas. Contanto que seja maior que 108;)

No C ++ 98 #define u8 "f", o pré-processador será substituído u8""[0]por "f"""[0]. Isso resultará em "f"[0], que finalmente se tornará o caractere único 'f', que é gravado em uma matriz.

puts(c) imprimirá a matriz resultante, consistindo em i-1 'f' .

Em C ++ 11 u8""[0] , a cadeia vazia será interpretada como uma cadeia UTF-8, portanto, nenhuma concatenação de cadeia é feita. Como esta é uma string C, o operador subscrito acessará o byte nulo final e o gravará em uma matriz.

No final puts(c), imprimirá a matriz resultante, que consiste apenas em bytes nulos. Mas, ao putsparar de ler a entrada assim que encontrar um byte nulo, ela imprimirá apenas uma nova linha e nada mais.

CSS2 vs CSS3 48 pontos

<i style='font-feature-settings:"smcp" on;'>abcdefghijklmnopqrstuvwxyz</i>

Renderizado como ABCDEFGHIJKLMNOPQRSTUVWXYZ (letras minúsculas) em navegadores CSS3

Renderizado como abcdefghijklmnopqrstuvwxyz em navegadores não CSS3

74 caracteres - 26 caracteres únicos diferença = 48

Perl, 24 caracteres - (9 * (10 ^ 9)) - 1 diferença de char = pontuação de - ((9 * (10 ^ 9)) - 1) +24

print$]>=5?"a":"a"x9e9;

Imprime 9e9 vezes apara todas as versões abaixo de 5, imprime apara todas as versões acima de 5. Você pode fazer a pontuação infinitamente baixa adicionando mais as à segunda saída.

Befunge, 36 - 378 = -342; 164 - 2576 = -2412

"v
"<v
" <v
"  <v
"   <v
 <v:,<
 ^_@

No Befunge 93, isso produziria 3 espaços, seguidos por <v, seguidos por 76 espaços, seguidos por <v76 espaços <v, depois 76 espaços, <vseguidos por 77 espaços e vseguidos por 78 espaços. Comprimento: 3 + 2 + 76 + 2 + 76 + 2 + 76 + 2 + 77 + 1 + 78 = 395é trivialmente extensível adicionando linhas extras semelhantes às 5 primeiras.

No Befunge 98, isso produziria <v <v <v <v v .

A diferença em comprimento: 395 - 17 = 378. Portanto, a pontuação teria sido (pelas regras antigas):-342

_{Nota: eu poderia ter obtido uma diferença ainda maior se usasse em .vez de ,; a diferença teria sido-684}

Alteração de regra:

Isso é um pouco mais complicado.

"  "-v>"Befunge 93 very long strings"v>"F"0g" "1-`!#v_   "F"0g1-"F"0pvz
     _^p0"F"-1g0"F"_v#    `-1" "g0"F"<^"j++a81zzzzzz]zzzzzzzzzzzzzzz"<
             _@#`0:,<

Saída Befunge 93:

sgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeBsgnirts gnol yrev 39 egnufeB

Saída Befunge 98:

j++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzzj++a81zzzzzz]zzzzzzzzzzzzzzz

Comprimentos: 2576. Nenhum dos personagens entre as seqüências é o mesmo, então se eu entendi o desafio corretamente, minha pontuação é 164 - 2576 = -2412(sim, eu deveria apontar para 0, mas isso era mais divertido). Se eu precisar fazer com que cada caractere de cada string seja único e diferente um do outro, posso fazê-lo, por favor, diga-me.

Powershell, pontuação "Melhor", -163 (diferença de 15 a 178 caracteres = -163)

$PSVersionTable

Powershell V2

Name                           Value                                                                   
----                           -----                                                                   
CLRVersion                     2.0.50727.5477                                                          
BuildVersion                   6.1.7601.17514                                                          
PSVersion                      2.0                                                                     
WSManStackVersion              2.0                                                                     
PSCompatibleVersions           {1.0, 2.0}                                                              
SerializationVersion           1.1.0.1                                                                 
PSRemotingProtocolVersion      2.1                                                                     

Powershell V3

Name                           Value                                                                   
----                           -----                                                                   
WSManStackVersion              3.0                                                                     
PSCompatibleVersions           {1.0, 2.0, 3.0}                                                         
SerializationVersion           1.1.0.1                                                                 
BuildVersion                   6.2.9200.16398                                                          
PSVersion                      3.0                                                                     
CLRVersion                     4.0.30319.1022                                                          
PSRemotingProtocolVersion      2.2 

PHP, Pontuação: 0 (melhor caso)

srand(2);echo rand();

Uau, isso vai ser divertido de explicar.

De acordo com este site , a srand()função parece estar quebrada do PHP 5.1.5 para o PHP 5.3.14 . Portanto, vamos considerar o PHP 4.4.9 e uma versão aleatória do PHP 5 que se enquadra no intervalo de versões especificado acima.

Saída do PHP 4.4.9: 1505335290

Eu não acho que isso seja uma quebra de regras; Como isso parece ser um bug, a saída deve ser a mesma, mas não é. Nossa outra versão do PHP simplesmente pula a srand()função e gera um número aleatório.

Java (cerca de -2.000.000.000)

As versões Java às vezes são chamadas de 1.x, mas acho que ainda está dentro das regras.

A maneira mais fácil é verificar se existe uma classe que foi introduzida em uma versão específica.

try {
    Class.forName("java.lang.AutoCloseable");
    // Java 7 or later
    char[] text = new char[Integer.MAX_VALUE];
    Arrays.fill(text, 'a');
    System.out.println(new String(text));
} catch (Exception e) {
    // Java 6 or earlier
    System.out.println("-");
}

(Depende um pouco do seu terminal se é possível gerar 2 bilhões de caracteres em dois segundos / Para a nova pontuação, substitua Integer.MAX_VALUE pela contagem de bytes do programa para obter uma pontuação zero perfeita.)

Esse código depende da versão da VM / JDK usada (isso conta?)

import java.lang.reflect.Field;
import java.util.Arrays;

{
    Field fValue = null;
    for (Field f: String.class.getDeclaredFields()) {
            if (f.getName().equals("value")) {
                    fValue = f;
            }
    }
    char[] text = new char[10];
    Arrays.fill(text, 'a');
    String s1 = new String(text);
    String s2 = s1.substring(1);
    fValue.setAccessible(true);
    text = (char[]) fValue.get(s2);
    Arrays.fill(text, 'z');
    System.out.println(s1);
}

Ele imprime zs para Java 6 e JDKs anteriores aes para versões recentes.

JavaScript (ES3 vs ES5) - 9 pontos

comprimento 10 + diferença de comprimento 0 - diferença de saída1

[].map?1:0

Saídas 1para navegadores modernos que suportam Array.prototype.map. Saídas0 em navegadores mais antigos. Eu testei isso com o IE8.

Com regras antigas: 0 pontos

comprimento 26 - diferença de comprimento26

Array([].map?27:0).join(0)

Saídas 00000000000000000000000000em navegadores modernos. E corda vazia na idade.

Python - 0

a='a=%r\ntry:print a%%a\nexcept:pass'
try:print a%a
except:pass

Python 2 imprime um quine, enquanto Python 3 imprime nada.

EDIT: Atualizado, corrigido.

APL (5 - (1988894 - 1) = -1988888)

Em APLs de estilo antigo (como Dyalog se ⎕ML=0*), ↑significa mistura , que, em um vetor unidimensional, não faz nada. Em APLs de estilo APL2, como GNU APL (ou Dyalog se ⎕ML=3), ↑significa primeiro , que pega o primeiro item de um vetor.

Assim, a seguinte 5bytes (o conjunto de caracteres APL faz ajuste em um byte),

↑⍳3e5

produzirá 1988894bytes (a lista de números separados por espaço de 1 a 3e5) em dialetos da APL à moda antiga,

e 1byte (apenas o primeiro número na referida lista, que é 1e, portanto, de comprimento 1), em dialetos APL2 no estilo APL2.

Notas:

• ⎕MLsignifica nível de migração . No Dyalog APL, quanto mais alto você definir ⎕ML, mais recursos no estilo APL2 serão ativados. O padrão é 0. (E é uma variável global! Divertido!)
• 3e5foi o valor mais alto de três caracteres que a Dyalog APL aceitaria ⍳. 4e5me deu um LIMIT ERROR. Essa restrição provavelmente depende do intérprete. (GNU APL não teve problemas com valores mais altos.)

Bash 7 (comprimento do programa de 14 bytes + 0 diferença no comprimento da saída - 7 diferenças em caracteres únicos na saída)

Relacionado à resposta do @Gilles, mas com um recurso de expansão diferente e versões diferentes. Pontuação de acordo com a pergunta editada:

echo {1..9..2}

Saída para o bash 3.x:

{1..9..2}

Saída para o bash 4.x:

1 3 5 7 9

PHP: −134217684 (43 - 134217727)

echo str_pad("",ip2long("")&0x7ffffff,"a");

Uso:

time php -r 'echo str_pad("",ip2long("")&0x7ffffff,"a");' > /tmp/test
1.61user 0.17system 0:01.79elapsed 99%CPU (0avgtext+0avgdata 142272maxresident)k
0inputs+0outputs (0major+35922minor)pagefaults 0swaps

No PHP5 +, isso não imprimirá nada, pois o ip2long com argumento inválido se transforma em false, que é convertido em zero. No PHP4, ele ip2long("")retorna -1 e preenchemos a string vazia com 128MB og a.

A máscara é ajustada para retornar muito antes dos 2 segundos na minha máquina. Se você não consegue fazer isso em 2s, compre um hardware melhor!

Com novas regras: 0 (40 - 40. Você não pode se aproximar de zero.)

echo str_pad("",40,chr(97+ip2long("")));

Saídas:

In PHP4: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 
In PHP5: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

Exploração de comentários C89 / C99, 45 caracteres, 0 pontuação

main(a){while(++a<47)putchar(79-a//**/~0
);}

saída c89

QRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|} - 45 caracteres.

saída c99

MLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"! - 45 caracteres.

C ++ 98 / C ++ 11

#include <iostream>

int main()
{
  for (long i = 0; i < __cplusplus; ++i)
     std::cout << "x";
}

Para um compilador C ++ 98 em conformidade padrão, isso gera 199711 vezes a letra 'x', enquanto que para um compilador C ++ 11 em conformidade padrão, gera 201103 vezes a letra 'x'. A diferença de comprimento da saída é, portanto, 1392 caracteres. Isso significa que, na verdade, jogar golfe no código fonte não vale a pena, pois um efeito muito maior pode ser alcançado apenas substituindo-o "x"por uma string mais longa ou multiplicando-o __cpluspluspor algum número.

SmileBASIC 3 / SmileBASIC 2, Pontuação: -5 (pontuação original)

?1E9

Nas versões modernas do SB, isso é impresso 1000000000conforme o esperado, mas na versão 2 e anterior, 10devido a um erro.

TI-Basic 83 Plus vs. 84 Plus, pontuação 5-1 = 4

length("setTime(

Saídas 2na TI-83 Plus, onde o mesmo programa é analisado como algo parecidolength("?►DMS porque osetTime( comando ainda não foi introduzido. Portanto, a string contém dois tokens de 1 byte, seu comprimento é 2.

Saídas 1na TI-84 Plus, porque uma cadeia que contém um único token de 2 bytes possui comprimento 1.

Vá 1.9-> 1.10. Pontuação = 1 - 1 = 0

Das notas 1.10 :

Não há mais um limite na configuração GOMAXPROCS. (No Go 1.9, o limite era 1024.)

package main 
import (r"runtime")
var g=r.GOMAXPROCS
func main() {g(10340)
print(g(0))}

1.8: 256

1.9: 1024

1.10: 10340