मार्जिन बहुत संकीर्ण है

30

वर्ष 1637 के आसपास, पियरे डी फ़र्मेट ने अरिथमेटिका की अपनी प्रति के हाशिये में लिखा: 

It is impossible to separate a cube into two cubes, or a fourth power 
into two fourth powers, or in general, any power higher than the 
second, into two like powers. I have discovered a truly marvelous 
proof of this, which this margin is too narrow to contain.

दुर्भाग्य से हमारे लिए, मार्जिन अभी भी सबूत शामिल करने के लिए संकीर्ण है। आज, हम हाशिये में एक सरल कार्यक्रम लिखने जा रहे हैं जो मनमाने आदानों के प्रमाण की पुष्टि करता है।

चुनौती

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

इनपुट

बिजली और बिजली की संख्या: c,x

अड़चनें: c > 2औरx > 2

इनपुट प्रोग्राम तर्क, फ़ंक्शन तर्क या उपयोगकर्ता से हो सकता है।

उत्पादन

इस सटीक स्ट्रिंग: " a^x + b^x < c^x" के साथ a, b, c, और xउनके शाब्दिक पूर्णांक मान के साथ बदल दिया। aऔर bइतना है कि चुना जाना चाहिए a^x + b^x < c^xकी और कोई अन्य मूल्यों aया bइसे करने के लिए करीब होगा c^x। इसके अलावा:a>=b>0

आउटपुट फंक्शन रिटर्न वैल्यू, स्टडआउट, फाइल में सेव या स्क्रीन पर प्रदर्शित करने के माध्यम से हो सकता है।

उदाहरण:

> 3 3
2^3 + 2^3 < 3^3
> 4 3
3^3 + 3^3 < 4^3
> 5 3
4^3 + 3^3 < 5^3
> 6 3
5^3 + 4^3 < 6^3
> 7 3
6^3 + 5^3 < 7^3
> 8 3
7^3 + 5^3 < 8^3

फ़र्मेट के औसत लेखन कौशल के कारण, अप्राप्य पात्रों की अनुमति नहीं है। कम से कम वर्णों वाला कार्यक्रम जीतता है।

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N characters

वैकल्पिक रूप से, आप इसके साथ शुरू कर सकते हैं:

## Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

## Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

## Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

कोड स्निपेट दिखाएं

code-golf  number 
— नंबर एक
स्रोत
1
मुझे लगता है कि यह होना चाहिए a>=b>0या आपका पहला उदाहरण अमान्य होगा। और हमें क्यों प्रदर्शित करना है< जब आप चाहते हैं कि है <=?
— 22
@flawr फिक्स्ड :)
— TheNumberOne
क्या विपरीत क्रम में तर्क देना ठीक रहेगा? प्रथमx , फिर c?
— रेटो कोराडी
@RetoKoradi ज़रूर :)
— TheNumberOne

जवाबों:

9

पायथ, 38 बाइट्स

Ls^Rvzbjd.imj\^,dz+eoyNf<yTy]Q^UQ2Q"+<

इस प्रारूप में इनपुट लेता है:

x
c
— orlp
स्रोत
8

मतलाब, 169 153 बाइट्स

टिप्पणी में अनसुलझी समस्याओं के आधार पर स्कोर + -1 हो सकता है) स्कोर समान रहता है। यह सर्वश्रेष्ठ (a,b)जोड़ी के लिए सिर्फ एक क्रूर खोज है ।

बहुत निराशाजनक: मैंने पहली बार कुछ 'फैंसी' सामानों के साथ प्रयोग किया और फिर महसूस किया कि दो सरल नेस्ट्स लूप्स के लिए छोटे हैं ...

function f(c,x);
m=0;p=@(x)int2str(x);
X=['^' p(x)];
for b=1:c;for a=b:c;
n=a^x+b^x;
if n<c^x&n>m;m=n;s=[p(a) X ' + ' p(b) X ' < ' p(c) X];end;end;end;
disp(s)

पुराना संस्करण:

function q=f(c,x);
[b,a]=meshgrid(1:c);
z=a.^x+b.^x;
k=find(z==max(z(z(:)<c^x & a(:)>=b(:))),1);
p=@(x)int2str(x);x=['^' p(x)];
disp([p(a(k)) x ' + ' p(b(k)) x ' < ' p(c) x])
— flawr
स्रोत
रिक्त स्थान निकालें m = 0? फिर भी, यह आपको मेरे उत्तर के करीब नहीं मिलेगा: -पी
— लुइस मेंडू
इसके अलावा, ऐसा लगता है कि आप q=फ़ंक्शन परिभाषा से हटा सकते हैं
— लुइस मेंडू
मुझे नहीं लगता कि qचर का उपयोग कहीं भी किया जा रहा है। आप बस कर सकते हैं function f(c,x)और अर्ध-बृहदान्त्र को हटाने के द्वारा बाइट्स के एक जोड़े को दाढ़ी ।
— रायरेंग - मोनिका
8

मेथेमेटिका, 79 95 80 बाइट्स

यह सिर्फ मार्जिन पर फिट हो सकता है।

c_~f~x_:=Inactivate[a^x+b^x<c^x]/.Last@Solve[a^x+b^x<c^x&&a>=b>0,{a,b},Integers]

परिक्षण

f[3, 3]
f[4, 3]
f[5, 3]
f[6, 3]
f[7, 3]
f[8, 3]

उत्पादन

— DavidC
स्रोत
7

CJam, 51 46 43 बाइट्स

q~_2m*\f+{W$f#)\:+_@<*}$W='^@s+f+"+<".{S\S}

यह पूरा कार्यक्रम पावर पढ़ता है, फिर एसटीडीआईएन से बेस।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

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

मतलाब, 141 140 बाइट्स

इसे फ़ंक्शन के रूप में कोडित किया जाता है जो परिणाम को stdout में प्रदर्शित करता है।

function f(c,x)
b=(1:c).^x;d=bsxfun(@plus,b,b');d(d>c^x)=0;[~,r]=max(d(:));sprintf('%i^%i + %i^%i < %i^%i',[mod(r-1,c)+1 ceil(r/c) c;x x x])

उदाहरण का उपयोग करें:

>> f(8,3)
ans =
7^3 + 5^3 < 8^3

या इसे ऑक्टेव में ऑनलाइन आज़माएं ।

एक बाइट निकालने के लिए @flawr को धन्यवाद।

— लुइस मेंडो
स्रोत
मैंने हमेशा टाल दिया sprintfक्योंकि यह बहुत जटिल लग रहा था जबकि वास्तव में यह वास्तव में नहीं है! और मैं bsxfunएक बार फिर से भूल गया , इसलिए एक बहुत ही सुंदर समाधान है। मैं विशेष रूप से जिस तरह से आपने पिछले तर्क =) में सिंगल / डबल इंडेक्सिंग को गाली दी थी (आप वहां एक स्पेस भी निकाल सकते हैं!)
— त्रुटी
धन्यवाद! मैं आमतौर पर dispकोड गोल्फ को छोड़कर भी उपयोग करता हूं :-P
— लुइस मेंडो सेप
यदि आप fprintfइसके बजाय उपयोग करते हैं sprintf, तो यह "ans" प्रदर्शित नहीं करता है
— जोनास
@ जोनास लेकिन यह परिणाम को प्रिंट करता है और फिर >>उसी लाइन में प्रॉम्प्ट होता है, जो थोड़ा अजीब है
— लुइस
आप उपयोग कर सकते हैं fprintf, लेकिन आपको मैन्युअल कैरिज रिटर्न डालना होगा।
— रायरेंग - मोनिका
5

CJam, 53 51 बाइट्स

l~:C\:X#:U;C2m*{Xf#:+_U<*}$W=~"^"X+:T" + "@T" < "CT

इसे ऑनलाइन आज़माएं

इनपुट प्रारूप वह है x c, जो उदाहरणों में प्रयुक्त क्रम का उल्टा है।

स्पष्टीकरण:

l~    Read and interpret input.
:C    Store c in variable C.
\     Swap x to top.
:X    Store it in variable X.
#     Calculate c^x.
:U;   Store it in variable U as the upper limit, and pop it from stack.
C2m*  Generate all pairs of values less than c. These are candidates for a/b.
{     Start of mapping function for sort.
  X     Get value of x.
  f#    Apply power to calculate [a^x b^x] for a/b candidates.
  :+    Sum them to get a^x+b^x.
  _U<   Compare value to upper limit.
  *     Multiply value and comparison result to get 0 for values above limit.
}$    End of sort block.
W=    Last a/b pair in sorted list is the solution.
~     Unpack it.
"^"X+ Build "^x" string with value of x.
:T    Store it in variable T, will use it 2 more times in output.
" + " Constant part of output.
@     Rotate b to top of stack.
T     "^x" again.
" < " Constant part of output.
C     Value of c.
T     And "^x" one more time, to conclude the output.
— रेटो कोराडी
स्रोत
5

आर, 139 वर्ण

function(c,x)with(expand.grid(a=1:c,b=1:c),{d=a^x+b^x-c^x
d[d>0]=-Inf
i=which.max(d)
sprintf("%i^%4$i + %i^%4$i < %i^%4$i",a[i],b[i],c,x)})
— flodel
स्रोत
4

पायथन 2, 182 161 157 बाइट्स

मैं आमतौर पर MATLAB में उत्तर देता हूं, लेकिन क्योंकि उस भाषा में पहले से ही दो समाधान हैं, मुझे लगता है कि मैं दूसरी भाषा आज़माऊंगा :)

def f(c,x):print max([('%d^%d + %d^%d < %d^%d'%(a,x,b,x,c,x),a**x+b**x) for b in range(1,c+1) for a in range(b,c+1) if a**x+b**x<c**x],key=lambda x:x[1])[0]

स्पष्टीकरण के साथ अघोषित कोड

def f(c,x): # Function declaration - takes in c and x as inputs

    # This generates a list of tuples where the first element is 
    # the a^x + b^x < c^x string and the second element is a^x + b^x
    # Only values that satisfy the theorem have their strings and their
    # corresponding values here
    # This is a brute force method for searching
    lst = [('%d^%d + %d^%d < %d^%d'%(a,x,b,x,c,x),a**x+b**x) for b in range(1,c+1) for a in range(b,c+1) if a**x+b**x<c**x]

    # Get the tuple that provides the largest a^x + b^x value
    i = max(lst, key=lambda x:x[1])

    # Print out the string for this corresponding tuple
    print(i[0])

उदाहरण रन

मैंने इसे आईपीथॉन में चलाया:

In [46]: f(3,3)
2^3 + 2^3 < 3^3

In [47]: f(4,3)
3^3 + 3^3 < 4^3

In [48]: f(5,3)
4^3 + 3^3 < 5^3

In [49]: f(6,3)
5^3 + 4^3 < 6^3

In [50]: f(7,3)
6^3 + 5^3 < 7^3

In [51]: f(8,3)
7^3 + 5^3 < 8^3

इसे ऑनलाइन आज़माएं!

http://ideone.com/tMjGdh

यदि आप कोड को चलाना चाहते हैं , तो शीर्ष के पास स्थित एडिट लिंक पर क्लिक करें , फिर STDIN पैरामीटर को संशोधित करके दो पूर्णांक एक स्थान से अलग कर दें। पहला पूर्णांक है cऔर अगला है x। अभी, c=3और x=3वर्तमान में इसका परिणाम प्रदर्शित किया गया है।

— रायरेंग - मोनिका को बहाल करें
स्रोत
2

सी, 175 बाइट्स

a,b,m,A,B,M;p(
a,x){return--x
?a*p(a,x):a;}f
(c,x){M=p(c,x)
;for(a=c,b=1;a
>=b;)(m=p(c,x)
-p(a,x)-p(b,x
))<0?--a:m<M?
(M=m,B=b++,A=
a):b++;printf
("%d^%d + %d"
"^%d < %d^%d",
A,x,B,x,c,x);}

कोड को मार्जिन में फिट करने के लिए, मैंने नई प्रविष्टियाँ सम्मिलित की हैं और ऊपर एक स्ट्रिंग शाब्दिक विभाजन किया है - गोल्फ कोड को गिना / संकलित किया जाना है

a,b,m,A,B,M;p(a,x){return--x?a*p(a,x):a;}f(c,x){M=p(c,x);for(a=c,b=1;a>=b;)(m=p(c,x)-p(a,x)-p(b,x))<0?--a:m<M?(M=m,B=b++,A=a):b++;printf("%d^%d + %d^%d < %d^%d",A,x,B,x,c,x);}

समारोह fलेता है cऔर xतर्क के रूप में, और पर परिणाम पैदा करता हैstdout ।

व्याख्या

यह एक पुनरावृत्तीय समाधान है जो परिभाषित की गई रेखा को zigzags करता है a^x + b^x = c^x। हम साथ शुरू a=cऔर b=1। जाहिर है, कि हमें लाइन के गलत पक्ष पर डालता है, क्योंकि c^x + 1 > c^x। हम aतब तक वेतन वृद्धि करते हैं जब तक हम लाइन पार नहीं कर लेते। जब हम लाइन के नीचे होते हैं, तो हम वृद्धि करते हैं bजब तक कि हम इसे दूसरी दिशा में पार नहीं करते। दोहराएँ जब तक bपूरा करती है a, में सबसे अच्छा समाधान याद Aऔर Bहम चले रूप में। फिर इसे प्रिंट करें।

pa^x(के लिए) का एक सरल पुनरावर्ती कार्यान्वयन हैx>0 सी) के क्योंकि सी घातांक के लिए कोई ऑपरेटर प्रदान नहीं करता है।

छद्म कोड में: 

a=c
b=1
M = c^x

while a >= b
do
   m = c^x - a^x - b^x
   if m < 0
      a -= 1
   else // (m > 0, by Fermat's Last Theorem)
      if m < M
         A,B,M = a,b,m
      b += 1
done
return A,B

सीमाएं

c^xकी सीमा के भीतर प्रतिनिधित्व करने योग्य होना चाहिए int। यदि यह सीमा अत्यंत सीमित है, के हस्ताक्षर pतुच्छता से करने के लिए संशोधित किया जा सकता है long p(long,int)या double p(double,int), और mऔर Mकरने के लिए longयाdouble क्रमशः, के लिए किसी भी संशोधन के बिनाf() ।

परीक्षण कार्यक्रम

यह स्वीकार करता है cऔर xकमांड-लाइन तर्क के रूप में, और परिणाम प्रिंट करता है।

#include<stdio.h>
int main(int argc, char**argv) {
    if (argc <= 2) return 1;
    int c = atoi(argv[1]);
    int x = atoi(argv[2]);
    f(c,x);
    puts("");
    return 0;
}
— टोबी स्पाईट
स्रोत
1

हास्केल, 120 बाइट्स

मुझे लगता है कि मैंने इसे जितना संभव हो उतना गोल्फ किया है:

c%x=a&" + "++b&" < "++c&""where(_,a,b)=maximum[(a^x+b^x,a,b)|b<-[1..c],a<-[b..c],a^x+b^x<c^x];u&v=show u++"^"++show c++v

Ungolfed:

fn c x = format a " + " ++ format b " < " ++ format c ""
    where format :: Integer -> String -> String
          -- `format u v` converts `u`, appends an exponent string, and appends `v`
          format u v = show u ++ "^" ++ show c ++ v
          -- this defines the variables `a` and `b` above
          (_, a, b) = maximum [(a^x + b^x, a, b) | b <- [1..c], 
                                                   a <- [b..c],
                                                   a^x + b^x < c^x]

उपयोग:

Prelude> 30 % 11
"28^30 + 28^30 < 30^30"
— सीआर ड्रॉस्ट
स्रोत
0

हास्केल, 132 128 बाइट्स

x!y=x++show y
c#x=(\[_,a,b]->""!a++"^"!x++" + "!b++"^"!x++" < "!c++"^"!x)$maximum[[a^x+b^x,a,b]|a<-[0..c],b<-[0..a],a^x+b^x<c^x]

उपयोग उदाहरण: 7 # 3स्ट्रिंग लौटाता है "6^3 + 5^3 < 7^3"।

— nimi
स्रोत
0

पर्ल 5, 119 बाइट्स

एक सबरूटीन:

{for$b(1..($z=$_[0])){for(1..$b){@c=("$b^$o + $_^$o < $z^$o",$d)if($d=$b**($o=$_[1])+$_**$o)<$z**$o and$d>$c[1]}}$c[0]}

उदाहरण के लिए उपयोग करें:

print sub{...}->(8,3)
— msh210
स्रोत
0

रूबी, 125 बाइट्स

अनाम फ़ंक्शन। aमूल्यों की एक सूची बनाता है , इसका उपयोग a,bजोड़े बनाने के लिए करता है , फिर उन लोगों के लिए अधिकतम पाता है जो मानदंड फिट करते हैं और वहां से एक स्ट्रिंग लौटाते हैं।

->c,x{r=[];(1..c).map{|a|r+=([a]*a).zip 1..a}
a,b=r.max_by{|a,b|z=a**x+b**x;z<c**x ?z:0}
"#{a}^#{x} + #{b}^#{x} < #{c}^#{x}"}
— मूल्य स्याही
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.