কৌশলযুক্ত গুগল সাক্ষাত্কার প্রশ্ন

169

আমার এক বন্ধু একটি কাজের জন্য সাক্ষাত্কার দিচ্ছে। একটি সাক্ষাত্কারের প্রশ্নটি আমাকে ভেবে পেয়েছিল, কিছু প্রতিক্রিয়া চেয়েছিল।

দুটি অ-নেতিবাচক পূর্ণসংখ্যা রয়েছে: i এবং j। নিম্নলিখিত সমীকরণটি দেওয়া হয়ে, i এবং j এর উপরে পুনরাবৃত্তি করার জন্য একটি (অনুকূল) সমাধানটি এমনভাবে সন্ধান করুন যাতে আউটপুটটি সাজানো হয়।

2^i * 5^j

সুতরাং প্রথম কয়েকটি রাউন্ড এটির মতো দেখাবে:

2^0 * 5^0 = 1
2^1 * 5^0 = 2
2^2 * 5^0 = 4
2^0 * 5^1 = 5
2^3 * 5^0 = 8
2^1 * 5^1 = 10
2^4 * 5^0 = 16
2^2 * 5^1 = 20
2^0 * 5^2 = 25

আমার যতটা সম্ভব চেষ্টা করুন, আমি কোনও প্যাটার্ন দেখতে পাচ্ছি না। আপনার চিন্তাগুলো?

algorithm  optimization  hamming-numbers  smooth-numbers 
— ক্রিস ইবারল
সূত্র
63
প্রোগ্রামার সময়ের নিরিখে সর্বোত্তম অ্যালগরিদম হল দুটি নেস্টেড লুপগুলি তৈরি করা, তারপরে বাছাই করা। তারা কেন এমন প্রশ্ন করে?
— টম জাইচ
21
কোন সংখ্যাটি আরও বেশি তা দেখে আপনি রূপান্তর পয়েন্টগুলি নির্ধারণ করতে সক্ষম হতে পারেন। 2^2 < 5তবে 2^3 > 5তাই আপনি জে বৃদ্ধি। আমি মনে করি আপনি O (n) এর পরিবর্তে O (n) এ আউটপুট উত্পাদন করতে পারবেন। @ টম-জিঞ্চ দুটি নেস্টেড লুপগুলি হ'ল ও (এন ^ 2)। এই প্রশ্নটি খুব বৈধ
— মিখাইল
1
কেবলমাত্র একটি আউটপুট রয়েছে, সুতরাং সর্বোত্তম সমাধানটি হ'ল (এন)। নীচে আমার সমাধানটি পড়ুন
— মিখাইল
3
আপাতদৃষ্টিতে এই জাতীয় প্রশ্নের আগেই সম্বোধন করা হয়েছে: স্ট্যাকওভারফ্লো . com / প্রশ্নস / 00046০০০৪০ / nth-ugly-number ।
1
... এবং ওপি সম্ভবত সম্ভবত ইতিমধ্যে একটি উত্তর চয়ন করা উচিত। সর্বোপরি, তিনি ইতিমধ্যে প্রচুর ভাল পেয়েছেন।
— Abeln

উত্তর:

123

ডিজকસ્ત્રা "প্রোগ্রামিংয়ের একটি শৃঙ্খলা" তে একটি সুস্পষ্ট সমাধান পান। তিনি এই সমস্যাটিকে দায়ী করেছেন হামিংয়ের কাছে। এটি আমার ডিজকস্ট্রার সমাধানটির বাস্তবায়ন।

int main()
{
    const int n = 20;       // Generate the first n numbers

    std::vector<int> v(n);
    v[0] = 1;

    int i2 = 0;             // Index for 2
    int i5 = 0;             // Index for 5

    int x2 = 2 * v[i2];     // Next two candidates
    int x5 = 5 * v[i5];

    for (int i = 1; i != n; ++i)
    {
        int m = std::min(x2, x5);
        std::cout << m << " ";
        v[i] = m;

        if (x2 == m)
        {
            ++i2;
            x2 = 2 * v[i2];
        }
        if (x5 == m)
        {
            ++i5;
            x5 = 5 * v[i5];
        }
    }

    std::cout << std::endl;
    return 0;
}
— user515430
সূত্র
18
প্রাসঙ্গিক লিঙ্ক: en.wikedia.org/wiki/Regular_number# অ্যালগোরিদম । আমি মনে করি না এটি উপায় দ্বারা খুব খুব ভাল একটি সাক্ষাত্কার প্রশ্ন। এখানে ডিজকস্ট্রার
— এলিয়ান এবিং
যখন লক্ষ্যটি "i এবং j এর উপর পুনরাবৃত্তি করা হয়" আপনার যখন কম সঞ্চয় ক্ষমতা প্রয়োজন তখন একটি ফিফো যথেষ্ট। আমার পাইথন সমাধান দেখুন।
— গাবার্গুলিয়া
7
যখন লক্ষ্যটি হয় "i এবং j এর উপরে পুনরাবৃত্তি করা", এটি একই সমস্যা নয়।
— মুহুম
সর্বনিম্ন মেমরি ব্যবহার করে এটি একটি দুর্দান্ত বাস্তবায়ন। এটি লিনিয়ার মেমরি এমনকি যদি আপনি কেবল একটি সংখ্যা চান।
— টমাস আহলে
1
@ThomasAhle না যদি তোমাকে দেখেছিলাম জানি না এই কিন্তু এটা শেষ যে একলা n- তম সংখ্যা গণনা করার করতে সক্ষম এ কোড আছে। যেমন একটি বিলিয়নতম সংখ্যা ।
— নেস
47

এখানে এটি করার আরও একটি পরিশোধিত পদ্ধতি রয়েছে (আমার আগের উত্তরের চেয়ে আরও পরিশ্রুত, এটি):

নম্বরগুলি একটি ম্যাট্রিক্সে স্থাপন করা হয়েছে তা কল্পনা করুন:

     0    1    2    3    4    5   -- this is i
----------------------------------------------
0|   1    2    4    8   16   32
1|   5   10   20   40   80  160
2|  25   50  100  200  400  800
3| 125  250  500 1000 2000 ...
4| 625 1250 2500 5000 ...
j on the vertical

আপনাকে যা করতে হবে তা এই ম্যাট্রিক্স থেকে শুরু করে 'হাঁটাচলা' (0,0)। আপনার পরবর্তী পদক্ষেপগুলি কী কী তা আপনাকেও নজর রাখতে হবে। আপনি যখন শুরু করবেন তখন (0,0)কেবল দুটি বিকল্প থাকে: হয় (0,1)বা (1,0): যেহেতু এর মান (0,1)কম হয়, আপনি এটি চয়ন করেন। তারপরে আপনার পরবর্তী পছন্দ (0,2)বা এর জন্য একই করুন (1,0)। এ পর্যন্ত, আপনি নিম্নলিখিত তালিকা আছে: 1, 2, 4। আপনার পরবর্তী পদক্ষেপ (1,0)মান যেহেতু চেয়ে ছোট (0,3)। যাইহোক, আপনি এখন তিন আপনার পরবর্তী পদক্ষেপ জন্য বিকল্পগুলির: হয় (0,3), অথবা (1,1), অথবা (2,0)।

তালিকা পেতে আপনার ম্যাট্রিক্সের দরকার নেই, তবে আপনার নিজের পছন্দগুলি (যেমন আপনি যখন 125+ তে যাবেন তখন আপনার 4 টি পছন্দ থাকবে) ট্র্যাক রাখা দরকার।

— Vlad
সূত্র
আমি এটিকে ভোট দিয়েছি কারণ আমি একই লাইন ধরে ভাবছিলাম, তবে সাধারণ ক্ষেত্রে এটি কি ও (i ^ 2 * j) এর মতো হবে না? আপনার আউটপুট প্রতিটি সংখ্যার জন্য আপনাকে বেশ কয়েকটি সংখ্যা পরীক্ষা করতে হবে।
— টম জাইচ
1
@ টম আপনাকে একাধিক সংখ্যার চেক করতে হবে, তবে এটি খুব খারাপ নয়: আপনি যখন 125 এবং 625 এর মধ্যে সংখ্যাগুলি আউটপুট করেন তখন আপনাকে 4 টি মান দেখতে হবে। 625 এবং 3025 এর মধ্যে আপনি 5 টি মান দেখেন। সুতরাং সত্যই, এটি jপ্রতি 1 আউটপুটের জন্য যাচাই করা হয়
— 21:515
+1: এই প্রশ্নের সাথে একত্রিত করুন: stackoverflow.com/questions/5000836/search-algorithm এবং দেখে মনে হচ্ছে আমাদের ও (এন) সমাধান রয়েছে।
@ মরন ডার্ন, আমি সেই অ্যালগরিদমের জন্য 25 ডলার দিতে চাই না, তবে এটি আকর্ষণীয় দেখাচ্ছে।
— vlad
1
প্রকৃতপক্ষে, j ~ n^0.5অনুক্রমের n-th মানের জন্য, যেহেতু nমানগুলি i x jপ্লেনে কোনও অঞ্চল পূরণ করে । সুতরাং এই আলগো O(n^1.5)সময়, O(n^0.5)স্থান সহ। তবে একই স্থানের সমাপ্তির সাথে একটি রৈখিক সময় আলগো বিদ্যমান রয়েছে n^0.5এবং নীচের উত্তর থেকে মিনি-হিপ অ্যালগো O(n*log(n))একই n^0.5স্থানের সাথে সময় হয় ।
— নেস
25

একটি মিনি-হিপ ব্যবহার করুন।

রাখুন 1।

নিষ্কর্ষ-ন্যূনতম। বলুন আপনি এক্স পাবেন।

2x এবং 5x কে গাদাতে চাপ দিন।

পদ্ধতি পুনরাবৃত্তি করুন।

X = 2 ^ i * 5 ^ j সংরক্ষণ করার পরিবর্তে, আপনি (i, j) সঞ্চয় করতে পারেন এবং একটি কাস্টম তুলনা ফাংশন ব্যবহার করতে পারেন।

1
একটি গাদা তার কাজগুলিতে এলজি এনকে সময় দেয়, যা জটিলতায় এন এলজি এনকে ধাক্কা দেয়।
— কর্সিকা 20
@ গ্লো: হ্যাঁ, আমি এখনও পর্যন্ত কোনও ও (এন) সমাধান পোস্ট করতে দেখছি না, যদিও :-)
@ আবেল: এই মন্তব্যটি পুরানো :-) দেখে মনে হচ্ছে তাঁর (১,১) থেকে (৪,০) থেকেও যেতে সমস্যা হবে। তবে এটিকে অল্প বয়স্কের ম্যাট্রিক্স হিসাবে দেখানো (ভ্লাদ এর উত্তর দেখুন) আসলে একটি ও (এন) সময়ের অ্যালগরিদমকে অনুমতি দেয়।
@ মরন: আমি মনে করি না যে সমাধানে কোনও সমস্যা আছে। অবশ্যই প্রথম 30 টি উপাদানগুলির মধ্যে কোনও ভুল নেই, যা আমি এখনই পরীক্ষা করেছি (এটি (1,1) -> (4,0) কেসটি কভার করবে)।
— 22.35 এ Abeln
@ আবেল: হ্যাঁ আসলে এটি চালানোর চেষ্টা করেনি :-) সম্ভবত এর সঠিকতারও সহজ প্রমাণ রয়েছে। FWIW, এটি ইতিমধ্যে আমার +1 আছে।
13

একটি ফিফো-ভিত্তিক সমাধানের জন্য কম সঞ্চয় ক্ষমতা থাকা দরকার। পাইথন কোড।

F = [[1, 0, 0]]             # FIFO [value, i, j]
i2 = -1; n2 = n5 = None     # indices, nexts
for i in range(1000):       # print the first 1000
    last = F[-1][:]
    print "%3d. %21d = 2^%d * 5^%d" % tuple([i] + last)
    if n2 <= last: i2 += 1; n2 = F[i2][:]; n2[0] *= 2; n2[1] += 1
    if n5 <= last: i2 -= 1; n5 = F.pop(0); n5[0] *= 5; n5[2] += 1
    F.append(min(n2, n5))

আউটপুট:

  0.                     1 = 2^0 * 5^0
  1.                     2 = 2^1 * 5^0
  2.                     4 = 2^2 * 5^0
 ...
998. 100000000000000000000 = 2^20 * 5^20
999. 102400000000000000000 = 2^27 * 5^17
— GaBorgulya
সূত্র
6

O(n)ক্রিয়ামূলক ভাষায় এটি করা খুব সহজ । তালিকা lএর 2^i*5^jনম্বর কেবল হিসাবে সংজ্ঞায়িত করা যেতে পারে 1এবং তারপর 2*lএবং 5*lমার্জ হয়েছে। এটি হাস্কেল-এ কেমন দেখাচ্ছে:

merge :: [Integer] -> [Integer] -> [Integer]
merge (a:as) (b:bs)   
  | a < b   = a : (merge as (b:bs))
  | a == b  = a : (merge as bs)
  | b > a   = b : (merge (a:as) bs)

xs :: [Integer]
xs = 1 : merge (map(2*)xs) (map(5*)xs)

mergeফাংশন আপনি ধ্রুবক সময় একটি নতুন মান দেয়। সুতরাং mapএবং তাই তাই না l।

— টমাস আহলে
সূত্র
আমি মনে করি যে 'কে' সংজ্ঞায়িত হয়নি
— ইথার
2
এর পরিবর্তে কেবল এই "মার্জ" ফাংশনটিকে কল unionকরুন, কারণ এটি সদৃশগুলি সরিয়ে দিচ্ছে। mergeএর অংশ হিসাবে mergesortঅবশ্যই এর উভয় ইনপুট ক্রম থেকে আসা নকলগুলি সংরক্ষণ করতে হবে। Data.List.Orderedসম্পর্কিত স্টাফ জন্য প্যাকেজ দেখুন ।
— নেস
1
+1 এর জন্য Data.List.Ordered.union। এটি এটিকে এক লাইন তৈরি করে:xs = 1 : union (map (2*) xs) (map (5*) xs)
— ফোব
@ গাবার্গুলিয়া হ্যাঁ, এটি তালিকার পাঁচগুণ অন্তর্ভুক্ত করে [1, 2, 4, 5,...]তাই এতে অন্তর্ভুক্ত রয়েছে 5*4।
— থমাস আহলে
1
@ ফোব হ্যাঁ, এটি Data.List.Ordered.unionফাংশন। বিভ্রান্ত হতে হবে না Data.List.union।
— থমাস আহলে
5

আপনাকে তাদের পৃথক অভিযোজক এবং তাদের পরিমাণগুলি কী হবে তা ট্র্যাক করে রাখতে হবে

সুতরাং আপনি f(0,0) --> 1 এখনই শুরু করুন তাদের মধ্যে একটি বৃদ্ধি করতে হবে:

f(1,0) = 2
f(0,1) = 5

সুতরাং আমরা জানি যে পরেরটি 2 - আমরা আরও জানি যে আমরা যোগফলকে বাড়িয়ে দিতে পারি যতক্ষণ না যোগফল 5 ছাড়িয়ে যায়।

আপনি যখন আপনার ডিজেড সংখ্যার রাউন্ডে না পৌঁছেছেন ততক্ষণ আপনি এভাবে পিছনে পিছনে যেতে থাকবেন।

— corsiKa
সূত্র
হ্যাঁ তাই হয়। আপনি প্রতিটি রাউন্ডের জন্য একটি ও (1) অপারেশন করেন। কখনও কখনও আপনি রাউন্ডটি প্রথম দিকে করেন তবে আপনি যখন এই রাউন্ডে পৌঁছবেন তখন আপনাকে এটি করতে হবে না, তাই এটি নিজেই কাজ করে।
— কর্সিকা
19
আপনি কীভাবে (1,1) থেকে (4,0) যান? দয়া করে আপনার অ্যালগোরিদম কী তা ব্যাখ্যা করুন।
সমস্যাটি হ'ল, আপনার কেবলমাত্র দুটি বর্ধনশীল সম্ভাবনা নেই - যেমন, আপনি f(*,2)কেবল এটি পেয়েছেন তাই আপনি এটি করেননি f(a1,b+1)>f(a2,b)। একটি বর্ধিত পদ্ধতির অবশেষে আপনি ইতিমধ্যে আউটপুট তৈরি করেছেন এমন অঞ্চলের প্রতিবেশী একটি সীমাহীন সংখ্যক জোড়া তৈরি করবে।
— আগত ঝড়
@ user515430 এমন একটি বাস্তবায়ন সরবরাহ করেছে যা আমার মধ্যাহ্নভোজনে যা করতে পারে তার চেয়ে বেশি ছিল তবে আমি যা পেতে চেষ্টা করছিলাম।
— corsiKa
4

গতিশীল প্রোগ্রামিং ব্যবহার করে আপনি ও (এন) এ এটি করতে পারেন। মূল সত্যটি হ'ল i এবং j এর কোনও মান আমাদের 0 দিতে পারে না এবং 1 পেতে উভয় মান 0 হতে হবে;

TwoCount[1] = 0
FiveCount[1] = 0

// function returns two values i, and j
FindIJ(x) {
    if (TwoCount[x / 2]) {
        i = TwoCount[x / 2] + 1
        j = FiveCount[x / 2]
    }
    else if (FiveCount[x / 5]) {
        i = TwoCount[x / 2]
        j = FiveCount[x / 5] + 1
    }
}

যখনই আপনি এই ফাংশনটি কল করবেন আমি এবং জে সেট করা আছে কিনা তা চেক করুন, সেগুলি শূন্য না হলে পপুলেট করুন TwoCountএবংFiveCount

সি ++ উত্তর। খারাপ কোডিং স্টাইলের জন্য দুঃখিত, তবে আমি তাড়াহুড়ো করছি :(

#include <cstdlib>
#include <iostream>
#include <vector>

int * TwoCount;
int * FiveCount;

using namespace std;

void FindIJ(int x, int &i, int &j) {
        if (x % 2 == 0 && TwoCount[x / 2] > -1) {
                cout << "There's a solution for " << (x/2) << endl;
                i = TwoCount[x / 2] + 1;
                j = FiveCount[x / 2];
        } else if (x % 5 == 0 && TwoCount[x / 5] > -1) {
                cout << "There's a solution for " << (x/5) << endl;
                i = TwoCount[x / 5];
                j = FiveCount[x / 5] + 1;
        }    
}

int main() {
        TwoCount = new int[200];
        FiveCount = new int[200];

        for (int i = 0; i < 200; ++i) {
                TwoCount[i] = -1;
                FiveCount[i] = -1;
        }

        TwoCount[1] = 0;
        FiveCount[1] = 0;

        for (int output = 2; output < 100; output++) {
                int i = -1;
                int j = -1;
                FindIJ(output, i, j);
                if (i > -1 && j > -1) {
                        cout << "2^" << i << " * " << "5^" 
                                     << j << " = " << output << endl;
                        TwoCount[output] = i;
                        FiveCount[output] = j;
                }
        }    
}

স্পষ্টতই আপনি আপনার স্টোরেজকে গতিশীলভাবে বাড়ানোর জন্য অ্যারে ব্যতীত ডেটা স্ট্রাকচারগুলি ব্যবহার করতে পারেন ইত্যাদি এটি প্রমাণিত করার জন্য এটি কেবল একটি স্কেচ।

— মিখাইল
সূত্র
4
এটি একটি আকর্ষণীয় উত্তরের মতো দেখায় তবে এটি কীভাবে কার্যকর হয় তা দেখতে আমি ব্যর্থ। আপনি আরও বিশদ যুক্ত করতে পারেন?
— ডেভিড ব্রুনেল
এটি নিজেই অধ্যয়ন করার পরে, আমি সত্যিই এটি কীভাবে কাজ করে তা দেখতে পাচ্ছি না। পূর্ণসংখ্যা বিভাগ ধরে নিলে, এটি 2 হিসাবে 3 হিসাবে ঠিক একই ফলাফল দেবে Moreover এছাড়াও, যদি শর্তগুলি অ শূন্যের জন্য পরীক্ষা করা হয় তবে এটি কখনই কার্যকর হবে না, কারণ কোনও শূন্য নথি নেই।
— ডেভিড থর্নলি
আপনারা নয় জন কথার জন্য একটি সি ++ সংস্করণ পোস্ট করেছেন। @ ডেভিড আপনার মন্তব্যগুলি সঠিক, তবে আমার মূল কোডটি সিউডো কোড ছিল এবং আমি স্ক্রিপ্টিং শর্তাদি নিয়ে ভাবছিলাম, সুতরাং পূর্ণসংখ্যার বিভাজন নয় এবং শূন্য 0 এর প্রবেশের মধ্যে পার্থক্য 0
— মিখাইল
এই কোড "আলাবামা মধ্যে Lost" দ্বারা উত্তর সব স্বাভাবিক সংখ্যার উল্লেখ, তাই, @ThomasAhle মন্তব্য প্রতি নীচে এটা লাগে O(exp(sqrt(n))), উত্পাদন করতে nক্রম সংখ্যা। লিনিয়ার অ্যালগরিদম বিদ্যমান, যেমন টমাসএহলে প্রদত্ত।
— নেস
1
তুমি ঠিক বলছো. আমার বোঝার O(n)অর্থ nহ'ল শেষ মান হওয়া, মুদ্রিত আইটেমের সংখ্যা নয় যা সঠিক নয়। আমি জানি না কীভাবে ক্রিয়ামূলক ভাষাগুলি কাজ করে, বা কীভাবে স্থির সময়ে একীভূত হয়ে কাজ করে, তবে তার উত্তরটি আমার উত্সাহ পেয়েছে
— মিখাইল
2

এটিকে অন্য দিক থেকে দেখার চেষ্টা কেন করবেন না। আসল সূত্রের বিপরীতে সম্ভাব্য উত্তরগুলি পরীক্ষা করতে একটি কাউন্টার ব্যবহার করুন। ছদ্ম কোডের জন্য দুঃখিত।

for x = 1 to n
{
  i=j=0
  y=x
  while ( y > 1 )
  {
    z=y
    if y divisible by 2 then increment i and divide y by 2
    if y divisible by 5 then increment j and divide y by 5

    if y=1 then print i,j & x  // done calculating for this x

    if z=y then exit while loop  // didn't divide anything this loop and this x is no good 
  }
}
— আলাবামায় হারিয়েছেন
সূত্র
এটি প্রায় চলমান O(4^sqrt(n))কারণ nthক্রম সংখ্যাটি প্রায় আকারের।
— থমাস আহলে
2

এটি ওইআইএসের প্রাসঙ্গিক এন্ট্রি।

প্রথম কয়েকটি পদ তৈরি করে অর্ডার করা ক্রমটি পাওয়া সম্ভব বলে মনে হচ্ছে, বলুন

1 2 4 5

এবং তারপরে, দ্বিতীয় টার্ম থেকে শুরু করে, পরবর্তী দুটি পেতে 4 এবং 5 দিয়ে গুণ করুন

1 2 4 5 8 10

1 2 4 5 8 10 16 20

1 2 4 5 8 10 16 20 25

এবং তাই ...

স্বজ্ঞাতভাবে, এটি সঠিক বলে মনে হচ্ছে, তবে অবশ্যই একটি প্রমাণ অনুপস্থিত।

— abeln
সূত্র
2
ভুল :( [1 2 4 5 8 10 16 20 25 32 40 50 64 80 100 125 128 160 200 250 256 320 400 500 625 ] তবে 500 <512 = 2 ^ 9 < 625 .
— গাবোরগুলিয়া
1
@ নাটকেরখফস, 512 উত্পন্ন হয়েছে তবে এটি কার্যকর নয় কারণ ইতিমধ্যে উত্পন্ন 625 এর চেয়ে 512 কম; আউটপুটটিকে যথাযথভাবে সাজানোর জন্য অ্যালগরিদমের আরও যুক্তি প্রয়োজন - সুতরাং আলগোরিদম প্রস্তাবিত হিসাবে এতটা সহজ নয় এবং একসাথে একই অ্যালগরিদমও নয়।
— গর্ডনবিগুড
1

আপনি জানেন যে লগ_2 (5) = 2.32। এটি থেকে আমরা দ্রষ্টব্য যে 2 ^ 2 <5 এবং 2 ^ 3> 5।

এখন সম্ভাব্য উত্তরের একটি ম্যাট্রিক্স দেখুন:

j/i  0   1   2   3   4   5
 0   1   2   4   8  16  32
 1   5  10  20  40  80 160 
 2  25  50 100 200 400 800
 3 125 250 500 ...

এখন, এই উদাহরণের জন্য, ক্রম সংখ্যা নির্বাচন করুন। অর্ডার দেওয়া হবে:

j/i  0   1   2   3   4   5
 0   1   2   3   5   7  10
 1   4   6   8  11  14  18
 2   9  12  15  19  23  27
 3  16  20  24...

নোট করুন যে প্রতিটি সারিটি শুরু করে সারির পিছনে 2 টি কলাম শুরু করে। উদাহরণস্বরূপ, i = 0 j = 1 সরাসরি আই = 2 জ = 0 পরে আসে।

একটি অ্যালগরিদম আমরা এই প্যাটার্নটি থেকে পেতে পারি তাই এটি হ'ল (ধরুন জে> আই):

int i = 2;
int j = 5;
int k;
int m;

int space = (int)(log((float)j)/log((float)i));
for(k = 0; k < space*10; k++)
{
    for(m = 0; m < 10; m++)
    {
        int newi = k-space*m;
        if(newi < 0)
            break;
        else if(newi > 10)
            continue;
        int result = pow((float)i,newi) * pow((float)j,m);
        printf("%d^%d * %d^%d = %d\n", i, newi, j, m, result);
    }
}

দ্রষ্টব্য: এখানে কোডটি i এবং j এর বহনকারীদের মানকে 10 এর চেয়ে কম হতে পারে You

দ্রষ্টব্য: এই অ্যালগরিদমের চলমান সময়টি প্রথম এন উত্তরগুলির জন্য ও (এন)।

দ্রষ্টব্য: এই অ্যালগরিদমের জন্য স্থান জটিলতা হ'ল হে (1)

— KLee1
সূত্র
আপনি লিখেছেন "প্রতিটি সারিতে সারিটির পিছনে 2 টি কলাম শুরু হয়"। তবে 2 ^ 9 = 512 এবং 5 ^ 4 = 625, সুতরাং এটি সারি 4
— র ক্ষেত্রে
@ user678105 আপনি ঠিক বলেছেন। এই কোডটি কাজ করে না। সবাই দুঃখিত। এই কোডটি লগ বন্ধ করে দেওয়ার কারণে এবং আমার ধারণা থেকে কোনও লাভ হয় নি বলে কাজ করে না।
— KLee1
1
আপনি কিভাবে এটি ঠিক করেন তা এখানে। অবিচ্ছেদ্য সহগগুলির সাথে পয়েন্ট পূর্ণ পূর্ণ (x, y) সমতলে, (0,1) থেকে (লগ 2 (5), 0) এ একটি লাইন আঁকুন। (0,0) শীর্ষ বাম কোণে রয়েছে। এক্স অক্ষটি ডানদিকে যায়, ওয়াই অক্ষটি নীচে যায়। এখন (0,0) মূল বিন্দু থেকে একটি লাইন আঁকুন যা 1 ম লাইনের লম্ব হয়। এখন প্রথম লাইনটি দ্বিতীয়টি বরাবর স্লাইড করুন, উত্স থেকে আরও এবং আরও দূরে এবং পূর্ণসংখ্যা-স্থানাঙ্ক পয়েন্টগুলি পার হয়ে যাওয়ার সাথে সাথে সংগ্রহ করুন। 3 2,3,5 ge-জেনারেটেড সিকোয়েন্সের জন্য, এটি (i, j, k) স্পেসে, একটি বিমান হবে across আপনি যদি এই ধারণাটি কোডে অনুবাদ করতে পারেন তবে আমাকে চিত্কার করুন। :)
— নেস
1

আমার বাস্তবায়ন নিম্নলিখিত ধারণার উপর ভিত্তি করে:

  • দুটি কিউ 2 এবং কিউ 5 ব্যবহার করুন, উভয়ই 1 দিয়ে শুরু করা হয়েছে We আমরা উভয় সারি সাজিয়ে রেখেছি।
  • প্রতিটি পদক্ষেপে, Q2 বা Q5 থেকে ক্ষুদ্রতম সংখ্যার উপাদান MIN সন্ধান করুন এবং এটি মুদ্রণ করুন। যদি Q2 এবং Q5 উভয়ের মধ্যে একই উপাদান থাকে - উভয়কে সরিয়ে দিন। এই নম্বরটি মুদ্রণ করুন। এটি মূলত দুটি বাছাই করা অ্যারে মার্জ করা হয় - প্রতিটি পদক্ষেপে ক্ষুদ্রতম উপাদান এবং অগ্রিমটি বেছে নিন।
  • এমআইএন * 2 থেকে কিউ 2 এবং এমআইএন * 5 থেকে কিউ 5 করুন। এই পরিবর্তনটি বাছাই করা Q2 / Q5 এর আক্রমণকারীকে ভাঙবে না, কারণ এমআইএন পূর্ববর্তী এমআইএন সংখ্যার চেয়ে বেশি higher

উদাহরণ:

Start with 1 and 1 (to handle i=0;j=0 case):
  Q2: 1
  Q5: 1
Dequeue 1, print it and enqueue 1*2 and 1*5:
  Q2: 2
  Q5: 5
Pick 2 and add 2*2 and 2*5:
  Q2: 4
  Q5: 5 10
Pick 4 and add 4*2 and 4*5:
  Q2: 8
  Q5: 5 10 20
....

জাভা কোড:

public void printNumbers(int n) {
    Queue<Integer> q2 = new LinkedList<Integer>();
    Queue<Integer> q5 = new LinkedList<Integer>();
    q2.add(1);
    q5.add(1);
    for (int i = 0; i < n; i++) {
        int a = q2.peek();
        int b = q5.peek();
        int min = Math.min(a, b);
        System.out.println(min);
        if (min == a) {
            q2.remove();
        }
        if (min == b) {
            q5.remove();
        }
        q2.add(min * 2);
        q5.add(min * 5);
    }
}
— ejboy
সূত্র
0

ফলাফল নিরূপণ এবং তাদের মান সঙ্গে একসঙ্গে একটি অনুসারে সাজানো তালিকা রাখা, iএবংj

— Vlad
সূত্র
এটি সম্ভবত আপনাকে আপনার ক্রমের শেষ প্রান্তে গর্ত দেবে। উদাহরণস্বরূপ, আপনার কাছে 2^n*5^nতবে 2^(n+1)*5^(n-1)ছোটটি নয়।
— টমাস আহলে
@ থমাস আমি নিশ্চিত নই যে আমি এখানে আপনার যুক্তি অনুসরণ করি। আপনি যদি একজনকে গণনা করেন তবে আপনি অন্যটিকে কেন গণনা করবেন না?
— ভ্লাদ
2
@vlad আপনার নিজের iএবং এর সীমাবদ্ধতা থাকা দরকার j, তাই না? অন্যথায় আপনি বাছাই অবস্থায় কখনও পাবেন না এবং তাই আপনি কোনও একক মান কখনই ফিরিয়ে আনবেন না। তবে nআপনি যে কোনও সীমা বেছে নেন তার জন্য আপনার তালিকাটি ত্রুটিযুক্ত হবে।
— থমাস আহলে
@ থমাস আপনার যুক্তিটি এখনও বোঝায় না। ওপি কখনই তার ফলাফলের তালিকার একটি শেষ নির্দিষ্ট করে নি। তিনি যদি করেন তবে আপনি সর্বাধিক iএবং খুঁজে পেতে পারেন j।
— ভ্লাদ
1
@ ভ্লাদ আমি আপনার উত্তরটি পড়ার সাথে সাথে আপনি প্রথমে "ফলাফল" / 2^i*5^jমানগুলি গণনা করুন এবং তারপরে সেগুলি সাজান। আপনার যদি সীমিত সংখ্যক "ফলাফল" না থাকে তবে আপনি কীভাবে বাছাইয়ের ধাপে উঠবেন?
— থমাস আহলে
0

এডজার ডিজকস্ট্রা (http://www.cs.utexas.edu/users/EWD/ewd07xx/EWD792.PDF) দ্বারা ব্যবহারকরা 1515430 দ্বারা প্রয়োগ করা অ্যালগরিদম সম্ভবত আপনি যত তাড়াতাড়ি পেতে পারেন। আমি প্রতিটি নম্বরকে 2^i * 5^j"বিশেষ নম্বর" এর একটি ফর্ম বলে কল করি । এখন ভ্ল্যাডসের উত্তরটি O(i*j)কেবল একটি দ্বিগুণ অ্যালগরিদম সহ থাকবে, একটি বিশেষ সংখ্যা উত্পন্ন করতে O(i*j)এবং একটি তাদের বাছাই করার জন্য (লিঙ্কযুক্ত নিবন্ধ অনুযায়ীও) O(i*j)।

তবে আসুন ডিজকস্ট্রার অ্যালগরিদমটি দেখুন (নীচে দেখুন)। এই ক্ষেত্রে nআমরা যে বিশেষ সংখ্যার উত্পন্ন করছি তার পরিমাণ হ'ল সমান i*j। আমরা একবার লুপিং করছি 1 -> nএবং প্রতিটি লুপে আমরা একটি ধ্রুবক ক্রিয়া করি। সুতরাং এই অ্যালগরিদম হয় O(i*j)। এবং একটি চমত্কার জ্বলন্ত দ্রুত ধ্রুবক সঙ্গে।

জিএমপি (সি ++ মোড়ক) দিয়ে সি ++ এ আমার বাস্তবায়ন, এবং এর উপর নির্ভরতা boost::lexical_castযদিও সহজেই মুছে ফেলা যায় (আমি অলস, এবং কে বুস্ট ব্যবহার করে না?)। সঙ্গে সংকলিত g++ -O3 test.cpp -lgmpxx -o test। কিউ 6600 উবুন্টু 10.10 এ time ./test 1000000দেয় 1145ms।

#include <iostream>
#include <boost/lexical_cast.hpp>
#include <gmpxx.h>

int main(int argc, char *argv[]) {
    mpz_class m, x2, x5, *array, r;
    long n, i, i2, i5;

    if (argc < 2) return 1;

    n = boost::lexical_cast<long>(argv[1]);

    array = new mpz_class[n];
    array[0] = 1;

    x2 = 2;
    x5 = 5;
    i2 = i5 = 0;

    for (i = 1; i != n; ++i) {
        m = std::min(x2, x5);

        array[i] = m;

        if (x2 == m) {
            ++i2;
            x2 = 2 * array[i2];
        }

        if (x5 == m) {
            ++i5;
            x5 = 5 * array[i5];
        }
    }

    delete [] array;
    std::cout << m << std::endl;

    return 0;
}
— orlp
সূত্র
0

আপনি যদি কলাম হিসাবে সারি এবং j হিসাবে i সহ একটি ম্যাট্রিক্স আঁকেন তবে আপনি প্যাটার্নটি দেখতে পারেন। I = 0 দিয়ে শুরু করুন এবং তারপরে ম্যাট্রিক্সের শীর্ষে না পৌঁছানো পর্যন্ত 2 সারি এবং ডান 1 কলামের উপরে গিয়ে ম্যাট্রিক্সটি অতিক্রম করুন j তারপরে আই +1 ইত্যাদি যান ...

সুতরাং আমি = 7 এর জন্য আপনি এইভাবে ভ্রমণ করেন:

7, 0 -> 5, 1 -> 3, 2 -> 1, 3

এবং আমি = 8 এর জন্য:

8, 0 -> 6, 1 -> 4, 2 -> 2, 3 -> 0, 4

এটি জাভাতে i = 9. পর্যন্ত চলেছে এটি ম্যাট্রিক্স অবস্থান (i, j) এবং মানটি মুদ্রণ করে।

for(int k = 0; k < 10; k++) {

    int j = 0;

    for(int i = k; i >= 0; i -= 2) {

        int value = (int)(Math.pow(2, i) * Math.pow(5, j));
        System.out.println(i + ", " + j + " -> " + value);
        j++;
    }
}
— ছোটো ঘেরা
সূত্র
0

আমার অন্তর্দৃষ্টি :

যদি আমি প্রাথমিক মান 1 হিসাবে গ্রহণ করি যেখানে i = 0, j = 0 হয় তবে আমি পরবর্তী সংখ্যাগুলি (2 ^ 1) (5 ^ 0), (2 ^ 2) (5 ^ 0), (2 ^ 0) হিসাবে তৈরি করতে পারি * (5 ^ 1), ... অর্থাৎ 2,4,5 ..

যেকোনও মুহুর্তে আমার নম্বরটি x বলে দিন। তারপরে আমি নিম্নলিখিত উপায়ে পরবর্তী সংখ্যাগুলি তৈরি করতে পারি:

  • x * 2
  • এক্স * 4
  • এক্স * 5

ব্যাখ্যা :

Since new numbers can only be the product with 2 or 5.
But 4 (pow(2,2)) is smaller than 5, and also we have to generate 
Numbers in sorted order.Therefore we will consider next numbers
be multiplied with 2,4,5.
Why we have taken x*4 ? Reason is to pace up i, such that it should not 
be greater than pace of j(which is 5 to power). It means I will 
multiply my number by 2, then by 4(since 4 < 5), and then by 5 
to get the next three numbers in sorted order.

টেস্ট রান

We need to take an Array-list of Integers, let say Arr.

Also put our elements in Array List<Integers> Arr.
Initially it contains Arr : [1]

  • এক্স = 1 দিয়ে শুরু করা যাক।

    পরবর্তী তিনটি সংখ্যা হল 1 * 2, 1 * 4, 1 * 5 [২,৪,৫]; আগমন [1,2,4,5]

  • এখন x = 2

    পরবর্তী তিনটি সংখ্যা [4,8,10] already যেহেতু 4 টি ইতিমধ্যে ঘটেছে আমরা এটিকে এড়িয়ে যাব} [8,10]; আগমন [1,2,4,5,8,10]

  • এখন x = 4

    পরবর্তী তিনটি সংখ্যা [৮,১,,২০] already 8 ইতিমধ্যে ঘটেছে এটিকে উপেক্ষা করুন 16 [16,20] অ্যার [1,2,4,5,8,10,16,20]

  • x = 5

    পরের তিনটি সংখ্যা [10,20,25] {10,20} ইতিমধ্যে [25] যুক্ত হয়েছে আরর [1,2,4,5,8,10,16,20,25]

সমাপ্তির শর্ত

 Terminating condition when Arr last number becomes greater 
 than (5^m1 * 2^m2), where m1,m2 are given by user.

বিশ্লেষণ

 Time Complexity : O(K) : where k is numbers possible between i,j=0 to 
 i=m1,j=m2.
 Space Complexity : O(K)
— bharatj
সূত্র
0

শুধু কৌতূহল ছিল পরবর্তী সপ্তাহে কী প্রত্যাশা করবেন এবং এই প্রশ্নটি পেয়েছেন।

আমি মনে করি, ধারণাটি 2 ^ আমি 5 ^ j এর মতো বড় পদক্ষেপগুলিতে বৃদ্ধি পাই না। পরের জে-স্টেপটি যত বড় হবে না ততক্ষণ আমি বাড়ান।

সি ++ এর উদাহরণ (Qt optionচ্ছিক):

QFile f("out.txt"); //use output method of your choice here
f.open(QIODevice::WriteOnly);
QTextStream ts(&f);

int i=0;
int res=0;
for( int j=0; j<10; ++j )
{
    int powI = std::pow(2.0,i );
    int powJ = std::pow(5.0,j );
    while ( powI <= powJ  ) 
    {
        res = powI * powJ;
        if ( res<0 ) 
            break; //integer range overflow

        ts<<i<<"\t"<<j<<"\t"<<res<<"\n";
        ++i;
        powI = std::pow(2.0,i );

    }
}

আউটপুট:

i   j   2^i * 5^j
0   0   1
1   1   10
2   1   20
3   2   200
4   2   400
5   3   4000
6   3   8000
7   4   80000
8   4   160000
9   4   320000
10  5   3200000
11  5   6400000
12  6   64000000
13  6   128000000
14  7   1280000000
— ভ্যালেনটিন হেইনিৎজ
সূত্র
এই সমাধানটি কিছু সংমিশ্রণ মিস করে। উদাহরণস্বরূপ, এটি i = 1, j = 2 যে কোনও ক্ষেত্রে i = 1 এবং j> 1 যে ক্ষেত্রে সে ক্ষেত্রে পরীক্ষা করে না ..
— ফেডেরিকো
@ ফেডেরিকো: আপনি ঠিক বলেছেন! অবাক হওয়ার কারণ নেই কেন আমি গুগল-সাক্ষাত্কারগুলিতে 6 বছরের ব্যবধানের সাথে দুবার ব্যর্থ হয়েছি কিন্তু প্রায় একই প্রশ্ন :-)
— ভ্যালেন্টিন হেইনিটজ
0

এখানে আমার সমাধান

#include <stdio.h>
#include <math.h>
#define N_VALUE 5
#define M_VALUE  5

int n_val_at_m_level[M_VALUE];

int print_lower_level_val(long double val_of_higher_level, int m_level)
{
int  n;
long double my_val;


for( n = n_val_at_m_level[m_level]; n <= N_VALUE; n++) {
    my_val =  powl(2,n) * powl(5,m_level);
    if(m_level != M_VALUE && my_val > val_of_higher_level) {
        n_val_at_m_level[m_level] = n;
        return 0;
    }
    if( m_level != 0) {
        print_lower_level_val(my_val, m_level - 1);
    }
    if(my_val < val_of_higher_level || m_level == M_VALUE) {
        printf("    %Lf n=%d m = %d\n", my_val, n, m_level);
    } else {
        n_val_at_m_level[m_level] = n;
        return 0;
    }
 }
 n_val_at_m_level[m_level] = n;
 return 0;
 }


 main()
 {
    print_lower_level_val(0, M_VALUE); /* to sort 2^n * 5^m */
 }

ফলাফল :

1.000000 n = 0 m = 0
2.000000 n = 1 m = 0
4.000000 n = 2 m = 0
5.000000 n = 0 m = 1
8.000000 n = 3 m = 0
10.000000 n = 1 m = 1
16.000000 n = 4 m = 0
20.000000 n = 2 m = 1
25.000000 n = 0 m = 2
32.000000 n = 5 m = 0
40.000000 n = 3 m = 1
50.000000 n = 1 m = 2
80.000000 n = 4 m = 1
100.000000 n = 2 m = 2
125.000000 n = 0 m = 3
160.000000 n = 5 m = 1
200.000000 n = 3 m = 2
250.000000 n = 1 m = 3
400.000000 n = 4 m = 2
500.000000 n = 2 m = 3
625.000000 n = 0 m = 4
800.000000 n = 5 m = 2
1000.000000 n = 3 m = 3
1250.000000 n = 1 m = 4
2000.000000 n = 4 m = 3
2500.000000 n = 2 m = 4
3125.000000 n = 0 m = 5
4000.000000 n = 5 m = 3
5000.000000 n = 3 m = 4
6250.000000 n = 1 m = 5
10000.000000 n = 4 m = 4
12500.000000 n = 2 m = 5
20000.000000 n = 5 m = 4
25000.000000 n = 3 m = 5
50000.000000 n = 4 m = 5
100000.000000 n = 5 m = 5
— dhanasubbu
সূত্র
0

আমি জানি আমি সম্ভবত ভুল হতে পারি তবে এখানে একটি খুব সাধারণ উপাচার্য রয়েছে কারণ এটিতে 2,3,5 এর মতো অনেক সংখ্যক জড়িত না। আমরা জানি যে যে কোনও আই, জে 2 ^ আই * 5 ^ জে পরবর্তী অনুক্রম 2 ^ (আই -2) * 5 ^ (জে + 1) হবে। গুগল কিউ হওয়ায় এটির একটি সহজ সমাধান থাকতে হবে। 

def func(i, j):
 print i, j, (2**i)*(5**j)

imax=i=2
j=0
print "i", "j", "(2**i)*(5**j)"

for k in range(20):
    func(i,j)
    j=j+1; i=i-2
    if(i<0):
        i = imax = imax+1
        j=0

এটি আউটপুট উত্পাদন করে:

i j (2**i)*(5**j)
2 0 4
0 1 5
3 0 8
1 1 10
4 0 16
2 1 20
0 2 25
5 0 32
3 1 40
1 2 50
6 0 64
4 1 80
2 2 100
0 3 125
7 0 128
5 1 160
3 2 200
1 3 250
8 0 256
6 1 320
— d1val
সূত্র
এটি 20 বা 200 অবধি কার্যকর হতে পারে তবে কিছু সময়ে এটি কিছু নম্বর এড়িয়ে চলতে শুরু করবে এবং / অথবা এগুলি ভুল ক্রমে আউটপুট দেয়।
— নেস
0

আমরা যখন এক্সপ্রেশনটিতে i বা j বৃদ্ধি করি তখন সত্যিই কী হয় তা যদি আপনি যান তবে আপনি 2^i * 5^jহয় অন্য 2 বা অন্য 5 দ্বারা গুণাচ্ছেন we যদি আমরা সমস্যাটি পুনরায় সেট করি - i এবং j এর একটি নির্দিষ্ট মান দেওয়া হয় তবে আপনি পরবর্তীটি কীভাবে খুঁজে পাবেন? বৃহত্তর মান, সমাধান স্পষ্ট হয়।

এখানে আমরা নিয়মগুলি বেশ স্বজ্ঞাতভাবে গণনা করতে পারি:

  • যদি i > 1এক্সপ্রেশনটিতে 2s ( ) এর জুড়ি থাকে তবে পরবর্তী বৃহত্তম নম্বর পেতে আমাদের তাদের 5 দিয়ে প্রতিস্থাপন করা উচিত। এইভাবে, i -= 2এবং j += 1।
  • অন্যথায়, যদি 5 ( j > 0) থাকে তবে আমাদের এটি তিনটি 2 দিয়ে প্রতিস্থাপন করতে হবে। তাই j -= 1এবং i += 3।
  • অন্যথায়, আমাদের সর্বনিম্ন মূল্য বাড়ানোর জন্য কেবল আরও 2 সরবরাহ করতে হবে। i += 1।

এখানে রুবিতে প্রোগ্রামটি দেওয়া হচ্ছে:

i = j = 0                                                                       
20.times do                                                                     
  puts 2**i * 5**j

  if i > 1                                                                      
    j += 1                                                                      
    i -= 2                                                                      
  elsif j > 0                                                                   
    j -= 1                                                                      
    i += 3                                                                      
  else                                                                          
    i += 1                                                                      
  end                                                                                                                                                               
end
— slowpoison
সূত্র
এটি 'i' কখনই 4-র চেয়ে বড় হয় না, তাই 32 (2 ^ 5) এর গুণক কখনই উপস্থিত হবে না।
— থ্রিপ্লসোন
0

যদি আমাদের জাভা সংগ্রহ ব্যবহার করার অনুমতি দেওয়া হয় তবে আমাদের কাছে এই সংখ্যাটি ও (N ^ 2) এ থাকতে পারে

public static void main(String[] args) throws Exception {
    int powerLimit = 7;  
     int first = 2;
     int second = 5;
    SortedSet<Integer> set = new TreeSet<Integer>();

    for (int i = 0; i < powerLimit; i++) {
        for (int j = 0; j < powerLimit; j++) {
            Integer x = (int) (Math.pow(first, i) * Math.pow(second, j));
            set.add(x);
        }
    }

    set=set.headSet((int)Math.pow(first, powerLimit));

    for (int p : set)
        System.out.println(p);
}

এখানে পাওয়ারলিমেটটি খুব সাবধানে ইনিশিয়েল করতে হবে !! আপনি কত নম্বর চান তার উপর নির্ভর করে।

— কবি তেমরে
সূত্র
এটি ভুল ফলাফল দেয়: 2 ^ 6 * 5 = 320 এর আগে 2 ^ 8 = 256 অনুপস্থিত। গণনা অঞ্চলটি ত্রিভুজাকার, আয়তক্ষেত্রাকার নয়।
— নেস
@ উইলনেস কিভাবে ?? যখন আমি পাওয়ারলিমিট = 9 সেট করছি, এই স্নিপেটটি 1 2 4 5 8 10 16 20 25 32 40 50 64 80 100 125 128 160 200 250 256 320 400 500
— kavi temre
না, এটি 100 সংখ্যা উত্পাদন করে। আপনি কোথায় থামবেন জানেন? আপনার অবশ্যই এটি ব্যাখ্যা করতে হবে। --- আমি আপনার কোড স্নিপেটে 7 হিসাবে উপস্থিত হিসাবে উল্লেখ করেছি। এটি কোনো বৈধ উত্তর দেওয়ার জন্য, আপনি ঠিক ব্যাখ্যা করতে হবে সংখ্যার একটি প্রদত্ত পরিমাণ সীমা সেট কিভাবে, এবং এটি কত নম্বর হবে overproduce ।
— নেস
0

স্কালার সাথে আমার চেষ্টা এখানে:

case class IndexValue(twosIndex: Int, fivesIndex: Int)
case class OutputValues(twos: Int, fives: Int, value: Int) {
  def test(): Boolean = {
    Math.pow(2,  twos) * Math.pow(5, fives) == value
  }
}

def run(last: IndexValue = IndexValue(0, 0), list: List[OutputValues] = List(OutputValues(0, 0, 1))): List[OutputValues] = {
  if (list.size > 20) {
    return list
  }

  val twosValue = list(last.twosIndex).value * 2
  val fivesValue = list(last.fivesIndex).value * 5

  if (twosValue == fivesValue) {
    val lastIndex = IndexValue(last.twosIndex + 1, last.fivesIndex + 1)
    val outputValues = OutputValues(value = twosValue, twos = list(last.twosIndex).twos + 1, fives = list(last.fivesIndex).fives + 1)
    run(lastIndex, list :+ outputValues)
  } else if (twosValue < fivesValue) {
    val lastIndex = IndexValue(last.twosIndex + 1, last.fivesIndex)
    val outputValues = OutputValues(value = twosValue, twos = list(last.twosIndex).twos + 1, fives = list(last.twosIndex).fives)
    run(lastIndex, list :+ outputValues)
  } else {
    val lastIndex = IndexValue(last.twosIndex, last.fivesIndex + 1)
    val outputValues = OutputValues(value = fivesValue, twos = list(last.fivesIndex).twos, fives = list(last.fivesIndex).fives + 1)
    run(lastIndex, list :+ outputValues)
  }
}

val initialIndex = IndexValue(0, 0)
run(initialIndex, List(OutputValues(0, 0, 1))) foreach println

আউটপুট:

OutputValues(0,0,1)
OutputValues(1,0,2)
OutputValues(2,0,4)
OutputValues(0,1,5)
OutputValues(3,0,8)
OutputValues(1,1,10)
OutputValues(4,0,16)
OutputValues(2,1,20)
OutputValues(0,2,25)
OutputValues(5,0,32)
OutputValues(3,1,40)
OutputValues(1,2,50)
OutputValues(6,0,64)
OutputValues(4,1,80)
OutputValues(2,2,100)
OutputValues(0,3,125)
OutputValues(7,0,128)
OutputValues(5,1,160)
OutputValues(3,2,200)
OutputValues(1,3,250)
OutputValues(8,0,256)
— nishnet2002
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.