11

পাই টাইম ই (বা পাই যদি আপনি অস্পষ্ট স্বরলিপি পছন্দ করেন) থেকে 100 দশমিক স্থানে থাকে:

8.5397342226735670654635508695465744950348885357651149618796011301792286111573308075725638697104739439...

( OIES A019609 ) ( সম্ভাব্য অযৌক্তিকতার পক্ষে যুক্তি )

আপনার কাজটি হ'ল এমন একটি প্রোগ্রাম লিখুন যা ইতিবাচক পূর্ণসংখ্যার এন নিয়ে যায় এবং পাই * ই আউটপুটগুলিকে এন দশমিক স্থানে ফেলে দেয়। উদাহরণস্বরূপ যদি এন = 2 হয় তবে আউটপুট হওয়া উচিত 8.53।

এটি একটি অপ্টিমাইজেশান সমস্যা, সুতরাং যে জমাটি এন এর সর্বোচ্চ মানের জন্য সঠিক আউটপুট দিতে পারে তা জিতবে।

একই কম্পিউটিং শক্তি ব্যবহার করে সমস্ত সাবমিশনগুলি বিচার করা হয় তা নিশ্চিত করার জন্য, আপনার কোডটি কোনও ভাষা ব্যবহার করে তাদের সমর্থন করে আদর্শকে চালিত করতে হবে । আইডিয়োন ফ্যাক্স অনুসারে , লগ-ইন না করা ব্যবহারকারীদের জন্য একটি 5 সেকেন্ড রান সময়সীমা রয়েছে। এই 5 সেকেন্ড সীমাটি আপনার অবশ্যই ব্যবহার করা উচিত, লগ ইন করা ব্যবহারকারীদের জন্য 15 সেকেন্ড সীমা নয় । ( অন্যান্য সীমা যেমন মেমরি, কোডের আকার ইত্যাদির জন্য FAQ দেখুন )

বিশেষত, যে কেউ আইডিয়নে লগইন করেননি সে আপনার প্রোগ্রামটি এন এর সমস্ত মানগুলির জন্য 1 থেকে কিছুটা সর্বোচ্চ এনম্যাক্সে আইডোনে চালাতে সক্ষম হবে এবং প্রায় সময়ই সঠিক আউটপুট দেখতে পাবে । কোনও Time limit exceededবা Memory limit exceededইত্যাদি ত্রুটি ছাড়াই । বৃহত্তম Nmax সহ জমাটি জয়লাভ করে।

(গ্রহণ করা আসল সময়টি 5 সেকেন্ডেরও বেশি সময় ধরে স্মিডের ত্রুটি না দেয় ততক্ষণ তা বিবেচনা করে না "" প্রায় সমস্ত সময় "কোনও নির্দিষ্ট এন এর জন্য সময়ের 95% এর বেশি হিসাবে সংজ্ঞায়িত করা হয়))

বিস্তারিত

আপনি পাই * ই গণনা করতে চান এমন কোনও গাণিতিক পদ্ধতি ব্যবহার করতে পারেন তবে আপনি পাই, ই বা পাই * ই এর প্রথম ডজন অঙ্ক ছাড়িয়ে আউটপুটটিকে হার্ডকোড করতে পারবেন না ।
- আপনার প্রোগ্রাম সীমাহীন সংস্থান দেওয়া কোনও এন এর জন্য কাজ করতে সক্ষম হওয়া উচিত।
- আপনি যদি পাই বা ই কনস্ট্যান্টে অন্তর্নির্মিত ব্যবহার করতে পারেন তবে যদি আপনার ভাষা সেগুলি হয়ে থাকে।
আপনি আপনার কোডের বাহ্যিক ওয়েবসাইটগুলি বা সংস্থানগুলি অ্যাক্সেস করতে পারবেন না (যদি আদর্শিকরা এটির অনুমতিও দেয়)।
হার্ডকোডিং এবং বাহ্যিক সংস্থান অ্যাক্সেসের বাইরে আদর্শের অনুমতিপ্রাপ্ত যে কোনও কিছু প্রায় অবশ্যই ঠিক।
আপনার ইনপুট এবং আউটপুট অবশ্যই (স্পষ্টতই) আইডোন আই / ও (স্ট্যান্ডিন / স্টডআউট কেবল এটি মনে হচ্ছে) যা সরবরাহ করে তা নিয়ে কাজ করতে হবে। এটা সূক্ষ্ম যদি আপনার চারপাশের ইনপুট এন কোট প্রয়োজন অথবা আউটপুট মত কিছু ans = ..., ইত্যাদি
ইনপুট হিসাবে আপনার Nmax সঙ্গে আপনার কোড একটি আদর্শ স্নিপেট একটি লিঙ্ক অন্তর্ভুক্ত করুন।
যদি কোনও টাই হয়ে থাকে (কেবলমাত্র যদি একাধিক জমাগুলি k৪ কেবি আউটপুট চরিত্রের সীমাতে আঘাত করে তবে) সর্বোচ্চ ভোটের উত্তর জিতবে answer

— ক্যালভিনের শখ
সূত্র

3

মিম ... অস্পষ্ট পাই

— ডেনিস

এটি খুব সহজেই একটি কোড-গল্ফ হতে পারে এবং এটি যদি হয় তবে এটি আরও মজাদার হয়।

— অপটিমাইজার

2

@ অপ্টিমাইজার এটি কোড-গল্ফ হতে পারে তবে এটি প্রতিটি ডিজিটের প্রজন্মের কোড-গল্ফের মতোই হবে। আমি একটি সময় ভিত্তিক প্রতিযোগিতা চেষ্টা করতে চেয়েছিলাম যা অনলাইনে যাচাই করা যেতে পারে। (যদিও আরও গণনামূলক জটিল সমস্যাটি আরও ভাল হতে পারে))

— ক্যালভিনের

এটি যদি কোড গল্ফ এপিএল সম্ভবত জিততে পারে (নির্বিচারে নির্ভুলতার অংশ বিয়োগ করে)

— টোয়নাট

1

আমি সন্দেহ করি যে এই প্রোগ্রামগুলি স্টোডাউটের অঙ্কগুলি লেখার চেষ্টা করার জন্য সম্পূর্ণ আইও আবদ্ধ থাকবে। পাঁচ সেকেন্ডে ওয়াই-ক্র্যাঙ্কারের মতো কোনও কিছুর জন্য দীর্ঘ সময় ।

— উইল

12

পাইথন - 65535

http://ideone.com/knKRhn

from math import exp, log

def divnr(p, q):
  """
    Integer division p/q using Newton-Raphson Division.
    Assumes p > q > 0.
  """

  sp = p.bit_length()-1
  sq = q.bit_length()-1
  sr = sp - sq + 1

  s = []
  t = sr
  while t > 15:
    s = [t] + s
    t = (t>>1) + 1
  # Base-case division
  r = (1 << (t<<1)) / (q >> sq-t)

  for u in s:
    r = (r << u-t+1) - (r*r * (q >> sq-u) >> (t<<1))
    t = u
  return (r * (p >> sq)) >> sr

def pibs(a, b):
  if a == b:
    if a == 0:
      return (1, 1, 1123)
    p = a*(a*(32*a-48)+22)-3
    q = a*a*a*24893568
    t = 21460*a+1123
    return (p, -q, p*t)
  m = (a+b) >> 1
  p1, q1, t1 = pibs(a, m)
  p2, q2, t2 = pibs(m+1, b)
  return (p1*p2, q1*q2, q2*t1 + p1*t2)

def ebs(a, b):
  if a == b:
    if a == 0:
      return (1, 1)
    return (1, a)
  m = (a+b) >> 1
  p1, q1 = ebs(a, m)
  p2, q2 = ebs(m+1, b)
  return (p1*q2+p2, q1*q2)

if __name__ == '__main__':
  n = input()

  pi_terms = int(n*0.16975227728583067)

  # 10^n == e^p
  p = n*2.3025850929940457

  # Lambert W_0(p/e) a la Newton
  k = log(p) - 1
  w = k - (k-1)/(k+1)
  while k > w:
    k = w
    w -= (k - p*exp(-k-1))/(k+1)

  # InverseGamma(e^p) approximation
  e_terms = int(p / w)

  pp, pq, pt = pibs(0, pi_terms)
  ep, eq = ebs(0, e_terms)

  z = 10**n
  p = 3528*z*ep*abs(pq)
  q = eq*abs(pt)

  pie = divnr(p, q)
  print pie,

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

জন্য সূত্র আমি ব্যবহারের π ছিল রামানুজন তালিকা ফর্মুলা (39) হিসাবে:

$\frac{1}{\pi}=4\sum_{_{n=0}}^{_\infty}{\frac{(-1)^n (4n)!(21460n+1123)}{(n!)^4 14112^{2n+1}}$

যা প্রতি পদে ~ 5.89 ডিজিটের হারে রূপান্তর করে । আমার জ্ঞানের মতে এটি এই ধরণের দ্রুততম রূপান্তরকারী সিরিজ যা একটি স্বেচ্ছাসেবী যথার্থ বর্গমূলের মূল্যায়নের প্রয়োজন হয় না। সূত্র (44) একই কাগজ (অভিসৃতি হার ~ 7,98 মেয়াদ প্রতি সংখ্যার) প্রায়শই হিসাবে উল্লেখ করা হয় রামানুজন ফর্মুলা।

আমি ই-র জন্য যে সূত্রটি ব্যবহার করি তা হ'ল বিপরীত ফ্যাক্টরিয়ালগুলির যোগফল। প্রয়োজনীয় পদগুলির সংখ্যা গণিতের ফ্লাওয়ারে পাওয়া একটি সন্নিবেশ ব্যবহার করে Γ ^-1 ( 10 ^এন ) হিসাবে গণনা করা হয় । ল্যামবার্ট ডাব্লু ₀ উপাদানটি নিউটনের পদ্ধতি ব্যবহার করে খুঁজে পাওয়া যায়।

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

আপডেট:
প্রোফাইলিং থেকে জানা গেছে যে গণনার জন্য প্রয়োজনীয় অর্ধেকের বেশি সময় চূড়ান্ত বিভাগে ব্যয় হয়েছিল। বড় হাতের সবচেয়ে লগ ₂ (10 ^ঢ ) এর বিট কুই তাই আমি পূর্বেই কয়েকটি বন্ধ ছাঁটা, পূর্ণ স্পষ্টতা প্রাপ্ত প্রয়োজন হয়। কোড এখন Ideone আউটপুট বাফার পূরণ 3.33s ।

আপডেট 2:
যেহেতু এটি একটি অপ্টিমাইজেশন চ্যালেঞ্জ, তাই সিপিথনের আস্তে লড়াইয়ের জন্য আমি নিজের বিভাগের রুটিন লেখার সিদ্ধান্ত নিয়েছি। divnrউপরের প্রয়োগটি নিউটন-রাফসন বিভাগ ব্যবহার করে । সাধারণ ধারণাটি হ'ল নিউটনের পদ্ধতিটি ব্যবহার করে ডি = 1 / কিউ · 2 ^এন গণনা করা , যেখানে n ফলাফলের বিটের সংখ্যা, এবং ফলাফলকে p · d >> n হিসাবে গণনা করে । রানটাইম এখন ২.8787 এর দশক - এবং এটি গণনার আগে বিটগুলি কেটে ছাড়াই হয়; এটি এই পদ্ধতির জন্য অপ্রয়োজনীয়।

— Primo
সূত্র

4

প্যারি / জিপি: 33000

এটি মূলত ওইআইএস- এ দেওয়া প্রোগ্রাম , ইনপুট এবং ফর্ম্যাট আউটপুটটিকে সঠিকভাবে নিতে সংশোধিত। এটি মারার জন্য বেসলাইন হিসাবে পরিবেশন করা উচিত, অন্য কিছু না হলে।

আমি অনুমান করি এটি সঠিক is আমি ওএআইএস এর বিপরীতে এটি 100 এবং 20 কে যাচাই করেছিলাম এবং এটি উভয়ের সাথে মিলে। বিপরীতে পরীক্ষা করতে অনলাইনে আরও অঙ্কগুলি খুঁজে পাওয়া বেশ শক্ত।

33,000 এর জন্য এটি প্রায় 4.5s লাগে, সুতরাং এটি সম্ভবত একটি সামান্য বিছিন্ন করা যেতে পারে। আমি কেবল ইনপুট এবং আইডিয়োনের স্লো-অ্যাস জমা / সংকলন / রান লুপটি নিয়ে ম্লান হয়ে ক্লান্ত হয়ে পড়েছি।

{ 
    m=eval(input());
    default(realprecision, m+80); 
    x=Pi*exp(1);
    s="8.";
    d=floor(x);
    x=(x-d)*10;
    for (n=1, m, d=floor(x); 
         x=(x-d)*10; 
         s=Str(s,d));
    print(s);
}

Ideone.com লিঙ্ক

— Geobits
সূত্র

আপনার অঙ্কগুলি আমার সাথে মেলে, তাই আমি একটি অঙ্গ নিয়ে বাইরে চলে যাব এবং বলব যে তারা সম্ভবত সঠিক।

— primo

এই প্রোগ্রামটি মূলত তার সমস্ত সময় লুপে ব্যয় করে একে একে ডিজিট তৈরি করে। আপনি যদি এটি গ্রহণ করেন তবে Str(floor(frac(x)*10^m)এটি কয়েকশ / হাজার হাজার গতিবেগে যায়।

— চার্লস

2

পাইথন ঘ

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

import decimal
import math
decimal.getcontext().prec=1000000
decimal=decimal.Decimal;b=2500
print(str(sum([decimal(1/math.factorial(x)) for x in range(b)])*sum([decimal(1/16**i*(4/(8*i+1)-2/(8*i+4)-1/(8*i+5)-1/(8*i+6))) for i in range(b)]))[0:int(input())+2])

আইডিয়োন লিঙ্ক

STDIN = 1000 এর আউটপুট:

8.5397342226735669504281233688422467204743749305568824722710929852470173635361001388261308713809518841081669216573834376992066672804294594807026609638293539437286935503772101801433821053915371716284188665787967232464763808892618434263301810056154560438283877633957941572944822034479453916753507796910068912594560500836608215235605783723340714760960119319145912948480279651779184356994356172418603464628747082162475871780202868607325544781551065680583616058471475977367814338295574582450942453416002008665325253385672668994300796223139976640645190237481531851902147391807396201201799703915343423499008135819239684881566321559967077443367982975103648727755579256820566722752546407521965713336095320920822985129589997143740696972018563360331663471959214120971348584257396673542429063767170337770469161945592685537660073097456725716654388703941509676413429681372333615691533682226329180996924321063261666235129175134250645330301407536588271020457172050227357541822742441070313522061438812060477519238440079

— বেটা ক্ষয়
সূত্র

আইডিয়োন আর চালিত না হওয়ার আগে এনএমএক্স হ'ল বৃহত্তম ইনপুট মান যা আপনি আপনার প্রোগ্রামটি দিতে পারেন।

— ক্যালভিনের

1

@ ক্যালভিনের শখগুলি আমি মনে করি যে এনম্যাক্স নির্বিচারে বড় হলেও ...

— বিটা

1

আদর্শ আপনাকে অসীম কম্পিউটিং শক্তি দেয় না। আপনার প্রোগ্রামটি আদর্শ হিসাবে চালাতে পারে এমন বৃহত্তম ইনপুট মানটি কী ? (আসলে যদিও আপনার প্রোগ্রাম অনুসরণ করে না should be able to work for any N, given unlimited resourcesনিয়ম আউটপুট সর্বাধিক n = 10000. প্রায় শূন্য হয়।)

— ক্যালভিন এর সখ

যে python3 নয়: NameError: name 'xrange' not defined।

— বাকুরিউ

2

স্কালা - 1790

আইডিউইন http://ideone.com/A2CIto এ ।

আমরা ওয়েটারফিল্ডের সূত্রটি π এর জন্য ব্যবহার করি (এবং মেশিন-সূত্র কোডটি এখান থেকে অশোধিতভাবে পোর্ট করা হয়েছে )। আমরা সাধারণ পাওয়ার সিরিজ ব্যবহার করে ই গণনা করি।

object Main extends App {
  import java.math.{BigDecimal => JDecimal}
  import java.math.RoundingMode._
  import scala.concurrent.Future
  import scala.concurrent.Await
  import scala.concurrent.ExecutionContext.Implicits._
  import scala.concurrent.duration._
  val precision = 1800

  def acotPrecision(numDigits: Int)(x: BigDecimal) = {
    val x1 = x.underlying
    val two = JDecimal.valueOf(2)
    val xSquared = x1 pow 2
    val unity = JDecimal.ONE.setScale(numDigits, HALF_EVEN)
    var sum = unity.divide(x1, HALF_EVEN)
    var xpower = new JDecimal(sum.toString)
    var term = unity

    var add = false

    var n = JDecimal.valueOf(3).setScale(numDigits)
    while (term.setScale(numDigits, HALF_EVEN).compareTo(JDecimal.ZERO) != 0) {
      xpower = xpower.divide(xSquared, HALF_EVEN)
      term = xpower.divide(n, HALF_EVEN)
      sum = if (add) sum add term else sum subtract term
      add = !add
      n = n add two
    }
    sum
  }

  def ePrecision(numDigits: Int) = {
    val zero = JDecimal.ZERO
    var sum = zero
    var term = JDecimal.ONE.setScale(numDigits, HALF_EVEN)
    var n = JDecimal.ONE.setScale(numDigits, HALF_EVEN)
    while(term.setScale(numDigits, HALF_EVEN).compareTo(zero) != 0) {
      sum = sum add term
      term = term.divide(n, HALF_EVEN)
      n = n add JDecimal.ONE
    }
    sum
  }

  val acot = acotPrecision(precision) _

  def d(x: Int) = JDecimal.valueOf(x)

  def piFuture = Future(d(4) multiply (
    (d(83) multiply acot(107)) add (d(17) multiply acot(1710)) subtract (d(22) multiply acot(103697))
    subtract (d(24) multiply acot(2513489)) subtract (d(44) multiply acot(18280007883L))
   add (d(12) multiply acot(7939642926390344818L))
   add (d(22) multiply acot(BigDecimal("3054211727257704725384731479018")))
  ))

  def eFuture = Future(ePrecision(precision))

  Await.result(
    for (pi <- piFuture;
         e <- eFuture) yield println((pi multiply e).setScale(precision - 10, DOWN))
  , 5 seconds) 
}

— James_pic
সূত্র

পাই খুঁজে 5 সেকেন্ড