নীচের মত গোল করে যেতে পারে এমন কোনও অন্তর্নির্মিত কার্য রয়েছে?
10 -> 10
12 -> 10
13 -> 15
14 -> 15
16 -> 15
18 -> 20
নীচের মত গোল করে যেতে পারে এমন কোনও অন্তর্নির্মিত কার্য রয়েছে?
10 -> 10
12 -> 10
13 -> 15
14 -> 15
16 -> 15
18 -> 20
উত্তর:
পাইথনে আমি কোনও স্ট্যান্ডার্ড ফাংশন জানি না, তবে এটি আমার পক্ষে কাজ করে:
def myround(x, base=5):
return int(base * round(float(x)/base))
def myround(x, base=5):
return base * round(x/base)
উপরের কাজগুলি কেন কাজ করে তা সহজেই দেখা যায়। আপনি নিশ্চিত করতে চান যে 5 দ্বারা বিভাজিত আপনার সংখ্যাটি একটি পূর্ণসংখ্যা, সঠিকভাবে বৃত্তাকার। সুতরাং, আমরা প্রথমে ঠিক এটিই করি ( round(float(x)/5)যেখানে floatকেবল পাইথন 2 তে প্রয়োজনীয়) এবং তারপরে আমরা 5 দ্বারা বিভক্ত হয়েছি, আমরা পাশাপাশি 5 দ্বারাও গুণ করি। চূড়ান্ত রূপান্তর intকারণ round()পাইথন 2 এ একটি ভাসমান-পয়েন্ট মান দেয়।
আমি base5 কে ডিফল্ট করে একটি প্যারামিটার দিয়ে ফাংশনটিকে আরও জেনেরিক করে তুলেছি।
floor()এবং ceil()তুলনায় ভোটদান বরং:base * floor(x/base)
math.floorএবং math.ceilকাস্টম বেসের সাথে ব্যবহারের অনুমতি দেবেন না, তাই পছন্দটি অপ্রাসঙ্গিক।
অ-পূর্ণসংখ্যার মানগুলিকে গোল করার জন্য যেমন 0.05:
def myround(x, prec=2, base=.05):
return round(base * round(float(x)/base),prec)
প্যারামিটারের মানগুলি পরিবর্তন না করেই "গোল (" "থেকে" মাইগ্রাউন্ডে "" পরিবর্তন করার জন্য) আমার কোডটিতে সন্ধান এবং প্রতিস্থাপন করতে পারার পরে আমি এটি দরকারী পেয়েছি।
def my_round(x, prec=2, base=0.05): return (base * (np.array(x) / base).round()).round(prec) যা নম্রি অ্যারে গ্রহণ করে।
'বিশ্রাম' অপসারণ কাজ করবে:
rounded = int(val) - int(val) % 5মানটি যদি পূর্ণসংখ্যক হয় তবে:
rounded = val - val % 5একটি ফাংশন হিসাবে:
def roundint(value, base=5):
return int(value) - int(value) % int(base)
def round_to_next5(n):
return n + (5 - n) % 5
বৃত্তাকার (x [, n]): মানগুলি 10 বিয়োগফলের নিকটতম একাধিকের সাথে গোল হয়। সুতরাং এন যদি নেতিবাচক হয় ...
def round5(x):
return int(round(x*2, -1)) / 2
যেহেতু 10 = 5 * 2, আপনি ভাসমান বিভাগ এবং 5.0 দিয়ে গুণনের পরিবর্তে পূর্ণসংখ্যা বিভাগ এবং 2 দিয়ে গুণ করতে পারেন। আপনি যদি কিছুটা স্থানান্তর পছন্দ না করেন তবে এটি যে খুব বেশি গুরুত্বপূর্ণ তা নয়
def round5(x):
return int(round(x << 1, -1)) >> 1
দুঃখিত, আমি অলোক সিংহাইয়ের জবাব সম্পর্কে মন্তব্য করতে চেয়েছিলাম, তবে খ্যাতির অভাবের কারণে এটি আমাকে আসতে দেয় না = /
যাইহোক, আমরা আরও একটি ধাপ সাধারণ করতে পারি এবং যেতে পারি:
def myround(x, base=5):
return base * round(float(x) / base)
এটি আমাদের পছন্দসই .25বা অন্য কোনও ভগ্নাংশের ভিত্তিতে অ-পূর্ণসংখ্যার ঘাঁটি ব্যবহার করতে দেয় ।
বিভাজনের সংস্করণ :-)
def divround(value, step, barrage):
result, rest = divmod(value, step)
return result*step if rest < barrage else (result+1)*step
ব্যবহার করুন:
>>> def round_to_nearest(n, m):
r = n % m
return n + m - r if r + r >= m else n - r
এটি গুন ব্যবহার করে না এবং থেকে / ফ্লোটে রূপান্তর করবে না।
10 এর নিকটতম একাধিকের সাথে গোলাকার:
>>> for n in range(-21, 30, 3): print('{:3d} => {:3d}'.format(n, round_to_nearest(n, 10)))
-21 => -20
-18 => -20
-15 => -10
-12 => -10
-9 => -10
-6 => -10
-3 => 0
0 => 0
3 => 0
6 => 10
9 => 10
12 => 10
15 => 20
18 => 20
21 => 20
24 => 20
27 => 30
আপনি দেখতে পাচ্ছেন, এটি নেতিবাচক এবং ধনাত্মক উভয় সংখ্যার জন্য কাজ করে। টাই (যেমন -15 এবং 15) সর্বদা উপরের দিকে বৃত্তাকার হবে।
একটি অনুরূপ উদাহরণ যা 5 এর নিকটতম একাধিকের সাথে ঘুরে দেখা যায় যে এটি পৃথক "বেস" এর প্রত্যাশা অনুযায়ী আচরণ করে:
>>> for n in range(-21, 30, 3): print('{:3d} => {:3d}'.format(n, round_to_nearest(n, 5)))
-21 => -20
-18 => -20
-15 => -15
-12 => -10
-9 => -10
-6 => -5
-3 => -5
0 => 0
3 => 5
6 => 5
9 => 10
12 => 10
15 => 15
18 => 20
21 => 20
24 => 25
27 => 25
যদি কারও "আর্থিক রাউন্ডিং" প্রয়োজন হয় (0.5 রাউন্ড সবসময়ই আপ থাকে):
def myround(x, base=5):
roundcontext = decimal.Context(rounding=decimal.ROUND_HALF_UP)
decimal.setcontext(roundcontext)
return int(base *float(decimal.Decimal(x/base).quantize(decimal.Decimal('0'))))ডকুমেন্টেশন অনুসারে অন্যান্য গোলাকার বিকল্পগুলি হ'ল:
ROUND_CEILING (অনন্তের দিকে),
ROUND_DOWN (শূন্যের দিকে),
ROUND_FLOOR (-ইনফিনিটির দিকে),
ROUND_HALF_DOWN (নিকটে নিকটতম শূন্যের দিকে যাওয়ার),
ROUND_HALF_EVEN (নিকটতম এমনকি পূর্ণসংখ্যার
সাথে বন্ধনের সাথে ), ROUND_HALF_UP (সম্পর্কের নিকটে নিকটে শূন্য থেকে দূরে) বা
ROUND_UP (শূন্য থেকে দূরে)
ROUND_05UP (শূন্যের থেকে দূরে থাকলে শেষ সংখ্যাটি শূন্যের দিকে গোল করার পরে 0 বা 5 হত; অন্যথায় শূন্যের দিকে)
ডিফল্টরূপে পাইথন ROUND_HALF_EVEN ব্যবহার করে কারণ এতে কিছু পরিসংখ্যানগত সুবিধা রয়েছে (বৃত্তাকার ফলাফল পক্ষপাতদুষ্ট নয়)।
পূর্ণসংখ্যার জন্য এবং পাইথন 3 সহ:
def divround_down(value, step):
return value//step*step
def divround_up(value, step):
return (value+step-1)//step*stepউত্পাদন:
>>> [divround_down(x,5) for x in range(20)]
[0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 10, 10, 10, 10, 10, 15, 15, 15, 15, 15]
>>> [divround_up(x,5) for x in range(20)]
[0, 5, 5, 5, 5, 5, 10, 10, 10, 10, 10, 15, 15, 15, 15, 15, 20, 20, 20, 20]এই সম্পর্কে কি:
def divround(value, step):
return divmod(value, step)[0] * stepএই আমার সি কোড। আমি যদি এটি সঠিকভাবে বুঝতে পারি তবে এটি এমন কিছু হওয়া উচিত;
#include <stdio.h>
int main(){
int number;
printf("Enter number: \n");
scanf("%d" , &number);
if(number%5 == 0)
printf("It is multiple of 5\n");
else{
while(number%5 != 0)
number++;
printf("%d\n",number);
}
}এবং এটি কেবল গোলাকার পরিবর্তে 5 এর নিকটতম একাধিকের দিকেও ঘুরবে;
#include <stdio.h>
int main(){
int number;
printf("Enter number: \n");
scanf("%d" , &number);
if(number%5 == 0)
printf("It is multiple of 5\n");
else{
while(number%5 != 0)
if (number%5 < 3)
number--;
else
number++;
printf("nearest multiple of 5 is: %d\n",number);
}
}এটি করার আরেকটি উপায় (সুস্পষ্ট গুণ বা বিভাগ অপারেটর ছাড়াই):
def rnd(x, b=5):
return round(x + min(-(x % b), b - (x % b), key=abs))আপনি যে নম্বরটি পাস int()করেছেন তাতে যোগ করে গোল করে নেওয়ার পরিবর্তে রাউন্ডিং অফ করতে "কৌশল" করতে পারেন ।0.5int()
x // base * base