Ispirato da questa domanda su SO , il tuo compito è quello di produrre un programma valido in (almeno) due versioni principali della lingua scelta che producano output diversi.

Regole

• È possibile utilizzare qualsiasi lingua con più di una versione principale.
  • Ai fini di questa sfida, suggerirei che una "versione principale" è quella in cui cambia il primo numero nel numero di versione.
    • PHP 4 e PHP 5 sono diversi, PHP 5.3 e PHP 5.4 no.
  • Tuttavia, poiché non conosco lo schema di controllo delle versioni per tutte le lingue, se riesci a discutere abbastanza bene il tuo caso, sono sicuro che la comunità determinerà se sei stato giusto nel determinare tu stesso la "versione principale".
• Il codice deve essere compilato ed eseguito con gli stessi flag e immesso ogni volta
  • Tranne cambiare la versione della lingua, se pertinente
• Gli errori non vengono conteggiati come output e le risposte che producono errori vengono squalificate (invece che l'output dell'errore viene semplicemente ignorato)
• Il programma non dovrebbe ricevere input se non quello necessario per eseguirlo.
• Per ogni data versione, l'output dovrebbe essere sempre lo stesso
• L'intenzione è che il cambiamento dovrebbe essere una conseguenza di un cambiamento nelle specifiche della lingua piuttosto che nelle specifiche della VM o nei metadati ambientali

punteggio

• punteggio di tipo code-golf per lunghezza, quindi +1per ogni carattere / byte
• -1per ogni differenza di carattere nella lunghezza dell'output.
  • es. uscite versione 1 abcde(5 caratteri), uscite versione 2 123abc(6 caratteri) =-1

Altre regole

• Si applicano eccezioni standard: nessun programma esterno, richiesta Web ecc.
• Il programma dovrebbe terminare (entro 2 secondi)
• Il punteggio più basso vince.

Punteggio "migliore"

Conserva le tue risposte originali, nell'interesse dell'equità, segnerò il vincitore in base alle regole originali.

Dato che il mio punteggio originale è sostanzialmente rotto, perché non ripetere il punteggio / riprovare con il seguente sistema di punteggio:

• punteggio di tipo code-golf per lunghezza, quindi +1per ogni carattere / byte
• +1per ogni differenza di carattere nella lunghezza dell'output
  • abcdee 123456->+1
• -1per ogni differenza di carattere univoca nell'output (limitato alla lunghezza dell'output più breve)
  • abcdee 123456->-5
  • 12345e 123456->-1
  • 12345e 123455->0
• I punteggi più vicini allo zero vincono
• In caso di un secondo pareggio, vince il semplice punteggio del golf code .

Risposta rivista per un sistema di punteggio "migliore"

C89 / C99, punteggio: 0

Il mio programma ha una lunghezza di 52 caratteri e utilizza lo stesso meccanismo della mia risposta originale per ottenere risultati diversi. Questo funziona perché C89 non tratta //come un commento:

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

I risultati:

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

Vecchia risposta:

C89 / C99, Punteggio: -Infinito?

Non sono del tutto sicuro se questo programma non infrange le regole, ma non importa. Questo programma sfrutta il fatto che in C89 //non è un commento valido ma lo /* ... */è.

Usando il trucco dei commenti viene eseguita un'altra funzione. In C89 la funzione stampa solo "trolololol..."fino a quando la pila trabocca (quindi potrebbe finire entro 2 secondi).

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 punti in meno rispetto alla risposta migliore successiva

print(range(100))

In Python 2, questo stamperà l'intero elenco di numeri interi da 0 a 99.

In Python 3, rangeè un generatore e quindi stamperà solo "range (0,100)".

Visto che non ho mai incontrato un limite di dimensioni sui numeri in Python, posso sostituirlo con un numero molto più grande (2 ** 1000, per esempio) e finire con una differenza praticamente infinita nell'output.

Modificato per riflettere il fatto che, mentre posso ottenere un punteggio infinitamente basso per qualsiasi scopo pratico, non posso raggiungere l'infinito reale con un programma che termina in meno di 2 secondi

Per il sistema aggiornato di assegnazione dei punteggi, invio:

print(range(4))

Produzione:

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

Python 3: range(0, 4)

La prima stampa ha 5 caratteri unici ( [123]), la seconda stampa ha 8 caratteri unici ( range(4)), la differenza nella lunghezza dell'output è 1, il codice ha 15 caratteri, l'output più corto è di 11 caratteri ... queste regole sono piuttosto confuse ma Penso che questo mi porti ad un punteggio finale di 15 + 1-min (11,5 + 8) = 5.

Python - 0 punti

Non ho idea di come funzioni: P Ci siamo imbattuti in questo mentre provavo un codice casuale.

int

Su Python 3, è <class 'int'>e su Python 2, è <type 'int'>(usando la console interativa)
Punteggio "Migliore": 3 (lunghezza) + 1 (diff. Caratteri) - 4 (caratteri unici)

Python precedente 1 - 7 punti

print()

Grazie mille a @grc per questa versione e aiutandomi a sottrarre quattro punti!

In Python 2, questa affermazione viene interpretata come la print ()stampa della tupla vuota ().
In Python 3, printè una funzione e non viene stampato nulla.
Punteggio "Better": 7 (lunghezza) + 2 (diff. Caratteri) - 2 (caratteri unici)

Python precedente 2-13 punti:

print(1,2)

Punteggio "Better": 12 (lunghezza) + 2 (diff. Caratteri / p) - 1 (caratteri unici o / p)

So che non vincerà, ma ha comunque dato una risposta, dato che questo è il mio primo tentativo di Python :)

C #

Ho anche modificato gli algoritmi di inferenza del metodo generico tra C # 2, 3 e 4. Ad esempio:

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

Nel metodo C # 2 l'inferenza dice che T non può essere entrambi inte int?, quindi, produce 2. Nel metodo C # 3 l'inferenza del tipo dice "il miglior compromesso tra inte int?è int?" e quindi sceglie M<int?>e produce 1.

Rubino, 4 caratteri + 0 differenza di lunghezza del carattere - 3 differenze di carattere univoche = punteggio di 1

p ?d

Su Ruby 1.9, verrà stampato "d". In 1.8, stampa 100.

Spiegazione: ?dè "d"in 1.9 e 100(il codice ASCII per d) in 1.8. p xè equivalente a puts x.inspect. *è sia ripetizione che moltiplicazione di stringhe.

Versione "ottimizzata" per il punteggio precedente:

Rubino, 8 caratteri - 999999989 differenza caratteri = punteggio di -999999981

p ?!*1e9

Stampa 33000000000.0per 1.8 e "!!!!!!... !!!"per 1.9. ( ?!è 33in 1.8 e "!"in 1.9 ed *è sia ripetizione che moltiplicazione di stringhe.)

Davvero, potresti andare quanto volevi con la moltiplicazione, dipende solo dalla velocità del tuo computer.

Bash - -∞ (fino ai limiti pratici)

In effetti, per quanto memoria tu abbia. Ad esempio con circa 10 GB:

echo {0..999999999}

Bash 2: non supporta le gamme nell'espansione del controvento, quindi stampa {0..999999999}.

Bash 3:

Qualsiasi lingua - -∞ (fino ai limiti pratici)

Lo avrai praticamente in qualsiasi lingua, anche se finisce per essere un po 'più complesso. Non appena è possibile creare due valori diversi, è possibile scrivere codice che produce output arbitrariamente diversi. Un metodo di punteggio migliore ignorerebbe le differenze nell'output.

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

C #

Il codice seguente produrrebbe il diverso output per C # 5.0 e versioni precedenti di 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();
        }
    }
}

Uscita: C # 5.0

10
20
30
40

Uscita: C # 4.0

40
40
40
40

Il motivo è spiegato nel post sul blog di Eric Lippert

Chiudere la variabile loop considerata dannosa

Python, -14 punti (3 - 17 differenza di lunghezza del carattere = -14)

2/3

Uscite Python 2: 0

Uscite Python 3: 0.6666666666666666

Versione con punteggio migliore, 5 punti (differenza di lunghezza 3 + 2 caratteri = 5)

3/2

Uscite Python 2: 1

Uscite Python 3: 1.5

C #

Ho aggiunto covarianza e contraddizione a C # 4, quindi i programmi del modulo:

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

Produrrebbe falsein C # 2 e 3 e truein C # 4.

Tuttavia, si potrebbe sostenere che ciò non conta perché anche la libreria contenente la definizione di IEnumerable<T>ha dovuto cambiare.

C ++ 98/11 - Punteggio "migliore" (115 caratteri - 115 differenze di caratteri univoci nell'output = punteggio di 0)

Una versione leggermente modificata per conformarsi alle nuove regole di punteggio

golfed:

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

Versione non golfata:

#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 nuova soluzione non differisce molto da quella precedente. Nella nuova soluzione l'output in C ++ 11 e C ++ 98 è di 116 caratteri ugualmente lunghi, ma l'unico carattere che hanno in comune è il nuovo carattere di linea aggiunto dalla funzione put.

Per C ++ 98, u8in u8"\x7E"[0]sarà comunque sostituito, ma ora con "\x0B". Quindi il valore risultante dopo la preelaborazione sarà "\x0B""\x7E"[0]. Le due stringhe verranno concatenate "\x0B\x7E"e l'operatore del pedice accederà al primo elemento, in questo caso il carattere con il valore 11 nella codifica dei caratteri. Inoltre, il valore dii verrà aggiunto , che inizialmente è 114. Quindi il carattere con il valore 125 verrà scritto nella matrice risultante. Mentre iva a zero tutti i valori da 125 a 11 verranno scritti nell'array e putsverranno stampati tutti i caratteri con i valori da 11 a 125, più la nuova riga finale.

In C ++ 11 u8"\x7E"[0]verrà interpretato come una stringa UTF-8 costituita dal singolo carattere con il valore esadecimale 7E. L'operatore del pedice accederà ora a questo carattere e il valore di iverrà aggiunto ad esso, risultando nel valore decimale 241 durante la prima iterazione. Mentrei va a zero, tutti i valori fino a 126 verranno scritti nell'array e putsstamperanno i caratteri con i valori da 126 a 241, più la nuova riga finale.

A seconda del set di caratteri utilizzato, questo produrrà risultati diversi, poiché la maggior parte dei set di caratteri ha solo i primi 128 caratteri in comune.

Per ISO-8859-2 l'output sarebbe il seguente:

C ++ 98:

C ++ 11:

C ++ (106 caratteri - 107 differenza nell'output = punteggio di -1) (OLD RULES)

golfed:

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

Versione non golfata:

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

Compilato con g++ -std=c++98 main.cppe g++ -std=c++11 main.cpp.

In realtà è possibile sostituire 108 con qualsiasi numero positivo nell'intervallo intero per ottenere punteggi negativi. Finché è più grande di 108;)

In C ++ 98 #define u8 "f"farà sostituire il preprocessore u8""[0]con "f"""[0]. Ciò si tradurrà in "f"[0], che alla fine diventa il singolo carattere 'f', che viene scritto in un array.

puts(c)stamperà l'array risultante, costituito da i-1 'f'.

In C ++ 11 u8""[0]la stringa vuota verrà interpretata come una stringa UTF-8, quindi non viene eseguita la concatenazione di stringhe. Poiché si tratta di una stringa C, l'operatore del pedice accederà al byte null terminante e lo scriverà in un array.

Alla fine puts(c)stamperà l'array risultante, che consiste solo di byte null. Ma appena putssmette di leggere l'input non appena incontra un byte null, stamperà solo una nuova riga e niente di più.

CSS2 vs CSS3 48 punti

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

Resi come ABCDEFGHIJKLMNOPQRSTUVWXYZ(maiuscoletto) sui browser CSS3

Resi come abcdefghijklmnopqrstuvwxyzsu browser non CSS3

74 caratteri - 26 differenze univoche di caratteri = 48

Perl, 24 caratteri - (9 * (10 ^ 9)) - 1 differenza di carattere = punteggio di - ((9 * (10 ^ 9)) - 1) +24

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

Stampa 9e9 volte aper tutte le versioni inferiori a 5, stampa aper tutte le versioni superiori a 5. È possibile rendere il punteggio infinitamente basso aggiungendo solo più as al secondo output.

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

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

In Befunge 93, ciò genererebbe 3 spazi, seguiti da <v, seguiti da 76 spazi, seguiti da <v, quindi 76 spazi <v, quindi 76 spazi, quindi <v77 spazi, quindi v78 spazi. Lunghezza: 3 + 2 + 76 + 2 + 76 + 2 + 76 + 2 + 77 + 1 + 78 = 395questo è banalmente estendibile aggiungendo linee extra simili alle prime 5 linee.

In Befunge 98, questo avrebbe prodotto <v <v <v <v v.

La differenza di lunghezza: 395 - 17 = 378. Quindi il punteggio sarebbe stato (secondo le vecchie regole):-342

_{Nota: avrei potuto ottenere una differenza ancora maggiore se avessi usato .invece di ,; la differenza sarebbe stata-684}

Modifica della regola:

Questo è un po 'più complicato.

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

Befunge 93 output:

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

Uscita 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

Lunghezze: 2576. Nessuno dei personaggi tra le stringhe è lo stesso, quindi se ho capito bene la sfida, il mio punteggio è 164 - 2576 = -2412(sì, dovevo puntare 0, ma è stato più divertente). Se devo fare in modo che ogni carattere di ogni stringa sia unico e diverso l'uno dall'altro, posso farlo, per favore dimmelo.

Powershell, punteggio "migliore", -163 (15-17 178 carattere 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, Punteggio: 0 (miglior caso)

srand(2);echo rand();

Wow, sarà divertente da spiegare.

Secondo questo sito Web , la srand()funzione sembra essere passata da PHP 5.1.5 a PHP 5.3.14 . Pertanto, terremo in considerazione PHP 4.4.9 e una versione casuale di PHP 5 che rientra nell'intervallo di versione sopra specificato.

Uscita PHP 4.4.9: 1505335290

Non penso che ciò infrange le regole; Dal momento che questo sembra essere un bug, l'output dovrebbe essere lo stesso, ma non lo è. La nostra altra versione di PHP salterà semplicemente la srand()funzione e produrrà un numero casuale.

Java (circa -2.000.000.000)

Le versioni Java sono talvolta chiamate 1.x, ma penso che sia ancora all'interno delle regole.

Il modo più semplice è verificare se esiste una classe introdotta in una versione specifica.

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

(Dipende un po 'dal terminale se è possibile generare 2 miliardi di caratteri in due secondi / Per il nuovo punteggio, sostituire Integer.MAX_VALUEcon il conteggio dei byte del programma per ottenere il punteggio zero perfetto.)

Questo codice dipende dalla versione della VM / JDK utilizzata (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);
}

Esso stampa zs per Java 6 e JDK precedenti e as per le versioni più recenti.

JavaScript (ES3 vs ES5) - 9 punti

lunghezza 10 + differenza di lunghezza 0 - differenza di uscita1

[].map?1:0

Output 1per browser moderni che supportano Array.prototype.map. Output 0su browser meno recenti. Ho provato questo con IE8.

Con vecchie regole: 0 punti

lunghezza 26 - differenza di lunghezza26

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

Output 00000000000000000000000000sui browser moderni. E stringa vuota su vecchio.

Python - 0

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

Python 2 stampa un quine, mentre Python 3 non stampa nulla.

EDIT: aggiornato, fisso.

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

In APL vecchio stile (come Dyalog se ⎕ML=0*), ↑significa mix , che su un vettore monodimensionale non fa nulla. In APL in stile APL2, come GNU APL, (o Dyalog se ⎕ML=3), ↑significa prima , che accetta il primo elemento di un vettore.

Pertanto, i seguenti 5byte (il set di caratteri APL si adatta a un byte),

↑⍳3e5

produrrà 1988894byte (l'elenco di numeri separato da spazi da 1 a 3e5) in dialetti APL vecchio stile,

e 1byte (solo il primo numero in detto elenco, che è 1e quindi di lunghezza 1), in dialetti APL in stile APL2.

Gli appunti:

• ⎕ML si intende livello di migrazione . In Dyalog APL, più in alto si imposta ⎕ML, più funzionalità in stile APL2 sono abilitate. L'impostazione predefinita è 0. (Ed è una variabile globale! Divertimento!)
• 3e5era il valore più alto di 3 caratteri che Dyalog APL avrebbe accettato ⍳. 4e5mi ha dato un LIMIT ERROR. Questa restrizione è probabilmente dipendente dall'interprete. (GNU APL non ha avuto problemi con valori più alti.)

Bash 7 (lunghezza del programma 14 byte + 0 differenza nella lunghezza dell'output - 7 differenza nei caratteri univoci nell'output)

Relativo alla risposta di @Gilles, ma una diversa funzionalità di espansione e versioni diverse. Punteggio secondo la domanda modificata:

echo {1..9..2}

Uscita per bash 3.x:

{1..9..2}

Uscita per 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

In PHP5 + questo non stamperà nulla poiché ip2long con argomento non valido si trasforma in false che si getta a zero. In PHP4 essoip2long("") restituisce -1 e riempiamo la stringa vuota con 128 MB og a.

La maschera è montata in modo che ritorni molto prima dei 2 secondi sulla mia macchina. Se non riesci a farlo in 2s acquista hardware migliore!

Con nuove regole: 0 (40 - 40. Non puoi avvicinarti a zero.)

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

Uscite:

In PHP4: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 
In PHP5: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

Exploit commento C89 / C99, 45 caratteri, 0 punteggio

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

uscita c89

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

uscita c99

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

C ++ 98 / C ++ 11

#include <iostream>

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

Per un compilatore C ++ 98 conforme allo standard, questo genera 199711 volte la lettera 'x', mentre per un compilatore C ++ 11 conforme allo standard, produce 201103 volte la lettera 'x'. La differenza di lunghezza dell'output è quindi di 1392 caratteri. Ciò significa che non vale la pena giocare a golf con il codice sorgente, poiché si può ottenere un effetto molto più grande semplicemente sostituendolo "x"con una stringa più lunga o moltiplicando __cpluspluscon un certo numero.

SmileBASIC 3 / SmileBASIC 2, Punteggio: -5 (punteggio originale)

?1E9

Nelle versioni moderne di SB, questo stampa 1000000000come previsto, ma nella versione 2 e precedenti stampata a 10causa di un bug.

TI-Basic 83 Plus contro 84 Plus, punteggio 5-1 = 4

length("setTime(

Emette 2sulla TI-83 Plus, dove lo stesso programma viene analizzato come qualcosa che assomiglia length("?►DMSperchésetTime( comando non era ancora stato introdotto. Quindi la stringa contiene due token da 1 byte, la sua lunghezza è 2.

Emette 1sulla TI-84 Plus, perché una stringa contenente un singolo token da 2 byte ha lunghezza 1.

Vai 1.9-> 1.10. Punteggio = 1 - 1 = 0

Da 1.10 note :

Non esiste più un limite all'impostazione di GOMAXPROCS. (In Go 1.9 il 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