निकटतम अच्छी संख्या

Question

मैं एक ऐसा एप्लीकेशन लिख रहा हूं जिसके लिए निकटतम 'अच्छा' नंबर पर गोल करने वाले लेबल की आवश्यकता है। मैं इसे प्रदर्शित करने के लिए नीचे कुछ कोड डालूंगा, लेकिन मेरी समस्या यह है कि मैं इस नंबर को खोजने के लिए किसी अन्य श्रृंखला का उपयोग कर रहा था लेकिन मुझे ऊपरी सीमा के बारे में सुनिश्चित नहीं हो सकता है, इसलिए यह वास्तव में एक अच्छी रणनीति नहीं है। क्या कोई ज्ञात एल्गोरिदम या संसाधन हैं जो मेरी मदद कर सकते हैं?

if (diff <= 1) { 
     roundAmount = 0.2; 
    } else if (diff <= 5) { 
     roundAmount = 1; 
    } else if (diff <= 10) { 
     roundAmount = 2; 
    } else if (diff <= 25) { 
     roundAmount = 5; 
    } else if (diff <= 50) { 
     roundAmount = 10; 
    } else if (diff <= 100) { 
     roundAmount = 20; 
    } else if (diff <= 250) { 
     roundAmount = 50; 
    } else if (diff <= 500) { 
     roundAmount = 100; 
    } else if (diff <= 1000){ 
     roundAmount = 200; 
    } etc... 

Answer 1

आप Math.log10 उपयोग कर सकते हैं अपने "अच्छा संख्या" खोज, कुछ इस तरह करने से पहले सभी मूल्यों को सामान्य बनाने में:

[संपादित करें] मैं सिर्फ महसूस किया आप सी # के बजाय जावा का उपयोग कर रहे हैं, इसलिए मैं थोड़ा सा कोड संशोधित किया। मैं चारों ओर यह परीक्षण करने के लिए एक संकलक की जरूरत नहीं है, लेकिन तुम वैसे भी सामान्य विचार मिलना चाहिए:

static double getNicerNumber(double val) 
{ 
    // get the first larger power of 10 
    var nice = Math.pow(10, Math.ceiling(Math.log10(val))); 

    // scale the power to a "nice enough" value 
    if (val < 0.25 * nice) 
     nice = 0.25 * nice; 
    else if (val < 0.5 * nice) 
     nice = 0.5 * nice; 

    return nice; 
} 

// test program: 
static void main(string[] args) 
{ 
    double[] values = 
    { 
     0.1, 0.2, 0.7, 
     1, 2, 9, 
     25, 58, 99, 
     158, 267, 832 
    }; 

    for (var val : values) 
     System.out.printf("$%.2f --> $%.2f%n", val, getNicerNumber(val)); 
} 

इस तरह कुछ प्रिंट होगा:

 
0,1 --> 0,1 
0,2 --> 0,25 
0,7 --> 1 
1 --> 1 
2 --> 2,5 
9 --> 10 
25 --> 50 
58 --> 100 
99 --> 100 
158 --> 250 
267 --> 500 
832 --> 1000

Answer 2

मैं यह काफी कच्चे समाधान के साथ आया था, जो मामलों मैं अभी परीक्षण किया सभी के लिए सही मान देता है:

public static double foo(long value) { 
    for (double i = 0.2; true; i *= 5) { 
     if (i >= value) { 
      return i/5; 
     } 
    } 
} 

हालांकि मैं मानता होगा कि एक गणितीय समाधान के रूप में Groo द्वारा पोस्ट की गई अधिक सुंदर हो जाएगा। ;)

Answer 3

मैं, Groo के दृष्टिकोण पर निम्नलिखित पसंद के रूप में यह दौर 267 275 के बजाय 500 के लिए यह मूल रूप से पहले अंक के लिए राउंड, और उसके बाद की है कि सत्ता के निकटतम तिमाही अंश 10.

static double round_pretty(double val) { 
    var fraction = 1; 
    var log = Math.floor(Math.log10(val)); 

    // This keeps from adding digits after the decimal 
    if(log > 1) { 
     fraction = 4; 
    } 

    return Math.round(val * fraction * Math.pow(10, -log)) 
     /fraction/Math.pow(10, -log); 
} 

उत्पादन इस प्रकार है:

0.01 -> 0.01 
0.025 -> 0.03 (Groo's does 0.025) 
0.1 -> 0.1 
0.2 -> 0.2  (Groo's does 0.25) 
0.49 -> 0.5 
0.5 -> 0.5  (Groo's does 1) 
0.51 -> 0.5  (Groo's does 1) 
0.7 -> 0.7  (Groo's does 1) 
1 -> 1 
2 -> 2   (Groo's does 2.5) 
9 -> 9 
23.07 -> 20 
25 -> 30 
49 -> 50 
50 -> 50   (Groo's does 100 here) 
58 -> 60 
94 -> 90 
95 -> 100 
99 -> 100 
100 -> 100 
109 -> 100  (Groo's does 250 here) 
158 -> 150 
249 -> 250 
267 -> 275 
832 -> 825 
1234567 -> 1250000 
1499999 -> 1500000 
1625000 -> 1750000