पाइथन में 5 से गोल (या अन्य संख्या)

Question

क्या कोई अंतर्निहित फ़ंक्शन है जो निम्न की तरह गोल हो सकता है?

10 -> 10
12 -> 10
13 -> 15
14 -> 15
16 -> 15
18 -> 20

Answer 1

मैं पायथन में एक मानक कार्य के बारे में नहीं जानता, लेकिन यह मेरे लिए काम करता है:

अजगर २

def myround(x, base=5):
    return int(base * round(float(x)/base))

python3

def myround(x, base=5):
    return base * round(x/base)

यह देखना आसान है कि ऊपर क्यों काम करता है। आप यह सुनिश्चित करना चाहते हैं कि आपकी संख्या 5 से विभाजित एक पूर्णांक है, सही ढंग से गोल है। इसलिए, हम पहले ठीक ऐसा ही करते हैं ( round(float(x)/5)जहां floatकेवल Python2 में जरूरत होती है), और फिर जब से हम 5 से विभाजित होते हैं, हम 5 से गुणा करते हैं। अंतिम रूपांतरण intइसलिए है क्योंकि round()पायथन 2 में एक फ्लोटिंग-पॉइंट वैल्यू देता है।

मैंने फंक्शन baseको 5 के लिए डिफॉल्ट करते हुए इसे एक पैरामीटर बना दिया है ।

Comments

यदि केवल पूर्णांक और नीचे x // base * base

— चक्कर

यह मेरे पागल जा रहा है, लेकिन मैं का उपयोग करना पसंद floor()और ceil()से कास्टिंग बल्कि:base * floor(x/base)

— user666412

@ user666412 math.floorऔर math.ceilकस्टम बेस के साथ उपयोग की अनुमति न दें, इसलिए वरीयता अप्रासंगिक है।

— एक्यूमेनस

Answer 2

गैर-पूर्णांक मानों के लिए राउंडिंग के लिए, जैसे कि 0.05:

def myround(x, prec=2, base=.05):
  return round(base * round(float(x)/base),prec)

मुझे यह उपयोगी लगा क्योंकि मैं केवल पैरामीटर मानों को बदलने के बिना "राउंड (" से "माय सराउंड") को बदलने के लिए अपने कोड में एक खोज कर सकता हूं।

Comments

आप उपयोग कर सकते हैं: def my_round(x, prec=2, base=0.05): return (base * (np.array(x) / base).round()).round(prec) जो सुन्न सरणियों को भी स्वीकार करता है।

— शुभ

Answer 3

यह केवल स्केलिंग की बात है

>>> a=[10,11,12,13,14,15,16,17,18,19,20]
>>> for b in a:
...     int(round(b/5.0)*5.0)
... 
10
10
10
15
15
15
15
15
20
20
20

Answer 4

'बाकी' को हटाने से काम होगा:

rounded = int(val) - int(val) % 5

यदि मान एक पूर्णांक को विभाजित करता है:

rounded = val - val % 5

एक समारोह के रूप में:

def roundint(value, base=5):
    return int(value) - int(value) % int(base)

Comments

मुझे निकटतम भिन्नात्मक मूल्य पर गोलाई के लिए यह उत्तर पसंद है। यानी अगर मुझे केवल 0.25 की वेतन वृद्धि चाहिए।

— जर्सी बीन

Answer 5

def round_to_next5(n):
    return n + (5 - n) % 5

Answer 6

राउंड (x [, n]): मानों को पावर माइनस n के 10 के निकटतम कई पर गोल किया जाता है। तो अगर n ऋणात्मक है ...

def round5(x):
    return int(round(x*2, -1)) / 2

10 = 5 * 2 के बाद से, आप पूर्णांक विभाजन और 2 के साथ गुणा का उपयोग कर सकते हैं, बजाय फ्लोट डिवीजन और 5.0 के साथ गुणा का। ऐसा नहीं है कि बहुत मायने रखता है, जब तक आप थोड़ा सा बदलाव पसंद नहीं करते हैं

def round5(x):
    return int(round(x << 1, -1)) >> 1

Comments

+1 हमें यह दिखाने के लिए कि उच्च मूल्यों सहित 1.0 (राउंड) को राउंडिंग को 1.0 से अधिक गुणा करने के लिए हैंडल किया जा सकता है। (ध्यान दें, हालांकि, बिट-शिफ्टिंग दृष्टिकोण फ्लोट्स के साथ काम नहीं करेगा, यह उल्लेख करने के लिए नहीं कि यह अधिकांश प्रोग्रामर के लिए बहुत कम पठनीय है।)

— पीटर हैनसेन

@Peter हैंनन +1 के लिए धन्यवाद। फ्लोट्स के साथ काम करने के लिए बिट शिफ्टिंग के लिए एक इंट (x) होना चाहिए। सबसे अधिक पढ़ने योग्य नहीं है और मैं इसे स्वयं उपयोग नहीं करूंगा, लेकिन मुझे इसमें "शुद्धता" पसंद थी, जिसमें केवल 1 का समावेश था और 2 का या 5 का नहीं।

— pwdyson

Answer 7

क्षमा करें, मैं आलोक सिंघई के उत्तर पर टिप्पणी करना चाहता था, लेकिन इसने मुझे प्रतिष्ठा की कमी के कारण नहीं होने दिया।

वैसे भी, हम एक और कदम और सामान्य कर सकते हैं:

def myround(x, base=5):
    return base * round(float(x) / base)

यह हमें गैर-पूर्णांक आधारों का उपयोग करने की अनुमति देता है, जैसे .25या किसी भी अन्य आंशिक आधार।

Comments

कृपया उत्तर के रूप में एक टिप्पणी पोस्ट करके नए उपयोगकर्ता प्रतिबंधों को बायपास करने का प्रयास न करें। प्रतिबंध एक कारण के लिए मौजूद हैं । इसे एक संभावित कारण के रूप में ध्यान में रखें कि कुछ उत्तर क्यों और कैसे हटाए जाते हैं?

— गुडबाय StackExchange

Answer 8

Divround :-) का संशोधित संस्करण

def divround(value, step, barrage):
    result, rest = divmod(value, step)
    return result*step if rest < barrage else (result+1)*step

Comments

तो इस मामले में आप divround (मान, 5, 3) का उपयोग करते हैं? या हो सकता है (चारों ओर मूल्य, 5, 2.5)?

— pwdyson

divround (मान, 5, 3), बिल्कुल।

— क्रिस्चियन हॉस्कनेच

Answer 9

उपयोग:

>>> 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

Answer 10

यदि किसी को "वित्तीय गोलाई" की जरूरत है (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 (-Infinity की ओर),
ROUND_HALF_DOWN, (संबंधों शून्य की ओर जाने के साथ निकटतम करने के लिए)
, (संबंधों निकटतम सम पूर्णांक के लिए जा रहा के साथ निकटतम करने के लिए) ROUND_HALF_EVEN
संबंधों जाने के साथ निकटतम करने के लिए ROUND_HALF_UP ( शून्य से दूर), या
ROUND_UP (शून्य से दूर)।
ROUND_05UP (शून्य से दूर यदि शून्य की ओर गोल होने के बाद अंतिम अंक 0 या 5 होता, अन्यथा शून्य की ओर)

डिफ़ॉल्ट रूप से पायथन ROUND_HALF_EVEN का उपयोग करता है क्योंकि इसके कुछ सांख्यिकीय लाभ हैं (गोल परिणाम स्पष्ट नहीं हैं)।

Answer 11

पूर्णांकों के लिए और पायथन 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]

Answer 12

इस बारे में क्या:

 def divround(value, step):
     return divmod(value, step)[0] * step

Comments

Divmod पर डॉक्स: docs.python.org/2/library/functions.html#divmod

— duhaime

Answer 13

5 के अगले कई

गौर कीजिए 51 को 55 में बदलने की जरूरत:

code here

mark = 51;
r = 100 - mark;
a = r%5;
new_mark = mark + a;

Answer 14

यहाँ मेरा C कोड है। अगर मैं इसे सही ढंग से समझता हूं, तो यह कुछ इस तरह से होना चाहिए;

#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);
  }
}

Answer 15

ऐसा करने का एक और तरीका (स्पष्ट गुणन या विभाजन ऑपरेटरों के बिना):

def rnd(x, b=5):
    return round(x + min(-(x % b), b - (x % b), key=abs))

Answer 16

आप जिस नंबर को पास int()करते हैं, उसे जोड़कर राउंडिंग डाउन करने के बजाय "ट्रिक" कर सकते हैं ।0.5int()

Comments

यह वास्तव में सवाल का जवाब नहीं देता है

— उड़ी अगस्सी