Inspirado por esta pregunta sobre SO , su tarea es producir un programa que sea válido en (al menos) dos versiones principales de su idioma elegido que produzca resultados diferentes.

Reglas

• Se puede usar cualquier idioma que tenga más de una versión principal.
  • Para los propósitos de este desafío, sugeriría que una "versión principal" es donde cambia el primer número en el número de versión.
    • PHP 4 y PHP 5 son diferentes, PHP 5.3 y PHP 5.4 no lo son.
  • Sin embargo, dado que no conozco el esquema de versiones para todos los idiomas, si puede argumentar su caso lo suficientemente bien, estoy seguro de que la comunidad determinará si usted ha sido justo al determinar usted mismo la "versión principal".
• El código debe compilarse y ejecutarse con los mismos indicadores e ingresar cada vez
  • Excepto para cambiar la versión del idioma si esto es pertinente
• Los errores no cuentan como salida y las respuestas que producen errores se descalifican (en lugar de ignorar la salida de error)
• El programa no debe tomar otra entrada que la requerida para que se ejecute.
• Para cada versión dada, la salida siempre debe ser la misma
• La intención es que el cambio sea consecuencia de un cambio en la especificación del lenguaje en lugar de la especificación VM o metadatos ambientales.

Tanteo

• puntuación de tipo de código de golf para la longitud, +1por lo que para cada carácter / byte
• -1para cada diferencia de caracteres en la longitud de la salida.
  • p. ej., salidas de la versión 1 abcde(5 caracteres), salidas de la versión 2 123abc(6 caracteres) =-1

Otras reglas

• Se aplican excepciones estándar: no hay programas externos, solicitudes web, etc.
• Su programa debería finalizar (en 2 segundos)
• La puntuación más baja gana.

Puntuación "mejor"

Mantenga sus respuestas originales, en aras de la equidad, marcaré al ganador según las reglas originales.

Dado que mi puntuación original está fundamentalmente rota, ¿por qué no volver a puntuar / volver a intentar con el siguiente sistema de puntuación:

• puntuación de tipo de código de golf para la longitud, +1por lo que para cada carácter / byte
• +1para cada diferencia de caracteres en longitud de salida
  • abcdey 123456->+1
• -1para cada diferencia de caracteres única en la salida (limitada a la longitud de la salida más corta)
  • abcdey 123456->-5
  • 12345y 123456->-1
  • 12345y 123455->0
• Las puntuaciones más cercanas a cero ganan
• En el caso de un segundo desempate, gana el puntaje simple de código de golf .

Respuesta revisada para un "mejor" sistema de puntuación

C89 / C99, Puntuación: 0

Mi programa tiene 52 caracteres y usa el mismo mecanismo que en mi respuesta original para lograr una salida diferente. Esto funciona porque C89 no trata //como un comentario:

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

Los 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

Vieja respuesta:

C89 / C99, Puntuación: -Infinito?

No estoy completamente seguro de si este programa no rompe las reglas, pero no importa. Este programa explota el hecho de que en C89 //no es un comentario válido, pero lo /* ... */es.

Usando el truco de comentarios se ejecuta otra función. En C89, la función solo se imprime "trolololol..."hasta que la pila se desborda (por lo que puede terminar en 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 puntos menos que la siguiente mejor respuesta

print(range(100))

En Python 2, esto imprimirá la lista completa de enteros de 0 a 99.

En Python 3, rangees un generador, por lo que solo imprimirá "rango (0,100)".

Como nunca me he topado con un límite de tamaño en los números en Python, puedo reemplazar ese 100 con un número mucho mayor (2 ** 1000, por ejemplo) y terminar con una diferencia prácticamente infinita en la salida.

Editado para reflejar el hecho de que, si bien puedo obtener una puntuación infinitamente baja para cualquier propósito práctico, no puedo alcanzar el infinito real con un programa que finaliza en menos de 2 segundos

Para el sistema actualizado de puntuación de desempate, enviaría:

print(range(4))

Salida:

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

Python 3: range(0, 4)

La primera impresión tiene 5 caracteres únicos ( [123]), la segunda impresión tiene 8 caracteres únicos ( range(4)), la diferencia en la longitud de salida es 1, el código tiene 15 caracteres, la salida más corta es de 11 caracteres ... estas reglas son bastante confusas pero Creo que esto me lleva a una puntuación final de 15 + 1 minuto (11,5 + 8) = 5.

Python - 0 puntos

No tengo idea de cómo funciona: P Simplemente me topé con él mientras probaba un código aleatorio.

int

En Python 3, es <class 'int'>y en Python 2, es <type 'int'>(usando la consola interactiva)
"Mejor" Puntuación: 3 (longitud) + 1 (diferencia de caracteres) - 4 (caracteres únicos)

Python 1 - 7 puntos más antiguos

print()

¡ Muchas gracias a @grc por esta versión y por ayudarme a restar cuatro puntos!

En Python 2, esta declaración se interpreta como la print ()que imprime la tupla vacía ().
En Python 3, printes una función y no se imprime nada.
Puntuación "Mejor": 7 (longitud) + 2 (diferencia de caracteres) - 2 (caracteres únicos)

Python 2 más antiguo: 13 puntos:

print(1,2)

Puntuación "Mejor": 12 (longitud) + 2 (diferencia de caracteres o / p) - 1 (caracteres únicos o / p)

Sé que esto no va a ganar, pero aún así respondí, ya que este es mi primer intento con Python :)

DO#

También cambié los algoritmos de inferencia de tipo de método genérico entre C # 2, 3 y 4. Por ejemplo:

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?()));
  }
}

En el método C # 2, la inferencia de tipos dice que T no puede ser ambos inty int?, por lo tanto , produce 2. En el método C # 3, la inferencia de tipos dice "el mejor compromiso entre inty int?es int?", por lo que elige M<int?>y produce 1.

Rubí, 4 caracteres + 0 diferencia de longitud de caracteres - 3 diferencia de caracteres únicos = puntuación de 1

p ?d

En Ruby 1.9, se imprimirá "d". En 1.8, se imprime 100.

Explicación: ?destá "d"en 1.9 y 100(el código ASCII para d) en 1.8. p xes equivalente a puts x.inspect. *es a la vez repetición de cuerda y multiplicación.

Versión "optimizada" para puntuación antigua:

Ruby, 8 caracteres - 999999989 diferencia de caracteres = puntaje de -999999981

p ?!*1e9

Imprime 33000000000.0para 1.8 y "!!!!!!... !!!"para 1.9. ( ?!está 33en 1.8 y "!"en 1.9, y *es a la vez repetición y multiplicación de cuerdas).

Realmente, podrías ir tan lejos como quisieras con la multiplicación, solo depende de qué tan rápido sea tu computadora.

Bash - -∞ (hasta límites prácticos)

Efectivamente, por mucho que tenga memoria. Por ejemplo, con aproximadamente 10 GB:

echo {0..999999999}

Bash 2: no admite rangos en la expansión de llaves, por lo que imprime {0..999999999}.

Golpe 3:

Cualquier idioma - -∞ (hasta límites prácticos)

Lo tendrás en casi cualquier idioma, incluso si termina siendo un poco más complejo. Tan pronto como pueda hacer dos valores diferentes, puede escribir código que produzca resultados arbitrariamente diferentes. Un mejor método de puntuación ignoraría las diferencias en la salida.

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

DO#

El siguiente código produciría una salida diferente para C # 5.0 y versiones anteriores de 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();
        }
    }
}

Salida: C # 5.0

10
20
30
40

Salida: C # 4.0

40
40
40
40

La razón se explica en la publicación del blog de Eric Lippert

Cerrar sobre la variable de bucle considerado dañino

Python, -14 puntos (diferencia de longitud de 17-17 caracteres = -14)

2/3

Python 2 salidas: 0

Python 3 salidas: 0.6666666666666666

Versión de mejor puntuación, 5 puntos (diferencia de longitud de 3 + 2 caracteres = 5)

3/2

Python 2 salidas: 1

Python 3 salidas: 1.5

DO#

Agregué covarianza y contravarianza a C # 4, por lo que los programas de la forma:

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

Produciría falseen C # 2 y 3 y trueen C # 4.

Sin embargo, uno podría argumentar que esto no cuenta porque la biblioteca que contiene la definición de IEnumerable<T>también tuvo que cambiar.

C ++ 98/11 - Puntuación "mejor" (115 caracteres - 115 diferencias de caracteres únicos en la salida = puntaje de 0)

Una versión ligeramente editada para cumplir con las nuevas reglas de puntuación.

Golfizado:

#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);}

Versión sin golf:

#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);
}

La nueva solución no difiere mucho de la anterior. En la nueva solución, el resultado en C ++ 11 y C ++ 98 tiene 116 caracteres igualmente largos, pero el único carácter que tienen en común es el nuevo carácter de línea agregado por la función put.

Para C ++ 98 el u8en u8"\x7E"[0]todavía será reemplazado, pero ahora con "\x0B". Entonces el valor resultante después del preprocesamiento será "\x0B""\x7E"[0]. Las dos cadenas se concatenarán "\x0B\x7E"y el operador del subíndice accederá al primer elemento, en este caso, el carácter con el valor 11 en la codificación de caracteres. Además i, se agregará el valor de , que inicialmente es 114. Por lo tanto, el carácter con el valor 125 se escribirá en la matriz resultante. A medida que ipasa a cero, todos los valores de 125 a 11 se escribirán en la matriz e putsimprimirán todos los caracteres con los valores de 11 a 125, más la nueva línea final.

En C ++ 11 u8"\x7E"[0]se interpretará como una cadena UTF-8 que consta del carácter único con el valor hexadecimal 7E. El operador de subíndice ahora accederá a este carácter y ise le agregará el valor de , dando como resultado el valor decimal 241 durante la primera iteración. Mientras iva a cero, todos los valores hasta 126 se escribirán en la matriz e putsimprimirán los caracteres con los valores de 126 a 241, más la nueva línea final.

Dependiendo del conjunto de caracteres utilizado, esto producirá resultados diferentes, ya que la mayoría de los conjuntos de caracteres solo tienen los primeros 128 caracteres en común.

Para ISO-8859-2, la salida sería la siguiente:

C ++ 98:

C ++ 11:

C ++ (106 caracteres - 107 diferencia en salida = puntaje de -1) (ANTIGUAS REGLAS)

Golfizado:

#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);}

Versión sin golf:

#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 con g++ -std=c++98 main.cppy g++ -std=c++11 main.cpp.

En realidad, puede reemplazar 108con cualquier número positivo en el rango entero para lograr puntajes negativos. Mientras sea más grande que 108;)

En C ++ 98 #define u8 "f"hará que el preprocesador se reemplace u8""[0]con "f"""[0]. Esto dará como resultado "f"[0], que finalmente se convierte en el carácter único 'f', que se escribe en una matriz.

puts(c)imprimirá la matriz resultante, que consta de i-1 'f'.

En C ++ 11 u8""[0]hará que la cadena vacía se interprete como una cadena UTF-8, por lo que no se realiza la concatenación de cadenas. Como se trata de una cadena en C, el operador del subíndice accederá al byte nulo de terminación y lo escribirá en una matriz.

Al final puts(c)se imprimirá la matriz resultante, que consta solo de bytes nulos. Pero como putsdeja de leer la entrada tan pronto como encuentra un byte nulo, solo imprimirá una nueva línea y nada más.

CSS2 vs CSS3 48 puntos

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

Representado como ABCDEFGHIJKLMNOPQRSTUVWXYZ(minúsculas) en los navegadores CSS3

Representado como abcdefghijklmnopqrstuvwxyzen navegadores que no son CSS3

74 caracteres - 26 caracteres únicos diferencia = 48

Perl, 24 caracteres - (9 * (10 ^ 9)) - 1 diferencia de caracteres = puntaje de - ((9 * (10 ^ 9)) - 1) +24

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

Imprime 9e9 veces apara todas las versiones inferiores a 5, imprime apara todas las versiones superiores a 5. Puede hacer que la puntuación sea infinitamente baja simplemente agregando más as a la segunda salida.

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

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

En Befunge 93, esto generaría 3 espacios, seguidos por <v, seguidos por 76 espacios, seguidos por <v, luego 76 espacios, luego <v, 76 espacios, luego <vseguidos por 77 espacios, luego vseguidos por 78 espacios. Longitud: 3 + 2 + 76 + 2 + 76 + 2 + 76 + 2 + 77 + 1 + 78 = 395esto es trivialmente extensible al agregar líneas adicionales similares a las primeras 5 líneas.

En Befunge 98, esto daría salida <v <v <v <v v.

La diferencia de longitud: 395 - 17 = 378. Entonces el puntaje habría sido (según las viejas reglas):-342

_{Nota: Podría haber obtenido una diferencia aún mayor si lo usara en .lugar de ,; la diferencia hubiera sido-684}

Cambio de regla:

Esto es un poco más 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:,<

Salida 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

Salida 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

Longitudes: 2576. Ninguno de los caracteres entre las cadenas es el mismo, por lo que si entendí el desafío correctamente, mi puntaje es 164 - 2576 = -2412(sí, se suponía que debía apuntar 0, pero fue más divertido). Si necesito hacer que cada carácter de cada cadena sea único y diferente, puedo hacerlo, por favor dígame.

Powershell, puntuación "Mejor", -163 (15-178 char diff = -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, Puntuación: 0 (mejor caso)

srand(2);echo rand();

Wow, esto va a ser divertido de explicar.

Según este sitio web , la srand()función parece estar rota de PHP 5.1.5 a PHP 5.3.14 . Por lo tanto, vamos a tener en consideración PHP 4.4.9 y una versión aleatoria de PHP 5 que se encuentra en el intervalo de versión especificado anteriormente.

Salida de PHP 4.4.9: 1505335290

No creo que esto rompa las reglas; Como esto parece ser un error, la salida debería ser la misma, pero no lo es. Nuestra otra versión de PHP simplemente omitirá la srand()función y generará un número aleatorio.

Java (alrededor de -2.000.000.000)

Las versiones de Java a veces se llaman 1.x, pero creo que todavía está dentro de las reglas.

La manera fácil es verificar si existe una clase que se introdujo en una versión 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 un poco de su terminal si es posible generar 2 mil millones de caracteres en dos segundos / Para la nueva puntuación, reemplace Integer.MAX_VALUEcon el recuento de bytes del programa para lograr una puntuación cero perfecta).

Este código depende de la versión de VM / JDK que se use (¿eso cuenta?)

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);
}

Imprime zs para Java 6 y JDK anteriores ys apara versiones recientes.

JavaScript (ES3 vs ES5) - 9 puntos

longitud 10 + diferencia de longitud 0 - diferencia de salida1

[].map?1:0

Salidas 1para navegadores modernos que admiten Array.prototype.map. Salidas 0en navegadores antiguos. Probé esto con IE8.

Con viejas reglas: 0 puntos

longitud 26 - diferencia de longitud26

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

Salidas 00000000000000000000000000en navegadores modernos. Y cadena vacía en viejo.

Python - 0

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

Python 2 imprime una quine, mientras que Python 3 no imprime nada.

EDITAR: actualizado, arreglado.

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

En las APL de estilo antiguo (como Dyalog if ⎕ML=0*), ↑significa mezcla , que en un vector unidimensional no hace nada. En las APL de estilo APL2, como GNU APL, (o Dyalog if ⎕ML=3), ↑significa primero , que toma el primer elemento de un vector.

Por lo tanto, la siguiente 5bytes (el juego de caracteres APL hace en forma en un byte),

↑⍳3e5

generará 1988894bytes (la lista de números separados por espacios del 1 al 3e5) en dialectos APL de estilo antiguo,

y 1byte (solo el primer número en dicha lista, que es 1y, por lo tanto, de longitud 1), en dialectos APL de estilo APL2.

Notas:

• ⎕MLsignifica nivel de migración . En Dyalog APL, cuanto más alto establezca ⎕ML, más funciones de estilo APL2 estarán habilitadas. Por defecto es 0. (¡Y es una variable global! ¡Diversión!)
• 3e5fue el valor más alto de 3 caracteres con el que Dyalog APL aceptaría ⍳. 4e5me dio un LIMIT ERROR. Esta restricción probablemente depende del intérprete. (GNU APL no tuvo problemas con valores más altos).

Bash 7 (longitud del programa de 14 bytes + 0 diferencia en la longitud de salida - 7 diferencia en caracteres únicos en la salida)

Relacionado con la respuesta de @Gilles, pero con una función de expansión diferente y versiones diferentes. Puntuación según la pregunta editada:

echo {1..9..2}

Salida para bash 3.x:

{1..9..2}

Salida para 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

En PHP5 +, esto no imprimirá nada, ya que ip2long con argumento inválido se convierte en falso y se convierte en cero. En PHP4 ip2long("")devuelve -1 y rellenamos la cadena vacía con 128 MB og a.

La máscara está ajustada para que regrese mucho antes de los 2 segundos en mi máquina. ¡Si no puedes hacerlo en 2s, compra un mejor hardware!

Con nuevas reglas: 0 (40 - 40. No puede acercarse más a cero).

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

Salidas:

In PHP4: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 
In PHP5: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

Explotación de comentario C89 / C99, 45 caracteres, 0 puntaje

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

salida c89

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

salida c99

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

C ++ 98 / C ++ 11

#include <iostream>

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

Para un compilador estándar C ++ 98, esto genera 199711 veces la letra 'x', mientras que para un compilador estándar C ++ 11, genera 201103 veces la letra 'x'. La diferencia de longitud de la salida es, por lo tanto, de 1392 caracteres. Esto significa que en realidad jugar al golf con el código fuente no vale la pena, ya que se puede lograr un efecto mucho mayor simplemente reemplazándolo "x"por una cadena más larga o multiplicándolo __cpluspluscon algún número.

SmileBASIC 3 / SmileBASIC 2, Puntuación: -5 (puntuación original)

?1E9

En versiones modernas de SB, esto se imprime 1000000000como se esperaba, pero en la versión 2 y anteriores se imprimió 10debido a un error.

TI-Basic 83 Plus vs. 84 Plus, puntaje 5-1 = 4

length("setTime(

Salidas 2en la TI-83 Plus, donde el mismo programa se analiza como algo que parece length("?►DMSporque el setTime(comando aún no se había introducido. Entonces, la cadena contiene dos tokens de 1 byte, su longitud es 2.

Salidas 1en la TI-84 Plus, porque una cadena que contiene un solo token de 2 bytes tiene longitud 1.

Ir 1.9-> 1.10. Puntuación = 1 - 1 = 0

De 1.10 notas :

Ya no hay un límite en la configuración de GOMAXPROCS. (En Go 1.9 el límite 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