प्रोग्राम जो सभी प्राकृतिक संख्याओं को जोड़ता है और उपज -1/12 [बंद]


53

जैसा कि आप जानते होंगे कि एक गणितीय मज़ेदार तथ्य यह है कि यदि आप सभी प्राकृतिक संख्याओं को जोड़ते हैं जो आपके साथ समाप्त होती हैं ... -1/12 (विकिपीडिया यहाँ देखें)

बेशक यह बहुत ही अजीब परिणाम है और केवल एक नंबर को दूसरे के द्वारा जोड़कर प्राप्त नहीं किया जा सकता है, लेकिन कुछ विशेष गणितीय चाल।

हालाँकि, आपका कार्य एक प्रोग्राम लिखना है, जो दिखता है कि यह सभी प्राकृतिक संख्याओं को जोड़ने का प्रयास करता है, लेकिन जब आप इसे चलाते हैं - यह -1/12 पर वापस लौटता है।

छद्मकोड में यह इस तरह दिख सकता है:

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

आप इसे किसी भी तरह से कर सकते हैं, जैसे - आप कुछ बफर अतिप्रवाह का शोषण कर सकते हैं, फेंकी गई त्रुटियों के साथ खेल सकते हैं जबकि कुछ चर बहुत बड़ा हो जाता है या कोड के साथ महत्वपूर्ण चीज को कुछ चतुर तरीके से छिपाते हैं। केवल स्थितियां यह हैं कि कोड को पहले देखना चाहिए जैसे कि यह सभी प्राकृतिक संख्याओं को जोड़ने का प्रयास करता है और जब इसे चलाता है -1/12 (किसी भी प्रारूप में, यह दशमलव, बाइनरी, पाठ, एएससीआई कला जो भी हो) हो सकता है।

कोड में निश्चित रूप से बहुत अधिक हो सकता है, ऊपर दिखाए गए की तुलना में, लेकिन यह पाठक को मूर्ख बनाने के लिए पर्याप्त स्पष्ट होना चाहिए।

यह लोकप्रियता प्रतियोगिता है - सबसे चतुर विचार के लिए वोट करें!


2
अपने टैग्स को निश्चित करें: यदि यह लोकप्रियता-प्रतियोगिता है तो यह कोड-गोल्फ नहीं हो सकता है, और हमारे पास "लिखने वाला कोड जो x जैसा दिखता है, लेकिन y करता है" जैसी चुनौतियों के लिए एक पूर्वनिर्मित टैग है। वैसे भी, यह एक नवागंतुक के लिए बहुत अच्छी चुनौती है! :)
मार्टिन एंडर

2
@ m.buettner - संपादन टैग के लिए धन्यवाद, हां, मैं यहां नया हूं, इसलिए मुझे सभी टैग के बारे में पता नहीं है। मैं नियमों का पालन करने की कोशिश करूँगा!
पावेल टोकरज

3
सवाल के जवाब के साथ ही सभी नीचे क्यों थे? Downvoter: कृपया एक टिप्पणी छोड़ दें।
अर्शजी

7
पहली पंक्ति अपने व्याख्या के आधार पर, पूरी तरह सच नहीं है math.stackexchange.com/questions/39802/...
qwr

3
मैं इस प्रश्न को ऑफ-टॉपिक के रूप में बंद करने के लिए मतदान कर रहा हूं क्योंकि इस साइट पर अंडरहैंड चुनौतियां अब विषय पर नहीं हैं। meta.codegolf.stackexchange.com/a/8326/20469
बिल्ली

जवाबों:


38

सी

प्लेटफार्मों पर काम करते हैं जहाँ दोनों चाहिए sizeof(float)और sizeof(int)4 कर रहे हैं और आईईईई फ्लोटिंग बिंदु मानक (मुझे लगता है) इस प्रकार है।

संस्करण 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;
}

आउटपुट: -0.083

स्पष्टीकरण:

बहुत दिलचस्प जवाब नहीं है, लेकिन भ्रामक टिप्पणियों के साथ।

1 से 79774 तक का योग 3181985425 है, जिसका द्विआधारी प्रतिनिधित्व -0.082638867199420928955078125 है, जिसकी floatबजाय एक के रूप में व्याख्या की गई है unsigned int

ध्यान दें कि जब लूप 2139135936 (NaN ) तक पहुंचता है तो लूप को छोड़ने से बचने !(abs<=0.001)के abs>0.001लिए इसका उपयोग किया जाता है float। (स्वतंत्र isNaNजांच के बजाय इस विचार के सुझाव के लिए @CodesInChaos का धन्यवाद ।)

काउंटर के बजाय राशि की तुलना करके लूप को समाप्त करने के विचार के लिए @Geobits के लिए विशेष धन्यवाद।

संपादित करें: संस्करण 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;
}

आउटपुट: -0.083333

स्पष्टीकरण:

समान int- floatचाल का उपयोग करता है , लेकिन यहां --> "ऑपरेटर" को जाता है। चूँकि हर संख्या अनंत से छोटी होती है इसलिए लूप को एक बार भी निष्पादित नहीं किया जाएगा। इसे

परिवर्तित करने के बाद मैजिक नंबर (यानी -0.83333 की तुलना , या 3182078635) के साथ की जाती है , जो निश्चित रूप से अलग है।floatint0xBDAAAAAB


3
शीर्ष पर #define जानकारी बनाएं और i <INFINITY
ojblass

2
लूप से बाहर निकलने के दिलचस्प तरीकों पर विचार किया जाना चाहिए।
ओजबलास

इसके लिए जो मूल्य है, वह हेक्स में 79776है 137A0, जो है ((int) "\rz") << 4। यह निश्चित नहीं है कि यह कितना उपयोगी है, हालांकि
डुर्रोन 597

3
आप पाश से बाहर निकलने के लिए एक एप्सिलॉन को परिभाषित कर सकते हैं। स्पष्टीकरण: "चूंकि हम अनंत तक नहीं चल सकते हैं, हम एक बार इसे त्रुटि के अस्थायी बिंदु मार्जिन के भीतर -1/12 पर परिवर्तित कर देंगे" या इसी तरह के। आपको प्रत्येक पुनरावृत्ति के फ्लोट मान की जांच करनी होगी, लेकिन इससे उस विषम 'अनंत' मूल्य से छुटकारा मिल जाएगा।
ज्योबिट्स

1
पहले कोड में आप NaN चेक को छोड़ने के while(!(abs<delta))बजाय उपयोग कर सकते हैं while(abs>delta)
कोडइन्चोज

20

अजगर

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

नतीजा:

-0.0833333333333

तो चाल क्या है?

चाल है: यह एक वैध गणना है।


18

मेथेमेटिका

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

(ध्यान दें: इसे एक गणितज्ञ नोटबुक में चिपकाने से संभवतः पता चल जाएगा कि क्या चल रहा है।)


यहाँ क्या हो रहा है कि हम डिफिकल्ट रेगुलराइजेशन होने के लिए डिफाल्ट रेगुलराइजेशन सेट कर रहे हैं Sum(पहली पंक्ति में इनकोड किया गया है - ध्यान दें कि मैथेमेटिका अपने स्रोत में यूनिकोड शाब्दिक अनुमति देता है), इसलिए दूसरी पंक्ति, जो संदर्भ से बाहर की तरह लग रही है अनंत, नियमित मूल्य का उत्पादन समाप्त होता है -1/12


3
मुझे पूरा यकीन है कि यह धोखा है क्योंकि आप योग को काम बनाने के लिए आवश्यक नियमितीकरण का उपयोग करने के लिए कह रहे हैं।
काइल कानोस २ '

4
@KyleKanos वह धोखा क्यों है?
अर्शजी २ '

2
मुझे पता है कि यह कोड गोल्फ नहीं है, लेकिन सिर्फ एक टिप: आप चार वर्णों को काट सकते हैं और सीधे जोड़ सकते हैं 68+{0,37,46,37,31,36,40,33,48}, क्योंकि Plusइसमें Listableविशेषता है। व्यक्तिगत रूप से, मुझे यह अधिक मुहावरेदार लगता है।
डेविड झांग

3
@ हर्षजी: यह धोखा है क्योंकि आप इस तथ्य को छिपाना चाहते हैं कि कोड भ्रामक है। 'नियमितीकरण' नामक पैकेज का उपयोग करने से यह बिल्कुल नहीं छिपता। -1 मुझसे।
काइल कानोस

1
@ वर्षाजी: यह इसे थोड़ा अधिक छिपा देता है और मैंने इसे अन-डाउन कर दिया है।
काइल कानोस

10

सी

के रूप में अच्छी तरह से प्रारूप का जवाब है -1/12, नहीं 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;
}

यह काम किस प्रकार करता है?

386106 को छोड़कर, 656618 तक सभी संख्याएँ। यह 215573541165 देता है।
जब एक स्ट्रिंग के रूप में व्याख्या की जाती है, तो थोड़ा एंडियन प्लेटफॉर्म पर, आपको -1/12 मिलता है।


7

Brainfuck

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

कोड सिर्फ 1 + 2 + 3 + का मूल्यांकन करता है ...

... जब तक i == 256और अतिप्रवाह हुआ, 8-बिट्स सेल आकार मान। उस पर, iबन जाता है 0, लूप समाप्त हो जाता है और निम्नलिखित टिप्पणियों को निष्पादित किया जाता है।


इसका कोई अर्थ नहीं निकलता। अधिकांश व्याख्याकार इस तथ्य के साथ-साथ यह भी दावा करते हैं कि आप इसका मूल्यांकन करते हैं 1 + 2 + 3 + ...जिसका अर्थ है कि 256 को त्रिकोणीय होना होगा i == 256क्योंकि आप भी दावा करते हैं, लेकिन 256 एक त्रिकोणीय संख्या नहीं है। इसके अलावा, आपका कोड आउटपुट -1/12कहां है?
टाइमटेक

@Timtech लूप समाप्त करता है। यह काउंटर है जो ओवरफ्लो कर रहा है, योग नहीं। बस एक छोटी सी समस्या: यह आउटपुट के 1/12बजाय -1/12(हैप्पी टुडे? + .- + - .+ .+ कृपया मुझे वोट दें .) ये चार .आउटपुट के लिए हैं।
ace_HongKongIndोसेंस

@ace यदि यह काउंटर होता, तो दो विकल्प होंगे: 1) यदि कोशिकाएं लपेटती हैं, तो कोई अतिप्रवाह नहीं होगा या 2) यदि कोशिकाएं लपेटती नहीं हैं, तो सम्‍पर्क समाप्‍त होने से पहले काउंटर के समीप जाने का रास्‍ता होगा 256
टाइमटेक

@ace मैं वह मूर्खतापूर्ण गलती कैसे कर सकता हूं? मैंने इसे ठीक कर दिया, लेकिन अब यह कम अंडरहैंड लगता है।
johnchen902

1
@Timtech सेल रैप करते हैं, इसलिए iजब यह हो जाता है तो शून्य हो जाता है 256(यह है कि मैं अतिप्रवाह से क्या मतलब था)। इस बिंदु पर, बाहरी लूप समाप्त हो जाता है, और निम्नलिखित लाइनें (जो टिप्पणियों की तरह लगती हैं) निष्पादित होती हैं, इसलिए का आउटपुट -1/12
जॉनचेन 902

6

बस लूप को इक्का के जवाब पर छोड़ने के लिए थोड़ा बेहतर ओफ़्सेटेशन जोड़ रहा है।

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

संकेत है कि कोई अतिप्रवाह नहीं है ...

इससे पहले कि मैं अपवाद हैंडलर बंद किकिंग चर को बढ़ाता हूं, मैं 0 से विभाजित करता हूं


कुछ टिप्पणी जोड़ें!
नवीन

3
वह बस तब तक योग करता रहता है जब तक कि मैं अतिप्रवाह के कारण फिर से शून्य नहीं हो जाता, जिस बिंदु पर average=sum/i;एक SIGFPE देता है handler, -1/12 को प्रिंट करके।
शाम

अंडरहैंड होने की भावना के खिलाफ टिप्पणी नहीं जोड़ रहा है?
ओजबलास

1
@ojblass इस बात पर निर्भर करता है कि टिप्पणियाँ कैसी हैं। ;-)
डैनियल वैगनर

8
unsigned int sum=3182065200L; printf("%.3f\n",*(float*) &sum);एक मृत जीव है कि वहाँ कुछ चल रहा है, और यह देखते हुए कि यह SIGFPE के लिए हैंडलर में है, यह मेरे स्वाद के लिए बहुत स्पष्ट करता है।
HVD

4

पर्ल 6

यह जीटा फ़ंक्शन का उपयोग करके योग की गणना करता है। मैंने [+] 1..*अनंत समय में रन के अलावा (1 और अनंत के बीच सभी संख्याओं का योग) का उपयोग किया होगा ।

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: "/";

हाहा, मैं एक साधारण योग पोस्ट कर रहा था और यह दावा कर रहा था कि यह काम करेगा, लेकिन आपको प्रिंट करने से पहले अनंत समय तक इंतजार करना होगा। किसी और को भी देखकर अच्छा लगा।
काइल कानोस

4

जावा

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

यह 0 से सभी संख्याओं को अधिकतम मूल्य में जोड़ता है, 12 से गुणा करता है, और अंत में 1 भी जोड़ता है। परिणाम 0 है, इसलिए संख्याओं का योग (0 - 1) / 12 होना चाहिए।

स्पष्टीकरण:

0xffffffff == -1, लूप निष्पादित नहीं करता है


3

माणिक

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)

डेमो

ठीक है, माना आउटपुट शब्दार्थ और वाक्यविन्यास यहाँ बहुत कम समझ में आता है, लेकिन शायद यह एक आकस्मिक नज़र में स्पष्ट नहीं है।

यह भी ध्यान दें कि यह वास्तव में, रूबी प्लेटफ़ॉर्म और संस्करण से स्वतंत्र है। यह उम्मीद के अनुसार परिभाषित किए जा रहे कुछ अन्य स्थिरांक पर निर्भर करता है।


3

सी

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

}

उचित समय में (लगभग) अनंत राशि के साथ सौदा करने के लिए, कुछ संकलक अनुकूलन (आवश्यक) के लिए निम्नलिखित विकल्पों का संकलन करें:

$ gcc -trigraphs sum.c

नमूना उत्पादन:

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

1
यदि आप जानना चाहते हैं कि यह कैसे काम करता है, तो .S फ़ाइल पढ़ें।
जोशुआ

8
आपका संकलक ध्वज सब कुछ दूर देता है ...
ace_HongKongI निर्भरता

3
मानक "कमियां" जो अब मज़ेदार नहीं हैं - ??/ट्रिग्राफ ट्रिक लंबे समय से चतुर होने से रोक दी गई है। :(
डोपेलग्रेनर

लिंक के लिए धन्यवाद, जो बहुत कुछ समझाता है। क्या कहीं भी अक्सर पूछे जाने वाले प्रश्न के लिए एक लिंक है, या मुझे हर बार इसकी खोज करनी है?

@tolos आप इसे पसंदीदा कर सकते हैं, या यह [ faq ] मेटा टैग के तहत एकमात्र प्रश्नों में से एक है , या सामुदायिक FAQ के माध्यम से इसे पा सकते हैं ।
doppelgreener

3

जावा

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

सिद्धांत रूप में, यह प्रिंट होगा true। हालाँकि, मुझे लगता है कि इसे चलाने से पहले मेरा कंप्यूटर धूल में धंस जाएगा।


1
यह सच क्यों माना जाता है? आपको क्यों उम्मीद है कि योग -1/12 तक पहुंच जाएगा?
पावेल टोकरज

@ PawełTokarz मैं जावा विशेषज्ञ नहीं हूं इसलिए मैं निश्चित रूप से नहीं बता सकता, लेकिन यह ध्यान देने योग्य है कि चूंकि जावा पूर्णांक विभाजन -1/12का उपयोग करता है, इसलिए यह शून्य है। तो मुझे लगता है कि यह किसी प्रकार का अतिप्रवाह व्यवहार है जिसके कारण लूप समाप्त हो जाता है और संयोगवश sumओवरफ्लो हो जाता है?
ace_HongKongI निर्भरता

हाँ, एक अतिप्रवाह लूप बंद कर देगा जब यह अधिकतम हो जाता है long। ब्रह्मांड शायद तब तक मौजूद नहीं होगा, लेकिन यह सिर्फ सैद्धांतिक है, है ना? और हां, नीचे के 32 बिट्स sumसभी शून्य होंगे - यही कारण है कि ए, नहीं sumहोना महत्वपूर्ण intहै long। बेशक, जैसा कि @ace ने कहा है, जावा मूल्यांकन करने के लिए पूर्णांक विभाजन का उपयोग करता है -1/12, इसलिए यह शून्य है।
दाऊद इब्न करीम

1
long.MAX_VALUE 9,223,372,036,854,775,807 है। यह बड़ा है, लेकिन केवल 1 लाख गुना प्रति सेकंड वेतन वृद्धि आपको कुछ सौ हजार वर्षों में मिल जाएगी। आपको केवल एक मानव जीवनकाल के भीतर समाप्त करने के लिए प्रति सेकंड लगभग 4 बिलियन वेतन वृद्धि की आवश्यकता होगी। हम यहां "ब्रह्मांड के अंत" टाइमस्केल्स पर बात नहीं कर रहे हैं, जब तक कि आप कुछ नहीं जानते हैं कि आप बाकी के साथ साझा नहीं कर रहे हैं।
user19057

1
@ user19057 सुधार के लिए धन्यवाद। आप बिल्कुल सही हैं, हालाँकि मुझे यह जानकर अच्छा लगेगा कि आपको क्यों लगता है कि ब्रह्मांड 100 000 से अधिक वर्षों तक चलने वाला है। किसी भी स्थिति में, मैं दौड़ने के लिए अपने कार्यक्रम की प्रतीक्षा कर रहा हूं। मुझे बढ़ते हुए देखने के लिए घास है।
दाऊद इब्न करीम

3

जावा

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

यह काम किस प्रकार करता है:

जावा सब कुछ के लिए UTF-8 कोडिंग का उपयोग करता है। मैं सामान्य 'ई' (@CodesInChaos के लिए धन्यवाद) के बजाय अंत में truеएक सिरिलिक वाई के साथ उपयोग करता हूं जो कि एक static booleanआरंभिक है false। मेरे परिभाषित और नाम के बजाय दो स्पष्ट हैक के बजाय import ȷava.math.BigDecimal;एक डॉटलेस जे के साथ है ।import java.math.BigDecimal;ȷava.math.BigDecimalpublic static boolean truе = false;public String toString() { return "-1/12"; }

काश मैं इसे एक बिगाड़ने के रूप में पोस्ट कर सकता लेकिन मैं कैसे काम नहीं कर सकता। यहाँ बाकी कोड है जो चुपके से छिपा हुआ है।

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

Therue / true स्पष्ट रूप से दिखाई दे रहा है, लेकिन java और जावा के बीच का अंतर इतना छोटा है कि मुझे इस बिंदु को देखने के लिए टिप्पणी को कुछ समय पढ़ना पड़ा!
पावेल टोकरज

1
@OldCurmudgeon मुझे लगता है कि सिरिलिक वर्णमाला में ई के लिए एक आदर्श लुकलाइक है: ये (सिरिलिक)
कोडइन्कॉउस

1
अगर मैं गलत नहीं हूं, तो आप अधूरा कोड पोस्ट करें। यदि आप गैर-मानक पैकेज आयात करते हैं, तो आपको उनका कोड भी पोस्ट करना चाहिए।
बदसूरत

1
चीजों को बिना पढ़े बनाने के लिए साइक्रिलिक 'ई' काफी अच्छा है। कल्पना कीजिए: अगर (सच! = सच) {वापसी सच} और {{सच सच}; : डी
पावेल टोकरज

1
@ और जी सच!
पावेल टोकरज

2

कोई हास्केल समाधान, अस्वीकार्य!

हम सटीक उत्तर प्राप्त करने के लिए हास्केल की अनंत सूचियों का उपयोग कर सकते हैं!

हास्केल:

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)

जब आप तीर खाते हैं तो समाधान काफी सीधा होता है ...।

तो चाल क्या है?

एकल पंक्ति टिप्पणी को परिभाषित करने के लिए कोई भाषा विस्तार नहीं है


2

सी

#include <stdio.h>

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

सी मानक के अनुसार, यह बहुत अच्छी तरह से प्रिंट कर सकता है Answer = -1/12क्योंकि एक हस्ताक्षरित पूर्णांक अतिप्रवाह होगा जो अपरिभाषित व्यवहार है। एक संकलक ढूँढना जो ऐसा करेगा उसे पाठक के लिए एक अभ्यास के रूप में छोड़ दिया जाता है।


यह कोड कभी भी नहीं पहुंचेगाprintf
बोगादाकुतु

5
मैं उन उत्तरों को पसंद करता हूं जो आमतौर पर आवश्यक आउटपुट का उत्पादन करते हैं, न कि केवल "इसे अनुमति दें"।
पाओलो एबरमन

2

मेथेमेटिका

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

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

यहाँ छवि विवरण दर्ज करें


2
क्या आप यहाँ क्या चल रहा है, इस पर स्पष्टीकरण देना चाहेंगे?
ace_HongKongInd डिपेंडेंस

हाहा, काफी मज़ेदार है, और यह परीक्षण करने के लिए एक अच्छी सामग्री हो सकती है कि क्या एक गणितज्ञ नौसिखिया ने मूल वाक्यविन्यास को समझ लिया है या नहीं!
xzczd

1

अजगर 3.x

Kinda यहाँ नया। कोई सुझाव?

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())

1

जावास्क्रिप्ट (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 );

यह काम किस प्रकार करता है:

1:

कोड टिप्पणी (बिल्कुल) सभी झूठ हैं, लेकिन वे मुख्य आक्षेप से एक व्याकुलता हैं।

2:

~ और ^ ऑपरेटर "बिटवाइज़ नहीं" और "बिटवाइज़ एक्सोर" हैं। -12 में एक को फिर से परिभाषित किया जा रहा है।

3:

add को ECMAScript 6 एरो फंक्शन "(रिजल्ट, काउंटर) => (रिजल्ट + काउंटर, काउंटर) पर सेट किया गया है" एक सेशन नहीं।

4:

दो "परिणाम" चर हैं - एक को शुद्ध ASCII वर्ण (वैश्विक दायरे में) में लिखा गया है और दूसरे में एक यूनिकोड सिरिलिक "ѕ" है (ऐड को परिभाषित करने के लिए उपयोग किए जाने वाले अनाम फ़ंक्शन के दायरे के भीतर)। "परिणाम = 1" वैश्विक दायरे के भीतर मान को रीसेट करता है और दूसरी पंक्ति "परिणाम = (0 | पुनः!) / एक;" वैश्विक दायरे में "परिणाम" चर का जिक्र करते हुए बाएं हाथ की तरफ भी है, लेकिन अभिव्यक्ति के दाईं ओर "पुन: परिणाम" फ़ंक्शन के दायरे को संदर्भित करता है और इसका मान 0 है (अपेक्षित मूल्य 1 के बजाय) ) इसलिए reѕult / one = -1/12 का मान।


1

सी ++

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

यदि दोनों #defineको हटा दिया जाता है तो कोड अभी भी मान्य होगा C ++ कोड और वास्तव में सभी पूर्णांकों की राशि की गणना करने के लिए प्रयास करें (लेकिन निश्चित रूप से विफल)।

यह काम किस प्रकार करता है:

प्रीप्रोसेसर निर्देश मुख्य कोड में बदल जाता है:

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

एक Aवस्तु को घोषित करने के अलावा पहली तीन पंक्तियाँ सिर्फ आक्षेप हैं। अंतिम पंक्ति <<किसी Aऑब्जेक्ट पर ओवरलोड ऑपरेटर का उपयोग करके सभी काम करती है ।

पोस्टर्स स्यूडोकोड को देखते हुए मैं इसे जोड़ने का विरोध नहीं कर सकता था। यह एक ही मूल और एक छोटे से विचार का उपयोग करता है लेकिन मुझे नहीं लगता कि यह उतना ही सुंदर है।

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

यह काम किस प्रकार करता है:

#defineपरिवर्तन के अर्थ
while(true) {
के लिए
while(test(counter)) {
मशीनों है कि चुपचाप एक अतिप्रवाह से पहले योग के प्रत्येक दौर अतिप्रवाह परिणाम की 0x80000001 जोड़ देगा पर। इसलिए b, b == परिणाम के बढ़ने के बाद जब b सम है और (b + 0x80000000) == परिणाम तब होता है जब b विषम होता है। 1034594986 फ्लोटिंग पॉइंट नंबर 1/12 का पूर्णांक प्रतिनिधित्व है। इसमें 0x80000001 को जोड़ने से पूर्णांक -1/12 के करीब हो जाएगा और परीक्षण फ़ंक्शन 0 (गलत) वापस आ जाएगा और लूप समाप्त हो जाएगा।

और आपको इसे चलाने की कोशिश क्यों नहीं करनी चाहिए:

यदि आप यह देखना चाहते हैं कि कामों को चेतावनी दी गई है: लूप को समाप्त करने से पहले परीक्षण का समापन 2 ^ 32 * 1034594986 बार कहा जाना चाहिए। (अर्थात आपके जीवनकाल में नहीं)। यदि आप उस फ़ंक्शन को सत्यापित करना चाहते हैं, जैसा कि बताया गया है, तो डिबगर का उपयोग करें या b ++ स्टेटमेंट के ठीक बाद परिणाम का मान और प्रोग्राम देखने के लिए प्रोग्राम बदलें। जब संतुष्ट हो जाता है कि वे बराबर हैं जब b भी सिर्फ b और काउंटर के प्रारंभिक मूल्य को बदल कर 1034594986 कर देता है। प्रोग्राम को कुछ समय बाद -0.08333 पर आउटपुट करना चाहिए।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.