কোন সংখ্যায় সংখ্যা পাওয়ার উপায়?

Question

এই পদ্ধতির চেয়ে কোনও ইন্টির দৈর্ঘ্য পাওয়ার জন্য কি আরও ভাল উপায় আছে?

int length = String.valueOf(1000).length();

Comments

অনুগ্রহ করে একটি int এর দৈর্ঘ্য নির্ধারণ করুন।

— টম

আমি মনে করি তিনি সংখ্যায় অঙ্কগুলি গণনা করতে চান।

— অ্যালবার্তো জ্যাক্যাগনি

লোকেরা আপনাকে যে উত্তর দিচ্ছে তা সঠিক ... তারা এটিকে কোনও স্ট্রিংয়ে রূপান্তর না করেই আপনার দৈর্ঘ্য দেয় ... তবে কেন আপনি এটিকে স্ট্রিতে রূপান্তর করতে চান না? এটা কি গতির জিনিস? যদি তা হয় তবে আমি নিশ্চিত নই যে এই পদ্ধতিগুলি আরও দ্রুততর হবে ... আপনি কিছু পরীক্ষা করতে চাইতে পারেন (বা এটি এমনকি গুরুত্বপূর্ণ কিনা তাও সিদ্ধান্ত নিতে পারেন)

— বেসকা

@ptomli হেক্সাডেসিমাল অঙ্কগুলি এখনও অন্য একটি বেস সিস্টেমের মধ্যে অঙ্ক।

— মার্ক পিম

@ পেটমলি শিওর, তবে উভয়ই Integer.toString ফাংশনে এবং সাধারণ কথোপকথনে দশমিকটি ডিফল্ট। ব্যাংক যখন আমাকে বলে, "এই বাক্সে আপনার চেকের পরিমাণটি লিখুন", আমি তাদের জিজ্ঞাসা করি না যে এটি আমার দশমিক, হেক্স বা অষ্টালে লিখতে হবে কিনা। আমরা দশমিক ধরে নিই যদি না অন্যথায় নির্দিষ্ট করে বলা হয় বা প্রসঙ্গে বলা হয় না।

— জে

Answer 1

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

একটি লগারিদম-ভিত্তিক সমাধান (কিছু) একইভাবে স্ট্রিং-ভিত্তিক ব্যক্তি অভ্যন্তরীণভাবে করে এবং সম্ভবত এটি (তুচ্ছভাবে) দ্রুত করে কারণ এটি কেবল দৈর্ঘ্য উত্পাদন করে এবং অঙ্কগুলি উপেক্ষা করে। তবে আমি আসলে এটি পরিষ্কারভাবে বিবেচনা করব না - এবং এটিই সবচেয়ে গুরুত্বপূর্ণ বিষয়।

Comments

কোনও সমস্যা সমাধানের উপায় বেছে নেওয়ার সময় কোডের উদ্দেশ্য বিবেচনা করার জন্য +1

— পুপেনো

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

— সিপারকিনস 20:30

নীচে আমার বেঞ্চমার্ক ইউনিট পরীক্ষাটি দেখুন (যা ত্রুটিযুক্তও হতে পারে আমি কোনও বেনমার্ক বিশেষজ্ঞ নই)। প্রচুর সংখ্যক রানের (100,000 000) ওভার, গতি আমার মেশিনে 11 থেকে 8 সেকিওর মতো দ্রুত দ্বিগুণ হয়।

— জিন

@CPerkins। অকাল অপ্টিমাইজেশন। আপনি স্পিল জানি।

— মাইকেল বর্গওয়ার্ট

কিছু (বেশ দেরিতে) সংযোজন: এটি যদি আপনি "-" ডিজিট হিসাবে প্রত্যাশা করেন বা না করেন তবে নির্ভর করে এটি নেতিবাচক মানগুলির জন্য সঠিকভাবে কাজ করবে না। যুক্ত করা Math.abs()যদিও এটি ঠিক করবে।

— ইং ইয়ং

Answer 2

লগারিদম আপনার বন্ধু:

int n = 1000;
int length = (int)(Math.log10(n)+1);

এনবি: কেবলমাত্র এন> 0 এর জন্য বৈধ।

Comments

এবং এই আমার বৈকল্পিক ব্যবহার চেয়ে দ্রুত বা ভাল?

— fnst

+1 আপনি আমাকে এক সেকেন্ডের মাধ্যমে মারলেন, এবং আপনার উত্তরটি ঠিক ছিল, যেখানে আমার কিছুটা দূরে ছিল। নোট যদিও, যে কম্পাইলার একটি হারানো ঢালাই কারণে অভিযোগ করবে int- এ

— ডির্ক

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

— বিল কে

কাজ করে ... যতক্ষণ না আপনি মান 0 পরীক্ষা করছেন, যা আপনাকে বিজোড় ফলাফল দেয় (-2147483647)। ম্যাথ.লগ 10 এপিআই: "যুক্তিটি যদি ইতিবাচক শূন্য বা orণাত্মক শূন্য হয় তবে ফলাফলটি নেতিবাচক অনন্ত।"

— মুজিমু

+1 এমন একটি পদ্ধতি উপস্থাপন যা অবজেক্ট মেমরির বরাদ্দকে জড়িত না, যা জিসি সংগ্রহগুলি এড়াতে পুনরায় ব্যবহারের সর্বাধিক প্রয়োজন।

— মাইকেল ওয়াজিক

Answer 3

দ্রুততম পদ্ধতির: বিভাজন এবং বিজয়।

আপনার পরিসীমা 0 থেকে MAX_INT হিসাবে ধরে নেওয়া হয়, তারপরে আপনার 1 থেকে 10 সংখ্যা রয়েছে। প্রতিটি ইনপুট প্রতি 4 টির তুলনা করে আপনি বিভাজন এবং বিজয় ব্যবহার করে এই ব্যবধানে যেতে পারেন। প্রথমত, আপনি [১.০.১০] কে [১.৫] এবং [...১০] কে একটি তুলনা দিয়ে ভাগ করুন এবং তারপরে প্রতিটি দৈর্ঘ্যের ৫ টি বিরতি আপনি একটি তুলনা ব্যবহার করে একটি দৈর্ঘ্য 3 এবং একটি দৈর্ঘ্য 2 ব্যবধানে ভাগ করেন। দৈর্ঘ্য 2 অন্তর আরও একটি তুলনা প্রয়োজন (মোট 3 তুলনা), দৈর্ঘ্য 3 বিরতি দৈর্ঘ্য 1 বিরতি (সমাধান) এবং একটি দৈর্ঘ্য 2 অন্তর মধ্যে বিভক্ত করা যেতে পারে। সুতরাং, আপনার 3 বা 4 তুলনা দরকার।

কোনও বিভাগ নেই, কোনও ফ্লোটিং পয়েন্ট অপারেশন নেই, ব্যয়বহুল লোগারিদম নেই, কেবলমাত্র পূর্ণসংখ্যার তুলনা।

কোড (দীর্ঘ তবে দ্রুত):

if (n < 100000){
        // 5 or less
        if (n < 100){
            // 1 or 2
            if (n < 10)
                return 1;
            else
                return 2;
        }else{
            // 3 or 4 or 5
            if (n < 1000)
                return 3;
            else{
                // 4 or 5
                if (n < 10000)
                    return 4;
                else
                    return 5;
            }
        }
    } else {
        // 6 or more
        if (n < 10000000) {
            // 6 or 7
            if (n < 1000000)
                return 6;
            else
                return 7;
        } else {
            // 8 to 10
            if (n < 100000000)
                return 8;
            else {
                // 9 or 10
                if (n < 1000000000)
                    return 9;
                else
                    return 10;
            }
        }
    }

বেঞ্চমার্ক (জেভিএম ওয়ার্ম-আপের পরে) - বেঞ্চমার্কটি কীভাবে চালিত হয়েছে তা দেখতে নীচের কোডটি দেখুন:

1. বেসলাইন পদ্ধতি (স্ট্রিং.লেন্থ সহ): 2145 মি
2. লগ 10 পদ্ধতি: বেসলাইন হিসাবে দ্রুত হিসাবে 711ms = 3.02 গুণ times
3. পুনরাবৃত্তি ভাগ: 2797ms = 0.77 বার বেসলাইন হিসাবে দ্রুত
4. বিভাজন এবং বিজয়:
   বেসলাইন হিসাবে দ্রুত 74ms = 28.99 গুণ

সম্পূর্ণ কোড:

public static void main(String[] args)
throws Exception
{

    // validate methods:
    for (int i = 0; i < 1000; i++)
        if (method1(i) != method2(i))
            System.out.println(i);
    for (int i = 0; i < 1000; i++)
        if (method1(i) != method3(i))
            System.out.println(i + " " + method1(i) + " " + method3(i));
    for (int i = 333; i < 2000000000; i += 1000)
        if (method1(i) != method3(i))
            System.out.println(i + " " + method1(i) + " " + method3(i));
    for (int i = 0; i < 1000; i++)
        if (method1(i) != method4(i))
            System.out.println(i + " " + method1(i) + " " + method4(i));
    for (int i = 333; i < 2000000000; i += 1000)
        if (method1(i) != method4(i))
            System.out.println(i + " " + method1(i) + " " + method4(i));

    // work-up the JVM - make sure everything will be run in hot-spot mode
    allMethod1();
    allMethod2();
    allMethod3();
    allMethod4();

    // run benchmark
    Chronometer c;

    c = new Chronometer(true);
    allMethod1();
    c.stop();
    long baseline = c.getValue();
    System.out.println(c);

    c = new Chronometer(true);
    allMethod2();
    c.stop();
    System.out.println(c + " = " + StringTools.formatDouble((double)baseline / c.getValue() , "0.00") + " times as fast as baseline");

    c = new Chronometer(true);
    allMethod3();
    c.stop();
    System.out.println(c + " = " + StringTools.formatDouble((double)baseline / c.getValue() , "0.00") + " times as fast as baseline");

    c = new Chronometer(true);
    allMethod4();
    c.stop();
    System.out.println(c + " = " + StringTools.formatDouble((double)baseline / c.getValue() , "0.00") + " times as fast as baseline");
}


private static int method1(int n)
{
    return Integer.toString(n).length();
}
private static int method2(int n)
{
    if (n == 0)
        return 1;
    return (int)(Math.log10(n) + 1);
}
private static int method3(int n)
{
    if (n == 0)
        return 1;
    int l;
    for (l = 0 ; n > 0 ;++l)
        n /= 10;
    return l;
}
private static int method4(int n)
{
    if (n < 100000)
    {
        // 5 or less
        if (n < 100)
        {
            // 1 or 2
            if (n < 10)
                return 1;
            else
                return 2;
        }
        else
        {
            // 3 or 4 or 5
            if (n < 1000)
                return 3;
            else
            {
                // 4 or 5
                if (n < 10000)
                    return 4;
                else
                    return 5;
            }
        }
    }
    else
    {
        // 6 or more
        if (n < 10000000)
        {
            // 6 or 7
            if (n < 1000000)
                return 6;
            else
                return 7;
        }
        else
        {
            // 8 to 10
            if (n < 100000000)
                return 8;
            else
            {
                // 9 or 10
                if (n < 1000000000)
                    return 9;
                else
                    return 10;
            }
        }
    }
}


private static int allMethod1()
{
    int x = 0;
    for (int i = 0; i < 1000; i++)
        x = method1(i);
    for (int i = 1000; i < 100000; i += 10)
        x = method1(i);
    for (int i = 100000; i < 1000000; i += 100)
        x = method1(i);
    for (int i = 1000000; i < 2000000000; i += 200)
        x = method1(i);

    return x;
}
private static int allMethod2()
{
    int x = 0;
    for (int i = 0; i < 1000; i++)
        x = method2(i);
    for (int i = 1000; i < 100000; i += 10)
        x = method2(i);
    for (int i = 100000; i < 1000000; i += 100)
        x = method2(i);
    for (int i = 1000000; i < 2000000000; i += 200)
        x = method2(i);

    return x;
}
private static int allMethod3()
{
    int x = 0;
    for (int i = 0; i < 1000; i++)
        x = method3(i);
    for (int i = 1000; i < 100000; i += 10)
        x = method3(i);
    for (int i = 100000; i < 1000000; i += 100)
        x = method3(i);
    for (int i = 1000000; i < 2000000000; i += 200)
        x = method3(i);

    return x;
}
private static int allMethod4()
{
    int x = 0;
    for (int i = 0; i < 1000; i++)
        x = method4(i);
    for (int i = 1000; i < 100000; i += 10)
        x = method4(i);
    for (int i = 100000; i < 1000000; i += 100)
        x = method4(i);
    for (int i = 1000000; i < 2000000000; i += 200)
        x = method4(i);

    return x;
}

আবার, বেঞ্চমার্ক:

1. বেসলাইন পদ্ধতি (স্ট্রিং.লেন্থ সহ): 2145 মি
2. লগ 10 পদ্ধতি: বেসলাইন হিসাবে দ্রুত হিসাবে 711ms = 3.02 গুণ times
3. পুনরাবৃত্তি ভাগ: 2797ms = 0.77 বার বেসলাইন হিসাবে দ্রুত
4. বিভাজন এবং বিজয়:
   বেসলাইন হিসাবে দ্রুত 74ms = 28.99 গুণ

সম্পাদনা: আমি মাপদণ্ডটি লেখার পরে, আমি জাভা 6 থেকে পূর্ণসংখ্যা.টো স্ট্রিংয়ের দিকে লুক্কায়িত শিখর নিয়েছি এবং আমি দেখতে পেলাম যে এটি ব্যবহার করে:

final static int [] sizeTable = { 9, 99, 999, 9999, 99999, 999999, 9999999,
                                  99999999, 999999999, Integer.MAX_VALUE };

// Requires positive x
static int stringSize(int x) {
    for (int i=0; ; i++)
        if (x <= sizeTable[i])
            return i+1;
}

আমি এটিকে আমার বিভাজন এবং বিজয়ী সমাধানের বিপরীতে চিহ্নিত করেছি:

4. বিভাজন এবং বিজয়: 104 মিমি
5. জাভা 6 সমাধান - পুনরাবৃত্তি করুন এবং তুলনা করুন: 406 মিমি

খনিটি জাভা 6 সমাধান হিসাবে প্রায় 4x দ্রুত।

Comments

এটি দুর্দান্ত দেখাচ্ছে আপনি আরও গ্রহণযোগ্যতা পেতে

— ?:

অকাল অপটিমাইজেশন সম্পর্কে কথা বলুন: ডি

— গর্ডন গুস্তাফসন

আমি এটা পছন্দ করি! কীভাবে যদি অন্যরকম নেস্ট করা হয় পরিবর্তে একটি সুইচ ব্লক সম্পর্কে?

— কেবম্যান

আমি এই সমস্ত বুঝতে পারি নি যদি অন্য বিবৃতিগুলি স্ট্রিংকে ইনটকে রূপান্তরিত করে তারপরে। +1

— ওগেন

টার্নারি অপারেটরটি ব্যবহার করে, এটি 101 টি অক্ষরে নেমে এসেছে:n<100000?n<100?n<10?1:2:n<1000?3:n<10000?4:5:n<10000000?n<1000000?6:7:n<100000000?8:n<1000000000?9:10

— জোনাথন গাওরিচ

Answer 4

আপনার মানদণ্ডের বিষয়ে দুটি মন্তব্য: জাভা একটি জটিল পরিবেশ, যা কেবলমাত্র সময়ে-সংকলন এবং আবর্জনা সংগ্রহের সাথে কী ঘটে যায়, তাই আমি যখনই একটি বেনমার্ক চালাই, তখন একটি ন্যায্য তুলনা পাওয়ার জন্য, আমি সর্বদা: (ক) দুটি পরীক্ষাকে ঘিরে রাখি একটি লুপ যা তাদের ক্রমানুসারে 5 বা 10 বার চালায়। বেশিরভাগ সময় লুপ দিয়ে দ্বিতীয় পাসের রানটাইম প্রথম থেকে বেশ আলাদা quite এবং (খ) প্রতিটি "পদ্ধতির" পরে, আবর্জনা সংগ্রহের চেষ্টা করার জন্য আমি একটি সিস্টেম.gc () করি। অন্যথায়, প্রথম পদ্ধতির ফলে প্রচুর পরিমাণে অবজেক্ট তৈরি হতে পারে তবে জঞ্জাল সংগ্রহের জন্য যথেষ্ট পরিমাণে যথেষ্ট নয়, তারপরে দ্বিতীয় পদ্ধতির কয়েকটি বস্তু তৈরি হয়, গাদা শেষ হয়ে যায় এবং আবর্জনা সংগ্রহ চলতে থাকে। তারপরে প্রথম পদ্ধতির দ্বারা আবর্জনা ফেলে রাখা জন্য দ্বিতীয় পদ্ধতির "চার্জ" করা হয়। খুব অন্যায়!

এটি বলেছিল, উপরের দুটিও এই উদাহরণে একটি উল্লেখযোগ্য পার্থক্য করেনি।

এই পরিবর্তনগুলি সহ বা ছাড়া, আমি আপনার চেয়ে খুব আলাদা ফলাফল পেয়েছি। আমি যখন এটি চালিয়েছি, হ্যাঁ, টু স্ট্রিং এপ্রোচটি 00৪০০ থেকে 66 66০০ মিলিসের রান সময় দিয়েছে, যখন লগটি 20,000 থেকে 20,400 মিলি পর্যন্ত শীর্ষে পৌঁছেছে। সামান্য দ্রুত হওয়ার পরিবর্তে, লগের পদ্ধতির জন্য আমার কাছে 3 গুণ বেশি ধীর ছিল।

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

আমি তৃতীয় পদ্ধতির চেষ্টাও করেছি। আমি এই ছোট্ট ফাংশনটি লিখেছি:

static int numlength(int n)
{
    if (n == 0) return 1;
    int l;
    n=Math.abs(n);
    for (l=0;n>0;++l)
        n/=10;
    return l;           
}

এটি 1600 থেকে 1900 মিলিসের মধ্যে চলেছিল - টসস্ট্রিং পদ্ধতির 1/3 এর চেয়ে কম এবং আমার মেশিনে 1/10 লগ অ্যাপ্রোচ।

আপনার যদি সংখ্যার বিস্তৃত পরিমাণ থাকে তবে লুপের মাধ্যমে সময়ের সংখ্যা হ্রাস করার জন্য আপনি 1,000 বা 1,000,000 দিয়ে ভাগ করে শুরু করে আরও গতি বাড়িয়ে দিতে পারেন। আমি এটা নিয়ে খেলিনি।

Comments

আপনি কি ইনপুটটি আলাদা করার চেষ্টা করেছেন? হটস্পট ভিএম অন্যথায় এই গ্রাফটি অপ্টিমাইজ করতে পারে, ফলে ভুল বেঞ্চমার্কের ফলস্বরূপ, কারণ এটি প্রতিবার একই প্রাক্পম্পিউটেড জিনিসটি ফিরিয়ে দিচ্ছে।

— এরিক অ্যাগনার

Answer 5

জাভা ব্যবহার করা

int nDigits = Math.floor(Math.log10(Math.abs(the_integer))) + 1;

import java.lang.Math.*;শুরুতে ব্যবহার করুন

সি ব্যবহার

int nDigits = floor(log10(abs(the_integer))) + 1;

inclue math.hশুরুতে ব্যবহার করুন

Comments

শুধু এফওয়াইআই, এর ফলে যদি অনন্তর পরিণতি the_integerহয় 0, তাই এটি পরীক্ষা করে দেখুন।

— এরিক অাইনার

Answer 6

এখনও কোনও মন্তব্য দিতে পারবেন না, তাই আমি পৃথক উত্তর হিসাবে পোস্ট করব।

লোগারিদম-ভিত্তিক সমাধান খুব বড় দীর্ঘ পূর্ণসংখ্যার জন্য অঙ্কের সঠিক সংখ্যা গণনা করে না, উদাহরণস্বরূপ:

long n = 99999999999999999L;

// correct answer: 17
int numberOfDigits = String.valueOf(n).length();

// incorrect answer: 18
int wrongNumberOfDigits = (int) (Math.log10(n) + 1); 

লোগারিদম-ভিত্তিক সমাধান বড় সংখ্যায় ভুল সংখ্যার গণনা করে

Comments

(int) (ম্যাথ.লগ 10 (এন + জে)) এর পরিবর্তে যেখানে জে 10 - (এন - এন / 10 * 10) চেষ্টা করুন।

— এরিক স্টোন

Answer 7

যেহেতু একটি পূর্ণসংখ্যার 10 নম্বরের অঙ্কের সংখ্যাটি কেবল 1 + ট্রান্সকেট (লগ 10 (সংখ্যা)) হয় তাই আপনি এটি করতে পারেন:

public class Test {

    public static void main(String[] args) {

        final int number = 1234;
        final int digits = 1 + (int)Math.floor(Math.log10(number));

        System.out.println(digits);
    }
}

সম্পাদিত কারণ আমার শেষ সম্পাদনাটি কোডের উদাহরণটি স্থির করেছে, তবে বিবরণটি নয়।

Comments

কুল। তবে আমি মনে করি এটির জন্য অ্যাবস (সংখ্যা) প্রয়োজন এবং "0" কেও বিশেষ ক্ষেত্রে?

— দিমিত্রিেকে

হ্যাঁ. আপনার যদি সাইনটির

— শির্ক

Math.floorএকটু অপ্রয়োজনীয়, তাই নয় কি? কাস্টিং intএটিকে যাইহোক ডাউন করে দেবে।

— CompuChip

Answer 8

মারিয়ানের দ্রবণটি দীর্ঘ প্রকার সংখ্যার জন্য (9,223,372,036,854,775,807 অবধি) অভিযোজিত , যদি কেউ এটি অনুলিপি করে আটকান করতে চায়। প্রোগ্রামটিতে আমি এটি লিখেছিলাম 10000 পর্যন্ত সংখ্যার জন্য অনেক বেশি সম্ভাব্য, তাই আমি তাদের জন্য একটি নির্দিষ্ট শাখা তৈরি করেছি। যাইহোক এটি একটি তাত্পর্যপূর্ণ পার্থক্য করতে হবে না।

public static int numberOfDigits (long n) {     
    // Guessing 4 digit numbers will be more probable.
    // They are set in the first branch.
    if (n < 10000L) { // from 1 to 4
        if (n < 100L) { // 1 or 2
            if (n < 10L) {
                return 1;
            } else {
                return 2;
            }
        } else { // 3 or 4
            if (n < 1000L) {
                return 3;
            } else {
                return 4;
            }
        }           
    } else  { // from 5 a 20 (albeit longs can't have more than 18 or 19)
        if (n < 1000000000000L) { // from 5 to 12
            if (n < 100000000L) { // from 5 to 8
                if (n < 1000000L) { // 5 or 6
                    if (n < 100000L) {
                        return 5;
                    } else {
                        return 6;
                    }
                } else { // 7 u 8
                    if (n < 10000000L) {
                        return 7;
                    } else {
                        return 8;
                    }
                }
            } else { // from 9 to 12
                if (n < 10000000000L) { // 9 or 10
                    if (n < 1000000000L) {
                        return 9;
                    } else {
                        return 10;
                    }
                } else { // 11 or 12
                    if (n < 100000000000L) {
                        return 11;
                    } else {
                        return 12;
                    }
                }
            }
        } else { // from 13 to ... (18 or 20)
            if (n < 10000000000000000L) { // from 13 to 16
                if (n < 100000000000000L) { // 13 or 14
                    if (n < 10000000000000L) { 
                        return 13;
                    } else {
                        return 14;
                    }
                } else { // 15 or 16
                    if (n < 1000000000000000L) {
                        return 15;
                    } else {
                        return 16;
                    }
                }
            } else { // from 17 to ...¿20?
                if (n < 1000000000000000000L) { // 17 or 18
                    if (n < 100000000000000000L) {
                        return 17;
                    } else {
                        return 18;
                    }
                } else { // 19? Can it be?
                    // 10000000000000000000L is'nt a valid long.
                    return 19;
                }
            }
        }
    }
}

Comments

এই প্রশ্নের শিরোনামটি কি "দীর্ঘ / দীর্ঘ সংখ্যার সংখ্যা পাওয়ার উপায়" তে পরিবর্তন করা উচিত? (এবং 'দীর্ঘ' ট্যাগ যুক্ত করেছেন)

— জেইল

Answer 9

অন্য স্ট্রিং পদ্ধতির। সংক্ষিপ্ত এবং মিষ্টি - কোনও পূর্ণসংখ্যার জন্য n।

int length = ("" + n).length();

Comments

কেবল ধনাত্মক পূর্ণসংখ্যার nএবং শূন্যের জন্য কাজ করে । ("" + Math.abs(n)).length()Negativeণাত্মক পূর্ণসংখ্যার দৈর্ঘ্য পেতে ব্যবহার করতে পারেন ।

— ক্লার্ক

Answer 10

আমি কি চেষ্টা করতে পারি? ;)

ডার্কের সমাধানের ভিত্তিতে

final int digits = number==0?1:(1 + (int)Math.floor(Math.log10(Math.abs(number))));

Answer 11

কিভাবে পুরানো গণিত সম্পর্কে? আপনি 0 এ পৌঁছা পর্যন্ত 10 দ্বারা ভাগ করুন।

public static int getSize(long number) {
        int count = 0;
        while (number > 0) {
            count += 1;
            number = (number / 10);
        }
        return count;
    }

Comments

আপনি এটি পরীক্ষা করেছেন? আপনি জানেন যে, এমনকি এটি একটি কঠিন মানুষের দৃষ্টিভঙ্গির পক্ষেও বোঝা যায়, এটি মেশিনের "চিন্তা-ভাবনা" এর সাথে একইভাবে কাজ করে না, তাই না? --- আমাকে একটি বিষয় প্রস্তাব দিন: প্রায় দুই মিলিয়ন সংখ্যার একটি অ্যারে তৈরি করুন, সম্ভবত Long.MAX_VALUEএটি আপনার কোডের সবচেয়ে জটিল জটিলতা এবং System.nanoTime()অন্য সমাধানের সবচেয়ে খারাপ জটিলতার ক্ষেত্রে ক্লকিং ট্রায়াল ব্যবহার করুন । ++, আসলে, এটা পরিসীমা করার জন্য একটি randomizer সেট ভরা একটি অ্যারের দিয়ে চেষ্টা 0করতে Long.MAX_VALUEখুব, শুধু "গড় জটিলতা" পরীক্ষা ++, আপনি ফলাফল পেতে পারে ... খুব জঘন্য জন্য।

— XenoRo

@ থেলিমা এটি শূন্য বা নেতিবাচক জন্য সঠিকভাবে কাজ করে না, তবে এটি একটি ছোটখাটো বাগ। নীতিটি আমার কাছে সঠিক দেখাচ্ছে। আপনি কোন "জঘন্য" ফলাফল উল্লেখ করছেন?

— জয়

আসুন কেবল কম্পিউটারগুলি বলি ... ভাল ... তারা ভাগ করা পছন্দ করে না। এবং এমন ক্ষেত্রে যেখানে বড় সংখ্যক বৃহত্তর "সারি" প্রক্রিয়াকরণ করা দরকার এবং প্রতিটি প্রক্রিয়াজাত সংখ্যায় প্রতিটি অঙ্কের একটি বিভাগের প্রয়োজন হবে ... ভাল ... বিষয়গুলি "সত্যই দ্রুত ধীরে ধীরে শুরু হওয়া শুরু করুন" ... আপনি যদি আমার ধরেন তবে অর্থ ... --- এই কারণেই আপনি এখানে পরীক্ষাগুলির উপর ভিত্তি করে কোডগুলি ব্যবহার করে এবং বিভাগের পরিবর্তে 'if এর' ব্যবহার করে প্রতিটি দশমিক ডিজিটের সাথে তুলনা করে অনেক উত্তর দেখতে পান: যদি এটি দ্রুত না হয় তবে কমপক্ষে এটি তার বেশিরভাগ গতি বজায় রাখে এটি সবচেয়ে খারাপ ক্ষেত্রে। --- প্রচুর সংখ্যায় বিভাগ এবং লগারিদম ব্যবহারের মধ্যে একটি পরীক্ষা করুন ...

— XenoRo

@TheLima আপনি কি সম্পর্কে কথা বলছেন? একটি জন্য int,এই লুপ 11 বার সর্বোচ্চ সঞ্চালন করে। আপনার বক্তব্যের জন্য আপনার কাছে কিছু প্রমাণ আছে?

— লার্নের মারকুইস

@ ইজেপি একটি হার্ডওয়্যার দৃষ্টিকোণ থেকে বিভাগ একটি পুনরাবৃত্ত প্রক্রিয়া। আমি জানি সবচেয়ে দ্রুত বিভাগের অ্যালগরিদমটি Radix4, যা পুনরাবৃত্তি প্রতি 4 বিট উত্পন্ন করে; সুতরাং একটি 32 বিট বিভাজনের জন্য কমপক্ষে 8 টি পুনরাবৃত্তি প্রয়োজন। উদাহরণস্বরূপ, গুণগুলি সমান্তরালভাবে করা যেতে পারে, এবং আরও সহজ গুণে বিভক্ত করা যেতে পারে; হয় নিচে বিট স্তরে (কেবল 5 টি অপারেশন প্রয়োজন), বা আংশিক ব্রেক ডাউন প্লাস শেষে একটি লুক-টেবিল সহ (ক্লাসিক আকারের ভিএস স্পিড ট্রেড-অফ)। এটি কেবল "কতগুলি পুনরাবৃত্তি" নয়; বিভাগগুলির সমস্যাটি "প্রতিটি পুনরাবৃত্তির দ্বারা একটি হার্ডওয়্যার স্তরে যা বোঝায় /

— করায় তা

Answer 12

মারিয়ান সলিউশন, এখন টার্নারি সহ:

 public int len(int n){
        return (n<100000)?((n<100)?((n<10)?1:2):(n<1000)?3:((n<10000)?4:5)):((n<10000000)?((n<1000000)?6:7):((n<100000000)?8:((n<1000000000)?9:10)));
    }

কারণ আমরা পারি

Comments

এটাই পড়তে কষ্টকর। হতে পারে কিছু স্পেস এবং / অথবা নিউলাইন যুক্ত করুন।

— michaelb958 - GoFundMonica

কিন্তু অভিশাপ এটি পোর্টেবল!

— ট্রেভর রুডল্ফ

Answer 13

কৌতূহলী, আমি এটি বেঞ্চমার্ক করার চেষ্টা করেছি ...

import org.junit.Test;
import static org.junit.Assert.*;


public class TestStack1306727 {

    @Test
    public void bench(){
        int number=1000;
        int a= String.valueOf(number).length();
        int b= 1 + (int)Math.floor(Math.log10(number));

        assertEquals(a,b);
        int i=0;
        int s=0;
        long startTime = System.currentTimeMillis();
        for(i=0, s=0; i< 100000000; i++){
            a= String.valueOf(number).length();
            s+=a;
        }
        long stopTime = System.currentTimeMillis();
        long runTime = stopTime - startTime;
        System.out.println("Run time 1: " + runTime);
        System.out.println("s: "+s);
        startTime = System.currentTimeMillis();
        for(i=0,s=0; i< 100000000; i++){
            b= number==0?1:(1 + (int)Math.floor(Math.log10(Math.abs(number))));
            s+=b;
        }
        stopTime = System.currentTimeMillis();
        runTime = stopTime - startTime;
        System.out.println("Run time 2: " + runTime);
        System.out.println("s: "+s);
        assertEquals(a,b);


    }
}

ফলাফলগুলি হ'ল:

রান সময় 1: 6765
s: 400000000
রান সময় 2: 6000
s: 400000000

এখন আমি অবাক হওয়ার মতোই রয়েছি যে আমার বেঞ্চমার্কটি আসলে কিছু বোঝায় তবে আমি বেঞ্চমার্কের একাধিক রানের চেয়ে সামঞ্জস্যপূর্ণ ফলাফল (এমএসের মধ্যে বিভিন্নতা) পাই ... :) দেখে মনে হচ্ছে এটি চেষ্টা করা এবং এটি অপ্টিমাইজ করা অযথা ...

---

সম্পাদনা করুন: পিটমলির মন্তব্যের পরে, আমি উপরের কোডে 'আমি' দ্বারা 'নম্বর' প্রতিস্থাপন করেছি এবং বেঞ্চের 5 রানের উপরে নিম্নলিখিত ফলাফল পেয়েছি:

রান সময় 1: 11500
s: 788888890
রান সময় 2: 8547
s: 788888890

রান সময় 1: 11485
s: 788888890
রান সময় 2: 8547
s: 788888890

রান সময় 1: 11469
s: 788888890
রান সময় 2: 8547
s: 788888890

রান সময় 1: 11500
s: 788888890
রান সময় 2: 8547
s: 788888890

রান সময় 1: 11484
s: 788888890
রান সময় 2: 8547
s: 788888890

Comments

কেবল এটির মজাদার জন্য, 0 থেকে ট্রিলিয়ন বলতে সংখ্যার মান বিতরণে কী পার্থক্য রয়েছে? :)

— ptomli

Answer 14

এই পুনরাবৃত্তির পদ্ধতি সম্পর্কে কী?

    private static int length = 0;

    public static int length(int n) {
    length++;
    if((n / 10) < 10) {
        length++;
    } else {
        length(n / 10);
    }
    return length;
}

Answer 15

সহজ সমাধান:

public class long_length {
    long x,l=1,n;
    for (n=10;n<x;n*=10){
        if (x/n!=0){
            l++;
        }
    }
    System.out.print(l);
}

Answer 16

একটি সত্যিই সহজ সমাধান:

public int numLength(int n) {
  for (int length = 1; n % Math.pow(10, length) != n; length++) {}
  return length;
}

Comments

আমি খালি শরীরের সরল দিয়ে লুপের জন্য একটি লাইনে কল করব না। আপনি যদি একই জিনিসটি ফিরে পান তবে এটির জন্য 10 এর শক্তিকে মডুলো করুন (আপনি কেবল তুলনাটি ব্যবহার করতে পারবেন না?)।

— তিপিম্ম

Answer 17

অথবা পরিবর্তে দৈর্ঘ্যটি আপনি পছন্দটি সংখ্যাটি আরও বড় বা ছোট কিনা তা পরীক্ষা করতে পারেন।

    public void createCard(int cardNumber, int cardStatus, int customerId) throws SQLException {
    if(cardDao.checkIfCardExists(cardNumber) == false) {
        if(cardDao.createCard(cardNumber, cardStatus, customerId) == true) {
            System.out.println("Card created successfully");
        } else {

        }
    } else {
        System.out.println("Card already exists, try with another Card Number");
        do {
            System.out.println("Enter your new Card Number: ");
            scan = new Scanner(System.in);
            int inputCardNumber = scan.nextInt();
            cardNumber = inputCardNumber;
        } while(cardNumber < 95000000);
        cardDao.createCard(cardNumber, cardStatus, customerId);
    }
}

}

Comments

আমি বুঝতে পারছি না। দেখে মনে হচ্ছে আপনি আলাদা প্রশ্নের উত্তর দিচ্ছেন।

— তিপিম্ম

Answer 18

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

/**
 * Returns the number of digits needed to represents an {@code int} value in 
 * the given radix, disregarding any sign.
 */
public static int len(int n, int radix) {
    radixCheck(radix); 
    // if you want to establish some limitation other than radix > 2
    n = Math.abs(n);

    int len = 1;
    long min = radix - 1;

    while (n > min) {
        n -= min;
        min *= radix;
        len++;
    }

    return len;
}

দশম বেসে, এটি কাজ করে কারণ এন মূলত 9, 99, 999 এর সাথে তুলনা করা হচ্ছে ... যেমন ন্যূনতম 9, 90, 900 ... এবং n 9, 90, 900 দ্বারা বিয়োগ করা হচ্ছে ...

দুর্ভাগ্যক্রমে, longএটি কেবল অতিরিক্ত intপ্রবাহের কারণে প্রতিটি প্রতিস্থাপনের দ্বারা পোর্টেবল নয় । অন্যদিকে, এটি ঠিক তাই ঘটে এটি 2 এবং 10 ঘাঁটির জন্য কাজ করবে (তবে অন্যান্য ঘাঁটির বেশিরভাগ ক্ষেত্রে খারাপভাবে ব্যর্থ হয়)। ওভারফ্লো পয়েন্টগুলির জন্য আপনার একটি সারণী লাগবে (বা বিভাগ পরীক্ষা ... ই)

/**
 * For radices 2 &le r &le Character.MAX_VALUE (36)
 */
private static long[] overflowpt = {-1, -1, 4611686018427387904L,
    8105110306037952534L, 3458764513820540928L, 5960464477539062500L,
    3948651115268014080L, 3351275184499704042L, 8070450532247928832L,
    1200757082375992968L, 9000000000000000000L, 5054470284992937710L,
    2033726847845400576L, 7984999310198158092L, 2022385242251558912L,
    6130514465332031250L, 1080863910568919040L, 2694045224950414864L,
    6371827248895377408L, 756953702320627062L, 1556480000000000000L,
    3089447554782389220L, 5939011215544737792L, 482121737504447062L,
    839967991029301248L, 1430511474609375000L, 2385723916542054400L,
    3902460517721977146L, 6269893157408735232L, 341614273439763212L,
    513726300000000000L, 762254306892144930L, 1116892707587883008L,
    1617347408439258144L, 2316231840055068672L, 3282671350683593750L,
    4606759634479349760L};

public static int len(long n, int radix) {
    radixCheck(radix);
    n = abs(n);

    int len = 1;
    long min = radix - 1;
    while (n > min) {
        len++;
        if (min == overflowpt[radix]) break;
        n -= min;
        min *= radix;

    }

    return len;
}

Answer 19

নকশা সহ (সমস্যার ভিত্তিতে)। এটি বিভাজন এবং বিজয়ের বিকল্প। আমরা প্রথমে একটি এনাম সংজ্ঞায়িত করব (এটি কেবল স্বাক্ষরযুক্ত স্বাক্ষরের জন্য বিবেচনা করে)।

public enum IntegerLength {
    One((byte)1,10),
    Two((byte)2,100),
    Three((byte)3,1000),
    Four((byte)4,10000),
    Five((byte)5,100000),
    Six((byte)6,1000000),
    Seven((byte)7,10000000),
    Eight((byte)8,100000000),
    Nine((byte)9,1000000000);

    byte length;
    int value;

    IntegerLength(byte len,int value) {
        this.length = len;
        this.value = value;
    }

    public byte getLenght() {
        return length;
    }

    public int getValue() {
        return value;
    }
}

এখন আমরা একটি শ্রেণি সংজ্ঞায়িত করব যা এনামের মানগুলির মধ্য দিয়ে যায় এবং তুলনা করে উপযুক্ত দৈর্ঘ্যটি ফেরত দেয়।

public class IntegerLenght {
    public static byte calculateIntLenght(int num) {    
        for(IntegerLength v : IntegerLength.values()) {
            if(num < v.getValue()){
                return v.getLenght();
            }
        }
        return 0;
    }
}

এই সমাধানের রান সময়টি বিভাজন এবং বিজয়ী পদ্ধতির সমান।

Comments

একটি বিভাজন এবং বিজয়ী মাঝখানে শুরু হবে এবং বাকী অনুসন্ধান অঞ্চলটি দ্বিখণ্ডিত করবে। এটির একটি লিনিয়ার রান সময় রয়েছে। তবে এটি কেবল 9 টি তুলনার জন্য গুরুত্বপূর্ণ নয়। তবে কি এই গোলযোগ হবে না num>=Nine.getValue()?

— তিপিম্ম

Answer 20

একজন এটি বেশিরভাগ ক্ষেত্রেই করতে চান কারণ তিনি এটিকে "উপস্থাপন" করতে চান, যার বেশিরভাগ অর্থ এটি শেষ পর্যন্ত "টু স্ট্রিং-এড" (বা অন্য কোনওভাবে রূপান্তরিত হওয়া) কোনওভাবেই বা স্পষ্টতই হোক; এটি উপস্থাপনের আগে (উদাহরণস্বরূপ মুদ্রিত)।

যদি এটি হয় তবে কেবল প্রয়োজনীয় "টু স্ট্রিং" কে সুস্পষ্ট করার চেষ্টা করুন এবং বিটগুলি গণনা করুন।

Answer 21

আমরা এটি পুনরাবৃত্তকারী লুপ ব্যবহার করে অর্জন করতে পারি

    public static int digitCount(int numberInput, int i) {
        while (numberInput > 0) {
        i++;
        numberInput = numberInput / 10;
        digitCount(numberInput, i);
        }
        return i;
    }

    public static void printString() {
        int numberInput = 1234567;
        int digitCount = digitCount(numberInput, 0);

        System.out.println("Count of digit in ["+numberInput+"] is ["+digitCount+"]");
    }

Answer 22

Integer.javaউত্স কোড দেখার পরে আমি এই ফাংশনটি লিখেছি ।

private static int stringSize(int x) {
    final int[] sizeTable = {9, 99, 999, 9_999, 99_999, 999_999, 9_999_999,
            99_999_999, 999_999_999, Integer.MAX_VALUE};
    for (int i = 0; ; ++i) {
        if (x <= sizeTable[i]) {
            return i + 1;
        }
    }
}

Answer 23

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

 private static int getLength(long num) {

    int count = 1;

    while (num >= 10) {
        num = num / 10;
        count++;
    }

    return count;
}

Answer 24

স্ট্রিং এপিআই নেই, কোনও ব্যবহার নেই, কোনও ধরণের রূপান্তর নেই, খাঁটি জাভা পুনরাবৃত্তি ->

public static int getNumberOfDigits(int input) {
    int numOfDigits = 1;
    int base = 1;
    while (input >= base * 10) {
        base = base * 10;
        numOfDigits++;
    }
    return numOfDigits;
 }

আপনি দয়া করে বড় মান জন্য দীর্ঘ যেতে পারে।

Answer 25

    int num = 02300;
    int count = 0;
    while(num>0){
         if(num == 0) break;
         num=num/10;
         count++;
    }
    System.out.println(count);

Comments

একটি "বিভক্ত 10" সমাধানটি দু'বছর আগে প্রথম সিনিস্তা পোস্ট করেছিলেন।

— তিপিম্ম

Answer 26

সহজ পুনরাবৃত্ত উপায়

int    get_int_lenght(current_lenght, value)
{
 if (value / 10 < 10)
    return (current_lenght + 1);
return (get_int_lenght(current_lenght + 1, value))
}

পরীক্ষিত না

Comments

আপনার সম্ভবত এটি পরীক্ষা করা উচিত (এবং এটি বৈধ জাভা এবং সঠিকভাবে ফর্ম্যাট করা আছে তা নিশ্চিত করুন)। তবে একটি পুনরাবৃত্ত "10 দ্বারা বিভাজন" পদ্ধতির 3 বছর আগে জেডি দুলা পোস্ট করেছিলেন।

— তিপিম্ম

Answer 27

দশটি করে ক্রমাগত বিভাগ ব্যবহার করে আপনি অঙ্কগুলি করতে পারতেন:

int a=0;

if (no < 0) {
    no = -no;
} else if (no == 0) {
    no = 1;
}

while (no > 0) {
    no = no / 10;
    a++;
}

System.out.println("Number of digits in given number is: "+a);

Comments

একটি "ডিভাইড টু 10" অ্যাপ্রোচ 3 বছর আগে সিনস্তা পরে পোস্ট করেছিলেন। আমি একমাত্র এই কারণটি ভাবতে পারি যে আপনি ডাউন ডাউন পেয়েছেন।

— তিপিম্ম

Answer 28

নম্বরটি প্রবেশ করান এবং একটি তৈরি করুন Arraylist, এবং সেই সময় লুপটি সমস্ত সংখ্যাকে রেকর্ড করবে Arraylist। তারপরে আমরা অ্যারের আকারটি বের করতে পারি, এটি আপনার প্রবেশপথের পূর্ণসংখ্যার মানের দৈর্ঘ্য হবে।

ArrayList<Integer> a=new ArrayList<>();

while(number > 0) 
{ 
    remainder = num % 10; 
    a.add(remainder);
    number = number / 10; 
} 

int m=a.size();

Comments

ব্যতীত আপনার আরেলিস্ট বা অঙ্কগুলির প্রয়োজন নেই।

— লার্নের মারকুইস

Answer 29

এখানে আমি তৈরি একটি খুব সহজ পদ্ধতি যা যে কোনও সংখ্যার জন্য কাজ করে:

public static int numberLength(int userNumber) {

    int numberCounter = 10;
    boolean condition = true;
    int digitLength = 1;

    while (condition) {
        int numberRatio = userNumber / numberCounter;
        if (numberRatio < 1) {
            condition = false;
        } else {
            digitLength++;
            numberCounter *= 10;
        }
    }

    return digitLength; 
}

নম্বর কাউন্টের ভেরিয়েবলের সাথে এটি যেভাবে কাজ করে তা হ'ল 10 = 1 ডিজিটের স্থান। উদাহরণস্বরূপ .1 = 1 দশম => 1 ডিজিটের স্থান। অতএব যদি আপনার কাছে থাকে তবে আপনি int number = 103342;6 পাবেন, কারণ এটি ফিরে .000001 স্পেসের সমতুল্য। এছাড়াও, কারওর জন্য আরও ভাল পরিবর্তনশীল নাম রয়েছে havenumberCounter ? আমি এর চেয়ে ভাল কিছু ভাবতে পারি না।

সম্পাদনা: কেবল একটি ভাল ব্যাখ্যা সম্পর্কে চিন্তা করা। মূলত এটি যখন লুপটি করছে তখন তা তৈরি করছে যাতে আপনি নিজের সংখ্যাটি 10 ​​দ্বারা বিভক্ত করেন, যতক্ষণ না এটি একের চেয়ে কম হয়। মূলত, যখন আপনি কোনও কিছু 10 দ্বারা বিভক্ত করেন আপনি এটিকে এক নম্বর স্থানটি পিছনে নিয়ে চলেছেন, সুতরাং আপনি নিজের সংখ্যার অঙ্কের পরিমাণের জন্য <1 না পৌঁছা পর্যন্ত আপনি কেবল 10 দ্বারা বিভক্ত করুন।

এখানে আরও একটি সংস্করণ যা দশমিকের মধ্যে সংখ্যার পরিমাণ গণনা করতে পারে:

public static int repeatingLength(double decimalNumber) {

    int numberCounter = 1;
    boolean condition = true;
    int digitLength = 1;

    while (condition) {
        double numberRatio = decimalNumber * numberCounter;

        if ((numberRatio - Math.round(numberRatio)) < 0.0000001) {
            condition = false;
        } else {
            digitLength++;
            numberCounter *= 10;
        }
    }
    return digitLength - 1;
}

Answer 30

রূপান্তর করার চেষ্টা করুন int- এ একটি থেকে স্ট্রিং এবং তারপর দৈর্ঘ্য পেতে স্ট্রিং । এটি int এর দৈর্ঘ্য পাওয়া উচিত ।

public static int intLength(int num){
    String n = Integer.toString(num);
    int newNum = n.length();
    return newNum;
}

Comments

এটি পুরোপুরি মূল কোডের সমতুল্য। numberনেতিবাচক হলে এবং মিস করবে ।

— তিপিম্ম