প্রোগ্রাম যা সমস্ত প্রাকৃতিক সংখ্যা এবং ফলন যোগ করে -1/12 [বন্ধ]

Question

আপনি জানেন যে একটি গাণিতিক মজাদার ঘটনা আছে যে আপনি যদি সমস্ত প্রাকৃতিক সংখ্যা যুক্ত করেন তবে আপনি শেষ করবেন ... -1/12 (এখানে উইকিপিডিয়া দেখুন) ।

অবশ্যই এটি খুব অদ্ভুত ফলাফল এবং কেবলমাত্র একটি নম্বর পরে অন্য একটি সংখ্যার যোগ করে পাওয়া যায় না, তবে কিছু বিশেষ গাণিতিক কৌশল।

তবে আপনার কাজটি কোনও প্রোগ্রাম লিখতে হচ্ছে , দেখে মনে হচ্ছে এটি সমস্ত প্রাকৃতিক সংখ্যা যুক্ত করার চেষ্টা করে তবে আপনি যখন এটি চালাবেন - এটি ফেরত -১/১২ আসে।

সিউডোকোডে এটি দেখতে দেখতে এটির মতো হতে পারে:

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

আপনি আপনার পছন্দ মতো কোনও উপায়ে এটি করতে পারেন - আপনি কিছু বাফার ওভারফ্লো শোষণ করতে পারেন, নিক্ষিপ্ত ত্রুটিগুলি নিয়ে খেলতে পারেন যখন কিছু পরিবর্তনশীল খুব বড় হয়ে যায় বা কিছু চালাক উপায়ে কোডের সাথে গুরুত্বপূর্ণ জিনিসটি আড়াল করে। একমাত্র শর্তটি হল কোডটি প্রথমে দেখতে হবে যেন এটি সমস্ত প্রাকৃতিক সংখ্যা যুক্ত করার চেষ্টা করে এবং এটি চালানোর সময় -১১/১২ (কোনও বিন্যাসে এটি দশমিক, বাইনারি, পাঠ্য, আসকি শিল্প যাই হোক না কেন)।

কোডটিতে অবশ্যই উপরে বর্ণিত চেয়ে অনেক বেশি কিছু থাকতে পারে তবে পাঠককে বোকা বানানোর জন্য এটি যথেষ্ট পরিষ্কার হওয়া উচিত।

এটি জনপ্রিয়তা প্রতিযোগিতা - সর্বাধিক চতুর ধারণাটির জন্য ভোট দিন!

Comments

আপনার ট্যাগগুলি স্থির করে: যদি এটি জনপ্রিয়তা-প্রতিযোগিতা হয় তবে এটি কোড-গল্ফ হতে পারে না এবং "লিখিত কোড যা এক্স এর মতো দেখায় কিন্তু y হয়" এর মতো চ্যালেঞ্জের জন্য আমাদের একটি আন্ডারহ্যান্ডড ট্যাগ রয়েছে। যাইহোক, এটি একটি নতুন আগতদের পক্ষে বেশ শালীন চ্যালেঞ্জ! :)

— মার্টিন এন্ডার

@ এম.বয়েটনার - ট্যাগ সম্পাদনা করার জন্য ধন্যবাদ, হ্যাঁ, আমি এখানে নতুন, তাই আমি সমস্ত ট্যাগ সম্পর্কে অবগত নই। আমি নিয়ম অনুসরণ করার চেষ্টা করব!

— পাওয়ে টোকার্জ

প্রশ্নের উত্তর সহ সমস্ত উত্তর কেন কেবল নিম্নচালিত? ডাউনভোটার: দয়া করে একটি মন্তব্য দিন।

— আর্শাজি ২

প্রথম লাইন আপনার ব্যাখ্যা উপর নির্ভর করে, সম্পূর্ণরূপে সত্য নয় math.stackexchange.com/questions/39802/...

— qwr

আমি এই প্রশ্নটিকে অফ-টপিক হিসাবে বন্ধ করতে ভোট দিচ্ছি কারণ ছদ্মবেশী চ্যালেঞ্জগুলি এখন আর এই সাইটে অন টপিক নয়। meta.codegolf.stackexchange.com/a/8326/20469

— বিড়াল

Answer 1

সি

উভয় sizeof(float)এবং sizeof(int)4 এর প্ল্যাটফর্মগুলিতে কাজ করা উচিত এবং আইইইই ভাসমান পয়েন্ট মান অনুসরণ করে (আমার ধারণা) ess

সংস্করণ 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।

নোটটি লুপটি এড়াতে !(abs<=0.001)পরিবর্তে ব্যবহৃত হয় abs>0.001যখন যোগফল 2139135936 (NaN in float) হয় তখন। (স্বাধীন isNaNচেকের পরিবর্তে এই ধারণাটি প্রস্তাব দেওয়ার জন্য @ কোডসআইএনচাউসকে ধন্যবাদ জানাই ))

কাউন্টারটির পরিবর্তে যোগফলের তুলনায় লুপটি শেষ করার ধারণার জন্য @ জিওবিটসকে বিশেষ ধন্যবাদ।

সম্পাদনা: সংস্করণ 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-to- floatকৌতুক, কিন্তু --> অপারেটর "থাকে" এখানে। প্রতিটি সংখ্যা অনন্তের চেয়ে ছোট হওয়ায় লুপটি একবারেও কার্যকর করা হবে না।

রূপান্তর করার পর floatএটা দিয়ে তুলনা করা হয় int(যেমন -0,83333 সঙ্গে তুলনা করা হয় ম্যাজিক নম্বর 0xBDAAAAABবা 3182078635,), যা অবশ্যই ভিন্ন।

Comments

শীর্ষে একটি # সংজ্ঞা

— ইনফিনিটি করুন

লুপ থেকে বেরিয়ে আসার আকর্ষণীয় উপায়গুলি বিবেচনা করা উচিত।

— ojblass

জন্য কি মূল্য আছে, হেক্স মধ্যে 79776হয় 137A0যা, ((int) "\rz") << 4। এটি কতটা কার্যকর তা নিশ্চিত নন

— durron597

লুপ থেকে বেরিয়ে আসার জন্য আপনি একটি অ্যাপসিলন সংজ্ঞায়িত করতে পারেন। ব্যাখ্যা: "যেহেতু আমরা অনন্তের দিকে দৌড়াতে পারি না, ততক্ষণে এটি ভুল ত্রুটির ফ্লোটিং পয়েন্ট মার্জিনের মধ্যে -১/১২ এ রূপান্তরিত হয়ে যায়" বা অনুরূপ। আপনাকে প্রতিটি পুনরাবৃত্তির ফ্লোট মানটি পরীক্ষা করতে হবে, তবে এটি সেই 'অনন্য' মান থেকে মুক্তি পাবে।

— জিওবিটস

প্রথম কোডে আপনি NaN চেক বাদ দেওয়ার while(!(abs<delta))পরিবর্তে ব্যবহার করতে পারেন while(abs>delta)।

— কোডসইনচওস

Answer 2

পাইথন

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

তাহলে কৌশলটি কী?

কৌশলটি হ'ল: এটি একটি বৈধ গণনা।

Answer 3

ম্যাথামেটিকাল

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

(দ্রষ্টব্য: এটি গাণিতিক নোটবুকে আটকানো সম্ভবত যা ঘটছে তা প্রকাশ করবে))

---

কি এখানে ঘটনাটি হল আমরা ডিফল্ট সেটিং করছি নিয়মিতকরণ এর SumDirichlet নিয়মিতকরণ করা (প্রথম লাইনে এনকোড - লক্ষ্য করুন যে ম্যাথামেটিকাল তার সোর্সে ইউনিকোড লিটারেল মঞ্জুর করে), তাই দ্বিতীয় লাইন, যা প্রসঙ্গের বাইরে বলে মনে হচ্ছে উত্পাদন করবে অনন্ত, নিয়মিত মান উত্পাদন শেষ -1/12।

Comments

আমি নিশ্চিত যে এটি প্রতারণা করছে কারণ আপনি ম্যাথমেটিকাকে যোগফলটি তৈরির জন্য প্রয়োজনীয় নিয়মিতকরণটি ব্যবহার করতে বলছেন।

— কাইল কানোজ

@ কাইলকানোস কেন এই প্রতারণা করছে?

— আরশাজি

আমি জানি এটি কোড গল্ফ নয়, তবে কেবল একটি টিপ: আপনি চারটি অক্ষর কেটে সরাসরি যুক্ত করতে পারেন 68+{0,37,46,37,31,36,40,33,48}, কারণ Plusএর Listableবৈশিষ্ট্যটি রয়েছে। ব্যক্তিগতভাবে আমি এটিকে আরও মূর্খ বলে মনে করি।

— ডেভিড জাং

@ মার্শজি: এটি প্রতারণা করছে কারণ আপনি কোডটি বিভ্রান্ত করছে এমন সত্যটি লুকিয়ে রাখার কথা । 'নিয়মিতকরণ' নামক একটি প্যাকেজ ব্যবহার করা এটিকে মোটেই আড়াল করে না। আমার কাছ থেকে।

— কাইল কানোজ

@ আরশাজি: এটি এটিকে আরও কিছুটা লুকিয়ে রাখে এবং আমি এটিকে হ্রাস করে ফেলেছি।

— কাইল কানোজ

Answer 4

সি

উত্তমরূপে উত্তরটি ফর্ম্যাট করে -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 পর্যন্ত সমস্ত সংখ্যার
যোগফল।

Answer 5

Brainfuck

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

কোডটি কেবল 1 + 2 + 3 + মূল্যায়ন করে ...

... i == 2568-বিট ঘরের আকার ধরে ধরে ওভারফ্লো হয়েছে until এর পরে, iহয়ে যায় 0, লুপটি সমাপ্ত হয় এবং নীচের মন্তব্যগুলি কার্যকর করা হয়।

Comments

এর কোন মানে নেই. বেশিরভাগ দোভাষীর সাথে মোড়ানো পাশাপাশি আপনি দাবি করেন যে এটি দাবি করে 1 + 2 + 3 + ...যা মূল্যায়ন করে যার অর্থ হল যে আপনি দাবি হিসাবে 256 ত্রিভুজাকার হতে হবে i == 256তবে 256 ত্রিভুজাকার সংখ্যা নয়। এছাড়াও, আপনার কোড আউটপুট -1/12কোথায়?

— টিমটেক

@ টিমটেক লুপটি সমাপ্ত হবে। এটি কাউন্টার যা উপচে পড়ছে, যোগফল নয়। একটি ছোট সমস্যা: এটি আজকের 1/12পরিবর্তে আউটপুট দেয় -1/12(আজ শুভ? + .- - .+ + .+ দয়া করে আমাকে ভোট দিন .) এই চারটি .আউটপুট দেওয়ার জন্য।

— #HongKongI depend depend

@ace যদি এটি পাল্টা হত তবে দুটি বিকল্প থাকবে: ১) যদি কোষগুলি মোড়ানো থাকে, তবে কোনও উপরি প্রবাহ বা 2 থাকবে না) যদি কোষগুলি মোড় না দেয় তবে সমষ্টিটি কাউন্টারের আরও নিকটবর্তী হওয়ার আগেই উপচে পড়বে 256।

— টিমটেক

@ace আমি কীভাবে এই নির্বোধ ভুল করতে পারি? আমি এটি ঠিক করেছিলাম, তবে এখন এটি কম আন্ডারহ্যান্ডেড মনে হচ্ছে।

— johnchen902

@ টিমটেক সেলগুলি মোড়ানো থাকে, সুতরাং iএটি শূন্য হয়ে যায় 256(এটাই আমি বোঝাতে চাইছি)। এই বিন্দুতে, বাহ্যিক লুপটি সমাপ্ত হয় এবং নিম্নলিখিত লাইনগুলি (যা মন্তব্যগুলির মতো মনে হয়) সম্পাদন করা হয়, সুতরাং এর আউটপুট -1/12।

— johnchen902

Answer 6

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

ইঙ্গিত কোনও ওভারফ্লো নেই ...

আমি পরিবর্তনশীল বর্ধিত হওয়ার আগে আমি 0 দিয়ে বিভক্ত হয়েছি ব্যতিক্রম হ্যান্ডলারটিকে লাথি মেরে

Comments

কিছু মন্তব্য যুক্ত করুন!

— নবীন

ওভারফ্লোর কারণে আমি আবার শূন্য না হওয়া পর্যন্ত সে কেবল সংশ্লেষ রাখে, যার পয়েন্টে 1-12/12-এ প্রিন্ট করা average=sum/i;একটি SIGFPE দেয় handler।

— টমসডিং

নিম্নচাপিত হওয়ার চেতনার বিরুদ্ধে মন্তব্য যোগ করছেন না?

— ojblass

@ ওজব্লাস মন্তব্যগুলি কীভাবে আন্ডারহ্যান্ডেড তা নির্ভর করে। ;-)

— ড্যানিয়েল ওয়াগনার

unsigned int sum=3182065200L; printf("%.3f\n",*(float*) &sum);এটি একটি মৃতপ্রদান যা কিছু সেখানে চলছে এবং এটি সিএফপিপিই-র হ্যান্ডলারের মধ্যে রয়েছে তা আমার স্বাদগুলির জন্য এটি খুব স্পষ্ট করে তোলে।

— এইচডিভি

Answer 7

পার্ল 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: "/";

Comments

হাহা, আমি একটি সাধারণ সংক্ষেপণ পোস্ট করার এবং এটি কাজ করবে বলে দাবি করার কথা ভাবছিলাম, তবে এটি মুদ্রণের আগে আপনাকে অসীম সময়ের জন্য অপেক্ষা করতে হবে। অন্য কারও ভেবে দেখে ভাল লাগল।

— কাইল কানোজ

Answer 8

জাভা

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, লুপ মোটেও কার্যকর হয় না

Answer 9

চুনি

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)

ডেমো

ঠিক আছে, অনুমিত আউটপুট শব্দার্থবিজ্ঞান এবং সিনট্যাক্সটি এখানে সামান্য ধারণা দেয়, তবে সম্ভবত এটি একটি নৈমিত্তিক নজরে স্পষ্ট নয়।

এছাড়াও লক্ষ করুন যে এটি প্রকৃতপক্ষে রুবি প্ল্যাটফর্ম এবং সংস্করণ থেকে স্বতন্ত্র। এটি প্রত্যাশিত হিসাবে সংজ্ঞায়িত করা কিছু অন্যান্য ধ্রুবকগুলির উপর নির্ভর করে।

Answer 10

সি

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

Comments

এটি কীভাবে কাজ করে তা আপনি জানতে চাইলে .S ফাইলটি পড়ুন।

— জোশুয়া

আপনার সংকলক পতাকাটি সমস্ত কিছু দূরে দেয় ...

— #HongKongInd dependence

স্ট্যান্ডার্ড "লুফোলস" যা আর মজার নয় - ??/ট্রাইগ্রাফ ট্রিকটি চালাক হওয়া বন্ধ করে দিয়েছে। :(

— ডপপেলগ্র্রাইনার

লিঙ্কটির জন্য আপনাকে ধন্যবাদ, যা অনেক কিছু ব্যাখ্যা করে। এফএকিউ-র কোনও লিঙ্ক কি কোথাও আছে, নাকি আমাকে প্রতিবার এটি অনুসন্ধান করতে হবে?

@ টলোস আপনি এটি পছন্দ করতে পারেন, বা এটি [ ফ্যাক্স ] মেটা ট্যাগের অধীনে কেবল প্রশ্নগুলির মধ্যে একটি , বা এটি কমিউনিটি FAQ এর মাধ্যমে খুঁজে পেতে পারেন ।

— ডপপেলগ্রিনিয়ার

Answer 11

জাভা

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

তত্ত্বগতভাবে, এটি মুদ্রণ করবে true। যাইহোক, আমি মনে করি আমার কম্পিউটার এটি চালানো শেষ হওয়ার আগে ধূলায় ডুবে যাবে।

Comments

কেন এটি সত্য মুদ্রণ করার কথা? কেন আপনি প্রত্যাশা করছেন যে যোগফলটি 1/12-এ পৌঁছাবে?

— পাওয়ে টোকার্জ

@ পাওয়েটোকার্জ আমি জাভা বিশেষজ্ঞ নই তাই আমি নিশ্চিত করে বলতে পারি না, তবে এটি লক্ষণীয় যে জাভা যেহেতু পূর্ণসংখ্যা বিভাগটি ব্যবহার করে -1/12তা নিছক শূন্য। সুতরাং আমি ধরে নিই যে এটি কোনও ধরণের ওভারফ্লো আচরণ যা লুপটি শেষ করে এবং কাকতালীয়ভাবে sumওভারফ্লোগুলি শূন্যের দিকে নিয়ে যায়?

— #HongKongInd dependence

হ্যাঁ, একটি ওভারফ্লো সর্বোচ্চের দিকে গেলে লুপটি থামিয়ে দেবে long। ততক্ষণে সম্ভবত মহাবিশ্বের আর অস্তিত্ব থাকবে না, তবে এটি ঠিক তাত্ত্বিক, তাই না? এবং হ্যাঁ, নীচের 32 বিটগুলি sumসমস্তই শূন্য হবে - এ কারণেই এটি sumএকটি intনয়, হওয়া গুরুত্বপূর্ণ long। অবশ্যই, @ace যেমনটি বলেছে, জাভা মূল্যায়নের জন্য পূর্ণসংখ্যা বিভাগ ব্যবহার করে -1/12, তাই এটি শূন্য।

— দাউদ ইবনে কেরেম

দীর্ঘ.ম্যাক্স_ভ্যালু হ'ল 9,223,372,036,854,775,807। এটি বড়, তবে প্রতি সেকেন্ডে মাত্র 1 মিলিয়ন বার বাড়ানো কেবল কয়েক লক্ষ হাজার বছরে আপনাকে সেখানে পেয়ে যাবে। মানুষের জীবনকাল শেষ করতে আপনার প্রতি সেকেন্ডে প্রায় 4 বিলিয়ন বৃদ্ধি প্রয়োজন। আপনি এখানে আমাদের "মহাবিশ্বের শেষ" টাইমসেকলে কথা বলছি না, যদি না আপনি আমাদের কিছুটা ভাগ করে নিচ্ছেন এমন কিছু জানেন।

— ব্যবহারকারী19057

@ user19057 সংশোধন করার জন্য ধন্যবাদ। আপনি অবশ্যই ঠিকই বলেছেন, যদিও আমি জানতে আগ্রহী যে আপনি কেন মনে করেন মহাবিশ্বটি আরও 100,000 এরও বেশি বছরের জন্য স্থায়ী হবে। যাই হোক না কেন, আমি আমার প্রোগ্রামটি শেষ হয়ে যাওয়ার অপেক্ষায় বসে পড়ব না। আমার বাড়ার জন্য ঘাস আছে।

— দাউদ ইবনে কেরেম

Answer 12

জাভা

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

কিভাবে এটা কাজ করে:

জাভা সব কিছুর জন্য ইউটিএফ -8 কোডিং ব্যবহার করে। আমি সাধারণ 'ই' (@ কোডসইনচায়োসকে ধন্যবাদ) এর পরিবর্তে শেষে truеএকটি সিরিলিক ইয়ে ব্যবহার করি যা এর static booleanসূচনা হয় false। আছে import ȷava.math.BigDecimal;একটি সঙ্গে বিন্দু বিহীন ঞ পরিবর্তে import java.math.BigDecimal; আমার ȷava.math.BigDecimalসংজ্ঞায়িত public 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;
    }
}

Comments

/Rue / সত্যটি স্পষ্টভাবে দৃশ্যমান, তবে জাভা এবং জাভা এর মধ্যে পার্থক্য এত ছোট, এই বিন্দুটি চিহ্নিত করার জন্য আমাকে কয়েকবার মন্তব্যটি পড়তে হয়েছিল!

— পাওয়ে টোকার্জ

@OldCurmudgeon আমার মনে হয় জন্য একটি নিখুঁত lookalike হয় ই সিরিলিক বর্ণমালায়: তোমরা (সিরিলিক)

— CodesInChaos

যদি আমি ভুল না হয়ে থাকেন তবে আপনি অসম্পূর্ণ কোডটি পোস্ট করুন। আপনি যদি মানহীন প্যাকেজগুলি আমদানি করেন তবে আপনার কোডও তাদের পোস্ট করা উচিত।

— উগোরেন

জিনিসগুলি অপঠনযোগ্য করার জন্য সাইরিলিক 'ই' বেশ দুর্দান্ত। কল্পনা করুন: যদি (সত্য! = সত্য) {সত্য প্রত্যাবর্তন করুন} অন্যথায় true সত্য প্রত্যাবর্তন করুন} : ডি

— পাওয়ে টোকার্জ

@ অ্যান্ড্রু জি সত্য!

— পাওয়ে টোকার্জ

Answer 13

হাস্কেল সমাধান নেই, অগ্রহণযোগ্য!

আমরা সঠিক উত্তর পেতে হাস্কেলের অসীম তালিকা ব্যবহার করতে পারি!

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)

আপনি যখন তীরগুলি অ্যাকাউন্টে নেন তখন সমাধানটি মোটামুটি সোজা হয়ে যায় ....

তাহলে কৌশলটি কী?

একক লাইন মন্তব্য সংজ্ঞায়িত করার জন্য কোনও ভাষা বর্ধন নেই

Answer 14

সি

#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করতে পারে যেহেতু একটি স্বাক্ষরিত পূর্ণসংখ্যা ওভারফ্লো হবে যা অপরিজ্ঞাত আচরণ। এটি করবে এমন একটি সংকলক সন্ধান করা পাঠকের অনুশীলন হিসাবে ছেড়ে গেছে।

Comments

এই কোডটি কখনই পৌঁছাবে নাprintf

— বগডাকুটু

আমি উত্তরগুলি পছন্দ করি যা সাধারণত প্রয়োজনীয় আউটপুট উত্পাদন করে, কেবল "এটির অনুমতি দিন" না।

— পাওলো ইবারম্যান

Answer 15

ম্যাথামেটিকাল

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

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

Comments

এখানে কী চলছে সে সম্পর্কে কোনও ব্যাখ্যা দিতে আপনি কি আপত্তি করবেন?

— #HongKongInd dependence

হাহাহা, বেশ মজার, এবং কোনও গণিতের নবাগত মৌলিক বাক্য গঠনটি বুঝতে পেরেছে কিনা তা পরীক্ষা করার জন্য এটি একটি ভাল উপাদান হতে পারে !

— xzczd

Answer 16

পাইথন 3.x

কিন্ডা এখানে নতুন। কোন টিপস?

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

Answer 17

জাভাস্ক্রিপ্ট (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:

যোগটি ECMAScript 6 টি তীর ফাংশনটিতে সেট করা হয়েছে "(ফলাফল, কাউন্টার) => (ফলাফল + কাউন্টার, কাউন্টার)" যা মন্তব্যগুলি তার পরামর্শ অনুযায়ী যা করে না - পরিবর্তে এটি কেবলমাত্র সর্বশেষ এক্সপ্রেশনটিকে "কাউন্টার" দেয় এবং কার্যকরভাবে কার্যকর হয় একটি অপ-বিকল্প

4:

দুটি "ফলস্বরূপ" ভেরিয়েবল রয়েছে - একটি খাঁটি ASCII অক্ষরগুলিতে লেখা হয় (বৈশ্বিক স্কোপগুলিতে) এবং অন্যটিতে একটি ইউনিকোড সিরিলিক "ѕ" থাকে (অ্যাড সংজ্ঞায়িত করার জন্য বেনামে ফাংশনের সুযোগের মধ্যে)। "ফলাফল = 1" গ্লোবাল স্কোপ এবং দ্বিতীয় লাইনের মধ্যে মানটিকে পুনরায় সেট করে "ফলাফল = (0 |! পুনঃসংশ্লিষ্ট) / এক;" বাম দিকটিও বিশ্বব্যাপী সুযোগে "ফলাফল" পরিবর্তনশীলকে উল্লেখ করে তবে অভিব্যক্তির ডানদিকে "পুনরায়" ফাংশনের সুযোগকে বোঝায় এবং মান 0 (1 এর প্রত্যাশিত মানের পরিবর্তে) ) তাই মান! রেজাল্ট / ওয়ান = -1/12।

Answer 18

সি ++

#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টি সরানো হয় তবে কোডটি এখনও বৈধ সি ++ কোড হবে এবং সমস্ত সংখ্যার যোগফল নির্ধারিত করতে আসলে চেষ্টা করবে (তবে অবশ্যই ব্যর্থ হবে)।

কিভাবে এটা কাজ করে:

প্রিপ্রোসেসর নির্দেশিকা প্রধান কোডকে এই রূপে পরিণত করে:

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 যোগ হবে অন। সুতরাং খ এর বর্ধনের পরে, খ == ফলাফল যখন খ সমান হয় এবং (বি + 0x80000000) == ফলাফল যখন বিজ বিজোড় হয়। 1034594986 হল ভাসমান পয়েন্ট সংখ্যা 1/12 এর পূর্ণসংখ্যা উপস্থাপনা। এতে 0x80000001 যুক্ত করার ফলে পূর্ণসংখ্যার -1/12 এর নিকটবর্তী হবে এবং পরীক্ষার ফাংশন 0 (মিথ্যা) ফিরে আসবে এবং লুপটি সমাপ্ত হবে।

এবং কেন আপনি এটি চালানোর চেষ্টা করবেন না:

যদি আপনি দেখতে চান যে কাজগুলি সতর্ক করা হয়েছে: লুপটি শেষ করার আগে পরীক্ষার ফান্টটিকে 2 ^ 32 * 1034594986 বার কল করতে হবে। (যেমন আপনার জীবদ্দশায় নয়)। আপনি যদি সেই ফাংশনটি যা যা বলেছেন তা যাচাই করতে চান, একটি ডিবাগার ব্যবহার করুন বা ফলাফলের মান দেখতে প্রোগ্রামটি পরিবর্তন করুন এবং বি ++ স্টেটমেন্টের ঠিক পরে। যখন সন্তুষ্ট হন যে তারা সমান হয় যখন খ এমনকি খ এর প্রাথমিক মান পরিবর্তন করে 1034594986 এ পাল্টায় The প্রোগ্রামটি কিছু সময়ের পরে আউটপুট -0.08333 করা উচিত।