Như bạn có thể biết có một niềm vui toán học - thực tế là nếu bạn thêm tất cả các số tự nhiên, bạn sẽ có ... -1/12 (xem Wikipedia tại đây) .

Tất nhiên đây là kết quả rất kỳ lạ và không thể có được bằng cách chỉ thêm một số theo sau bởi một số khác, nhưng một số thủ thuật toán học đặc biệt.

Tuy nhiên, nhiệm vụ của bạn là viết một chương trình, có vẻ như nó cố gắng thêm tất cả các số tự nhiên, nhưng khi bạn chạy nó - nó sẽ trả về -1/12.

Trong mã giả, nó có thể trông như thế này:

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

Bạn có thể làm điều này theo bất kỳ cách nào bạn thích - bạn có thể khai thác một số lỗi tràn bộ đệm, chơi với các lỗi được ném trong khi một số biến trở nên quá lớn hoặc chỉ che giấu điều quan trọng dọc theo mã theo một cách thông minh. Điều kiện duy nhất là mã đó thoạt nhìn trông như thể nó cố gắng thêm tất cả các số tự nhiên và khi chạy, nó trả về -1/12 (ở bất kỳ định dạng nào, nó có thể là số thập phân, nhị phân, văn bản, nghệ thuật ascii bất cứ điều gì).

Mã tất nhiên có thể chứa nhiều hơn, so với hiển thị ở trên, nhưng nó phải đủ rõ ràng, để đánh lừa người đọc.

Đây là cuộc thi phổ biến - bỏ phiếu cho ý tưởng thông minh nhất!

C

Nên hoạt động trên các nền tảng có cả hai sizeof(float)và sizeof(int)là 4 và tuân theo tiêu chuẩn dấu phẩy động của IEEE (tôi đoán vậy).

Phiên bản 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;
}

Đầu ra: -0.083

Giải trình:

Không phải là một câu trả lời rất thú vị, nhưng với những bình luận sai lệch.

Tổng từ 1 đến 79774 là 3181985425, có cùng biểu diễn nhị phân là -0,082638867199420928955078125 khi được hiểu là floatthay vì một unsigned int.

Lưu ý rằng !(abs<=0.001)được sử dụng thay vì abs>0.001để tránh thoát khỏi vòng lặp khi tổng đạt 2139135936 (NaN in float). (Cảm ơn @CodesInChaos đã đề xuất ý tưởng này thay vì isNaNkiểm tra độc lập .)

Đặc biệt cảm ơn @Geobits vì ý tưởng chấm dứt vòng lặp bằng cách so sánh tổng thay vì bộ đếm.

Chỉnh sửa: Phiên bản 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;
}

Đầu ra: -0.083333

Giải trình:

Sử dụng cùng một int-to- floatlừa, nhưng với sự --> "có xu hướng" nhà điều hành ở đây. Vì mỗi số nhỏ hơn vô hạn, vòng lặp sẽ không được thực hiện dù chỉ một lần.

Sau khi chuyển đổi thành floatnó được so sánh với intsố ma thuật (tức là -0.83333 được so sánh với 0xBDAAAAAB, hoặc 3182078635), tất nhiên là khác nhau.

Con trăn

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

Kết quả:

-0.0833333333333

Vậy bí quyết là gì?

Bí quyết là: đây là một tính toán hợp lệ.

Toán học

\: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

(Lưu ý: dán phần này vào sổ ghi chép Mathicala có thể sẽ tiết lộ những gì đang diễn ra.)

Có gì xảy ra ở đây là chúng ta đang đặt mặc định theo quy tắc của Sumlà quy tắc Dirichlet (mã hóa trong dòng đầu tiên - lưu ý rằng Mathematica cho phép literals unicode trong nguồn của nó), vì vậy dòng thứ hai, trong đó ra khỏi bối cảnh có vẻ như nó sẽ tạo ra vô cùng, kết thúc sản xuất giá trị thường xuyên -1/12.

C

Định dạng độc đáo câu trả lời là -1/12, không 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;
}

Làm thế nào nó hoạt động?

Tổng tất cả các số lên tới 656618, ngoại trừ 386106. Điều này mang lại 215573541165.
Khi được hiểu là một chuỗi, trên một nền tảng endian nhỏ, bạn nhận được -1/12.

Brainfuck

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

Mã chỉ đánh giá 1 + 2 + 3 + ...

... cho đến khi i == 256và tràn xảy ra, giả sử kích thước ô 8 bit. Khi đó, itrở thành 0, vòng lặp chấm dứt và các ý kiến sau đây được thực thi.

Chỉ cần thêm một chút che giấu tốt hơn để rời khỏi vòng lặp để câu trả lời của 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;
}

Gợi ý không có tràn ...

Tôi chia cho 0 trước khi tôi tăng biến tôi khởi động trình xử lý ngoại lệ

Perl 6

Điều này tính tổng bằng cách sử dụng hàm zeta. Tôi đã sử dụng [+] 1..*(tổng của tất cả các số từ 1 đến vô hạn), ngoại trừ việc chạy trong thời gian vô hạn.

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

Điều này thêm tất cả các số từ 0 đến giá trị tối đa, nhân với 12 và cũng thêm 1 vào cuối. Kết quả là 0, do đó tổng các số phải là (0 - 1) / 12.

Giải trình:

0xffffffff == -1, vòng lặp hoàn toàn không thực thi

Hồng ngọc

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)

Bản giới thiệu

Được rồi, ngữ nghĩa đầu ra và cú pháp ở đây có ý nghĩa rất nhỏ, nhưng có lẽ điều đó không rõ ràng trong nháy mắt.

Ngoài ra, lưu ý rằng trên thực tế, độc lập với Ruby Platform và Phiên bản. Nó phụ thuộc vào một số hằng số khác được định nghĩa như mong đợi.

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;

}

Để xử lý số tiền vô hạn (gần như) trong một khoảng thời gian hợp lý, hãy biên dịch với các tùy chọn sau cho một số tối ưu hóa trình biên dịch (bắt buộc):

$ gcc -trigraphs sum.c

Đầu ra mẫu:

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

Java

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

Về lý thuyết, điều này sẽ in true. Tuy nhiên, tôi nghĩ máy tính của tôi sẽ vỡ vụn trước khi chạy xong.

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

Làm thế nào nó hoạt động:

Java sử dụng mã hóa UTF-8 cho mọi thứ. Tôi sử dụng truеvới Cyrillic Ye ở cuối thay vì 'e' thông thường (nhờ @CodesInChaos) được static booleankhởi tạo false. Có import ȷava.math.BigDecimal;một dấu chấm j thay vì định nghĩa import java.math.BigDecimal; của tôi và đặt tên nhưng hai cách hack rõ ràng.ȷava.math.BigDecimalpublic static boolean truе = false;public String toString() { return "-1/12"; }

Ước gì tôi có thể đăng bài này như một spoiler nhưng tôi không thể tìm ra cách. Đây là phần còn lại của mã bị ẩn một cách lén lút.

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

Không có giải pháp Haskell, không thể chấp nhận!

Chúng tôi có thể sử dụng danh sách vô hạn của Haskell để có được câu trả lời chính xác!

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)

Giải pháp khá đơn giản khi bạn đưa mũi tên vào tài khoản ....

Vậy bí quyết là gì?

Không có phần mở rộng ngôn ngữ để xác định nhận xét dòng đơn

C

#include <stdio.h>

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

Theo tiêu chuẩn C, điều này rất có thể in ra Answer = -1/12vì sẽ có một tràn số nguyên được ký là hành vi không xác định. Tìm một trình biên dịch sẽ làm điều này được để lại như một bài tập cho người đọc.

Toán học

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

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

Python 3.x

Kinda mới đây. Lời khuyên nào?

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 (Bản thảo 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 );

Làm thế nào nó hoạt động:

1:

Các ý kiến ​​mã là (không ngạc nhiên) tất cả những lời nói dối nhưng chúng là một sự phân tâm từ obfuscation chính.

2:

~ và ^ là các toán tử "bitwise not" và "bitwise xor". Kết quả là một được xác định lại thành -12.

3:

add được đặt thành hàm mũi tên ECMAScript 6 "(result, counter) => (result + counter, counter)" không thực hiện những gì các bình luận gợi ý - thay vào đó, nó chỉ trả về "bộ đếm" biểu thức cuối cùng và có hiệu quả một không-op.

4:

Có hai biến "kết quả" - một biến được viết bằng các ký tự ASCII thuần túy (trong phạm vi toàn cầu) và biến còn lại có Unicode "Cyrillic" (trong phạm vi của hàm ẩn danh được sử dụng để xác định thêm). "result = 1" đặt lại giá trị trong phạm vi toàn cầu và dòng thứ hai "result = (0 |! reѕult) / one;" cũng có phía bên trái đề cập đến biến "kết quả" trong phạm vi toàn cầu nhưng "giới thiệu" ở phía bên phải của biểu thức đề cập đến phạm vi của hàm và có giá trị 0 (thay vì giá trị mong đợi là 1 ) vì vậy giá trị của! reult / 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';
}

Nếu hai #defines bị loại bỏ, mã vẫn sẽ là mã C ++ hợp lệ và thực sự thử (nhưng tất nhiên không thành công) để tính tổng của tất cả các số nguyên.

Làm thế nào nó hoạt động:

Các chỉ thị tiền xử lý biến mã chính thành:

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

Ngoài việc khai báo một Ađối tượng, ba dòng đầu tiên chỉ là obfuscation. Dòng cuối cùng thực hiện tất cả các công việc sử dụng toán tử quá tải <<trên một Ađối tượng.

Đưa ra các áp phích giả mã, tôi không thể cưỡng lại để thêm cái này. Nó sử dụng cùng một ý tưởng cơ bản và nhỏ khác nhưng tôi không nghĩ nó thanh lịch.

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

Làm thế nào nó hoạt động:

Các #definethay đổi ý nghĩa của
while(true) {
để
while(test(counter)) {
Mở máy mà âm thầm tràn mỗi vòng của tổng trước khi tràn sẽ thêm 0x80000001 là kết quả. Do đó sau khi tăng b, b == kết quả khi b chẵn và (b + 0x80000000) == kết quả khi b là số lẻ. 1034594986 là biểu diễn số nguyên của số dấu phẩy động 1/12. Thêm 0x80000001 vào đó sẽ dẫn đến số nguyên gần với -1/12 và hàm kiểm tra sẽ trả về 0 (sai) và vòng lặp sẽ chấm dứt.

Và tại sao bạn không nên thử chạy nó:

Nếu bạn muốn xem các tác phẩm đó được cảnh báo: chức năng kiểm tra phải được gọi là 2 ^ 32 * 1034594986 lần trước khi kết thúc vòng lặp. (tức là không có trong cuộc đời của bạn). Nếu bạn muốn xác minh chức năng đó như đã nói, hãy sử dụng trình gỡ lỗi hoặc thay đổi chương trình để xem giá trị của kết quả và b ngay sau câu lệnh b ++. Khi hài lòng rằng chúng bằng nhau khi b thậm chí chỉ thay đổi giá trị ban đầu của b và bộ đếm thành 1034594986. Sau đó, chương trình sẽ xuất -0,08333 sau một thời gian.