"Disprove" Fermat की अंतिम प्रमेय [बंद]

49

अपनी पसंद की भाषा में, एक प्रोग्राम लिखें, जो फ़र्म के लास्ट प्रमेय का प्रतिवाद सफलतापूर्वक पता करने के लिए प्रकट होता है । यही है, पूर्णांक a , b , c > 0 और n > 2 को ऐसे खोजें जो n + b n = c n हो ।

बेशक, आप वास्तव में ऐसा नहीं कर सकते , जब तक एंड्रयू विल्स के प्रमाण में कोई दोष नहीं है। मेरा मतलब नकली पर है , भरोसा करने से

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

आप कड़ी मेहनत से कोड कुछ या चर के सभी कर सकते हैं a, b, c, या n, या छोरों करके उनके लिए खोज की तरह है for a = 1 to MAX।

यह एक कोड गोल्फ नहीं है; यह चतुर और सूक्ष्म समाधान खोजने की एक प्रतियोगिता है।

popularity-contest  math  underhanded 
— dan04
स्रोत
वास्तव में, आप एक्सप्रेशन के अलावा उन सभी के रूप में हो सकते हैं, जो 3 या अधिक होना चाहिए। तो, 1 ^ 3 + 1 ^ 3 = 1 ^ 3 इसका सरल है।
2
@ दाता: १S + १³ = २; 1³ = 1; 2 14 1
— dan04

जवाबों:

57

जे

वास्तव में, फर्मेट ने काफी गड़बड़ी की है: यह वास्तव में किसी भी बी, सी या एन के लिए गलत है यदि एक 1 है:

   1^3 + 4^3 = 5^3
1
   1^4 + 5^4 = 11^4
1
   1^9 + 3^9 = 42^9
1

शायद बस हो सकता है, Fermat की पूर्वता के नियम कड़ाई से बाएं से दाएं नहीं थे।

— jpjacobs
स्रोत
19
+1 वास्तव में वास्तव में बाएं से दाएं। सिर्फ उन लोगों के लिए जो बाएं से दाएं पढ़ते हैं; पिछले एक के लिए सामान्य संकेतन होगा1^(9 + (3^(9 = (42^9))))
— Seequ
1
डरपोक, मेरा दिमाग तब तक पिघलने वाला था जब तक मैंने @ दरे की टिप्पणी को नहीं देखा
— जर्मन_गुई
3
क्या यह J की एक इच्छित विशेषता है? यह इस तरह की बात है जो वास्तव में लोगों को पागल कर देगी।
— qwr
2
@qwr जम्मू में, सभी मूल्यांकन दाएं से बाएं, कुछ अपवादों के साथ हैं। यह अजीब लगता है, लेकिन वास्तव में बहुत साफ है।
— देखिए
1
@ dan04 सख्ती से सच नहीं बोल रहा। 1^i.5का मूल्यांकन करता है 1 1 1 1 1।
— atı
36

TI-बेसिक

1782^12+1841^12=1922^12

आउटपुट (सत्य)

1
— qwr
स्रोत
8
— dan04
1
मैंने उस एपिसोड को इतनी बार देखा, कभी गौर नहीं किया। अच्छा पकड़ा!
— डोम ०
1
यह उत्तर केवल TI-89-स्वाद TI-Basic के साथ लिखे गए अनुसार काम करता है। TI-84 + SE पर, कोड में एक सिंटैक्स त्रुटि है, क्योंकि TI-Basic का वह संस्करण रिक्त स्थान की अनुमति नहीं देता है। लेकिन जवाब अभी भी एक पुराने कैलकुलेटर पर काम करता है यदि आप रिक्त स्थान, लेखन को हटाते हैं 1782^12+1841^12=1922^12।
— रोरी ओ'केन
1
टीआई-बेसिक का उपयोग करने के लिए +1, यह मेरी पहली प्रोग्रामिंग भाषा थी :)
— किक
2
@ThaneBrimhall यह विडंबना है, एक कैलकुलेटर एक साधारण गणित की समस्या को विफल कर रहा है
— qwr
35

जावा

यह फ़र्मेट आदमी सो रहा होगा। मुझे समीकरणों के सैकड़ों समाधान मिलते हैं। मैंने केवल अपने एक्सेल सूत्र को जावा प्रोग्राम में परिवर्तित किया है।

public class FermatNoMore {
    public static void main(String[] args) {
        for (int n = 3; n < 6; n++)
            for (int a = 1; a < 1000; a++)
                for (int b = 1; b < 1000; b++)
                    for (int c = 1; c < 1000; c++)
                        if ((a ^ n + b ^ n) == (c ^ n))
                            System.out.println(String.format("%d^%d + %d^%d = %d^%d", a, n, b, n, c, n));
    }
}

^ऑपरेटर वास्तव में, जावा में XOR का मतलब है के रूप में ठेठ सादे-पाठ में घातांक करने का विरोध किया

— इरविन बोलविडेट
स्रोत
यह क्यों काम करता है पर एक विस्तार पर कोई मौका?
— वैध
20
@Vality: ^जावा में xor है, पावर नहीं।
— मारिनस
3
यह तकनीकी रूप से लगभग किसी भी C- आधारित भाषाओं पर काम करता है
— phuclv
19

सी ++

#include <cstdlib>
#include <iostream>

unsigned long pow(int a, int p) {
  unsigned long ret = a;

  for (int i = 1; i < p; ++i)
    ret *= a;

  return ret;
}

bool fermat(int n) {
  // surely we can find a counterexample with 0 < a,b,c < 256;
  unsigned char a = 1, b = 1, c = 1;

  // don't give up until we've found a counterexample
  while (true) {
    if (pow(a, n) + pow(b, n) == pow(c, n)) {
      // found one!
      return true;
    }

    // make sure we iterate through all positive combinations of a,b,c
    if (!++a) {
      a = 1;
      if (!++b) {
        b = 1;
        if (!++c)
          c = 1;
      }
    }
  }

  return false;
}

int main(int argc, char** argv) {
  if (fermat(std::atoi(argv[1])))
   std::cout << "Found a counterexample to Fermat's Last Theorem" << std::endl;
}

के साथ संकलित clang++ -O3 -o fermat fermat.cpp, के साथ संकलित Ubuntu clang version 3.4.1-1~exp1 (branches/release_34) (based on LLVM 3.4.1):

./fermat 3
Found a counterexample to Fermat's Last Theorem

हमने स्पष्ट रूप से एक, बी, सी> 0 पाया ताकि एक 3 + बी 3 = सी 3 (यह एन = 4, 5, 6, ... के लिए भी काम करता है)।

ए, बी और सी को प्रिंट करना थोड़ा मुश्किल साबित हो सकता है ...

— Ventero
स्रोत
1
@ dan04: ओह, भूल गया ++में clang++।
— वेंचरो
2
वैसे, यह एक कंपाइलर बग नहीं है। सी (और सी ++) मानक यहां कुछ भी करने की अनुमति देता है, क्योंकि val.uयह अतिप्रवाह कर सकता है (यह uint32_tइसके बजाय अलग होगा )। इसके अलावा, यह कोड unionगलत तरीके से भी उपयोग होता है (मानक के अनुसार, आप एक फ़ील्ड में नहीं लिख सकते हैं, और दूसरे फ़ील्ड को पढ़ सकते हैं), लेकिन यह कई कंपाइलरों (उनके प्रलेखन के अनुसार) द्वारा अनुमत है।
— कोनराड बोरोस्की
3
इसका कारण यह अनुमति दी जाती है C ++ मानक का एक खंड है जो कहता है: एक लूप जो एक स्टेटमेंट के मामले में फॉर-इन-स्टेटमेंट के बाहर, * लाइब्रेरी I / O फ़ंक्शन के लिए कोई कॉल नहीं करता है, और * नहीं करता है अस्थिर वस्तुओं को एक्सेस या संशोधित करना, और * कोई सिंक्रनाइज़ेशन ऑपरेशन (1.10) या परमाणु संचालन करता है (क्लाज 29) को समाप्त करने के लिए कार्यान्वयन द्वारा ग्रहण किया जा सकता है।
— dan04
3
@ dan04 कि वास्तव में शब्दांकन बाद के मसौदे में मानक से हटा दिया गया है, यूएस 38 को open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3196.htm में देखें - लेकिन निश्चित रूप से, यह केवल है सामान्यीकृत। यही कारण है कि फंक्शन (कभी a,b,cभी, उस मामले के लिए) को प्रिंट करने fermat()से फ़ंक्शन कभी वापस नहीं आता है।
— वेंचरो
8
अर्घ मैं एक पोस्ट करने जा रहा था। किसी के लिए भी जो उलझन में है: जॉन रेगेहर ने यहाँ एक अच्छी व्याख्या की है ।
— वू
13

जावा

ऐसा लगता है कि प्रमेय n = 3 के लिए है, लेकिन मुझे n = 4 के लिए प्रतिउत्तर मिले:

public class Fermat {
    public static int p4(final int x) {
        return x * x * x * x;
    }

    public static void main(final String... args) {
        System.out.println(p4(64) + p4(496) == p4(528));
    }
}

आउटपुट:

true

स्पष्टीकरण:

यदि संख्या छोटी लगती है, तब भी जब वे 4 वें शक्ति तक बढ़ जाते हैं, तो वे बह जाते हैं। वास्तव में, ६४ ४ + ४ ९ ६ ४ = ५२ when ४ - २ ३४ , लेकिन २ ३४ बन जाता है जब इंट (३२ बिट्स) तक सीमित रहता है।

— aditsu
स्रोत
क्या आप इसे समझा सकते हैं?
— अबूझ नोब
@AnubianNoob ने किया
— aditsu
9

अजगर

import math
print math.pow(18014398509481984,3) + math.pow(1, 3) \
      == math.pow(18014398509481983,3)

कौन कहता है कि c , a और b से बड़ा होना चाहिए ?

— पेट्र पुडलक
स्रोत
2
यह प्रिंट True, क्योंकि math.pow चल बिन्दु संख्या देता है, और इन सही जवाब पाने के लिए पर्याप्त सटीक नहीं है False।
— 23
5

GolfScript

# Save the number read from STDIN in variable N and format for output.

:N"n="\+

{
  [{100rand)}3*] # Push an array of three randomly selected integers from 1 to 100.
  .{N?}/         # Compute x**N for each of the three x.
  +=!            # Check if the sum of the topmost two results equals the third.
}{;}while        # If it doesn't, discard the array and try again.

# Moar output formatting.

~]["a=""\nb=""\nc="""]]zip

यह दृष्टिकोण विभिन्न समाधानों का एक गुच्छा पाता है। उदाहरण के लिए:

$ golfscript fermat.gs <<< 3
n=3
a=43
b=51
c=82

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

पहली पंक्ति को ~इनपुट की व्याख्या करने के लिए शुरू करना चाहिए । इसके बजाय, उदाहरण के लिए, संख्या 3, चर Nमें स्ट्रिंग शामिल है 3\n। 3 की गणना
करते समय , ASCII कोड 2 के साथ एक चरित्र के सूचकांक को धक्का देता है (-1 में पाया नहीं गया)। इस तरह, और धक्का और धक्का (51 के ASCII वर्ण कोड है )। चूंकि , स्थिति संतुष्ट है और एक "समाधान" है।2 3 ?2 N ?N
43 N ?82 N ?-151 N ?03
-1 + 0 = -1(43,51,82)

— डेनिस
स्रोत
4

सी

बेशक आप लोग सब काउंटरटेम्पल खोज रहे हैं, आप पूर्णांक ओवरफ्लो प्राप्त करते रहते हैं। साथ ही, आप सी पर भी पुनरावृति करके वास्तव में धीमा हो रहे हैं। यह करने के लिए एक बेहतर तरीका है!

#include <stdio.h>
#include <math.h>

int main(void) {
  double a, b, c;
  for (a = 2; a < 1e100; a *= 2) {
    for (b = 2; b < 1e100; b *= 2) {
      c = pow(pow(a, 3) + pow(b, 3), 1.0/3);
      if (c == floor(c)) {
        printf("%f^3 + %f^3 == %f^3\n", a, b, c);
      }
    }
  }
  return 0;
}

double सीमा पर महान हो सकता है, लेकिन यह अभी भी परिशुद्धता में थोड़ा कमी है ...

— शराबी
स्रोत
4

सी

हम सभी पूर्णांक से अधिक नफरत करते हैं, इसलिए हम एक छोटे घातांक nऔर कुछ अस्थायी बिंदु रूपांतरण का उपयोग करेंगे । लेकिन फिर भी प्रमेय के लिए पकड़ नहीं होगी a = b = c = 2139095040।

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

int a, b, c;
int n;

int disprove(int a, int b, int c, int n)
{
    // Integers are so prone to overflow, so we'll reinforce them with this innocent typecast.
    float safe_a = *((float *)&a);
    float safe_b = *((float *)&b);
    float safe_c = *((float *)&c);

    return pow(safe_a, n) + pow(safe_b, n) == pow(safe_c, n);
}

int main(void)
{
    srand(time(NULL));

    a = b = c = 2139095040;
    n = rand() % 100 + 3;

    printf("Disproved for %d, %d, %d, %d: %s\n", a, b, c, n, disprove(a, b, c, n) ? "yes" : "no");
}

आउटपुट:

Disproved for 2139095040, 2139095040, 2139095040, 42: yes

Disproved for 2139095040, 2139095040, 2139095040, 90: yes

IEEE 754 में, संख्या 2139095040, या 0x7F800000, एकल-सटीक फ़्लोटिंग पॉइंट प्रकारों में सकारात्मक अनंतता का प्रतिनिधित्व करता है। सभी pow(...)कॉल + इन्फिनिटी, और + इन्फिनिटी + इन्फिनिटी के बराबर होगी। एक आसान काम 0x7F800001 (शांत NaN) का उपयोग करके पाइथागोरस प्रमेय को बाधित करना होगा जो मानक के अनुसार खुद के बराबर नहीं है।

— यूरी हिम्मत
स्रोत
2

जावास्क्रिप्ट

var a, b, c, MAX_ITER = 16;
var n = 42;
var total = 0, error = 0;

for(a = 1 ; a <= MAX_ITER ; a++) {
  for(b = 1 ; b <= MAX_ITER ; b++) {
    for(c = 1 ; c <= MAX_ITER ; c++) {
      total++;
      if(Math.pow(a, n) + Math.pow(b, n) == Math.pow(c, n)) {
        error++;
        console.log(a, b, c);
      }
    }
  }
}

console.log("After " + total + " calculations,");
console.log("I got " + error + " errors but Fermat ain't one.");

42 जादू है, आप जानते हैं।

> node 32696.js
After 2176 calculations,
I got 96 errors but Fermat ain't one.

और विल्स एक भी नहीं है।

जावास्क्रिप्ट Numberबहुत बड़ा नहीं है।

— नाश्ता
स्रोत
2

T-SQL

इस फर्मेट आदमी के प्रमेय को अस्वीकार करने के लिए, हमें केवल एक काउंटर उदाहरण खोजने की आवश्यकता है। ऐसा लगता है, वह सुपर आलसी था, और केवल उसने वास्तव में छोटे क्रमचय के लिए प्रयास किया। वास्तव में, वह कोशिश भी नहीं कर रहा था। मुझे सिर्फ ० <a, b, c <१५ और २ <e १५ में एक काउंटर उदाहरण मिला। क्षमा करें मैं दिल से एक गोल्फ खिलाड़ी हूं इसलिए मैं इस कोड को बाद में अनगल करूंगा!

with T(e)as(select 1e union all select (e+1) from T where e<14)select isnull(max(1),0)FROM T a,T b,T c,T e where e.e>2 and power(a.e,e.e)+power(b.e,e.e)=power(c.e,e.e)

रिटर्न 1, जिसका अर्थ है कि हमें एक काउंटर उदाहरण मिला!

चाल यह है कि जबकि पहले ई एक उपनाम की तरह दिखता है, यह वास्तव में ई के डेटा प्रकार को एक इंट से एक फ्लोटिंग पॉइंट प्रकार के लिए एक डबल के बराबर बदलने का एक डरपोक तरीका है। जब तक हम 14 के पास पहुंचे तब तक हम एक फ्लोटिंग पॉइंट नंबर की शुद्धता से परे हैं, इसलिए हम इसमें 1 जोड़ सकते हैं और हम अभी भी कुछ भी नहीं खो सकते हैं। मिनिएशन एक अच्छा बहाना है जो समझाने के लिए है कि मेरे उतने ही मूर्खतापूर्ण दोहरे ऐलान की घोषणा आरकेटी में की जाती है। अगर मैंने ऐसा नहीं किया तो 14 ^ 14 के होने से पहले ही यह ओवरफ्लो हो जाएगा।

— माइकल बी
स्रोत
1

जावास्क्रिप्ट

ऐसा लगता है कि यह लड़का कुछ ठीक था। यदि आप मुझसे पूछते हैं तो ओटो दवाओं पर। बाधाओं को देखते हुए, मूल्यों का कोई सेट नहीं पाया जा सकता है जिसके लिए प्रमेय सही है।

var a = 1,
    b = 1,
    c = 1,
    n = 3,
    lhs = (a^n + b^n),
    rhs = c^n;

alert(lhs === rhs);

जावा के रूप में, ^ऑपरेटर जावास्क्रिप्ट में बिटवाइस XOR ऑपरेटर है। किसी संख्या की शक्ति की गणना करने का सही तरीका Math.pow का उपयोग करना है।

— thomaux
स्रोत
2
फर्मेट के लिए, प्रतिपादक ( n) होना चाहिए >= 3।
— पुनरावर्ती
अच्छा बिंदु, कोड अभी भी काम करता है :)
— थोमक्स
0

एक और बुनियादी जवाबी कार्रवाई

10 a = 858339
20 b = 2162359
30 c = 2162380
40 IF (a^10 + b^10) = c^10 THEN
50   PRINT "Fermat disproved!"
60 ENDIF
— बग़ल में ossifrage
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.