বক্সের বাইরে চিন্তা

Question

আপনি 5-পার্শ্বযুক্ত বাক্সে একটি গোলকের সাথে ফিট করার চেষ্টা করছেন তবে কখনও কখনও এটি পুরোপুরি ফিট হয় না। বাক্সের বাইরে কতগুলি গোলক রয়েছে তার গণনা করতে একটি ফাংশন লিখুন of

সম্ভাব্য 3 টি পরিস্থিতি রয়েছে:

• গোলকটি পুরোপুরি বাক্সে ফিট করে। উত্তর 0 হবে।
• গোলকের বাক্সের রিমে বসে আছে। উত্তরটি মোট আয়তনের অর্ধেকের বেশি হবে।
• গোলকের বাক্সের নীচে বসে আছে।

আপনি এখানে প্রতিটি পরিস্থিতি দেখতে পারেন:

এই মানটি কমপক্ষে 4 টি উল্লেখযোগ্য সংখ্যায় গুণতে আপনাকে অবশ্যই একটি প্রোগ্রাম বা ফাংশন লিখতে হবে।

ইনপুট: যে কোনও বিন্যাসে সুবিধাজনক হিসাবে 4 টি অ-নেতিবাচক আসল সংখ্যা * - প্রস্থ, দৈর্ঘ্য, বাক্সটির গভীরতা (অভ্যন্তরীণ পরিমাপ) এবং গোলকের ব্যাস।

আউটপুট: 1 ব্যবহারযোগ্য বিন্যাসে অ-নেতিবাচক আসল সংখ্যা * - বাক্সের বাইরে গোলকের মোট ভলিউম (শতাংশ নয়)।

_{* দশমিক স্ট্রিং থেকে / এ রূপান্তরিত হতে হবে}

আপনার যতটা সম্ভব ত্রিকোণমিতির ব্যবহার সীমিত করতে উত্সাহিত করা হচ্ছে।

এটি একটি জনপ্রিয়তা প্রতিযোগিতা, তাই বাক্সের বাইরে চিন্তা করুন!

Comments

কোন উদাহরণ দয়া করে?

— এমনিপ

আমরা অনুমান করতে পারেন পারেন বাক্সের দেয়াল অসীম পাতলা হয় বা প্রদত্ত মাত্রা অভ্যন্তর মাত্রা কি? :)

— ড্যারেন স্টোন

ইনপুটগুলির সর্বাধিক মানগুলি কী কী?

— ব্লেন্ডার

@ ড্যারেনস্টোন আমি মনে করি যে দেয়ালগুলির বেধ অপ্রয়োজনীয়। আপনি এটিকেও অসীম বিবেচনা করতে পারেন, তাই বক্সটি একটি ইনফিন্ট ব্লকের একটি আয়তক্ষেত্রাকার গর্ত হবে। ফলাফল প্রাচীর বেধ জন্য অন্য মান হিসাবে একই হবে। আপনি যদি বাক্স বা গোলকটিকে শারীরিকভাবে ভেঙে ফেলা, বিকৃত করে বা কাটা করে নিয়মগুলি বাঁকানো / ঠকানোর উদ্দেশ্যে থাকেন বা সত্যিই অদ্ভুত কিছু করেন Ex

— ভিক্টর স্টাফুসা

@ ড্যারেনস্টোন বাক্সগুলির মধ্যে কেবল একটি সুন্দর চিত্রের উদ্দেশ্যে বেধ রয়েছে। সমস্যাটি অভ্যন্তরের মাত্রাগুলি নিয়ে কাজ করে।

— কেন্ডল ফ্রে

Answer 1

বের

নীচে, বাক্সের বাইরে একটি গোলকটি সন্ধান করুন।

"গোলক" হ'ল ভলিউম-কম্পিউটিং ফাংশন f। রেফারেন্স পরীক্ষার কেসগুলি "বক্স" রচনা করে।

                     ( x y z d -- v )
                 : f { F: z F: d } d f2/ 
              { F: r } fmin { F: m } m f2/ {
             F: b } d m f<= d z f<= and if 0e
             else r r r f* b b f* f- fsqrt f-
              { F: t } d m f<= t z f> or if d 
               z f- else d t f- then r 3e f* 
                  fover f- pi f* fover f*
                      f* 3e f/ then ;

                     1e                 1e      
                     1e                 1e 
                     f                  f. 
            cr       1e        1e       0e      
            1e       f         f.       cr 
            1e       1e 0.5e 1e f f. cr 1e 
            0.999e 1e          1e     f  
            f.  cr            0.1e 1e   
            1.000e 0.500e f f. cr

আউটপুট:

0. 
0.523598775598299 
0.261799387799149 
0.279345334323962 
0.0654299441440212 

Answer 2

জাভা - পূর্ণসংখ্যার উপর ভিত্তি করে

এই প্রোগ্রামটি পাই ব্যবহার করে না এবং কোনও বাহ্যিক ফাংশন কল করে না - এমনকি স্কয়ারটিও নয়। এটা শুধুমাত্র সহজ গাণিতিক ব্যবহার করে - +, -, *এবং /। তদুপরি, একটি স্কেলিং পদক্ষেপ ব্যতীত, এটি পূর্ণসংখ্যার সাথে একচেটিয়াভাবে কাজ করে। এটি মূলত গোলকটিকে সামান্য কিউবগুলিতে বিভক্ত করে এবং বাক্সের বাইরে যেগুলি গণনা করে।

public class Box {
    private static final int MIN = 10000;
    private static final int MAX = MIN * 2;

    private static final int[] SQ = new int[MAX * MAX + 1];

    static {
        int t = 1;
        for (int i = 1; i <= MAX; ++i) {
            while (t < i * i) SQ[t++] = i - 1;
        }
        SQ[MAX * MAX] = MAX;
    }

    public static long outsideInt(int r, int w, int z) {
        int r2 = r * r;
        int o = z - r + 1;
        if (w < r * 2) {
            int t = 1 - SQ[r2 - w * w / 4];
            if (t < o) o = t;
        }
        long v = 0;
        for (int i = o; i <= r; ++i) {
            int d = r2 - i * i;
            int j0 = SQ[d];
            v += 1 + 3 * j0;
            for (int j = 1; j <= j0; ++j)
                v += 4 * SQ[d - j * j];
        }
        return v;
    }

    public static double outside(double x, double y, double z, double d) {
        double f = 1;
        double w = x < y ? x : y;
        double r = d / 2;
        while (r < MIN) {
            f *= 8;
            r *= 2;
            w *= 2;
            z *= 2;
        }
        while (r > MAX) {
            f /= 8;
            r /= 2;
            w /= 2;
            z /= 2;
        }
        return outsideInt((int) r, (int) w, (int) z) / f;
    }

    public static void main(final String... args) {
        System.out.println(outside(1, 1, 1, 1));
        System.out.println(outside(1, 1, 0, 1));
        System.out.println(outside(1, 1, 0.5, 1));
        System.out.println(outside(1, 0.999, 1, 1));
        System.out.println(outside(0.1, 1, 1, 0.5));
    }
}

আউটপুট:

0.0
0.5235867850933005
0.26178140856157484
0.27938608275528054
0.06542839088004015

এই ফর্মটিতে, প্রোগ্রামটির জন্য 2 জিবি-র বেশি মেমরি প্রয়োজন (এটি -Xmx2300mএখানে কাজ করে ) এবং এটি খুব ধীর গতির হয়। এটি স্মৃতিটিকে বর্গমূলের একগুচ্ছ প্রাক্কলক করতে ব্যবহার করে (গাণিতিকভাবে); এটি সত্যিই প্রয়োজনীয় নয়, তবে এটি ছাড়া এটি খুব ধীর হবে। মেমরির প্রয়োজনীয়তা এবং গতি উভয়ই উন্নত করতে MINধ্রুবকের মান হ্রাস করুন (এটি যদিও সঠিকতা হ্রাস করবে)।

Answer 3

পাইথন 2 (অ্যারে-ভিত্তিক পদ্ধতির)

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

import math as magic
magic.more = magic.pow
magic.less = magic.sqrt

def a( width, length, depth, diameter ):
  precision = 350 #Crank this up to higher values, such as 20000

  circle = []
  for x in xrange(-precision,precision):
    row = []
    for y in xrange(-precision,precision):
      if magic.less(magic.more(x, 2.0)+magic.more(y, 2.0)) <= precision:
        row.append(True)
      else:
        row.append(False)
    circle.append(row)

  if min(width,length,depth) >= diameter:
    return 0
  elif min(width,length) >= diameter:
    row = precision*2-int(precision*2*float(depth)/float(diameter))
    total = len([x for y in circle for x in y if x])
    ammo = len([x for y in circle[:row] for x in y if x])
    return float(ammo)/float(total)
  else:
    #Why try to fit a sphere in a box if you can try to fit a box on a sphere
    maxwidth = int(float(precision*2)*float(min(width,length))/float(diameter))
    for row in xrange(0,precision*2):
      rowwidth = len([x for x in circle[row] if x])
      if rowwidth > maxwidth:
        total = len([x for y in circle for x in y if x])
        ammo = len([x for y in circle[row:] for x in y if x])
        return float(ammo)/float(total)

Answer 4

পাইথন ২.7, গোলাকার ক্যাপ সূত্র

এই সংস্করণটি কিছু ক্ষেত্রে একটি রানটাইম সতর্কতা নিক্ষেপ করবে, তবে এখনও সঠিক উত্তরটি আউটপুট করে।

import numpy as n
x,y,z,d=(float(i) for i in raw_input().split(' '))
r=d/2
V=4*n.pi*r**3/3
a=n.sqrt((d-z)*z)
b=min(x,y)/2
h=r-n.sqrt(r**2-b**2)
c=lambda A,H: (3*A**2+H**2)*n.pi*H/6
print(0 if d<=z and r<=b else c(a,d-z) if r<=b and z>r else V-c(a,z) if r<=b or z<h else V-c(b,h))

আরও ১১ টি চরিত্রের জন্য আমি সতর্কতা থেকে মুক্তি পেতে পারি।

import math as m
x,y,z,d=(float(i) for i in raw_input().split(' '))
r=d/2
V=4*m.pi*r**3/3
if d>z:
    a=m.sqrt((d-z)*z)
b=min(x,y)/2
h=r-m.sqrt(r**2-b**2)
c=lambda A,H: (3*A**2+H**2)*m.pi*H/6
print(0 if d<=z and r<=b else c(a,d-z) if r<=b and z>r else V-c(a,z) if r<=b or z<h else V-c(b,h))

সংস্করণ 1 এ চালিত পরীক্ষাগুলি এখানে:

$ python spherevolume.py
1 1 1 1
0
$ python spherevolume.py
1 1 0 1
0.523598775598
$ python spherevolume.py
1 1 .5 1
0.261799387799
$ python spherevolume.py
1 .999 1 1        
0.279345334324
$ python spherevolume.py
.1 1 1 0.5
spherevolume.py:65: RuntimeWarning: invalid value encountered in sqrt
  a=n.sqrt((d-z)*z) or b
0.065429944144

Comments

যদিও এটি কোড গল্ফ নয়, আপনি নিজের কোডের সমস্তটি সংক্ষিপ্ত import numpy as nকরে from numpy import*নিয়ে যেতে পারেন n.।

— টিমটেক

@ টিমটেক মাথা আপ এবং পরামর্শের জন্য ধন্যবাদ।

— ব্যবহারকারী 2487951

Answer 5

ম্যাথামেটিকাল

যথাযথ সীমাবদ্ধতার সাথে সংখ্যাগত সংহতকরণ ব্যবহার করা Using

f[width_, length_, height_, diam_] := 
 With[{r = diam/2, size = Min[width, length]/2},
  Re@NIntegrate[
    Boole[x^2 + y^2 + z^2 < r^2], {x, -r, r}, {y, -r, r}, 
      {z, -r, Max[-r, If[size >= r, r - height, Sqrt[r^2 - size^2]]]}]
  ]

Answer 6

রেফারেন্স বাস্তবায়ন - সি #

using System;

namespace thinkoutsidethebox
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(OutsideTheBox(1, 1, 1, 1));
            Console.WriteLine(OutsideTheBox(1, 1, 0, 1));
            Console.WriteLine(OutsideTheBox(1, 1, 0.5, 1));
            Console.WriteLine(OutsideTheBox(1, 0.999, 1, 1));
            Console.WriteLine(OutsideTheBox(0.1, 1, 1, 0.5));
        }

        static double OutsideTheBox(double x, double y, double z, double d)
        {
            x = Math.Min(x, y);
            double r = d / 2; // radius
            double xr = x / 2; // box 'radius'
            double inside = 0; // distance the sphere sits inside the box
            if (d <= x && d <= z) // it fits
            {
                return 0;
            }
            else if (d <= x || r - Math.Sqrt(r * r - xr * xr) > z) // it sits on the bottom
            {
                inside = z;
            }
            else // it sits on the rim
            {
                inside = r - Math.Sqrt(r * r - xr * xr);
            }
            // now use the formula from Wikipedia
            double h = d - inside;
            return (Math.PI * h * h / 3) * (3 * r - h);
        }
    }
}

আউটপুট:

0
0.523598775598299
0.261799387799149
0.279345334323962
0.0654299441440212

Comments

আমি এই ফলাফলগুলি বুঝতে পারি না। প্রথমটি স্পষ্টতই 0. টি। দ্বিতীয়টির কোনও উচ্চতা নেই, যাতে 1 হওয়া উচিত The তৃতীয়টি বল রাখতে পারে, এবং এর অর্ধেকটি তার উপরে থাকে (উত্তরটি 0.5 হওয়া উচিত)। ৪ নম্বর ক্ষেত্রে বাক্সটি কেবল সামান্য থেকে ছোট, তাই এটি বাক্সের শীর্ষে রয়েছে। উত্তরটি 0.5 এর চেয়ে কিছুটা বেশি হওয়া উচিত। শেষেরটির উত্তর> 0.5% হওয়া উচিত, কারণ প্রস্থ / দৈর্ঘ্যটি বলটি ভিতরে রাখার জন্য যথেষ্ট নয়।

— সুমুরাই

@ সুমুরাই 8 "আউটপুট: বাক্সের বাইরে গোলকের মোট ভলিউম ( শতাংশ নয় )" "

— কেন্ডাল ফ্রে

Answer 7

চুনি

আসুন দেখুন ...
বাক্সটি যদি পুরো ভিতরে থাকে তবে প্রস্থ> ব্যাস; দৈর্ঘ্য> ব্যাস এবং উচ্চতা> ব্যাস।
এটি চালানোর জন্য 1 ম চেক হওয়া উচিত।

যদি এটি নীচে বসে থাকে তবে ডাব্লু> ডি; l> d এবং h V=(pi*h^2 /3)*(3r-h)সুতরাং সেক্ষেত্রে আমরা কেবল উচ্চতা পেয়েছি এবং এটির মাধ্যমে এটি চালাই।

যদি এটি আটকে থাকে তবে আমরা একটি অনুরূপ সূত্র ( V=(pi*h/6)*(3a^2 + h^2)) ব্যবহার করি । আসলে আমাদের আগের সূত্রটি এর উপর ভিত্তি করে! মূলত, আমরা এটি ব্যবহার করি এবং একটি হ'ল ডাব্লু এবং এল এর ছোট একটি। (ইঙ্গিত, আমরা করে উচ্চতা পেতে পারি h=r-a)

এখন কোড!

def TOTB(wi,le,hi,di)
  if wi>=di and le>=di and hi>=di
    res = 0
  elsif wi>=di and le>=di
    r = di/2
    res = 3*r
    res -= hi
    res *= Math::PI
    res *= hi*hi
    res /= 3
  else
    r = di/2
    if wi>le
      a=le
    else
      a=wi
    end #had issues with the Ternary operator on ruby 2.2dev
    h = r-a
    res = 3*a*a
    res += h*h
    res *= Math::PI
    res *= h
    res /= 6
  end
  res
end

দ্রষ্টব্য ** আমি এটি খুব বেশি পরীক্ষা করিনি, সুতরাং কোনও ত্রুটি ঘটতে পারে, যদি কেউ তা খেয়াল করে, বলুন!
গণিত যদিও শক্ত।
সংক্ষিপ্ত সংস্করণ:

v1 = ->r,h{(3*r -h)*Math::PI*h*h/3}
v2 = ->r,a{h=r-a;((3*a*a)+(h*h))*h*Math::PI/6}
TOTB = ->wi,le,hi,di{(di<wi&&di<le&&di<hi)?0:((di<wi&&di<le)?v1[di/2,hi]:v2[di/2,((wi>le)?le:wi)])}

(এখন আমি নিশ্চিত জানি যে ভি 2 এর জন্য এইচ প্রাপ্তি অন্যভাবে করা হয় তবে আমি এটি পরে ঠিক করব fix

Comments

খুশী হলাম। এই কোডটি পরিষ্কারভাবে পড়ে reads তবে আপনি কি নিম্নলিখিত বিবৃতি সম্পর্কে নিশ্চিত? "আমরা করে উচ্চতা পেতে h=r-aপারি" আমি কেবলমাত্র গোলাকার ক্যাপ সূত্রগুলি পড়ছিলাম এবং ডায়াগ্রামটি এত সহজ সম্পর্কের প্রস্তাব দেয় না। আমি এটি অন্য পড়তে দেব।

— ড্যারেন স্টোন

পুনঃটুইট করুন আমি অসাধারণ / নিঃসৃত, তবে যেভাবেই হোক, প্যাচ করা খুব সহজ!

আমি প্রায় নিশ্চিত a = wi > le ? le : wiকাজ করা উচিত। অন্যথায়, আপনি একটি বাগ আছে।

— কনরাড বোরোস্কি

a = wi>le?le:wiএটা কাজ করছে না. আমি অনুমান করছি কারণ আমি গিট রুবি (২.২ বিকাশকারী) চালাচ্ছি, এটি ভারসাম্যহীন বলে থাকতে পারে।

Answer 8

C ++

#define _USE_MATH_DEFINES   //so I can use M_PI
#include <math.h>           //so I can use sqrt()
#include <iostream>
#include <algorithm>

using namespace std;


int main()
{
    double w;
    double l;
    double d;
    double sd;
    double min_wl;
    double pdbd;
    double sl;
    cin >> w >> l >> d >> sd;

    min_wl = min(w, l);
    if(sd <= min_wl)
    {
        pdbd = 0.0;
    } else
    {
        pdbd = (sqrt((((sd/2)*(sd/2))-((min_wl/2)*(min_wl/2)))) + (sd/2));
    }
    sl = sd - d;

    if(sd <= min(min_wl, d))
    {
        cout << 0;
        return 0;
    } else if((sl < pdbd) && (pdbd > 0.0))    //sits on lip of box
    {
        cout << (M_PI * (((sd/2) * pdbd * pdbd) - ((pdbd * pdbd * pdbd)/(3))));
        return 0;
    } else                  //sits on bottom of box
    {
        cout << (M_PI * (((sd/2) * sl * sl)-((sl * sl * sl)/(3))));
        return 0;
    }
    return 0;
}

আমার কোডটি একটি অর্ধ-বৃত্তের কিছু অংশের গ্রাফের ঘূর্ণনের ঘনকটির ভলিউমটি আবিষ্কার করে। pdbdগোলকের পৃষ্ঠের উপরের পয়েন্টের প্রক্ষেপণের লিনিয়ার দূরত্ব ধরে যা বাক্সের ঠোঁটের সাথে গোলকের ব্যাসকে স্পর্শ করে যা প্রসারিত হলে বাক্সের তলদেশে স্বাভাবিক হবে। দুটি অভিব্যক্তি যা M_PIমূলত pi * -(x^2)+2rxx এর সাথে সম্মানের সাথে অখণ্ডের অ্যান্টি-ডেরাইভেটিভ (যেখানে x গোলকের মধ্য দিয়ে উল্লিখিত ব্যাসের সাথে দৈর্ঘ্যের একটি পরিমাপ এবং যেখানে গোলকের ব্যাসার্ধ সেখানে) উভয়ই মূল্যায়ন করা হয় pdbdবা গোলকের ব্যাস এবং বক্সের গভীরতার পার্থক্য নির্দিষ্ট মাত্রার উপর নির্ভর করে যা বিভিন্ন মাত্রার সাথে ঘটে।