क्लासिक सबूत पतन [बंद]

Question

पृष्ठ - भूमि

तो, हम सभी इस तरह से जाने वाले क्लासिक प्रूफ को जानते हैं:

a = b
a² = अब
a² - b² = अब - b²
(ab) (ए + बी) = ख (ab)
(ए + बी) = ख
ख + b = ख
2 बी = बी
2 = 1 (हा हा!)
के बेशक, गलती यह है कि आप 0. से विभाजित नहीं कर सकते हैं। चूंकि a = b, a - b = 0 है, इसलिए 0 से एक छिपा हुआ विभाजन था।

चुनौती

आपको इस प्रमाण को दोहराना होगा। सबसे पहले, दो पूर्णांकों को ए और बी घोषित करें (इससे कोई फर्क नहीं पड़ता कि आप उन्हें क्या कहते हैं)। फिर aMod और bMod को क्रमशः a और b के रूपांतरों के रूप में घोषित करें और क्रमशः a और b के बराबर। आपको उन दोनों को एक से गुणा करना होगा, फिर दोनों से b * b को घटाएं। फिर आपको a - b से विभाजित करना होगा और फिर प्राप्त करने के लिए उन्हें b (या a) से विभाजित करना होगा। फिर, उनके बीच एक समान चिह्न के साथ एमोड और बीमोड का प्रिंट आउट लें।

द अंडरहैंड

बेशक, चूँकि आपने a और b को बराबर घोषित किया है, a - b = 0, और 0 से विभाजित करने से त्रुटि होती है। इसलिए आपको इसे रचनात्मक रूप से नकली बनाना चाहिए। इसके अलावा, क्योंकि आप प्रूफ को दोहराने की कोशिश कर रहे हैं, प्रिंट होने पर एमोड और एममॉड पर सभी ऑपरेशन का परिणाम बराबर नहीं होना चाहिए। उन्हें ठीक 2 और 1 की बराबरी करने की जरूरत नहीं है, सिर्फ दो नंबर बराबर नहीं हैं।

यहाँ एक उदाहरण है:

#include <iostream>
#define subtract(a, b) a - b

using namespace std;
int main()
{
    int a = 4, b = 4;
    int a_2 = a, b_2 = b;

    a_2 *= a;
    b_2 *= b;

    a_2 -= b * b;
    b_2 -= b * b;

    a_2 = a_2 / subtract(a, b);
    b_2 = b_2 / subtract(-b, -a); // a - b == (-b) - (-a)

    a_2 /= a;
    b_2 /= a;

    cout << a_2 << " = " << b_2 << " because I did the same operations on both of them.";

    return 0;
}

शायद सबसे अच्छा नहीं है, लेकिन यह इस बिंदु को दिखाता है।

बोनस अंडरहैंड किया गया

बराबरी के संकेत को प्रिंट करने के बजाय, आप केवल दो चर (aMod और bMod) का प्रिंट आउट ले सकते हैं, और फिर कोड है जो समानता के लिए दो चर की तुलना करने के लिए प्रकट होता है, लेकिन वास्तविकता में वे झूठ बोलते हैं (और किसी न किसी रूप में छापते हैं true)।

याद रखें, यह एक लोकप्रियता प्रतियोगिता है, इसलिए सबसे अधिक संख्या में जीत होती है।
इसके अलावा, गणित के एक नए संस्करण जिसे गणित 2.0 कहा जाता है, ने मानक खामियों का उपयोग स्वचालित रूप से एक सबूत को अमान्य कर दिया है।

Comments

यहाँ गणितीय

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

— बिल्ली

Answer 1

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

var a=3,b=3,a2=3,b2=3
[a2,b2]=[a2*a,b2*a]
[a2,b2]=[a2-b*b,b2-b*b]
[a2,b2]=[a2/(a-b),b2/(a-b)]
console.log([a2/a,b2/a])

आउटपुट:

[1, NaN]

ध्यान दें कि 0/0 = NaN

संकेत

कुछ अर्धविराम जोड़ने की कोशिश करें।
यह कार्यक्रम वास्तव में है var a=3,b=3,a2=3,b2=3[a2,b2]=...=[a2/(a-b),b2/(a-b)];console.log([a2/a,b2/a])।
और NaN है [3/0,undefined/0]/3।

Comments

वाह। यह बहुत चालाक था , "गलती से" अर्धविराम बनाने (लगभग) पूरे कार्यक्रम को एक रन-ऑन वाक्य जोड़ना भूल गया।

— user155698

Answer 2

अजगर २

मुझे पूरा यकीन है कि यह स्पष्ट है क्योंकि हर कोई अजगर जानता है, लेकिन यहाँ मेरा प्रयास है:

a=b=1
x,y=a*a,a*b
x,y=x-b*b,y-b*b
x,y=a+b/a-b,b
x,y=x/a,y/a
print(x==y)

यह आउटपुट करता है True।

संकेत:

मेरे विभाग की जाँच करें।

Comments

चूंकि हर कोई अजगर का उपयोग करता है । मैं अजगर जानता हूं, लेकिन मैं शायद ही कभी इसका इस्तेमाल करता हूं

— rpax

@rpax यही मेरा मतलब है।

— mbomb007

क्षमा करें, मैंने आपका उत्तर ठीक से नहीं पढ़ा।

— rpax

Answer 3

माणिक

def calculate a,
  b = a
  left, right = a, b
  left, right = [left, right].map { |x| x * a     }
  left, right = [left, right].map { |x| x - b*b   }
  left, right = [left, right].map { |x| x / a - b }
  left, right = [left, right].map { |x| x / b     }
  puts $/=[left, right].join(' = ')
end

calculate 3,
STDOUT.write($/)

ideone

संकेत:

,

स्पष्टीकरण:

कॉमा में समाप्त होने वाली दो लाइनें प्रोग्राम को अलग तरीके से व्यवहार करने का कारण बनती हैं। अल्पविराम के बिना, विधि एक ही तर्क लेती है a, bबराबर सेट aकरती है , प्रत्येक पर प्रमाण से परिवर्तन करती है (कुछ गुम कोष्ठक को छोड़कर, यह 0 से विभाजित नहीं होता है), और परिणाम को आउटपुट करता है (3 के इनपुट के साथ) , यह आउटपुट "-1 = -1" होगा। अनुगामी अल्पविराम के साथ, हालांकि, b = aलाइन विधि हस्ताक्षर का हिस्सा बन जाती है, जिसका अर्थ है कि यह एक डिफ़ॉल्ट मान के साथ दूसरा तर्क घोषित कर रहा है। अंत में विधि मंगलाचरण गुजरता है। परिणाम STDOUT.write($/), जो कि 1 है (बाइट्स की संख्या जो STDOUT को लिखी गई है, क्योंकि $/एक नए वर्ण में पूर्वनिर्धारित है।) तो एक 3 है और b 1 है, जिसके परिणामस्वरूप समीकरण "3 = 1" के रूप में शुरू होता है। कचरा। कचड़ा बाहर।

Comments

आपकी नई सुर्खियों के साथ अच्छी चाल।

— लेजिओनमल 978

क्या आप गैर-रूबिस्टों के लिए स्पष्टीकरण जोड़ सकते हैं?

— kirbyfan64sos

@ kirbyfan64sos ज़रूर, किया।

— हिस्टोक्रैट

Answer 4

GolfScript

चेतावनी: यह प्रोग्राम थोड़ा धोखा दे रहा है, इसमें यह aMod और bMod प्रिंट नहीं करता है

1nt main(){
  int a = 2, b = 2;
  int aMod,bMod;
//The next line should throw and error, but why doesn't it??/
  aMod = (a*a - b*b) / (a-b);
//The next line should throw and error, but why doesn't it??/
  bMod = (b*a - b*b) / (a-b);
//The if should fail, but it works??/
  if(aMod == bMod)
    printf("1");
  return 0;
};

इसे यहाँ आज़माएँ !

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

पहली चीज़ जो आपने देखी होगी, वह है "निषिद्ध ट्रिग्राफ"। लेकिन याद रखें, यह गोल्फस्क्रिप्ट है, सी नहीं! इसके अलावा, शायद ध्यान दिया जाता है कि यह वास्तव में "int main ()" नहीं कहता है, यह "1nt main ()" कहता है। गोल्फस्क्रिप्ट में, "1" का मतलब स्टैक पर 1 धक्का है, और "एनटी मुख्य" को दो असिंचित चर के रूप में संसाधित किया जाता है, जो कुछ भी नहीं करते हैं। दो कोष्ठक पहले स्टैक के शीर्ष संख्या में 1 जोड़ते हैं, और फिर एक को घटाते हैं, अनिवार्य रूप से खुद को बाहर निकालते हैं। कोष्ठक एक ब्लॉक को दर्शाता है जो स्टैक पर धकेल दिया जाता है, और फिर अर्धविराम इसे तुरंत बंद कर देता है। तो, अंत में, हमारे पास मूल "1" है जिसे धक्का दिया गया था, और एक गोल्फस्क्रिप्ट कार्यक्रम के अंत में, स्टैक मुद्रित किया गया था। इस उत्तर से प्रेरित था इस एक।

Comments

ट्रिग्राफ का पता चला। स्वचालित -1 प्रणाली को सक्रिय करना। त्रुटि: -1 विफल (4792, आरपीएलएस)

— कैलकुलेटरफैलीन

यह डरपोक है, क्योंकि यह आपको चकरा देता है यह सोचकर कि यह आपको धोखा देने में विफल रहा है। +1

— Rɪᴋᴇʀ

Answer 5

Prolog

areEqual(A, B) :-
    Amod = A,
    Bmod = B,

    Amod = Amod * A,
    Bmod = Bmod * B,

    Amod = Amod - B*B,
    Bmod = Bmod - B*B,

    Amod = Amod / (A-B),
    Bmod = Bmod / (A-B),

    Amod = Amod / A,
    Bmod = Bmod / A,

    Amod == Bmod.

जब areEqual(4,4)कहा जाता है आउटपुट (या वास्तव में किसी भी अन्य संख्या):

false

क्यों?

प्रोलॉग में, ऑपरेटर "=" प्रभावित नहीं होता है; यह "एकीकरण" है। इसलिए Amod = Amod * Aविफल रहता है क्योंकि Amodपहले से ही एकीकृत किया गया है A, और इस तरह संभवतः के साथ एकीकृत नहीं किया जा सकता है Amod * A। Prolog तो immediatly वर्तमान नियम और रिटर्न को क्रियान्वित बंद हो जाता है false।

Comments

मुझे लगता है कि यह चारों ओर का दूसरा तरीका होना चाहिए, आपको "सही" आउटपुट करना होगा जब दो मान अलग-अलग होंगे, "झूठे" नहीं जब वे ^ ^ 'के बराबर होंगे

— काटनेंको

Answer 6

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

//Very badly written code!
//No! It is "poetic" code!
while(true){break;}{ 
let scrollMaxX = 3, screenX = 3;
var scrollBarWithBeerMax = scrollMaxX, Yscroll = screenX; for(var i = 0; i<1; i++){}}

scrollBarWithBeerMax *= scrollMaxX;
Yscroll *= screenX;

scrollBarWithBeerMax -= screenX * screenX;
Yscroll -= screenX * screenX;

scrollBarWithBeerMax /= (scrollMaxX - screenX);
Yscroll /= (scrollMaxX - screenX);

alert(scrollBarWithBeerMax + ' = ' + Yscroll);

आउटपुट:
http://jsbin.com/furino/2/edit?js,output JsBin इस कोड को निष्पादित करने में सक्षम नहीं लगता है। इसके बजाय ब्राउज़र कंसोल का उपयोग करें।

क्यों?

स्क्रॉलमाक्सएक्स और स्क्रीनएक्स पहले से ही विद्यमान चर हैं। वे ब्राउज़र में बनाए गए हैं। इस प्रकार, परिणाम भिन्न हो सकते हैं। कीवर्ड को केवल अस्थायी रूप से उनके मूल्य में परिवर्तन करता है।

एक और जावास्क्रिप्ट एक: यह बिल्कुल नियमों का पालन नहीं करता है, यह केवल आउटपुट करता है अगर चर समान हैं या नहीं।

var a = 2;
var b = 2;

var a_duplicate = a;
var b_duplicate = b;

a_duplicate*=a
b_duplicate*=b;

a_duplicate-=b*b;
b_duplicate-=b*b;

a_duplicate/=(a-b);
b_duplicate/=(a-b);

alert(a_duplicate==b_duplicate);

क्यों?

आईईई फ्लोट विनिर्देशों द्वारा NaN NaN के बराबर नहीं है। यह बताने के लिए कि यह जावास्क्रिप्ट पर लागू नहीं होता है, यह बताने के लिए एलेक्स वान एलईवी का धन्यवाद।

Comments

NaNNaNIEEE फ्लोट विनिर्देशों के बराबर नहीं है । वास्तव में, यदि आपके पास NaNC में परीक्षण करने का एक त्वरित तरीका है, तो इसकी तुलना स्वयं से करना। इसलिए यह सभी भाषाओं पर लागू होता है, न कि केवल JS पर।

— वैन में एलेक्स वान एलवाईयू

@AlexVanLiew दिलचस्प। मुझे नहीं पता था कि! ठीक है, मेरे जवाब को थोड़ा बदलकर क्रेडिट जोड़ दो जहां यह होने वाला है।

— स्टेफनोच

Answer 7

Fantom

a := 3
b := 3
duplicates := [a:b]
duplicates = duplicates.map {it * a}
duplicates = duplicates.map {it - b*b}
duplicates = duplicates.map {it / a-b}
echo(duplicates.join("") |Int a_2, Int b_2 ->Str| {"" +  a_2 + " = " + b_2})

आउटपुट:

-3 = 3

क्यों?

[a: b] एक नक्शा है, सूची नहीं। इतना डरपोक नहीं, मुझे पता है :(

Comments

आपको अंत में a समान होना चाहिए b।

— mbomb007

मूल गिरावट का अंत 2 = 1 है, इसलिए यहां किसी भी उत्तर का अंत "सत्य" नहीं होना चाहिए

— कैन

मैं सोच रहा था कि बॉनस अंडरहैंड हो गया है। कोई बात नहीं। "बराबरी के संकेत को प्रिंट करने के बजाय, आप सिर्फ दो वेरिएबल्स (aMod और bMod) का प्रिंट आउट ले सकते हैं, और फिर कोड है जो समानता के लिए दो वेरिएबल्स की तुलना करने के लिए प्रकट होता है, लेकिन वास्तविकता में वे समान हैं (और सत्य के कुछ रूप प्रिंट करता है) । "

— mbomb007

Answer 8

सी

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

a,b,LHS,RHS;
main(){
    a=2; b=2;
    LHS=a; RHS=b;

    //multiply both sides by a
    LHS,RHS *= a; 
    //subtract b squared from both sides
    LHS,RHS -= b*b; 
    //assert that it factors correctly
    if (LHS,RHS != (a+b)*(a-b), b*(a-b)) printf("ERROR!\n");
    //'hard' division, just to be sure the compiler doesn't remove it
    LHS,RHS /=! (a-b);
    //assert that a+a really is b+b
    if (a+a != b+b) printf("ERROR!\n");
    //now just divide them by b
    printf("%d = %d ? ", LHS/b, RHS/b);
    if (RHS = LHS) 
        printf("true!");
    else
        printf("false!");
}

निश्चित रूप से यह काफी काम नहीं करता है जब #include <stdio.h>घोषणाओं के साथ और मुहावरों के साथ अधिक मुहावरेदार लिखा जाता है ।

Comments

हालांकि यह कैसे काम करता है?

— कैलकुलेटरफाइनल

पहले ध्यान दें कि यदि आप एक घोषणा में int को 'भूल' जाते हैं, तो यह मानता है कि वह k & r c के साथ पीछे की ओर संगत होने के लिए int को टाइप करता है। अगला, सी में ऑपरेटर को देखें और इसकी पूर्वता पर ध्यान दें। अगला नोट = अंतिम के बजाय == यदि कथन में है।

— लैंबडाबेटा