বৃত্তাকার শতাংশগুলি কীভাবে 100% যুক্ত করা যায়

192

নীচে চার শতাংশ বিবেচনা করুন, floatসংখ্যা হিসাবে প্রতিনিধিত্ব :

    13.626332%
    47.989636%
     9.596008%
    28.788024%
   -----------
   100.000000%

আমার এই সংখ্যাগুলি পুরো সংখ্যা হিসাবে উপস্থাপন করতে হবে। আমি যদি সহজভাবে ব্যবহার করি তবে আমি Math.round()মোট 101% দিয়ে শেষ করি।

14 + 48 + 10 + 29 = 101

যদি আমি ব্যবহার করি তবে আমি parseInt()মোট 97% দিয়ে শেষ করব।

13 + 47 + 9 + 28 = 97

মোট সংখ্যা 100% বজায় রেখে সম্পূর্ণ সংখ্যার শতাংশের প্রতিনিধিত্ব করার জন্য একটি ভাল অ্যালগরিদম কী?

সম্পাদনা করুন : কিছু মন্তব্য এবং উত্তর পড়ার পরে, এটিকে সমাধান করার বিষয়ে স্পষ্টভাবে অনেকগুলি উপায় রয়েছে।

আমার মনে, সংখ্যার সাথে সত্য থাকতে, "ডান" ফলাফলটি হ'ল সামগ্রিক ত্রুটিটিকে ন্যূনতম করে দেয়, সংশোধন করা হয় যে ত্রুটিটি কতটা ত্রুটি দ্বারা গোল করা প্রকৃত মানটির সাথে সম্পর্কিত হবে:

        value  rounded     error               decision
   ----------------------------------------------------
    13.626332       14      2.7%          round up (14)
    47.989636       48      0.0%          round up (48)
     9.596008       10      4.0%    don't round up  (9)
    28.788024       29      2.7%          round up (29)

টাই (৩.৩৩, ৩.৩৩, ৩.৩৩) এর ক্ষেত্রে একটি স্বেচ্ছাসেবী সিদ্ধান্ত নেওয়া যেতে পারে (যেমন 3, 4, 3)।

algorithm  math  rounding  percentage 
— poezn
সূত্র
21
ধরুন আপনার কাছে 3.33, 3.33 এবং 3.33 রয়েছে and আপনি কোনটি 4 করবেন?
— রবিজি
3
যথাযথভাবে। প্রশ্ন পদ একটি বৈপরীত্য মূর্ত।
— লোর্নের মারকুইস
4
এটি প্রতিবেদনের একটি খুব সাধারণ দৃশ্য - দশমিক মানগুলির একটি "মোট" কীভাবে প্রদর্শিত হবে যা প্রদর্শিত মানগুলির যোগফলের সাথে সর্বদা মেলে না।
— ডি স্ট্যানলি
1
আপনার উদাহরণের ক্ষেত্রে "সঠিক" ফলাফলটি কী ? এটি "সেরা" সমাধান কী তা নিয়ে মতভেদ সমাধান করতে পারে।
— ডি স্ট্যানলি
3
— সাওয়া

উত্তর:

35

যেহেতু এখানে উত্তরগুলির কোনওটিই এটি সঠিকভাবে সমাধান করতে পারে না বলে এখানে আন্ডারস্কোর ব্যবহার করে আমার অর্ধ-অস্পষ্ট সংস্করণটি দেওয়া হয়েছে :

function foo(l, target) {
    var off = target - _.reduce(l, function(acc, x) { return acc + Math.round(x) }, 0);
    return _.chain(l).
            sortBy(function(x) { return Math.round(x) - x }).
            map(function(x, i) { return Math.round(x) + (off > i) - (i >= (l.length + off)) }).
            value();
}

foo([13.626332, 47.989636, 9.596008, 28.788024], 100) // => [48, 29, 14, 9]
foo([16.666, 16.666, 16.666, 16.666, 16.666, 16.666], 100) // => [17, 17, 17, 17, 16, 16]
foo([33.333, 33.333, 33.333], 100) // => [34, 33, 33]
foo([33.3, 33.3, 33.3, 0.1], 100) // => [34, 33, 33, 0]
— yonilevy
সূত্র
6
আমি ভুল হলে আমাকে সংশোধন করুন, তবে এটি কি আমার উত্তর দ্বারা প্রস্তাবিত অ্যালগরিদমের বাস্তবায়ন নয়? (আন্ডারস্কোরগুলিতে পরিষ্কার করার জন্য নয়)
— vvohra87
@VarunVohra দুঃখিত আমি এখন পর্যন্ত এই খেয়ালই করেন নি, হ্যাঁ মনে হচ্ছে আপনার অ্যালগরিদম মত একই :) নিশ্চিত না কেন আমার পোস্ট গৃহীত উত্তর, বিভ্রান্তিকারী কোড শুধু আরো lolz জন্য ছিল ...
— yonilevy
@ ইউনিলিভি আমার মন্তব্য মুছে ফেলেছে; আমি ঠিক বুঝতে পারি নি যে এটি একটি সাজানো তালিকা ফেরত দেওয়ার কথা ছিল। আমি ক্ষমা প্রার্থনা করছি!
— জ্যাক বার্ট
2
সর্বশেষ উপাদানটি 0 এবং পূর্ববর্তী উপাদানগুলি 100 এ যুক্ত হয়ে গেলে এই ক্রিয়াকলাপটির সাথে অ্যাপ্রোলেম রয়েছে [ সর্বশেষটি যৌক্তিকভাবে -1 প্রদান করে। আমি নীচের সমাধানটি সত্যিই দ্রুত চিন্তা করেছি তবে সম্ভবত এর থেকে আরও ভাল কিছু রয়েছে: jsfiddle.net/0o75bw43/1
— ক্রুস্লাক্স
1
@ ক্রিক্লাক্স এটি সমস্ত 1 দেখায় যখন ইনপুট অ্যারেতে সমস্ত এন্ট্রি শূন্য হয়
— tony.0919
158

এটি করার অনেকগুলি উপায় রয়েছে তবে শর্ত থাকে যে আপনি মূল দশমিক ডেটার উপর নির্ভরতা নিয়ে উদ্বিগ্ন নন।

প্রথম এবং সম্ভবত সবচেয়ে জনপ্রিয় পদ্ধতিটি হ'ল বৃহত্তম রিমেন্ডার পদ্ধতি

যা মূলত:

  1. নিচে সবকিছু গোল করা
  2. যোগফল এবং 100 এর মধ্যে পার্থক্য পাওয়া
  3. দশমিক অংশের ক্রম হ্রাসে আইটেমগুলিতে 1 যুক্ত করে পার্থক্যটি বিতরণ করা

আপনার ক্ষেত্রে এটি এমন হবে:

13.626332%
47.989636%
 9.596008%
28.788024%

আপনি যদি পূর্ণসংখ্যার অংশগুলি নেন তবে আপনি পাবেন

13
47
 9
28

যা 97 পর্যন্ত যোগ করে এবং আপনি আরও তিনটি যুক্ত করতে চান। এখন, আপনি দশমিক অংশগুলি দেখুন, যা

.626332%
.989636%
.596008%
.788024%

এবং সর্বমোট 100 টি না হওয়া পর্যন্ত সবচেয়ে বড়গুলি নিন So সুতরাং আপনি পাবেন:

14
48
 9
29

বিকল্পভাবে, আপনি কেবল পূর্ণসংখ্যার মানগুলির পরিবর্তে একটি দশমিক স্থান দেখানো চয়ন করতে পারেন। সুতরাং সংখ্যাগুলি হবে 48.3 এবং 23.9 ইত্যাদি This এটি 100 থেকে প্রচুর পরিমাণে প্রকরণটি নামিয়ে দেবে।

— vvohra87
সূত্র
5
আমেরিকান ম্যাথমেটিকাল সোসাইটির ওয়েবসাইটে এই "ফিচার কলাম" - অ্যাপোমেন্টমেন্ট II: অ্যাপোপারমেন্ট সিস্টেমগুলি - বেশ কয়েকটি অনুরূপ 'অ্যাপোপারমেন্ট' পদ্ধতি বর্ণনা করে।
— কেনি এভিট
1
এটি প্রায়শই আমার উত্তরটির অনুলিপি এবং পেস্টের মতো দেখতে এখানে stackoverflow.com/questions/5227215/… ।
— সাওয়া
মনে রাখবেন, @ ডিস্টানির জবাব সম্পর্কে আপনার মন্তব্যের বিপরীতে, আপনার উত্তরে 9.596008% 9% হয়েছে, যা 0.5% পার্থক্যের চেয়ে বেশি। এখনও একটি ভাল উত্তর, যদিও।
— রোলজারো আজিভেরিস
32

সম্ভবত এটি করার "সেরা" উপায় (যেহেতু "সেরা" একটি সাবজেক্টিভ শব্দটি হিসাবে উদ্ধৃত) আপনি যেখানে রয়েছেন তার চলমান (অ-অবিচ্ছেদ্য) তালিকান রাখা এবং সেই মানটি গোল করা ।

তারপরে কোন মানটি ব্যবহার করা উচিত তা নিয়ে ইতিহাসের পাশাপাশি এটি ব্যবহার করুন। উদাহরণস্বরূপ, আপনি যে মানগুলি দিয়েছেন তা ব্যবহার করে:

Value      CumulValue  CumulRounded  PrevBaseline  Need
---------  ----------  ------------  ------------  ----
                                  0
13.626332   13.626332            14             0    14 ( 14 -  0)
47.989636   61.615968            62            14    48 ( 62 - 14)
 9.596008   71.211976            71            62     9 ( 71 - 62)
28.788024  100.000000           100            71    29 (100 - 71)
                                                    ---
                                                    100

প্রতিটি পর্যায়ে, আপনি সংখ্যাটি নিজেই গোল করেন না। পরিবর্তে, আপনি সঞ্চিত মানটি গোল করে এবং সর্বোত্তম পূর্ণসংখ্যার কাজ করে যা পূর্বের বেসলাইন থেকে সেই মানটিতে পৌঁছায় - সেই বেসলাইনটি পূর্ববর্তী সারির সংশ্লেষক মান (বৃত্তাকার)।

এটি কাজ করে কারণ আপনি প্রতিটি পর্যায়ে তথ্য হারাচ্ছেন না বরং তথ্যটি আরও বুদ্ধিমানের সাথে ব্যবহার করছেন। 'সঠিক' বৃত্তাকার মানগুলি চূড়ান্ত কলামে রয়েছে এবং আপনি দেখতে পাচ্ছেন যে সেগুলির পরিমাণ 100 হয়।

উপরের তৃতীয় মানের মধ্যে প্রতিটি এবং অন্ধভাবে প্রতিটি মানের গোল করার মধ্যে পার্থক্যটি দেখতে পাবেন। যখন 9.596008সাধারণত সাধারণত গোল হয়ে যায় 10তবে জমে থাকা 71.211976সঠিকভাবে গোল হয় 71- এর অর্থ এটি কেবল 9এর পূর্বের বেসলাইনটিতে যুক্ত করা দরকার 62।

এটি মোটামুটি তিনটি মানের মতো "সমস্যাযুক্ত" সিক্যুয়েন্সের জন্যও কাজ করে , যেখানে তাদের একটিকে গোল করা উচিত:1/3

Value      CumulValue  CumulRounded  PrevBaseline  Need
---------  ----------  ------------  ------------  ----
                                  0
33.333333   33.333333            33             0    33 ( 33 -  0)
33.333333   66.666666            67            33    34 ( 67 - 33)
33.333333   99.999999           100            67    33 (100 - 67)
                                                    ---
                                                    100
— paxdiablo
সূত্র
1
দ্বিতীয় পদ্ধতির উভয়ই এই সমস্যার সমাধান করে। প্রথম দেয় 26, 25, 26, 23, দ্বিতীয়টি 1, 0, 1, 0, 1, 0, ...।
— প্যাক্সডিয়াবলো
এই পদ্ধতিটি ছোট সংখ্যার বৃত্তাকার জন্যও ভাল কাজ করে কারণ এটি নেতিবাচক সংখ্যাকে আউটপুট পাপ করতে বাধা দেয়
— Jonty5817
19

গোল করার লক্ষ্যটি হ'ল ন্যূনতম পরিমাণে ত্রুটি তৈরি করা। আপনি যখন একটি একক মানের গোল করে চলেছেন, সেই প্রক্রিয়াটি সহজ এবং সোজা এবং বেশিরভাগ লোকেরা এটি সহজেই বুঝতে পারে। আপনি যখন একই সাথে একাধিক সংখ্যার গোল করছেন, তখন প্রক্রিয়াটি আরও জটিল হয়ে উঠবে - আপনাকে অবশ্যই নির্ধারণ করতে হবে যে ত্রুটিগুলি কীভাবে একত্রিত হতে চলেছে, অর্থাত কী হ্রাস করা উচিত।

বরুণ Vohra দ্বারা ভালভাবে ভোট উত্তর পরম ত্রুটি সমষ্টি ছোট, এবং এটি বাস্তবায়নের জন্য খুব সহজ। তবে প্রান্তের কেসগুলি এটি পরিচালনা করে না - গোল করার ফলাফলটি কী হওয়া উচিত 24.25, 23.25, 27.25, 25.25? এর মধ্যে একটির নীচে পরিবর্তে গোল করা দরকার। আপনি সম্ভবত নির্বিচারে তালিকার প্রথম বা শেষটিকে বেছে নিতে পারেন।

সম্ভবত পরম ত্রুটির পরিবর্তে আপেক্ষিক ত্রুটিটি ব্যবহার করা ভাল । ২৩.২৫ অবধি ২৪ অবধি এটি ২.২% দ্বারা পরিবর্তিত হয় এবং ২.2.২৫-এর ২৮ গোল করে কেবল এটি ২.৮% দ্বারা পরিবর্তন করে। এখন একটি স্পষ্ট বিজয়ী আছে।

এটি আরও টুইঙ্ক করা সম্ভব। একটি সাধারণ কৌশল হ'ল প্রতিটি ত্রুটিটিকে স্কোয়ার করা , যাতে বড় ত্রুটিগুলি ছোটগুলির চেয়ে তুলনামূলকভাবে বেশি গণনা করে। আপেক্ষিক ত্রুটি পেতে আমি একটি অ-লিনিয়ার বিভাজকও ব্যবহার করতাম - এটি 1% এ ত্রুটি 99% এ ত্রুটির চেয়ে 99 গুণ বেশি গুরুত্বপূর্ণ বলে মনে হয় না। নীচের কোডে আমি বর্গমূল ব্যবহার করেছি।

সম্পূর্ণ অ্যালগরিদম নিম্নরূপ:

  1. সমস্তগুলি গোল করার পরে শতাংশের সমষ্টি করুন এবং 100 থেকে বিয়োগ করুন This এর পরিবর্তে এই শতাংশের কতটি গোল করা উচিত তা আপনাকে বলে।
  2. প্রতিটি শতাংশের জন্য দুটি ত্রুটি স্কোর উত্পন্ন করে, একটি যখন বৃত্তাকার ডাউন হয় এবং একটি যখন গোল হয়। দুজনের মধ্যে পার্থক্য নিন।
  3. উপরে উত্পন্ন ত্রুটি পার্থক্য বাছাই করুন।
  4. শতকরা শতাংশের সংখ্যার জন্য যেগুলি বৃত্তাকার করা প্রয়োজন, বাছাই করা তালিকা থেকে একটি আইটেম নিন এবং বৃত্তাকার ডাউন শতাংশকে 1 দ্বারা বৃদ্ধি করুন।

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

পাইথনে সব কিছু একসাথে রাখার মতো দেখাচ্ছে।

def error_gen(actual, rounded):
    divisor = sqrt(1.0 if actual < 1.0 else actual)
    return abs(rounded - actual) ** 2 / divisor

def round_to_100(percents):
    if not isclose(sum(percents), 100):
        raise ValueError
    n = len(percents)
    rounded = [int(x) for x in percents]
    up_count = 100 - sum(rounded)
    errors = [(error_gen(percents[i], rounded[i] + 1) - error_gen(percents[i], rounded[i]), i) for i in range(n)]
    rank = sorted(errors)
    for i in range(up_count):
        rounded[rank[i][1]] += 1
    return rounded

>>> round_to_100([13.626332, 47.989636, 9.596008, 28.788024])
[14, 48, 9, 29]
>>> round_to_100([33.3333333, 33.3333333, 33.3333333])
[34, 33, 33]
>>> round_to_100([24.25, 23.25, 27.25, 25.25])
[24, 23, 28, 25]
>>> round_to_100([1.25, 2.25, 3.25, 4.25, 89.0])
[1, 2, 3, 4, 90]

আপনি যে শেষ উদাহরণটি দেখতে পাচ্ছেন, এই অ্যালগরিদম এখনও অ-স্বজ্ঞাত ফলাফল সরবরাহ করতে সক্ষম। যদিও 89.0 এর যাবতীয় বৃত্তাকার প্রয়োজন নেই, সেই তালিকার মানগুলির মধ্যে একটিকে বৃত্তাকার করা প্রয়োজন; সর্বনিম্ন আপেক্ষিক ত্রুটির ফলে অনেকগুলি ছোট বিকল্পের পরিবর্তে বৃহত্তর মানটি সংগ্রহ করা হয়।

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

— মার্ক মুক্তি
সূত্র
1
থেকে যাচ্ছে ভরযুক্ত ত্রুটি ড্রপ হ্রাস ক্রমানুসারে প্রক্রিয়া: আমি আপনি সব সমন্বয় বিবেচনা করতে হবে তা মনে করি না শুন্যতে বৃত্তাকার থেকে অনন্ত বৃত্তাকার (প্রায় কাছাকাছি শুধু উপস্থাপক ওজনের মধ্যে Verun Vohras এর এবং yonilevy এর ( "অভিন্ন") উত্তর)।
— গ্রেইবার্ড
@ গ্রেইবার্ড আপনি ঠিক বলেছেন, আমি এটিকে বোঝাচ্ছি inking আমি কেবল ত্রুটিটিকে বাছাই করতে পারি না কারণ প্রতিটি মানের জন্য দুটি ত্রুটি রয়েছে, তবে পার্থক্যটি গ্রহণ করা সমস্যার সমাধান করেছে। আমি উত্তর আপডেট করেছি।
— মার্ক রান্সম
আসল সংখ্যা 0% হলে আমি সর্বদা 0% থাকতে পছন্দ করি। তাই যোগ if actual == 0: return 0করার error_genকাজ মহান।
— নিকোলে বালুক
1
iscloseশুরুতে পদ্ধতিটি কী round_to_100?
— টোটো_টিকো
2
— মার্ক মুক্তিপণ
7

বৃত্তাকার সংখ্যাগুলি যোগ করবেন না। আপনার ভুল ফলাফল হতে চলেছে। পদ সংখ্যা এবং ভগ্নাংশ অংশ বিতরণ উপর নির্ভর করে মোট উল্লেখযোগ্যভাবে বন্ধ হতে পারে।

প্রদর্শন বৃত্তাকার সংখ্যার কিন্তু যোগফল প্রকৃত মান। আপনি কীভাবে সংখ্যা উপস্থাপন করছেন তার উপর নির্ভর করে, এটি করার আসল উপায়টি পৃথক হবে। এইভাবে আপনি পাবেন

 14
 48
 10
 29
 __
100

আপনি যেভাবেই যান না কেন আপনার তাত্পর্য হতে চলেছে। আপনার উদাহরণটিতে এমন সংখ্যা দেখানোর কোনও উপায় নেই যা "মান রাউন্ডিং" না করে 100 টি যোগ করে ভুল উপায়ে (কমপক্ষে ত্রুটি 9.596 থেকে 9 এ পরিবর্তিত হবে)

সম্পাদনা

আপনাকে নিম্নলিখিতগুলির মধ্যে একটি চয়ন করতে হবে:

  1. আইটেমের নির্ভুলতা
  2. যোগফলের যথার্থতা (আপনি যদি গোলাকার মানগুলি যোগ করে দিচ্ছেন)
  3. বৃত্তাকার আইটেম এবং বৃত্তাকার যোগফলের মধ্যে সামঞ্জস্যতা)

শতকরা # 3 নিয়ে কাজ করার সময় বেশিরভাগ সময় হ'ল সর্বোত্তম বিকল্প কারণ যখন পৃথক আইটেমগুলি 100 না হয় তার তুলনায় মোট 101% সমান হয় এবং আপনি পৃথক আইটেমগুলি নির্ভুল রাখেন it's 9.596 থেকে 9 "9 রাউন্ডিং" আমার মতে ভুল।

এটি ব্যাখ্যা করতে আমি মাঝে মাঝে একটি পাদটীকা যুক্ত করি যা ব্যাখ্যা করে যে পৃথক মানগুলি বৃত্তাকার হয় এবং মোট 100% নাও হতে পারে - যে কেউ রাউন্ডিং বুঝতে পারে তাকে সেই ব্যাখ্যাটি বুঝতে সক্ষম হওয়া উচিত।

— ডি স্ট্যানলি
সূত্র
6
মুদ্রিত মানগুলি 100 টির বেশি যোগ করবে না বলে এটি খুব কার্যকর নয় the প্রশ্নের উদ্দেশ্য হ'ল ব্যবহারকারীদের মানগুলি ভুল বলে ভাবতে বাধা দেওয়া ছিল, যা এই ক্ষেত্রে, বেশিরভাগ লোকেরা মোটের সাথে দেখার এবং তুলনা করার সময় করতেন ।
— vvohra87
@ বরুণভোহরা আমার সম্পাদনাটি পড়েন, আপনি আপনার সংখ্যাগুলি এমনভাবে প্রদর্শন করতে পারবেন না যে তারা 0.5% এর চেয়ে বেশি "গোলাকার" না করে 100 টি যোগ করতে পারে।
— ডি স্ট্যানলে
1
@ ডিস্টানলি আসলে, এমন একটি সেট ব্যতীত যেখানে সমস্ত সংখ্যার লজ্জা হয়, আপনি পারেন। আমার উত্তরটি দেখুন - এলআরএম ঠিক তা করে that
— vvohra87
3
@ ভারুনভোহরা মূল উদাহরণে এলআরএম 14, 48, 9 এবং 29 প্রদান করবে যা 9.596 থেকে 9 কে "বৃত্তাকার" হবে আমরা যদি পুরো সংখ্যার উপর ভিত্তি করে বরাদ্দ দিই তবে এলআরএম সবচেয়ে নির্ভুল হবে, তবে এটি এখনও আরও একটি ফলাফলের পরিবর্তনে চলেছে একটি অর্ধ ইউনিট চেয়ে।
— ডি স্ট্যানলে
7

আমি একটি সি # সংস্করণ রাউন্ডিং সহায়ক সাহায্যে লিখেছি, অ্যালগরিদম বরুণ ভোহর এর উত্তর মত , আশা করি এটি সাহায্য করবে।

public static List<decimal> GetPerfectRounding(List<decimal> original,
    decimal forceSum, int decimals)
{
    var rounded = original.Select(x => Math.Round(x, decimals)).ToList();
    Debug.Assert(Math.Round(forceSum, decimals) == forceSum);
    var delta = forceSum - rounded.Sum();
    if (delta == 0) return rounded;
    var deltaUnit = Convert.ToDecimal(Math.Pow(0.1, decimals)) * Math.Sign(delta);

    List<int> applyDeltaSequence; 
    if (delta < 0)
    {
        applyDeltaSequence = original
            .Zip(Enumerable.Range(0, int.MaxValue), (x, index) => new { x, index })
            .OrderBy(a => original[a.index] - rounded[a.index])
            .ThenByDescending(a => a.index)
            .Select(a => a.index).ToList();
    }
    else
    {
        applyDeltaSequence = original
            .Zip(Enumerable.Range(0, int.MaxValue), (x, index) => new { x, index })
            .OrderByDescending(a => original[a.index] - rounded[a.index])
            .Select(a => a.index).ToList();
    }

    Enumerable.Repeat(applyDeltaSequence, int.MaxValue)
        .SelectMany(x => x)
        .Take(Convert.ToInt32(delta/deltaUnit))
        .ForEach(index => rounded[index] += deltaUnit);

    return rounded;
}

এটি নিম্নলিখিত ইউনিট পরীক্ষা পাস:

[TestMethod]
public void TestPerfectRounding()
{
    CollectionAssert.AreEqual(Utils.GetPerfectRounding(
        new List<decimal> {3.333m, 3.334m, 3.333m}, 10, 2),
        new List<decimal> {3.33m, 3.34m, 3.33m});

    CollectionAssert.AreEqual(Utils.GetPerfectRounding(
        new List<decimal> {3.33m, 3.34m, 3.33m}, 10, 1),
        new List<decimal> {3.3m, 3.4m, 3.3m});

    CollectionAssert.AreEqual(Utils.GetPerfectRounding(
        new List<decimal> {3.333m, 3.334m, 3.333m}, 10, 1),
        new List<decimal> {3.3m, 3.4m, 3.3m});


    CollectionAssert.AreEqual(Utils.GetPerfectRounding(
        new List<decimal> { 13.626332m, 47.989636m, 9.596008m, 28.788024m }, 100, 0),
        new List<decimal> {14, 48, 9, 29});
    CollectionAssert.AreEqual(Utils.GetPerfectRounding(
        new List<decimal> { 16.666m, 16.666m, 16.666m, 16.666m, 16.666m, 16.666m }, 100, 0),
        new List<decimal> { 17, 17, 17, 17, 16, 16 });
    CollectionAssert.AreEqual(Utils.GetPerfectRounding(
        new List<decimal> { 33.333m, 33.333m, 33.333m }, 100, 0),
        new List<decimal> { 34, 33, 33 });
    CollectionAssert.AreEqual(Utils.GetPerfectRounding(
        new List<decimal> { 33.3m, 33.3m, 33.3m, 0.1m }, 100, 0),
        new List<decimal> { 34, 33, 33, 0 });
}
— ব্রুস
সূত্র
নিস! শুরু করার জন্য আমাকে একটি গ্রাউন্ড বেজ দিয়েছে .. আমার বিশ্বাস করার পরেও অগণনীয়দের জন্য ফরিচ নেই
— জ্যাক0ফসাদ0 নিউজ
4

রাউন্ডিংয়ের কারণে আপনি নিজের ত্রুটিটি ট্র্যাক করে রাখতে চেষ্টা করতে পারেন এবং তারপরে শস্যের বিরুদ্ধে গোল করে যদি সঞ্চিত ত্রুটি বর্তমান সংখ্যার ভগ্নাংশের চেয়ে বেশি হয়।

13.62 -> 14 (+.38)
47.98 -> 48 (+.02 (+.40 total))
 9.59 -> 10 (+.41 (+.81 total))
28.78 -> 28 (round down because .81 > .78)
------------
        100

এটি সাধারণভাবে কাজ করবে কিনা তা নিশ্চিত নয়, তবে আদেশটি বিপরীত হলে এটি একই রকম কাজ করবে বলে মনে হচ্ছে:

28.78 -> 29 (+.22)
 9.59 ->  9 (-.37; rounded down because .59 > .22)
47.98 -> 48 (-.35)
13.62 -> 14 (+.03)
------------
        100

আমি নিশ্চিত যে প্রান্তের কেসগুলি এখানে ভেঙে যেতে পারে তবে আপনি যেভাবে ইনপুট ডেটাটি মূলত সংশোধন করছেন তা যেহেতু কোনও পদ্ধতিকে অন্তত কিছুটা নির্বিচারে হতে চলেছে।

— atkretsch
সূত্র
2
হিসাবরক্ষক এবং ব্যাংকাররা কয়েকশ বছর ধরে একই জাতীয় কৌশল ব্যবহার করে আসছে। "বাকি অংশটি বহন করুন" এক সারি থেকে পরের দিকে। "বাহন" এর এক শতাংশের 1/2 দিয়ে শুরু করুন। প্রথম মানটিতে "ক্যারি" যুক্ত করুন এবং কেটে দিন। এখন আপনি যে পরিমাণ পরিমাণ ছাঁটাই করে হারিয়েছেন তা "বহন" -এ রাখুন। সর্বত্র এইভাবে করুন, এবং বৃত্তাকার সংখ্যাগুলি প্রতিবার ঠিক পছন্দসই পরিমাণে যোগ করবে।
— জেফ গ্রিগ
অ্যাক্সেস ভিবি 2007-এ ক্যারোলিন কে এই প্রয়োগের পরামর্শ দিয়েছিলেন: <কোড> 'বাকীটি বহন করুন "পদ্ধতিটি রেফ 1 = আরএসকিরি ব্যবহার করে রাউন্ড রিফান্ড ডলার! [ফেরত দেওয়া অর্থ $$$] * আরএসক্রি! [সম্পত্তির মান] / প্রোপাল্টটট রেফ 2 = রেফ 1 + রেফ 5 'বহনকারী অবশিষ্টটি যোগ করুন, শূন্য শুরুর জন্য ref3 = ref2 * 100' পূর্ণ সংখ্যা দ্বারা 100 দ্বারা গুণিত করুন রেফ 4 = রেফ 3/100 'দশমিক সংখ্যায় আরএসটিবিএলকে 100 দ্বারা ভাগ করুন! [ফেরত অর্থ প্রদান $$$] = রেফ 4' রাখুন " অবশিষ্ট "টেবিলের গোলাকার নম্বর ref5 = ref2 - ref4 'নতুন অবশিষ্টটি বহন করুন </ কোড>
— জেফ গ্রিগ
2

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

সুতরাং প্রথম উপাদানটির জন্য, আমরা এটি 14 বা 13 এর নিচে গোল করতে পারি। এটি করার ব্যয়টি (বাইনারি পূর্ণসংখ্যা প্রোগ্রামিং অর্থে) রাউন্ড ডাউনের চেয়ে রাউন্ড আপের জন্য কম হয়, কারণ রাউন্ড ডাউনের প্রয়োজন হয় আমাদের we মানটি আরও বড় দূরত্বের দিকে সরান। একইভাবে, আমরা প্রতিটি সংখ্যাকে উপরে বা নীচে করে নিতে পারি, সুতরাং আমাদের মোট 16 টি পছন্দ বেছে নিতে হবে।

  13.626332
  47.989636
   9.596008
+ 28.788024
-----------
 100.000000

আমি সাধারণত ম্যাটল্যাবের সাধারণ সমস্যাটি সমাধান করতে চাইতাম, এখানে একটি বাইনারি ইন্টিজার প্রোগ্রামিং সরঞ্জাম বিন্টপ্রোগ ব্যবহার করে, তবে পরীক্ষার জন্য কয়েকটি মাত্র পছন্দ রয়েছে, সুতরাং 16 টি বিকল্পের প্রতিটি পরীক্ষার জন্য সহজ লুপগুলি সহ এটি যথেষ্ট সহজ। উদাহরণস্বরূপ, ধরুন আমরা এই সেটটিকে এইভাবে গোল করব:

 Original      Rounded   Absolute error
   13.626           13          0.62633
    47.99           48          0.01036
    9.596           10          0.40399
 + 28.788           29          0.21198
---------------------------------------
  100.000          100          1.25266

মোট নিখুঁত ত্রুটি 1.25266। নিম্নলিখিত বিকল্প রাউন্ডিং দ্বারা এটি কিছুটা হ্রাস করা যেতে পারে:

 Original      Rounded   Absolute error
   13.626           14          0.37367
    47.99           48          0.01036
    9.596            9          0.59601
 + 28.788           29          0.21198
---------------------------------------
  100.000          100          1.19202

প্রকৃতপক্ষে, এটি পরম ত্রুটির ক্ষেত্রে সর্বোত্তম সমাধান হবে। অবশ্যই, যদি 20 পদ থাকে তবে অনুসন্ধানের স্থানটি আকার 2 ^ 20 = 1048576 হবে 30 30 বা 40 টি শর্তের জন্য, সেই স্থানটি উল্লেখযোগ্য আকারের হবে। সেক্ষেত্রে আপনাকে এমন একটি সরঞ্জাম ব্যবহার করতে হবে যা দক্ষতার সাথে স্থানটি অনুসন্ধান করতে পারে, সম্ভবত একটি শাখা এবং আবদ্ধ স্কিম ব্যবহার করে।

কেবলমাত্র ভবিষ্যতের রেফারেন্সের জন্য: "বৃহত্তম शेष" এলগরিদমটি অবশ্যই আপনার মেট্রিক অনুসারে মোট নিখুঁত ত্রুটিটি হ্রাস করতে হবে (@ ভারুনভোহরের উত্তর দেখুন)। প্রমাণটি সহজ: ধরুন এটি ত্রুটিটি হ্রাস করে না। তারপরে অবশ্যই মানগুলির কয়েকটি সেট থাকতে হবে যা এটি বৃত্তাকার হবে যা বৃত্তাকার হওয়া উচিত, এবং বিপরীতে (দুটি সেট একই আকারের হবে)। তবে প্রতিটি মান যেটিকে গোল করে তা পরবর্তী পূর্ণসংখ্যার চেয়ে আরও বেশি যে কোনও মান এটি গোল করে (এবং ভিভি) তাই নতুন ত্রুটির পরিমাণ অবশ্যই বেশি হওয়া উচিত। Qed। তবে এটি সমস্ত ত্রুটি মেট্রিকের জন্য কাজ করে না; অন্যান্য অ্যালগরিদম প্রয়োজন।
— ধনী
2

আমি মনে করি যে নীচেরগুলি আপনি পরে যা অর্জন করবে

function func( orig, target ) {

    var i = orig.length, j = 0, total = 0, change, newVals = [], next, factor1, factor2, len = orig.length, marginOfErrors = [];

    // map original values to new array
    while( i-- ) {
        total += newVals[i] = Math.round( orig[i] );
    }

    change = total < target ? 1 : -1;

    while( total !== target ) {

        // Iterate through values and select the one that once changed will introduce
        // the least margin of error in terms of itself. e.g. Incrementing 10 by 1
        // would mean an error of 10% in relation to the value itself.
        for( i = 0; i < len; i++ ) {

            next = i === len - 1 ? 0 : i + 1;

            factor2 = errorFactor( orig[next], newVals[next] + change );
            factor1 = errorFactor( orig[i], newVals[i] + change );

            if(  factor1 > factor2 ) {
                j = next; 
            }
        }

        newVals[j] += change;
        total += change;
    }


    for( i = 0; i < len; i++ ) { marginOfErrors[i] = newVals[i] && Math.abs( orig[i] - newVals[i] ) / orig[i]; }

    // Math.round() causes some problems as it is difficult to know at the beginning
    // whether numbers should have been rounded up or down to reduce total margin of error. 
    // This section of code increments and decrements values by 1 to find the number
    // combination with least margin of error.
    for( i = 0; i < len; i++ ) {
        for( j = 0; j < len; j++ ) {
            if( j === i ) continue;

            var roundUpFactor = errorFactor( orig[i], newVals[i] + 1)  + errorFactor( orig[j], newVals[j] - 1 );
            var roundDownFactor = errorFactor( orig[i], newVals[i] - 1) + errorFactor( orig[j], newVals[j] + 1 );
            var sumMargin = marginOfErrors[i] + marginOfErrors[j];

            if( roundUpFactor < sumMargin) { 
                newVals[i] = newVals[i] + 1;
                newVals[j] = newVals[j] - 1;
                marginOfErrors[i] = newVals[i] && Math.abs( orig[i] - newVals[i] ) / orig[i];
                marginOfErrors[j] = newVals[j] && Math.abs( orig[j] - newVals[j] ) / orig[j];
            }

            if( roundDownFactor < sumMargin ) { 
                newVals[i] = newVals[i] - 1;
                newVals[j] = newVals[j] + 1;
                marginOfErrors[i] = newVals[i] && Math.abs( orig[i] - newVals[i] ) / orig[i];
                marginOfErrors[j] = newVals[j] && Math.abs( orig[j] - newVals[j] ) / orig[j];
            }

        }
    }

    function errorFactor( oldNum, newNum ) {
        return Math.abs( oldNum - newNum ) / oldNum;
    }

    return newVals;
}


func([16.666, 16.666, 16.666, 16.666, 16.666, 16.666], 100); // => [16, 16, 17, 17, 17, 17]
func([33.333, 33.333, 33.333], 100); // => [34, 33, 33]
func([33.3, 33.3, 33.3, 0.1], 100); // => [34, 33, 33, 0] 
func([13.25, 47.25, 11.25, 28.25], 100 ); // => [13, 48, 11, 28]
func( [25.5, 25.5, 25.5, 23.5], 100 ); // => [25, 25, 26, 24]

একটি শেষ কথা, আমি কাঙ্ক্ষিত আউটপুটটির সাথে তুলনা করতে মূলত প্রশ্নে দেওয়া সংখ্যাগুলি ব্যবহার করে ফাংশনটি চালিয়েছি

func([13.626332, 47.989636, 9.596008, 28.788024], 100); // => [48, 29, 13, 10]

এই প্রশ্নটি যা চেয়েছিল তার চেয়ে আলাদা ছিল => [48, 29, 14, 9]। আমি ত্রুটির মোট মার্জিনের দিকে না তাকানো পর্যন্ত এটি বুঝতে পারি না

-------------------------------------------------
| original  | question | % diff | mine | % diff |
-------------------------------------------------
| 13.626332 | 14       | 2.74%  | 13   | 4.5%   |
| 47.989636 | 48       | 0.02%  | 48   | 0.02%  |
| 9.596008  | 9        | 6.2%   | 10   | 4.2%   |
| 28.788024 | 29       | 0.7%   | 29   | 0.7%   |
-------------------------------------------------
| Totals    | 100      | 9.66%  | 100  | 9.43%  |
-------------------------------------------------

মূলত, আমার ফাংশন থেকে প্রাপ্ত ফলাফলটি আসলে ত্রুটির ন্যূনতম পরিমাণের পরিচয় দেয়।

ফিডল এখানে

— ব্রুনো
সূত্র
এটি আমার মনের মধ্যে বেশ কিছু ছিল, ত্রুটিটি মানের সাথে তুলনামূলকভাবে পরিমাপ করা উচিত (9.8 থেকে 10 গোল করা 19 19 থেকে 20 এর মধ্যে গোল করার চেয়ে বড় ত্রুটি)। যদিও এটি সহজে সাজানো কলব্যাকে প্রতিফলিত করেই করা যেতে পারে।
— poezn
এটি [33.33, 33.33, 33.33, 0.1] এর জন্য ভুল, এটি ফিরে আসে [1, 33, 33, 33] আরও নির্ভুলতার চেয়ে [34, 33, 33, 0]
— yonilevy
@ ইউনিলিভি এর জন্য ধন্যবাদ এখনই স্থির।
— ব্রুনো
এখনও নয়, [16.666, 16.666, 16.666, 16.666, 16.666, 16.666] এটি [15, 17, 17, 17, 17, 17] এর পরিবর্তে [15, 17, 17, 17, 17, 17] - আমার দেখুন উত্তর
— yonilevy
2

আপনার কোন স্তরের যথাযথতা প্রয়োজন তা আমি নিশ্চিত নই, তবে আমি কী করব কেবলমাত্র প্রথম nসংখ্যাটি যোগ করাই হ'ল nমোট দশমিকের যোগফলের সিল। এই ক্ষেত্রে এটি 3, তাই আমি প্রথম 3 আইটেম 1 যোগ এবং বাকি মেঝে হবে। অবশ্যই এটি অত্যন্ত নির্ভুল নয়, কিছু সংখ্যার বৃত্তাকার বা নীচে নামানো হতে পারে যখন এটি করা উচিত নয় তবে এটি ঠিক কাজ করে এবং সর্বদা 100% এর ফলস্বরূপ হয়।

তাই [ 13.626332, 47.989636, 9.596008, 28.788024 ]হবে [14, 48, 10, 28]কারণMath.ceil(.626332+.989636+.596008+.788024) == 3

function evenRound( arr ) {
  var decimal = -~arr.map(function( a ){ return a % 1 })
    .reduce(function( a,b ){ return a + b }); // Ceil of total sum of decimals
  for ( var i = 0; i < decimal; ++i ) {
    arr[ i ] = ++arr[ i ]; // compensate error by adding 1 the the first n items
  }
  return arr.map(function( a ){ return ~~a }); // floor all other numbers
}

var nums = evenRound( [ 13.626332, 47.989636, 9.596008, 28.788024 ] );
var total = nums.reduce(function( a,b ){ return a + b }); //=> 100

আপনি ব্যবহারকারীদের সর্বদা অবহিত করতে পারেন যে সংখ্যাগুলি বৃত্তাকার এবং অতি-সঠিক নাও হতে পারে ...

— elclanrs
সূত্র
1

আপনি যদি এটি গোল করে থাকেন তবে সর্বক্ষেত্রে একেবারে একই রকম হওয়ার কোনও ভাল উপায় নেই।

আপনার কাছে থাকা এন শতাংশের দশমিক অংশ নিতে পারেন (উদাহরণস্বরূপ আপনি এটি দিয়েছেন 4)।

দশমিক অংশ যুক্ত করুন। আপনার উদাহরণে আপনার মোট ভগ্নাংশ অংশ = 3 রয়েছে।

সর্বাধিক ভগ্নাংশ সহ 3 নম্বর সিল করুন এবং বাকী অংশটি মেঝে করুন।

(সম্পাদনাগুলির জন্য দুঃখিত)

— arunlalam
সূত্র
1
এটি যদি 100-তে যোগ হওয়া সংখ্যক সরবরাহ করতে পারে তবে আপনি শেষ হতে পারে 3.9 থেকে 3 এবং 25.1 এ 26 তে পরিণত হবে
— রবজি
কোন। 3.9 4 এবং 25.1 হবে 25. আমি সর্বাধিক ভগ্নাংশের সাথে সর্বাধিক মান নয় সিল করতে বলেছিলাম।
— অরুনল্লাম
2
.9 এ শেষ হওয়া অনেকগুলি ভগ্নাংশ থাকলে 9.9% এর 9 টি মান এবং 10.9 এর একটি মান বলে সেখানে একটি মান 9%, 8 হিসাবে 10% এবং একটি 11% হিসাবে শেষ হবে।
— অরুনল্লাম
1

আপনার যদি সত্যিই তাদের অবশ্যই গোল করা উচিত তবে ইতিমধ্যে এখানে খুব ভাল পরামর্শ রয়েছে (সবচেয়ে বড় অবশিষ্ট, কমপক্ষে আপেক্ষিক ত্রুটি এবং আরও কিছু)।

ইতিমধ্যে গোল না করার একটি ভাল কারণ রয়েছে (আপনি কমপক্ষে একটি সংখ্যা পাবেন যা "আরও ভাল দেখাচ্ছে" তবে এটি "ভুল"), এবং কীভাবে এটি সমাধান করবেন (আপনার পাঠকদের সতর্ক করুন) এবং এটিই আমি করি।

আমাকে "ভুল" নম্বর অংশটি যুক্ত করুন।

ধরুন আপনার কাছে তিনটি ইভেন্ট / সত্তা / ... রয়েছে কিছু শতাংশের সাথে আপনি যা অনুমান করেন:

DAY 1
who |  real | app
----|-------|------
  A | 33.34 |  34
  B | 33.33 |  33
  C | 33.33 |  33

পরে মানগুলি সামান্য পরিবর্তিত হয় to

DAY 2
who |  real | app
----|-------|------
  A | 33.35 |  33
  B | 33.36 |  34
  C | 33.29 |  33

প্রথম সারণীতে একটি "ভুল" নম্বর থাকার বিষয়ে ইতিমধ্যে উল্লিখিত সমস্যা রয়েছে: 33.34 এর 34 এর চেয়ে বেশি কাছে।

তবে এখন আপনার একটি বড় ত্রুটি রয়েছে। দিনকে 2 থেকে 1 দিনের সাথে তুলনা করে, এ এর ​​আসল শতাংশের মান 0.01% বৃদ্ধি পেয়েছে, তবে আনুমানিক 1% হ্রাস দেখায়।

এটি একটি গুণগত ত্রুটি, সম্ভবত প্রাথমিক পরিমাণগত ত্রুটি এটির চেয়েও খারাপ।

একটি পুরো সেটটির জন্য একটি আনুমানিক ধারণা তৈরি করতে পারে তবে, আপনাকে একদিন ডেটা প্রকাশ করতে হতে পারে, সুতরাং আপনি দ্বিতীয় দিন সম্পর্কে জানতে পারবেন না। সুতরাং, যদি না আপনি সত্যই, সত্যই, আনুমানিক, আপনি সম্ভবত ভাল না।

— রোলজারো আজিভায়ার্স
সূত্র
আরও ভাল টেবিলগুলি কীভাবে
— বানাতে
0

এটি পরীক্ষার ক্ষেত্রে যেমন আমি বৈধ হয়েছি তেমন বৈধ কিনা তা পরীক্ষা করে দেখুন this

যাক সংখ্যাটি কে;

  1. ওডার অবতরণ করে শতাংশ সাজান।
  2. ক্রমবর্ধমান ক্রম থেকে প্রতিটি শতাংশের উপর পুনরাবৃত্তি করুন।
  3. প্রথম শতাংশের জন্য কে এর গণনা শতাংশ গণনা করুন output
  4. পরবর্তী কে = কে -1
  5. সমস্ত শতাংশ গ্রাস না হওয়া পর্যন্ত পুনরাবৃত্তি করুন।
— শিথিল
সূত্র
0

আমি তালিকা এবং নকল উভয়ের জন্য বরুণ ভোহর এর উত্তর থেকে পদ্ধতিটি এখানে প্রয়োগ করেছি।

import math
import numbers
import operator
import itertools


def round_list_percentages(number_list):
    """
    Takes a list where all values are numbers that add up to 100,
    and rounds them off to integers while still retaining a sum of 100.

    A total value sum that rounds to 100.00 with two decimals is acceptable.
    This ensures that all input where the values are calculated with [fraction]/[total]
    and the sum of all fractions equal the total, should pass.
    """
    # Check input
    if not all(isinstance(i, numbers.Number) for i in number_list):
        raise ValueError('All values of the list must be a number')

    # Generate a key for each value
    key_generator = itertools.count()
    value_dict = {next(key_generator): value for value in number_list}
    return round_dictionary_percentages(value_dict).values()


def round_dictionary_percentages(dictionary):
    """
    Takes a dictionary where all values are numbers that add up to 100,
    and rounds them off to integers while still retaining a sum of 100.

    A total value sum that rounds to 100.00 with two decimals is acceptable.
    This ensures that all input where the values are calculated with [fraction]/[total]
    and the sum of all fractions equal the total, should pass.
    """
    # Check input
    # Only allow numbers
    if not all(isinstance(i, numbers.Number) for i in dictionary.values()):
        raise ValueError('All values of the dictionary must be a number')
    # Make sure the sum is close enough to 100
    # Round value_sum to 2 decimals to avoid floating point representation errors
    value_sum = round(sum(dictionary.values()), 2)
    if not value_sum == 100:
        raise ValueError('The sum of the values must be 100')

    # Initial floored results
    # Does not add up to 100, so we need to add something
    result = {key: int(math.floor(value)) for key, value in dictionary.items()}

    # Remainders for each key
    result_remainders = {key: value % 1 for key, value in dictionary.items()}
    # Keys sorted by remainder (biggest first)
    sorted_keys = [key for key, value in sorted(result_remainders.items(), key=operator.itemgetter(1), reverse=True)]

    # Otherwise add missing values up to 100
    # One cycle is enough, since flooring removes a max value of < 1 per item,
    # i.e. this loop should always break before going through the whole list
    for key in sorted_keys:
        if sum(result.values()) == 100:
            break
        result[key] += 1

    # Return
    return result
— beruic
সূত্র
0

এখানে @ বরুণ-ভোহর উত্তরের একটি সহজ পাইথন বাস্তবায়ন:

def apportion_pcts(pcts, total):
    proportions = [total * (pct / 100) for pct in pcts]
    apportions = [math.floor(p) for p in proportions]
    remainder = total - sum(apportions)
    remainders = [(i, p - math.floor(p)) for (i, p) in enumerate(proportions)]
    remainders.sort(key=operator.itemgetter(1), reverse=True)
    for (i, _) in itertools.cycle(remainders):
        if remainder == 0:
            break
        else:
            apportions[i] += 1
            remainder -= 1
    return apportions

আপনি প্রয়োজন math, itertools, operator।

— CMCDragonkai
সূত্র
0

পান্ডাস সিরিজের শতকরা ভাগ প্রাপ্তদের জন্য, এখানে আমার সবচেয়ে বৃহত্তর অবশিষ্ট পদ্ধতিটি প্রয়োগ করা হয়েছে ( বরুণ ভোহরের উত্তর হিসাবে ), আপনি যে দশমিকগুলি আপনি যে গোল করতে চান তা চয়ন করতে পারেন।

import numpy as np

def largestRemainderMethod(pd_series, decimals=1):

    floor_series = ((10**decimals * pd_series).astype(np.int)).apply(np.floor)
    diff = 100 * (10**decimals) - floor_series.sum().astype(np.int)
    series_decimals = pd_series - floor_series / (10**decimals)
    series_sorted_by_decimals = series_decimals.sort_values(ascending=False)

    for i in range(0, len(series_sorted_by_decimals)):
        if i < diff:
            series_sorted_by_decimals.iloc[[i]] = 1
        else:
            series_sorted_by_decimals.iloc[[i]] = 0

    out_series = ((floor_series + series_sorted_by_decimals) / (10**decimals)).sort_values(ascending=False)

    return out_series
— maxi.marufo
সূত্র
-1

এটি ব্যাঙ্কারের গোলাকার জন্য একটি মামলা, ওরফে 'রাউন্ড হাফ-ইওন'। এটি বিগডিসিমাল দ্বারা সমর্থিত। এর উদ্দেশ্য হ'ল রাউন্ডিং ব্যালেন্সগুলি নিশ্চিত হয়ে যাওয়া, অর্থাত্ ব্যাংক বা গ্রাহকের পক্ষে নয়।

— লার্নের মারকুইস
সূত্র
5
এটি নিশ্চিত করে না যে রাউন্ডিং ভারসাম্যগুলি ব্যয় হয় - এটি কেবল সম এবং বিজোড় সংখ্যার মধ্যে অর্ধ-বৃত্তাকার বিতরণ করে ত্রুটির পরিমাণ হ্রাস করে। এখনও এমন পরিস্থিতি রয়েছে যেখানে ব্যাংকারদের রাউন্ডিংয়ের ফলে সঠিক ফলাফল পাওয়া যায় না।
— ডি স্টানলে
@ ডিস্টানলে সম্মত আমি অন্যথায় বলিনি। আমি এর উদ্দেশ্য বলেছি । খুব সতর্কভাবে.
— লার্নের মারকুইস
2
যথেষ্ট ভাল - আপনি যা বলতে চাইছেন তা আমি ভুল ব্যাখ্যা করেছি। উভয় ক্ষেত্রেই আমি মনে করি না যে এটি সমস্যার সমাধান করে কারণ ব্যাংকারদের রাউন্ডিং ব্যবহার করা উদাহরণের ফলে ফলাফল পরিবর্তন করবে না।
— ডি স্ট্যানলে
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.