Inspiré par cette question sur SO , votre tâche consiste à produire un programme qui est valide dans (au moins) deux versions principales de votre langue choisie qui produisent une sortie différente.

Règles

• Toute langue ayant plusieurs versions principales peut être utilisée.
  • Aux fins de ce défi, je suggérerais qu'une "version majeure" soit l'endroit où le premier numéro du numéro de version change.
    • PHP 4 et PHP 5 sont différents, PHP 5.3 et PHP 5.4 ne le sont pas.
  • Cependant, comme je ne connais pas le schéma de versionnage pour toutes les langues, si vous pouvez défendre votre cas suffisamment bien, je suis sûr que la communauté déterminera si vous avez été juste dans la détermination de la "version majeure" vous-même.
• Le code doit être compilé et exécuté avec les mêmes indicateurs et entrées à chaque fois
  • Sauf pour changer la version de la langue si cela est pertinent
• Les erreurs ne comptent pas comme sortie et les réponses qui produisent des erreurs sont disqualifiées (plutôt que la sortie d'erreur est simplement ignorée)
• Le programme ne doit prendre aucune entrée autre que celle requise pour le faire fonctionner.
• Pour chaque version donnée, la sortie doit toujours être la même
• L'intention est que le changement soit une conséquence d'un changement de la spécification de langue plutôt que la spécification VM ou les métadonnées environnementales

Notation

• type de code-golf marquant la longueur, donc +1pour chaque caractère / octet
• -1pour chaque différence de caractère dans la longueur de la sortie.
  • ex. sorties version 1 abcde(5 caractères), sorties version 2 123abc(6 caractères) =-1

Autres règles

• Des exceptions standard s'appliquent - aucun programme externe, demande Web, etc.
• Votre programme devrait se terminer (dans les 2 secondes)
• Le score le plus bas l'emporte.

"Meilleur" score

Gardez vos réponses originales, dans un souci d'équité, je marquerai le gagnant en fonction des règles d'origine.

Étant donné que mon score d'origine est fondamentalement cassé, pourquoi ne pas re-marquer / réessayer avec le système de score suivant:

• type de code-golf marquant la longueur, donc +1pour chaque caractère / octet
• +1pour chaque caractère différence de longueur de sortie
  • abcdeet 123456->+1
• -1pour chaque différence de caractère unique dans la sortie (limitée à la longueur de la sortie la plus courte)
  • abcdeet 123456->-5
  • 12345et 123456->-1
  • 12345et 123455->0
• Scores les plus proches de zéro victoire
• En cas de deuxième bris d'égalité, un simple score de golf par code l' emporte.

Réponse révisée pour un «meilleur» système de notation

C89 / C99, Score: 0

Mon programme comporte 52 caractères et utilise le même mécanisme que dans ma réponse d'origine pour obtenir une sortie différente. Cela fonctionne car C89 ne traite pas //comme un commentaire:

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

Les resultats:

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

Ancienne réponse:

C89 / C99, Score: -Infini?

Je ne suis pas tout à fait sûr si ce programme n'enfreint pas les règles, mais tant pis. Ce programme exploite le fait qu'en C89 //n'est pas un commentaire valide mais l' /* ... */est.

En utilisant l'astuce de commentaire, une autre fonction est exécutée. En C89, la fonction s'imprime "trolololol..."jusqu'à ce que la pile déborde (elle peut donc se terminer dans les 2 secondes).

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 points de moins que la meilleure réponse suivante

print(range(100))

En Python 2, cela affichera la liste entière des entiers de 0 à 99.

En Python 3, rangeest un générateur et il n'imprimera donc que "range (0,100)".

Étant donné que je n'ai jamais rencontré de limite de taille sur les nombres en Python, je peux remplacer ce 100 par un nombre beaucoup plus grand (2 ** 1000, par exemple) et finir avec une différence pratiquement infinie dans la sortie.

Modifié pour refléter le fait que, même si je peux obtenir un score infiniment bas à des fins pratiques, je ne peux pas atteindre l'infini réel avec un programme qui se termine en moins de 2 secondes

Pour la mise à jour du système de notation des bris d'égalité, je soumets:

print(range(4))

Sortie:

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

Python 3: range(0, 4)

La première impression a 5 caractères uniques ( [123]), la deuxième impression a 8 caractères uniques ( range(4)), la différence de longueur de sortie est de 1, le code a 15 caractères, la sortie la plus courte est de 11 caractères ... ces règles sont assez déroutantes mais Je pense que cela m'amène à un score final de 15 + 1-min (11,5 + 8) = 5.

Python - 0 point

Je ne sais pas comment celui-ci fonctionne: P Je suis juste tombé dessus en essayant du code aléatoire.

int

Sur Python 3, c'est <class 'int'>et sur Python 2, c'est <type 'int'>(en utilisant la console interactive)
"Meilleur" Score: 3 (longueur) + 1 (diff. Char) - 4 (chars uniques)

Python plus ancien 1-7 points

print()

Un grand merci à @grc pour cette version et à m'aider à soustraire quatre points!

En Python 2, cette instruction est interprétée comme print ()qui imprime le tuple vide ().
En Python 3, la printest une fonction et n'entraîne aucune impression.
"Meilleur" score: 7 (longueur) + 2 (diff. De caractères) - 2 (caractères uniques)

Python plus ancien 2-13 points:

print(1,2)

"Meilleur" score: 12 (longueur) + 2 (caractère diff. O / p) - 1 (caractère unique o / p)

Je sais que cela ne va pas gagner mais j'ai quand même donné une réponse, car c'est mon premier essai Python :)

C #

J'ai également changé les algorithmes d'inférence de type de méthode générique entre C # 2, 3 et 4. Par exemple:

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

Dans la méthode C # 2, l'inférence de type dit que T ne peut pas être à la fois intet int?, et donc produit 2. Dans la méthode C # 3, l'inférence de type dit "le meilleur compromis entre intet int?est int?" et donc choisit M<int?>et produit 1.

Ruby, 4 caractères + 0 différence de longueur de caractère - 3 différence de caractère unique = score de 1

p ?d

Sur Ruby 1.9, il s'imprime "d". Le 1.8, il s'imprime 100.

Explication: ?dest "d"en 1.9 et 100(le code ASCII pour d) en 1.8. p xest équivalent à puts x.inspect. *est à la fois la répétition et la multiplication de chaînes.

Version "optimisée" pour les anciens scores:

Ruby, 8 caractères - 999999989 différence de caractères = score de -999999981

p ?!*1e9

Imprime 33000000000.0pour 1.8 et "!!!!!!... !!!"pour 1.9. ( ?!est 33en 1.8 et "!"en 1.9, et *est à la fois la répétition et la multiplication de chaînes.)

Vraiment, vous pouvez aller aussi loin que vous le souhaitez avec la multiplication, cela dépend simplement de la vitesse de votre ordinateur.

Bash - -∞ (jusqu'aux limites pratiques)

Effectivement, quelle que soit la mémoire dont vous disposez. Par exemple, avec environ 10 Go:

echo {0..999999999}

Bash 2: ne prend pas en charge les plages dans l'extension d'accolade, donc imprime {0..999999999}.

Bash 3:

N'importe quelle langue - -∞ (jusqu'à des limites pratiques)

Vous l'aurez dans presque toutes les langues, même si cela finit par être un peu plus complexe. Dès que vous pouvez créer deux valeurs différentes, vous pouvez écrire du code qui produit une sortie arbitrairement différente. Une meilleure méthode de notation ignorerait les différences de sortie.

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

C #

Le code suivant produirait la sortie différente pour C # 5.0 et les versions précédentes 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();
        }
    }
}

Sortie: C # 5.0

10
20
30
40

Sortie: C # 4.0

40
40
40
40

La raison est expliquée dans le billet de blog d'Eric Lippert

La fermeture de la variable de boucle est considérée comme nuisible

Python, -14 points (différence de longueur de 3 à 17 caractères = -14)

2/3

Sorties Python 2: 0

Sorties Python 3: 0.6666666666666666

Meilleure version de notation, 5 points (différence de longueur de 3 + 2 caractères = 5)

3/2

Sorties Python 2: 1

Sorties Python 3: 1.5

C #

J'ai ajouté la covariance et la contravariance à C # 4, donc les programmes de la forme:

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

Produirait falseen C # 2 et 3 et trueen C # 4.

Cependant, on pourrait affirmer que cela ne compte pas car la bibliothèque contenant la définition de IEnumerable<T>devait également changer.

C ++ 98/11 - Score "meilleur" (115 caractères - 115 différences de caractères uniques dans la sortie = score de 0)

Une version légèrement modifiée pour se conformer aux nouvelles règles de notation

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

Version non golfée:

#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 nouvelle solution ne diffère pas beaucoup de l'ancienne. Dans la nouvelle solution, la sortie en C ++ 11 et C ++ 98 est de 116 caractères également longs, mais le seul caractère qu'ils ont en commun est le nouveau caractère de ligne ajouté par la fonction put.

C ++ 98 le u8en u8"\x7E"[0]sera toujours remplacé, mais maintenant avec "\x0B". Ainsi, la valeur résultante après prétraitement sera "\x0B""\x7E"[0]. Les deux chaînes seront concaténées "\x0B\x7E"et l'opérateur d'indice accèdera au premier élément, dans ce cas le caractère avec la valeur 11 dans le codage de caractères. De plus, la valeur de isera ajoutée, qui est initialement 114. Le caractère avec la valeur 125 sera donc écrit dans le tableau résultant. Comme ià zéro, toutes les valeurs de 125 à 11 seront écrites dans le tableau et putsimprimeront tous les caractères avec les valeurs de 11 à 125, plus la nouvelle ligne de fin.

En C ++ 11 u8"\x7E"[0]sera interprété comme une chaîne UTF-8 composée du caractère unique avec la valeur hexadécimale 7E. L'opérateur en indice accède maintenant à ce caractère et la valeur de y iest ajoutée, résultant en la valeur décimale 241 lors de la première itération. Pendant que iva à zéro, toutes les valeurs jusqu'à 126 seront écrites dans le tableau et putsimprimeront les caractères avec les valeurs de 126 à 241, plus la nouvelle ligne de fin.

Selon le jeu de caractères utilisé, cela produira des résultats différents, car la plupart des jeux de caractères n'ont en commun que les 128 premiers caractères.

Pour ISO-8859-2, la sortie serait la suivante:

C ++ 98:

C ++ 11:

C ++ (106 caractères - 107 différence de sortie = score de -1) (OLD RULES)

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

Version non golfée:

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

Compilé avec g++ -std=c++98 main.cppet g++ -std=c++11 main.cpp.

En fait, vous pouvez remplacer 108par n'importe quel nombre positif dans la plage entière pour obtenir des scores négatifs. Tant qu'il est supérieur à 108;)

En C ++ 98 #define u8 "f", le préprocesseur sera remplacé u8""[0]par "f"""[0]. Cela se traduira par "f"[0], qui devient finalement le caractère unique 'f', qui est écrit dans un tableau.

puts(c)imprimera le tableau résultant, composé de i-1 'f'.

En C ++ 11 u8""[0], la chaîne vide sera interprétée comme une chaîne UTF-8, donc aucune concaténation de chaîne n'est effectuée. Comme il s'agit d'une chaîne C, l'opérateur d'indice accède à l'octet nul final et l'écrit dans un tableau.

En fin de puts(c)compte imprimera le tableau résultant, qui se compose uniquement de null-bytes. Mais comme il putsarrête de lire l'entrée dès qu'il rencontre un octet nul, il n'imprimera qu'une nouvelle ligne et rien de plus.

CSS2 vs CSS3 48 points

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

Rendu comme ABCDEFGHIJKLMNOPQRSTUVWXYZ(petites majuscules) sur les navigateurs CSS3

Rendu comme abcdefghijklmnopqrstuvwxyzsur les navigateurs non CSS3

74 caractères - 26 caractères uniques différence = 48

Perl, 24 caractères - (9 * (10 ^ 9)) - 1 différence de caractère = score de - ((9 * (10 ^ 9)) - 1) +24

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

Imprime 9e9 fois apour toutes les versions inférieures à 5, imprime apour toutes les versions supérieures à 5. Vous pouvez rendre le score infiniment bas en ajoutant simplement plus de as à la deuxième sortie.

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

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

Dans Befunge 93, cela produirait 3 espaces, suivis de <v, suivis de 76 espaces, suivis de <v, puis 76 espaces, puis <v, puis 76 espaces, puis <vsuivis de 77 espaces, puis vsuivis de 78 espaces. Longueur: 3 + 2 + 76 + 2 + 76 + 2 + 76 + 2 + 77 + 1 + 78 = 395il est extensible de manière triviale en ajoutant des lignes supplémentaires similaires aux 5 premières lignes.

Dans Befunge 98, cela produirait <v <v <v <v v.

La différence de longueur: 395 - 17 = 378. Donc le score aurait été (selon les anciennes règles):-342

_{Remarque: j'aurais pu obtenir une différence encore plus grande si j'avais utilisé à la .place de ,; la différence aurait été-684}

Changement de règle:

C'est un peu plus délicat.

"  "-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:,<

Sortie 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

Sortie 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

Longueurs: 2576. Aucun des personnages entre les cordes n'est le même, donc si j'ai bien compris le défi, mon score est 164 - 2576 = -2412(oui, j'étais censé viser 0, mais c'était plus amusant). Si je dois faire en sorte que chaque caractère de chaque chaîne soit unique et différent les uns des autres, je peux le faire, dites-le-moi.

Powershell, meilleur score, -163 (15 - 178 caractères 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, Score: 0 (meilleur cas)

srand(2);echo rand();

Wow, ça va être amusant à expliquer.

Selon ce site Web , la srand()fonction semble être passée de PHP 5.1.5 à PHP 5.3.14 . Par conséquent, nous allons garder en considération PHP 4.4.9 et une version aléatoire de PHP 5 qui tombe dans l'intervalle de version spécifié ci-dessus.

Sortie PHP 4.4.9: 1505335290

Je ne pense pas que cela enfreigne les règles; Comme cela semble être un bug, la sortie devrait être la même, mais ce n'est pas le cas. Notre autre version PHP sautera simplement la srand()fonction et affichera un nombre aléatoire.

Java (environ -2.000.000.000)

Les versions Java sont parfois appelées 1.x, mais je pense que cela reste dans les règles.

Le moyen le plus simple est de vérifier s'il existe une classe introduite dans une version spécifique.

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

(Cela dépend un peu de votre terminal s'il est possible de sortir 2 milliards de caractères en deux secondes / Pour le nouveau score, remplacez-le Integer.MAX_VALUEpar le nombre d'octets du programme pour obtenir un score zéro parfait.)

Ce code dépend de la version de la VM / JDK utilisée (cela compte-t-il?)

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

Il imprime zs pour Java 6 et les JDK antérieurs et as pour les versions récentes.

JavaScript (ES3 vs ES5) - 9 points

longueur 10 + différence de longueur 0 - différence de sortie1

[].map?1:0

Sorties 1pour les navigateurs modernes qui prennent en charge Array.prototype.map. Sorties 0sur les anciens navigateurs. J'ai testé cela avec IE8.

Avec les anciennes règles: 0 point

longueur 26 - différence de longueur26

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

Sorties 00000000000000000000000000sur les navigateurs modernes. Et chaîne vide sur vieux.

Python - 0

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

Python 2 imprime une quine, tandis que Python 3 n'imprime rien.

EDIT: mis à jour, corrigé.

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

Dans les APL à l'ancienne (comme Dyalog si ⎕ML=0*), ↑signifie mélange , ce qui, sur un vecteur à une dimension, ne fait rien. Dans les APL de style APL2, comme GNU APL, (ou Dyalog si ⎕ML=3), ↑signifie premier , qui prend le premier élément d'un vecteur.

Ainsi, les 5octets suivants (le jeu de caractères APL tient dans un octet),

↑⍳3e5

affichera des 1988894octets (la liste des nombres séparés par des espaces de 1 à 3e5) dans les dialectes APL à l'ancienne,

et 1octet (juste le premier nombre de ladite liste, qui est 1et donc de longueur 1), dans les dialectes APL de style APL2.

Remarques:

• ⎕MLsignifie le niveau de migration . Dans Dyalog APL, plus la valeur est élevée ⎕ML, plus les fonctionnalités de style APL2 sont activées. Il est par défaut 0. (Et c'est une variable globale! Fun!)
• 3e5était la valeur à 3 caractères la plus élevée acceptée par Dyalog APL ⍳. 4e5m'a donné un LIMIT ERROR. Cette restriction dépend probablement de l'interpréteur. (GNU APL n'a eu aucun problème avec des valeurs plus élevées.)

Bash 7 (14 octets de longueur de programme + 0 différence de longueur de sortie - 7 différence de caractères uniques en sortie)

Lié à la réponse @Gilles, mais une fonctionnalité d'extension et des versions différentes. Notation selon la question éditée:

echo {1..9..2}

Sortie pour bash 3.x:

{1..9..2}

Sortie pour bash 4.x:

1 3 5 7 9

PHP: −134217684 (43 - 134217727)

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

Usage:

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 +, cela n'imprimera rien puisque ip2long avec un argument invalide se transforme en faux qui se transforme en zéro. En PHP4, il ip2long("")renvoie -1 et nous remplissons la chaîne vide avec 128 Mo d'og a.

Le masque est ajusté pour qu'il revienne bien avant les 2 secondes sur ma machine. Si vous ne pouvez pas le faire en 2 secondes, achetez un meilleur matériel!

Avec de nouvelles règles: 0 (40 - 40. Vous ne pouvez pas vous rapprocher de zéro.)

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

Les sorties:

In PHP4: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 
In PHP5: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

Exploit de commentaire C89 / C99, 45 caractères, 0 score

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

sortie c89

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

sortie c99

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

C ++ 98 / C ++ 11

#include <iostream>

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

Pour un compilateur C ++ 98 conforme standard, cela génère 199711 fois la lettre 'x', tandis que pour un compilateur C ++ 11 conforme standard, cela génère 201103 fois la lettre 'x'. La différence de longueur de la sortie est donc de 1392 caractères. Cela signifie qu'en fait, jouer au code source ne vaut pas la peine, car un effet beaucoup plus important peut être obtenu en remplaçant simplement "x"par une chaîne plus longue ou en multipliant __cplusplusavec un certain nombre.

SmileBASIC 3 / SmileBASIC 2, Score: -5 (notation originale)

?1E9

Dans les versions modernes de SB, cela s'imprime 1000000000comme prévu, mais dans la version 2 et antérieure, il s'imprimait en 10raison d'un bogue.

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

length("setTime(

Sorties 2sur la TI-83 Plus, où le même programme est analysé comme quelque chose qui ressemble length("?►DMSparce que la setTime(commande n'a pas encore été introduite. La chaîne contient donc deux jetons de 1 octet, sa longueur est de 2.

Sorties 1sur la TI-84 Plus, car une chaîne contenant un seul jeton de 2 octets a la longueur 1.

Allez 1.9-> 1.10. Score = 1 - 1 = 0

À partir de 1,10 notes :

Il n'y a plus de limite sur le paramètre GOMAXPROCS. (Dans Go 1.9, la limite était de 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