13

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

इनपुट , n, किसी भी है पूर्णांक संख्या (कम से कम समर्थन पूर्णांकों पर है, लेकिन जरूरत तक ही सीमित नहीं किया जाना चाहिए)। उत्पादन है औसत की:

n
का वर्ग n
के निकटतम प्राइम नंबर n
nफाइबोनैचि अनुक्रम में निकटतम संख्या

शीघ्र ही, कार्यक्रम को मानक आउटपुट चैनल के परिणाम के लिए प्रिंट करना चाहिए (n+(n*n)+closestPrime(n)+closestFib(n))/4।

आपको संभावित ओवरफ्लो आदि के बारे में परवाह नहीं है। सामान्य फ्लोटिंग पॉइंट सटीक भी ठीक है।

जिस तरह से इनपुट दिया गया है वह पूरी तरह से आपके ऊपर है। सबसे कम कार्यक्रम (पात्रों में) जीतता है, हमेशा की तरह कोड गोल्फ के साथ।

यदि आप निकटतम की तलाश कर रहे हैं तो एक टाई होती है, निम्नलिखित में से कोई एक चुनें:

ऊपर जाना
नीचे जाओ
एक बेतरतीब ढंग से चुनें

— Anto
स्रोत

"निकटतम" परिभाषित करें। कैसे टूट जाते हैं संबंध?

— पीटर टेलर

@Peter टेलर: ऊपर, नीचे, या एक बेतरतीब ढंग से चुनें।

— Anto

समाधानों को सत्यापित करने के लिए कुछ नमूना इनपुट / आउटपुट दें।

— fR0DDY

जब आप कहते हैं कि "सीमित नहीं होना चाहिए", तो और क्या चाहिए? या क्या आपका मतलब है कि "सीमित होने की जरूरत नहीं है"?

— टिमवी

@Timwi! "जरूरत नहीं", क्षमा करें, इसे ठीक कर देगा

— एंटो

10

अजगर 160 चार्ट

p=lambda n:any(n%x<1for x in range(2,n))
N=input()
a=0;b=1
while b<N:a,b=b,a+b
c=d=N
while p(c)and p(d):c-=1;d+=1
print (N+N*N+[b,a][2*N-a-b<0]+[c,d][p(c)])/4.0

निकटतम भाग के बारे में थोड़ा स्पष्टीकरण:

जब लूप समाप्त होता है, तो N से छोटा होता है और B, N के बराबर होता है [b,a][2*N-a-b<0]। इसे [b, a] [(Na) - (bN)] के रूप में देखें। (Na) N और a और इसी तरह (bN) के बीच का अंतर है b और N के बीच का अंतर। अगर इन दोनों के बीच का अंतर 0 से कम है तो इसका मतलब है कि यह N और इसके विपरीत के करीब है।

— fR0DDY
स्रोत

क्या आप इस बात का स्पष्टीकरण जोड़ सकते हैं कि यह काम क्यों कर रहा है?

— क्विक्सोटिक

@ डबजन कुछ भी विशिष्ट, आप जानना नहीं चाहेंगे? मैंने सोचा कि सब कुछ आत्म व्याख्यात्मक था। :)

— fR0DDY

बस सबसे नज़दीकी [b,a][2*N-a-b<0]

— रेशे वाला

7

GolfScript, 59 अक्षर

~:N..*.,2>{:P{(.P\%}do(!},{{N-.*}$0=}:C~[1.{.@+.N<}do]C+++4/

यह स्क्रिप्ट कुछ आवश्यकताओं को पूरा नहीं करती है:

यह केवल इनपुट के लिए सही तरीके से काम करता है n >= 2, अन्यथा यह क्रैश हो जाता है।
आउटपुट को पूर्णांक में काट दिया जाता है।
किसी भी बड़े के लिए भयानक प्रदर्शन n

कोड का एक संक्षिप्त पूर्वाभ्यास:

~:N..*इनपुट एन में संग्रहित है, और हम दोनों nऔर वर्ग को n*nतुरंत धक्का देते हैं ।
.,2>हम एरे को फ़िल्टर करके प्रिम्स की एक सूची तैयार करेंगे [2..n*n]। हम अपनी पिछली गणना का उपयोग n*nएक (बहुत खराब!) के रूप में करते हैं, जो कि n की तुलना में बड़ा होता है।
{:P{(.P\%}do(!},हमारा पिछला सरणी परीक्षण प्रभाग द्वारा फ़िल्टर किया गया है। प्रत्येक पूर्णांक P को प्रत्येक पूर्णांक [P-1..1] के विरुद्ध जांचा जाता है।
{{N-.*}$0=}:C~दूरी के आधार पर पिछले सरणी को सॉर्ट करता है n, और पहले तत्व को पकड़ता है। अब हमारे पास निकटतम प्रधान है।
[1.{.@+.N<}do]Cहम Fibonnacis उत्पन्न करते हैं जब तक हम एक से अधिक नहीं हो जाते n। सौभाग्य से, यह एल्गोरिथ्म स्वाभाविक रूप से पिछली फिबोनेसी का ट्रैक रखता है, इसलिए हम उन दोनों को एक सरणी में फेंक देते हैं और हमारे पहले की दूरी की तरह का उपयोग करते हैं। अब हमारे पास निकटतम Fibonnaci है।
+++4/औसत। ध्यान दें कि GolfScript के पास फ़्लोट्स के लिए समर्थन नहीं है, इसलिए परिणाम छोटा है।

गोल्फक्राफ्ट, 81 अक्षर

यहां एक ऐसा संस्करण है जो सभी आवश्यकताओं को पूरा करता है।

~:N..*2N*,3,|2,^{:P{(.P\%}do(!},{{N-.*}$0=}:C~[0.1{.@+.N<}do]C+++100:E*4/.E/'.'@E%

के लिए उचित व्यवहार सुनिश्चित करने के लिए n<2, मैं 2<(क्रैश जब सरणी छोटा है) से बचें , और इसके बजाय उपयोग करें 3,|2,^। यह सुनिश्चित करता है कि अभ्यर्थी का अभिप्राय [2]तब है जब n < 2। मैंने अगले प्राइम के लिए ऊपरी सीमा n*nको 2*n( बर्ट्रेंड के डाक्यूमेंट ) में बदल दिया। इसके अलावा, 0 को एक फिबोनासी संख्या माना जाता है। परिणाम की गणना अंत में निश्चित बिंदु गणित में की जाती है। दिलचस्प है, ऐसा लगता है कि परिणाम हमेशा चौथे (0, .25, .5, .75) में होता है, इसलिए मुझे उम्मीद है कि परिशुद्धता के 2 दशमलव स्थान पर्याप्त हैं।

GolfScript का उपयोग करने पर मेरी पहली दरार, मुझे यकीन है कि सुधार के लिए जगह है!

— माइक वेल्श
स्रोत

7

तुम्हें पता है, जब 4 से विभाजित यह बहुत आश्चर्य की बात नहीं है कि आप चौथा पाते हैं;;

— जॉय

...वास्तव में! +1;)

— माइक वेल्श

3

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

function n(n)
{z=i(n)?n:0
for(x=y=n;!z;x--,y++)z=i(x)?x:i(y)?y:0
for(a=b=1;b<n;c=a+b,a=b,b=c);
return(n+n*n+(2*n-a-b<0?a:b)+z)/4}
function i(n)
{for(j=2;j<n;j++)
if(!(n%j))return 0
return 1}

[257]

function n(n)
{return(n+n*n+p(n)+f(n))/4}
function p(n)
{if(i(n))return n
for(a=b=n;;a--,b++){if(i(a))return a
if(i(b))return b}}
function i(n)
{for(j=2;j<n;j++)
if(!(n%j))return 0
return 1}
function f(n)
{for(a=b=1;b<n;c=a+b,a=b,b=c);
return 2*n-a-b<0?a:b}

असम्पीडित:

function closest( a, b, c )
{
  return 2*a-b-c < 0 ? b : c;
}

function closestPrime( n )
{
  a=b=n;
  if (isPrime( n ) ) return n;
  while ( true )
  {
    a-=1;
    b+=1;
    if (isPrime(a))return a;
    if (isPrime(b))return b;
  }
}

function isPrime( n )
{
  for (i=2;i<n;i++)
  {
    if ( !( n % i ) ) return false;
  }
  return true;
}

function closestFib( n )
{
  for(fib1=0,fib2=1;fib2<n;fib3=fib1+fib2,fib1=fib2,fib2=fib3);
  return closest( n, fib1, fib2 );
}

function navg(n)
{
  n2 = n*n;
  np = closestPrime( n );
  nf = closestFib( n );
  return ( n + n2 + np + nf ) / 4;
}

— zzzzBov
स्रोत

अपने निकटतम प्राइम फंक्शन के लिए: मैं सोच रहा हूं कि आप अंतरिक्ष को बचा सकते हैं यदि आप सिर्फ a=0और सकारात्मक वृद्धि का उपयोग करते हैं । इसके बजाय जाँच के isPrimeलिए aऔर b, बस की जांच isPrime(n+a)और isPrime(n-a)। आप शायद एक पागल बयान में यह सब मैश कर सकते हैं, लेकिन मैं जावास्क्रिप्ट के साथ भयानक हूँ।

— श्री लामा

निम्नलिखित बहुत अच्छी तरह से काम करने लगता है function closestPrime(n,o){return isPrime(n+o)?n+o:isPrime(n-o)?n-o:closestPrime(n,o+1);}:। इसे कॉल करें closestPrime(n,0)और यह स्वयं काम करेगा। आवश्यकतानुसार छोटा किया।

— श्री लामा

1

गणितज्ञ, 70 69 बाइट्स

एक बाइट ने Sp3000 के लिए धन्यवाद बचाया (कभी-कभी अंतर्निहित इन्स जाने का सबसे अच्छा तरीका नहीं है)।

((n=#)+#^2+(f=#&@@#@Range@Max[1,2n]~Nearest~n&)@Prime+f@Fibonacci)/4&

यह एक अनाम फ़ंक्शन को पूर्णांक लेने और सटीक माध्य को एक परिमेय संख्या के रूप में निर्मित करने को परिभाषित करता है। संबंधों के मामले में, छोटे प्राइम / फाइबोनैचि संख्या को चुना जाता है।

यह बड़े आदानों के लिए बहुत ही अक्षम है, क्योंकि यह वास्तव 2nमें निकटतम चुनने से पहले पहले primes और फाइबोनैचि संख्या उत्पन्न करता है ।

— मार्टिन एंडर
स्रोत

#&@@#.. हुह?

— देखिए

@Sieg दाईं ओर से शुरू होता है: #एक शुद्ध फ़ंक्शन (का f) का तर्क है । इस मामले में, यह वास्तव में एक फ़ंक्शन ही है, क्योंकि fइसे लागू किया जाता है Primeऔर Fibonacci। ताकि #@Range@...रेंज में प्रत्येक पूर्णांक के लिए दिए गए फ़ंक्शन को लागू करता है। फिर एक सूची के पहले तत्व को निकालने के लिए #&@@सिर्फ एक गोल्फ का रास्ता है। यह #&सूची पर लागू होने से काम करता है , जो एक फ़ंक्शन है जो केवल अपना पहला तर्क देता है।

— मार्टिन एंडर

0

क्यू, ११ ९

सबसे कुशल नहीं है।

{%[;4]x+(x*x)+((*:)a(&)b=min b:abs x-a:{x,sum -2#x}/[x-2;1 1])+(*:)d(&)e=min e:x-d:(&)1={(min x mod 2_(!)x)}each(!)x+2}

— tmartin
स्रोत

0

MATLAB 88 शुल्क

C=@(F)(F(abs(F-n)==min(abs(F-n))));(n+n^2+C(primes(n*2))+C(round(1.618.^(1:n)/2.236)))/4

n आपका पूर्णांक है

गैर पूर्णांकों के साथ काम करता है, जहां तक मैंने परीक्षण किया है यह बहुत बड़ी संख्या के साथ काम करता है, बहुत जल्दी से बहुत ज्यादा चलता है।

— दौड़ के लिये कभी भी न उतारा गया घोड़ा
स्रोत

0

स्काला 299

object F extends App{type I=Int
def f(n:I,b:I=1,a:I=1):I=if(a>=n)if(a-n>n-b)b else a else f(n,a,b+a)
def p(n:I)=(2 to n-1).exists(n%_==0)
def i(n:I,v:I):Int=if(!p(n+v))n+v else i(n+v,v)
val a=readInt
println(({val p=Seq(-1,1).map(i(math.max(a,3),_))
if(a-p(0)>p(1)-a)p(1)else p(0)}+f(a)+a+a*a)/4.0)}

परीक्षण और आह्वान:

a  a² nP(a) nF  ∑   /4.0 
------------------------
-2  4   2   1   5   1.25
-1  1   2   1   3   0.75
0   0   2   1   3   0.75
1   1   2   1   5   1.25
2   4   2   2   10  2.5
3   9   2   3   17  4.25
4   16  3   5   28  7.0
5   25  3   5   38  9.5

सवाल के बारे में बात करता है, any Integerलेकिन समस्या नीचे के मूल्यों के लिए दिलचस्प नहीं है। हालांकि - हम कैसे शुरू करते हैं? 0 पर? 1 पर? और 11 के लिए अगला प्रमुख क्या है? 11 ही?

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

— अज्ञात उपयोगकर्ता
स्रोत

N का औसत, n के निकटतम निकटतम n, n का वर्ग और n से निकटतम फाइबोनैचि संख्या क्या है?