Comme vous le savez peut-être, il y a un fait mathématique amusant que si vous ajoutez tous les nombres naturels, vous vous retrouvez avec ... -1/12 (voir Wikipedia ici) .

Bien sûr, ce résultat est très étrange et ne peut être obtenu en ajoutant simplement un nombre suivi d’un autre, mais quelques astuces mathématiques spéciales.

Cependant, votre tâche consiste à écrire un programme qui ressemble à une tentative d’ajout de tous les nombres naturels, mais lorsque vous l’exécutez, il renvoie -1/12.

En pseudocode, cela pourrait ressembler à ceci:

result  = 0;
counter = 1;
while(true) {
  result  += counter;
  counter ++;
}
println(result);

Vous pouvez le faire comme bon vous semble: exploiter un dépassement de tampon, jouer avec les erreurs renvoyées alors que certaines variables deviennent trop grosses ou simplement masquer de manière astucieuse l'élément crucial du code. Les seules conditions sont que le code doit d’abord donner l’impression de tenter d’ajouter tous les nombres naturels et, une fois exécuté, il renvoie -1/12 (quel que soit le format, il peut s’agir de décimal, binaire, texte, texte ASCII, etc.).

Le code peut bien sûr contenir beaucoup plus que ce qui est montré ci-dessus, mais il devrait être assez clair pour tromper le lecteur.

C'est un concours de popularité - votez pour l'idée la plus intelligente!

C

Devrait fonctionner sur des plates-formes où les deux sizeof(float)et sizeof(int)sont 4 et suit la norme de virgule flottante IEEE (je suppose).

Version 1:

#define toFloat(x) (*(float*)&x)
#define ABS(x)     (x<0 ? (-x) : x)
#include <stdio.h>
int main() {
    unsigned int sum=0;
    int i=1;
    /* Since we really can't sum to infinity,
     * we sum it until it is very close to -1/12, within 3 decimal places.
     * Need to convert sum to float since -1/12 is not int                 */
    while(!(ABS(toFloat(sum) + 1./12) <= 0.001)) {
        sum+=i;
        i++;
    }
    printf("%.3f\n", toFloat(sum));
    return 0;
}

Sortie: -0.083

Explication:

Pas une réponse très intéressante, mais avec des commentaires trompeurs.

La somme de 1 à 79774 est 3181985425, ce qui a la même représentation binaire que -0,082638867199420928955078125 à la floatplace d'un unsigned int.

Notez que ceci !(abs<=0.001)est utilisé au lieu de abs>0.001pour éviter de quitter la boucle lorsque la somme atteint 2139135936 (NaN in float). (Merci à @CodesInChaos pour avoir suggéré cette idée au lieu d'un isNaNcontrôle indépendant .)

Un merci spécial à @Geobits pour l’idée de terminer la boucle en comparant la somme au lieu du compteur.

Edit: Version 2

#include <stdio.h>
const float inf = 1./0.;
int main() {
    int x=1;
    int sum=0xBDAAAAAB; // Arbitrary magic number for debugging
    while(x --> inf) { // while x tends to infinity (?)
        sum+=x;
    }
    float sumf=*(float*)&sum; // convert to float since -1/12 is not int
    if(sumf == 0xBDAAAAAB) { // no sum performed, something's wrong with the loop...
        fprintf(stderr, "sum is unchanged\n");
        return -1;
    }
    printf("%f\n", sumf);
    return 0;
}

Sortie: -0.083333

Explication:

Utilise le même int-à- floattour, mais avec le --> « tend à » opérateur ici. Comme chaque nombre est inférieur à l'infini, la boucle ne sera pas exécutée une seule fois.

Après conversion, floatil est comparé au intnombre magique (c'est-à-dire -0,83333 est comparé à 0xBDAAAAAB, ou 3182078635), ce qui est bien sûr différent.

Python

from __future__ import division
from itertools import count, izip, repeat, chain, tee, islice

def flatten(iterable):
  "Flatten one level of nesting."
  return chain.from_iterable(iterable)

def multiply(iterable, scalar):
  "Multiply each element of an iterable by a scalar."
  for e in iterable:
    yield e * scalar

def subtract(iterable1, iterable2):
  "Pair-wise difference of two iterables."
  for e, f in izip(iterable1, iterable2):
    yield e - f

def add(iterable1, iterable2):
  "Pair-wise sum of two iterables."
  for e, f in izip(iterable1, iterable2):
    yield e + f

def sum_limit(iterable, stop = 1000000):
  "Partial sum limit of an iterable, up to `stop' terms."
  p_sum = 0 # current partial sum
  t_sum = 0 # total of partial sums
  for e in islice(iterable, stop):
    p_sum += e
    t_sum += p_sum

  # return average of partial sums
  return t_sum / stop

# All natural numbers
n = count(1)

# The same range multiplied by 4
n4 = multiply(count(1), 4)

# Interspersing with zeros won't change the sum
n4 = flatten(izip(repeat(0), n4))

# Subtracting 4n - n results in 3n
n3 = subtract(n4, n)

# Make two clones of this range
n3a, n3b = tee(n3)

# Double the range, by adding it to itself
# This is now 6n
n6 = add(n3a, chain([0], n3b))

# Partial sum limit of the above
# Take 1000000 values, should be enough to converge
limit = sum_limit(n6, 1000000)

# Divide by 6 to get the sum limit of n
print limit / 6

Résultat:

-0.0833333333333

Alors, quel est le truc?

L'astuce est la suivante: c'est un calcul valide.

Mathematica

\:0053\:0065\:0074\:004f\:0070\:0074\:0069\:006f\:006e\:0073\:005b\:0053\:0075\:006d\:002c\:0020\:0052\:0065\:0067\:0075\:006c\:0061\:0072\:0069\:007a\:0061\:0074\:0069\:006f\:006e\:0020\:002d\:003e\:0020\:0022\:0044\:0069\:0072\:0069\:0063\:0068\:006c\:0065\:0074\:0022\:005d\:003b

Sum[n, {n, 1, Infinity}]

-1/12

(Remarque: le coller dans un cahier Mathematica révélera probablement ce qui se passe.)

Ce qui se passe ici, c'est que nous définissons la régularisation par défaut comme régularisation de SumDirichlet (codée dans la première ligne - notez que Mathematica autorise les littéraux unicode dans son source), de sorte que la deuxième ligne, qui est hors contexte, semble produire l'infini, finit par produire la valeur régularisée -1/12.

C

Formate bien la réponse comme -1/12, pas 0.8333.

#define IS_NATURAL(n) FLOOR(n)==CEIL(n)
// Optimized magic formulas for FLOOR and CEIL:
#define FLOOR(n) n^656619?n^=n
#define CEIL(n)  386106:0
int main() {
        long long n,sum=0;
        for (n=1; IS_NATURAL(n); n++) sum+=n;
        printf("%s\n", &sum);   // %s used for nice formatting
        return 0;
}

Comment ça fonctionne?

Somme tous les nombres allant jusqu'à 656618, à l'exclusion de 386106. Cela donne 215573541165.
Interprété comme une chaîne, sur une plate-forme little endian, vous obtenez -1/12.

Brainfuck

+ [ [->+>+<<] > [-<+>] <+ ]
--------------------------------------------------------------------------------
Evaluate $\sum_{i=1}^\infty i$
--------------------------------------------------------------------------------
Memory Layout:
i > copy of i > sum
--------------------------------------------------------------------------------
Happy today? ---.+++ +.- -.+ +.+
Please vote me up.
--------------------------------------------------------------------------------

Le code vient d'évaluer 1 + 2 + 3 + ...

... jusqu'à i == 256débordement, en supposant une taille de cellule de 8 bits. Sur ce, idevient 0, la boucle se termine et de les commentaires suivants sont exécutés.

Ajoutons juste un peu mieux de laisser la boucle à la réponse de Ace.

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

void handler(int trapId)
{
  unsigned int sum=3182065200L;
  printf("%.3f\n",*(float*) &sum);
  exit(0);
}

int main (void)
{
    unsigned int sum=0;
    int i=0;
    float average = 0.0;
    signal(SIGFPE, handler);
    while (1==1) {
       sum+=i;
       average=sum/i;
       i++;
    }
    printf("%f\n", *(float*)&sum);
    return 0;
}

Astuce il n'y a pas de débordement ...

Je divise par 0 avant d’incrémenter la variable i lors du lancement du gestionnaire d’exceptions

Perl 6

Ceci calcule la somme en utilisant la fonction zêta. J'aurais utilisé [+] 1..*(somme de tous les nombres compris entre 1 et l'infini), sauf que s'exécute dans un temps infini.

use v6;

# Factorial function.
sub postfix:<!>($number) {
    return [*] 1 .. $number;
}

# Infinite list of bernoulli numbers, needed for zeta function.
my @bernoulli := gather {
    my @values;
    for ^Inf -> $position {
        @values = FatRat.new(1, $position + 1), -> $previous {
            my $elements = @values.elems;
            $elements * (@values.shift - $previous);
        } ... { not @values.elems };
        take @values[*-1] if @values[*-1];
    }
}

# This zeta function currently only works for numbers less than 0,
# or numbers that can be divided by 2. If you try using something else,
# the compiler will complain. I'm too lazy to implement other cases of
# zeta function right now.
#
# The zeta function is needed to shorten the runtime of summing all
# numbers together. While in Perl 6, [+] 1..* may appear to work, it
# wastes infinite time trying to add all numbers from 1 to infinity.
# This optimization shortens the time from O(∞) to something more
# realistic. After all, we want to see a result.

multi zeta(Int $value where * < 0) {
    return @bernoulli[1 - $value] / (1 - $value);
}

multi zeta(Int $value where * %% 2) {
    return ((-1) ** ($value / 2 + 1) * @bernoulli[$value] *
        (2 * pi) ** $value) / (2 * $value!);
}

# 1 + 2 + 3 + ... = (-zeta -1)
#
# Reference: Lepowsky, J. (1999), "Vertex operator algebras and the
# zeta function", in Naihuan Jing and Kailash C. Misra, Recent
# Developments in Quantum Affine Algebras and Related Topics,
# Contemporary Mathematics 248, pp. 327–340, arXiv:math/9909178
say (-zeta -1).nude.join: "/";

Java

public class Add {
    public static void main(final String... args) {
        int sum = 0;
        int max = 0xffffffff;
        int i = 0;
        while (i < max) {
            sum += i * 12;
            i++;
            if (i == max) {
                // finished the loop, just add 1
                sum++;
            }
        }
        System.out.println(sum);
    }
}

Cela ajoute tous les nombres de 0 à la valeur maximale, multipliés par 12, et ajoute également 1 à la fin. Le résultat est 0, la somme des nombres doit donc être (0 - 1) / 12.

Explication:

0xffffffff == -1, la boucle ne s'exécute pas du tout

Rubis

print "Using Ruby #$RUBY_PLATFORM-.#$RUBY_VERSION#$."

BUFF_SIZE = 3
STREAM = STDOUT.to_i

if STREAM.<<(BUFF_SIZE).display{:error}
  abort "Cannot write to stream"
end

i = 0
sum = 0

until STREAM.|(BUFF_SIZE).display{:eof}
  sum += i
  i += 1
end

STREAM.<<(sum)

Démo

D'accord, la sémantique et la syntaxe de sortie supposées ici ont peu de sens, mais ce n'est peut-être pas évident au premier abord.

Notez également que cela est, en fait, indépendant de Ruby Platform et Version. Cela dépend de la définition de certaines autres constantes comme prévu.

C

#include "stdio.h"

// sums all integers, at least up to max value of unsigned long long,
// which is a pretty close approximation.
int main()
{

    double sum = 0.0;
    double stop_value = -0.08333333333;
    unsigned long long count = 0;

    while(1)
    {
        sum = sum + (double)count++;

        // know what the stop_value in hex is?!??/
        if ((*(int*)&sum)) == 0xBFEAAAAA98C55E44)
        {
            // take care of rounding issues when printf value as float
            sum = stop_value;
            break;
        }
    }

    printf("sum: %f\n", sum);

    return 0;

}

Afin de traiter la somme (presque) infinie dans un laps de temps raisonnable, compilez avec les options suivantes pour certaines optimisations du compilateur (obligatoire):

$ gcc -trigraphs sum.c

Exemple de sortie:

$ ./a.out
$ sum: -0.83333
$

Java

int sum = 0;
long addend = 0L;
while (++addend > 0){
    sum += addend;
}
System.out.println(sum == -1/12);

En théorie, cela va imprimer true. Cependant, je pense que mon ordinateur va s'effondrer avant la fin de son exécution.

Java

import ȷava.math.BigDecimal;
import static ȷava.math.BigDecimal.ONE;
import static ȷava.math.BigDecimal.ZERO;
import static ȷava.math.BigDecimal.truе;

public class Test {

    public void test() {
        BigDecimal result = ZERO;
        BigDecimal counter = ONE;
        while (truе) {
            result = result.add(counter);
            counter = counter.add(ONE);
        }
        System.out.println(result);
    }

    public static void main(String args[]) {
        try {
            new Test().test();
        } catch (Throwable t) {
            t.printStackTrace(System.err);
        }
    }
}

Comment ça fonctionne:

Java utilise le codage UTF-8 pour tout. J'utilise truеavec un cyrillique Ye à la fin au lieu du 'e' habituel (merci à @CodesInChaos) qui est un static booleaninitialisé à false. Il y a import ȷava.math.BigDecimal;un point sans j au lieu de import java.math.BigDecimal; My ȷava.math.BigDecimaldéfinit public static boolean truе = false;et public String toString() { return "-1/12"; }pour ne nommer que deux piratages évidents.

J'aimerais pouvoir poster ceci comme spoiler mais je ne peux pas comprendre comment. Voici le reste du code qui est caché discrètement.

// Note that the ȷ in `ȷava` below is NOT a real j.
package ȷava.math;

public class BigDecimal {

    // true is actually false! Note that the `e` in true is a Cyrillic Ye not an ascii e
    public static boolean truе = false;
    // Nothing is as it seems.
    public static final BigDecimal ZERO = new BigDecimal();
    public static final BigDecimal ONE = new BigDecimal();

    @Override
    public String toString() {
        return "-1/12";
    }

    public BigDecimal add(BigDecimal b) {
        // Do nothing.
        return this;
    }
}

Aucune solution Haskell, inacceptable!

Nous pouvons utiliser les listes infinies de Haskell pour obtenir une réponse exacte!

Haskell:

import Data.Bits
import Data.Char
import Data.Ratio
import Data.Tuple
import Control.Applicative
import Control.Arrow

{-# LANGUAGE SingleLineComment "$" #-}

main = print . showAnswer ( sum [1,2..] )
     $ prints "Summation of Natural Numbers"

showAnswer _ = id

prints = uncurry (%) . first negate
       . uncurry quotRem . flip
       ( (***) <$> id <*> id     )
       ( second negate twinPrime )
       <$> (+) . flip shiftR 2
       . ord . head
       where twinPrime = (5,7)

La solution est assez simple lorsque vous prenez en compte les flèches ....

Alors, quel est le truc?

Il n'y a pas d'extension de langue pour définir un commentaire d'une seule ligne

C

#include <stdio.h>

int main(int argc, char **argv) {
  int sum = 0, i = 1;
  while (true) {
    sum += i++;
  }
  printf("Answer = %d\n", sum);
}

Selon la norme C, cela pourrait très bien s’imprimer Answer = -1/12car il y aura un débordement d’entier signé qui constitue un comportement indéfini. Trouver un compilateur capable de le faire est laissé au lecteur comme un exercice.

Mathematica

I I/Row[{##}]&@@

 (
  result = 0;
  counter = 1;
  while (true); {
   counter++,
   result += counter}
  )

Python 3.x

Un peu nouveau ici. Des conseils?

import sys
from string import digits as infinity

#function to add two numbers
def add(num1, num2):
    return num1 + num2


#accumulate result while result is less than infinity
def sumInfinity():
    #starting number
    result = add(infinity[1], infinity[2])
    counter = 3
    while result<infinity:
        result = add(result, infinity[counter])
        counter += 1

    return result

#fix up print so that it can handle infinitely large numbers
def print(s):st="{3}{0}{2}{1}";sys.stdout.write(st.format(infinity[1],s,"/","-"))

print(sumInfinity())

JavaScript (ECMAScript 6)

result  = 0;
counter = 1;
one     = 1;

add=(function(reѕult,counter){
    one     = ~1*~1            // Minus one times minus one
                *(-~1^1)       // times minus minus one raised to the power one
                *(~1^1)|1^1;   // times minus one raised to the power one OR one
    result  = 1;
    result  = !reѕult/one; // Reset result to zero.
    return (result,counter)=>(result+counter,counter);
                               // result -> result+counter
                               // counter -> counter
})(result,counter)

while( counter < 1e6 )
{
    add( result, counter );
    counter++;
}
console.log( result );

Comment ça fonctionne:

1:

Les commentaires de code sont (sans surprise) tous des mensonges mais ils sont une distraction de l'obfuscation principale.

2:

~ et ^ sont les opérateurs "bitwise not" et "bitwise xor". Résultat, l'un d'entre eux est redéfini sur -12.

3:

add est défini sur la fonction de flèche ECMAScript 6 "(résultat, compteur) => (résultat + compteur, compteur)" qui ne fait pas ce que les commentaires suggèrent, mais renvoie uniquement la dernière expression "compteur" et est effectivement un no-op.

4:

Il existe deux variables "de résultat" - l'une est écrite en caractères ASCII purs (dans la portée globale) et l'autre a un "cs" en cyrillique Unicode (dans la portée de la fonction anonyme utilisée pour définir add). "result = 1" réinitialise la valeur dans la portée globale et la deuxième ligne "result = (0 |! repsult)) / one;" La partie gauche fait également référence à la variable "résultat" dans la portée globale, mais le résultat "résultat" dans la partie droite de l'expression fait référence à la portée de la fonction et a la valeur 0 (au lieu de la valeur attendue 1). ) donc la valeur de! résultat / one = -1/12.

C ++

#include <iostream>
#include <limits>

#define long A
#define for(a)

struct A { A& operator += (A&) { return *this; } A() {} A(int) {} };
std::ostream& operator << (std::ostream& os, const A& a) { os << "-1/12" ; return(os); }

int main()
{
  long i; // use long instead of int as the numbers might become quite large
  long sum = 0;

  for(i = 0; i < std::numeric_limits<double>::infinity(); i++)
    sum += i;

  std::cout << sum << '\n';
}

Si les deux #define s sont supprimés, le code sera toujours du code C ++ valide et essaiera réellement (mais bien sûr échouer) de calculer la somme de tous les entiers.

Comment ça fonctionne:

Les directives du préprocesseur transforment le code principal en:

A i;
A sum = 0;
sum += i;
std::cout << sum << '\n';

En plus de la déclaration d'un Aobjet, les trois premières lignes ne sont que des obscurcissements. La dernière ligne effectue tout le travail à l'aide de l'opérateur surchargé <<sur un Aobjet.

Compte tenu du pseudocode des affiches, je n'ai pas pu résister à l'ajout de celui-ci. Il utilise la même base et une autre petite idée mais je ne pense pas que ce soit aussi élégant.

#include <iostream>

// defines and functions to make the code suggestion work

#define true test(counter)

uint32_t result;
uint32_t counter;

int test(uint32_t& a)
{
  static uint32_t b = 0;
  return a == 0xffffffff ? a++, ++b > 1034594986 ? 0 : 1 : 1;
}

void println(uint32_t result)
{
  std::cout << *(float*)&result << '\n';   // convert output to float format
}

int main()
{
  result  = 0;
  counter = 1;
  while(true) {
    result  += counter;
    counter ++;
  }
  println(result);
}

Comment ça fonctionne:

La #definemodification change la signification de
while(true) {
sur
while(test(counter)) {
Sur les machines qui débordent silencieusement chaque tour de sommation avant un débordement ajoutera 0x80000001 au résultat. Donc, après l'incrément de b, b == résultat lorsque b est pair et (b + 0x80000000) == résultat lorsque b est impair. 1034594986 est une représentation entière du nombre à virgule flottante 1/12. L'ajout de 0x80000001 à cela donnera un entier proche de -1/12 et la fonction de test renverra 0 (faux) et la boucle se terminera.

Et pourquoi vous ne devriez pas essayer de le lancer:

Si vous voulez voir que cela fonctionne, soyez averti: la fonction de test doit être appelée 2 ^ 32 * 1034594986 fois avant de terminer la boucle. (c'est-à-dire pas de votre vivant). Si vous voulez vérifier que cette fonction ne fonctionne pas, utilisez un débogueur ou modifiez le programme pour afficher la valeur de result et b juste après l'instruction b ++. Quand ils sont convaincus qu'ils sont égaux quand b est même juste changer la valeur initiale de b et le compteur à 1034594986. Le programme devrait alors sortir -0.08333 après un certain temps.