সমাধান
নিম্নলিখিত এক্সটেনশন পদ্ধতির যে কোনও একটি কাজ করবে। তারা সকলেই বিয়োগ চিহ্নটিকে একটি অঙ্ক হিসাবে বিবেচনা করে এবং সমস্ত সম্ভাব্য ইনপুট মানগুলির জন্য সঠিকভাবে কাজ করে। তারা নেট নেট ফ্রেমওয়ার্ক এবং। নেট কোরের জন্যও কাজ করে। প্ল্যাটফর্ম / ফ্রেমওয়ার্ক আপনার পছন্দ উপর নির্ভর করে প্রাসঙ্গিক পারফরম্যান্স পার্থক্য রয়েছে (নীচে আলোচনা করা হয়েছে)।
ইন্টার 32 সংস্করণ:
public static class Int32Extensions
{
// IF-CHAIN:
public static int Digits_IfChain(this int n)
{
if (n >= 0)
{
if (n < 10) return 1;
if (n < 100) return 2;
if (n < 1000) return 3;
if (n < 10000) return 4;
if (n < 100000) return 5;
if (n < 1000000) return 6;
if (n < 10000000) return 7;
if (n < 100000000) return 8;
if (n < 1000000000) return 9;
return 10;
}
else
{
if (n > -10) return 2;
if (n > -100) return 3;
if (n > -1000) return 4;
if (n > -10000) return 5;
if (n > -100000) return 6;
if (n > -1000000) return 7;
if (n > -10000000) return 8;
if (n > -100000000) return 9;
if (n > -1000000000) return 10;
return 11;
}
}
// USING LOG10:
public static int Digits_Log10(this int n) =>
n == 0 ? 1 : (n > 0 ? 1 : 2) + (int)Math.Log10(Math.Abs((double)n));
// WHILE LOOP:
public static int Digits_While(this int n)
{
int digits = n < 0 ? 2 : 1;
while ((n /= 10) != 0) ++digits;
return digits;
}
// STRING CONVERSION:
public static int Digits_String(this int n) =>
n.ToString().Length;
}
ইন্টার 64 সংস্করণ:
public static class Int64Extensions
{
// IF-CHAIN:
public static int Digits_IfChain(this long n)
{
if (n >= 0)
{
if (n < 10L) return 1;
if (n < 100L) return 2;
if (n < 1000L) return 3;
if (n < 10000L) return 4;
if (n < 100000L) return 5;
if (n < 1000000L) return 6;
if (n < 10000000L) return 7;
if (n < 100000000L) return 8;
if (n < 1000000000L) return 9;
if (n < 10000000000L) return 10;
if (n < 100000000000L) return 11;
if (n < 1000000000000L) return 12;
if (n < 10000000000000L) return 13;
if (n < 100000000000000L) return 14;
if (n < 1000000000000000L) return 15;
if (n < 10000000000000000L) return 16;
if (n < 100000000000000000L) return 17;
if (n < 1000000000000000000L) return 18;
return 19;
}
else
{
if (n > -10L) return 2;
if (n > -100L) return 3;
if (n > -1000L) return 4;
if (n > -10000L) return 5;
if (n > -100000L) return 6;
if (n > -1000000L) return 7;
if (n > -10000000L) return 8;
if (n > -100000000L) return 9;
if (n > -1000000000L) return 10;
if (n > -10000000000L) return 11;
if (n > -100000000000L) return 12;
if (n > -1000000000000L) return 13;
if (n > -10000000000000L) return 14;
if (n > -100000000000000L) return 15;
if (n > -1000000000000000L) return 16;
if (n > -10000000000000000L) return 17;
if (n > -100000000000000000L) return 18;
if (n > -1000000000000000000L) return 19;
return 20;
}
}
// USING LOG10:
public static int Digits_Log10(this long n) =>
n == 0L ? 1 : (n > 0L ? 1 : 2) + (int)Math.Log10(Math.Abs((double)n));
// WHILE LOOP:
public static int Digits_While(this long n)
{
int digits = n < 0 ? 2 : 1;
while ((n /= 10L) != 0L) ++digits;
return digits;
}
// STRING CONVERSION:
public static int Digits_String(this long n) =>
n.ToString().Length;
}
আলোচনা
এই উত্তরে এলোমেলোভাবে নমুনা / সংখ্যার অ্যারে ব্যবহার করে উভয় Int32এবং Int64প্রকারের জন্য সম্পাদিত পরীক্ষাগুলি অন্তর্ভুক্ত রয়েছে । পরীক্ষাগুলি সম্পাদন করার আগে এলোমেলোভাবে ডেটাসেট একটি অ্যারেতে প্রাক-প্রক্রিয়াজাত করা হয়।100.000.000intlong
4 বিভিন্ন পদ্ধতি মধ্যে সমন্নয় পরীক্ষার এছাড়াও, মৃত্যুদন্ড কার্যকর করা হয় জন্য MinValue, নেতিবাচক সীমান্ত ক্ষেত্রে, -1, 0, 1ইতিবাচক সীমান্ত ক্ষেত্রে, MaxValue, এবং এছাড়াও পুরো র্যান্ডম ডেটা সেটটি জন্য। উপরোক্ত প্রদত্ত পদ্ধতিগুলির জন্য কোনও ধারাবাহিকতা পরীক্ষা ব্যর্থ হয় না, LOG10 পদ্ধতির জন্য ব্যতিক্রম (এটি পরে আলোচনা করা হবে)।
পরীক্ষাগুলি কার্যকর করা হয়েছিল .NET Framework 4.7.2এবং .NET Core 2.2; জন্য x86এবং x64প্ল্যাটফর্মের, একটি 64-বিট Intel প্রসেসর মেশিনে সঙ্গে Windows 10, এবং VS2017 v.15.9.17। নিম্নলিখিত 4 টি ক্ষেত্রে পারফরম্যান্স ফলাফলের ক্ষেত্রে একই প্রভাব রয়েছে:
। নেট ফ্রেমওয়ার্ক (x86)
। নেট ফ্রেমওয়ার্ক (x64)
.NET কোর (x86)
। নেট কোর (x64)
ফলাফল
নীচের পারফরম্যান্স পরীক্ষাগুলি একটি পূর্ণসংখ্যার ধরে নিতে পারে এমন মানগুলির বিস্তৃত মানগুলির মধ্যে মূল্যগুলির অভিন্ন বন্টন উত্পাদন করে। এর অর্থ হ'ল বড় অঙ্কের সংখ্যার সাথে মানগুলি পরীক্ষার অনেক বেশি সম্ভাবনা রয়েছে। বাস্তব জীবনের পরিস্থিতিতে, বেশিরভাগ মান ছোট হতে পারে, তাই যদি আইএফ-চ্যান আরও ভাল সঞ্চালন করে। তদ্ব্যতীত, প্রসেসর আপনার ডেটাসেট অনুযায়ী আইএফ-চেইন সিদ্ধান্তগুলি ক্যাশে এবং অনুকূলিত করবে।
হিসাবে @AlanSingfield মন্তব্য বিভাগে নির্দিষ্ট, LOG10 পদ্ধতি করার জন্য একটি ঢালাই সঙ্গে সংশোধন করা হয়েছিল doubleভিতরে Math.Abs()ক্ষেত্রে জন্য যখন ইনপুট মান int.MinValueবা long.MinValue।
এই প্রশ্নটি সম্পাদনার আগে আমি প্রাথমিক সম্পাদনা পরীক্ষাগুলি প্রয়োগ করেছি (এটি ইতিমধ্যে এক মিলিয়ন বার সম্পাদনা করতে হয়েছিল), @ গাইরিগেরস্কেগ দ্বারা চিহ্নিত একটি নির্দিষ্ট কেস ছিল , যেখানে আইএফ-চেইন পদ্ধতি LOG10 পদ্ধতির চেয়ে ধীর সম্পাদন করে।
এটি এখনও ঘটে, যদিও @ অ্যালানসিংফিল্ড দ্বারা ইস্যু করা ইস্যুটির স্থিরতার পরে পার্থক্যটির মাত্রা অনেক কম হয়ে গেছে । doubleযখন এই ইনপুট মানটি হুবহু হয় তখন এই সংশোধন (এতে একটি কাস্ট যোগ করা ) একটি গণনা ত্রুটির কারণ ঘটে -999999999999999999: LOG10 পদ্ধতি 20পরিবর্তে ফিরে আসে 19। ifইনপুট মানটি শূন্য হলে LOG10 পদ্ধতিতে কেসটির জন্যও একজন প্রহরী থাকতে হবে ।
LOG10 পদ্ধতিটি সমস্ত মানগুলির জন্য কাজ করা বেশ জটিল, যার অর্থ আপনার এড়ানো উচিত। যদি কেউ নীচের সমস্ত ধারাবাহিকতা পরীক্ষার জন্য এটি সঠিকভাবে কাজ করার কোনও উপায় খুঁজে পায় তবে দয়া করে একটি মন্তব্য পোস্ট করুন!
WHILE পদ্ধতিটি একটি সাম্প্রতিক রিফ্যাক্টরড সংস্করণও পেয়েছে যা দ্রুততর তবে এটি এখনও ধীর গতির Platform = x86( এখনও পর্যন্ত এর কারণটি আমি খুঁজে পাইনি)।
STRING পদ্ধতিটি ধারাবাহিকভাবে ধীরে ধীরে: লোভের সাথে কিছুই করার জন্য খুব বেশি মেমরি বরাদ্দ করে। মজার বিষয় হল। নেট কোরে স্ট্রিং বরাদ্দকরণটি নেট ফ্রেমওয়ার্কের চেয়ে অনেক দ্রুত be জানা ভাল.
যদি আইএফ-চেইন পদ্ধতিটি 99.99% ক্ষেত্রে অন্যান্য সমস্ত পদ্ধতিকে ছাড়িয়ে যায়; এবং, আমার ব্যক্তিগত মতে, আপনার সেরা পছন্দ (LOG10 পদ্ধতিটি সঠিকভাবে কাজ করার জন্য প্রয়োজনীয় সমস্ত সামঞ্জস্য এবং অন্য দুটি পদ্ধতির খারাপ পারফরম্যান্স বিবেচনা করে) is
অবশেষে, ফলাফলগুলি হ'ল:
যেহেতু এই ফলাফলগুলি হার্ডওয়্যার-নির্ভর, তাই আপনার নিজের কম্পিউটারে যদি আপনার সত্যিকারের 100% নিশ্চিত হওয়ার দরকার হয় তবে আমি নীচে আপনার নিজের কম্পিউটারে কর্মক্ষমতা পরীক্ষা চালানোর পরামর্শ দিচ্ছি।
পরীক্ষার কোড
নীচে পারফরম্যান্স টেস্টের কোড, এবং ধারাবাহিকতা পরীক্ষাও। নেট কোড ফ্রেমওয়ার্ক এবং। নেট কোর উভয়ের জন্য একই কোড ব্যবহার করা হয়।
using System;
using System.Diagnostics;
namespace NumberOfDigits
{
// Performance Tests:
class Program
{
private static void Main(string[] args)
{
Console.WriteLine("\r\n.NET Core");
RunTests_Int32();
RunTests_Int64();
}
// Int32 Performance Tests:
private static void RunTests_Int32()
{
Console.WriteLine("\r\nInt32");
const int size = 100000000;
int[] samples = new int[size];
Random random = new Random((int)DateTime.Now.Ticks);
for (int i = 0; i < size; ++i)
samples[i] = random.Next(int.MinValue, int.MaxValue);
Stopwatch sw1 = new Stopwatch();
sw1.Start();
for (int i = 0; i < size; ++i) samples[i].Digits_IfChain();
sw1.Stop();
Console.WriteLine($"IfChain: {sw1.ElapsedMilliseconds} ms");
Stopwatch sw2 = new Stopwatch();
sw2.Start();
for (int i = 0; i < size; ++i) samples[i].Digits_Log10();
sw2.Stop();
Console.WriteLine($"Log10: {sw2.ElapsedMilliseconds} ms");
Stopwatch sw3 = new Stopwatch();
sw3.Start();
for (int i = 0; i < size; ++i) samples[i].Digits_While();
sw3.Stop();
Console.WriteLine($"While: {sw3.ElapsedMilliseconds} ms");
Stopwatch sw4 = new Stopwatch();
sw4.Start();
for (int i = 0; i < size; ++i) samples[i].Digits_String();
sw4.Stop();
Console.WriteLine($"String: {sw4.ElapsedMilliseconds} ms");
// Start of consistency tests:
Console.WriteLine("Running consistency tests...");
bool isConsistent = true;
// Consistency test on random set:
for (int i = 0; i < samples.Length; ++i)
{
int s = samples[i];
int a = s.Digits_IfChain();
int b = s.Digits_Log10();
int c = s.Digits_While();
int d = s.Digits_String();
if (a != b || c != d || a != c)
{
Console.WriteLine($"Digits({s}): IfChain={a} Log10={b} While={c} String={d}");
isConsistent = false;
break;
}
}
// Consistency test of special values:
samples = new int[]
{
0,
int.MinValue, -1000000000, -999999999, -100000000, -99999999, -10000000, -9999999, -1000000, -999999, -100000, -99999, -10000, -9999, -1000, -999, -100, -99, -10, -9, - 1,
int.MaxValue, 1000000000, 999999999, 100000000, 99999999, 10000000, 9999999, 1000000, 999999, 100000, 99999, 10000, 9999, 1000, 999, 100, 99, 10, 9, 1,
};
for (int i = 0; i < samples.Length; ++i)
{
int s = samples[i];
int a = s.Digits_IfChain();
int b = s.Digits_Log10();
int c = s.Digits_While();
int d = s.Digits_String();
if (a != b || c != d || a != c)
{
Console.WriteLine($"Digits({s}): IfChain={a} Log10={b} While={c} String={d}");
isConsistent = false;
break;
}
}
// Consistency test result:
if (isConsistent)
Console.WriteLine("Consistency tests are OK");
}
// Int64 Performance Tests:
private static void RunTests_Int64()
{
Console.WriteLine("\r\nInt64");
const int size = 100000000;
long[] samples = new long[size];
Random random = new Random((int)DateTime.Now.Ticks);
for (int i = 0; i < size; ++i)
samples[i] = Math.Sign(random.Next(-1, 1)) * (long)(random.NextDouble() * long.MaxValue);
Stopwatch sw1 = new Stopwatch();
sw1.Start();
for (int i = 0; i < size; ++i) samples[i].Digits_IfChain();
sw1.Stop();
Console.WriteLine($"IfChain: {sw1.ElapsedMilliseconds} ms");
Stopwatch sw2 = new Stopwatch();
sw2.Start();
for (int i = 0; i < size; ++i) samples[i].Digits_Log10();
sw2.Stop();
Console.WriteLine($"Log10: {sw2.ElapsedMilliseconds} ms");
Stopwatch sw3 = new Stopwatch();
sw3.Start();
for (int i = 0; i < size; ++i) samples[i].Digits_While();
sw3.Stop();
Console.WriteLine($"While: {sw3.ElapsedMilliseconds} ms");
Stopwatch sw4 = new Stopwatch();
sw4.Start();
for (int i = 0; i < size; ++i) samples[i].Digits_String();
sw4.Stop();
Console.WriteLine($"String: {sw4.ElapsedMilliseconds} ms");
// Start of consistency tests:
Console.WriteLine("Running consistency tests...");
bool isConsistent = true;
// Consistency test on random set:
for (int i = 0; i < samples.Length; ++i)
{
long s = samples[i];
int a = s.Digits_IfChain();
int b = s.Digits_Log10();
int c = s.Digits_While();
int d = s.Digits_String();
if (a != b || c != d || a != c)
{
Console.WriteLine($"Digits({s}): IfChain={a} Log10={b} While={c} String={d}");
isConsistent = false;
break;
}
}
// Consistency test of special values:
samples = new long[]
{
0,
long.MinValue, -1000000000000000000, -999999999999999999, -100000000000000000, -99999999999999999, -10000000000000000, -9999999999999999, -1000000000000000, -999999999999999, -100000000000000, -99999999999999, -10000000000000, -9999999999999, -1000000000000, -999999999999, -100000000000, -99999999999, -10000000000, -9999999999, -1000000000, -999999999, -100000000, -99999999, -10000000, -9999999, -1000000, -999999, -100000, -99999, -10000, -9999, -1000, -999, -100, -99, -10, -9, - 1,
long.MaxValue, 1000000000000000000, 999999999999999999, 100000000000000000, 99999999999999999, 10000000000000000, 9999999999999999, 1000000000000000, 999999999999999, 100000000000000, 99999999999999, 10000000000000, 9999999999999, 1000000000000, 999999999999, 100000000000, 99999999999, 10000000000, 9999999999, 1000000000, 999999999, 100000000, 99999999, 10000000, 9999999, 1000000, 999999, 100000, 99999, 10000, 9999, 1000, 999, 100, 99, 10, 9, 1,
};
for (int i = 0; i < samples.Length; ++i)
{
long s = samples[i];
int a = s.Digits_IfChain();
int b = s.Digits_Log10();
int c = s.Digits_While();
int d = s.Digits_String();
if (a != b || c != d || a != c)
{
Console.WriteLine($"Digits({s}): IfChain={a} Log10={b} While={c} String={d}");
isConsistent = false;
break;
}
}
// Consistency test result:
if (isConsistent)
Console.WriteLine("Consistency tests are OK");
}
}
}