একটি নম্বর দেওয়া হয়েছে, পরবর্তী উচ্চতর সংখ্যাটি সন্ধান করুন যার আসল সংখ্যার মতো একই সংখ্যার অঙ্ক রয়েছে

Question

আমি কেবল একটি সাক্ষাত্কারে বোমা মেরেছিলাম এবং আমার সাক্ষাত্কারের প্রশ্নে শূন্য অগ্রগতি করেছি। কেউ আমাকে কীভাবে এটি করতে চান তা বলতে পারেন? আমি অনলাইনে অনুসন্ধানের চেষ্টা করেছি কিন্তু কিছুই পাইনি:

একটি নম্বর দেওয়া হয়েছে, পরবর্তী উচ্চতর সংখ্যাটি সন্ধান করুন যার আসল সংখ্যার মতো একই সংখ্যার অঙ্ক রয়েছে। উদাহরণস্বরূপ: প্রদত্ত 38276 রিটার্ন 38627

আমি প্রথম অঙ্কটির সূচকটি (ডান দিক থেকে) যে সংখ্যার চেয়ে কম ছিল তা আবিষ্কার করে সূচনা করতে চেয়েছিলাম। তারপরে আমি সাবসেটের শেষ অঙ্কগুলি এমনভাবে ঘুরিয়ে দেব যে এটি একই অঙ্কের সমন্বিত পরবর্তী বৃহত্তম সংখ্যা ছিল তবে আটকে গেল।

সাক্ষাত্কারকারক একবারে একটিতে অঙ্কের অদলবদল করার চেষ্টা করার পরামর্শও দিয়েছিল, তবে আমি অ্যালগরিদমটি বুঝতে পারি নি এবং কেবল 20-30 মিনিটের মতো পর্দায় তাকিয়ে রইলাম। বলা বাহুল্য, আমি মনে করি আমাকে চাকরির সন্ধান চালিয়ে যেতে হবে।

সম্পাদনা করুন: এর মূল্য কী, তার জন্য আমাকে পরের সাক্ষাত্কারে আমন্ত্রণ জানানো হয়েছিল

Comments

এটি নিয়ে খুব বেশি চিন্তা না করেই একটি সূচনা কমপক্ষে

— নিষ্ঠুরূপে অঙ্কের সমস্ত ক্রমশক্তি

সি ++ এ আপনি কেবল next_permutation;-) ব্যবহার করতে পারেন

— ই

এফওয়াইআই, আমি এখানে প্রায় 15 মিনিটের মধ্যে কীভাবে সমস্যাটি নিয়ে ভাবতে শুরু করেছি তা সমাধান করেছি: আমি প্রথমে 5 মিনিট একটি নিষ্ঠুর-বলের অ্যালগরিদম লেখার জন্য ব্যয় করেছি যা কেবলমাত্র অঙ্কের একটি সেটগুলির সমস্ত সম্ভাব্য ক্রমবিন্যাস তৈরি করেছে, সেগুলি সাজিয়েছে এবং তাদের প্রদর্শন করেছে। আমি তালিকাটি থেকে কোনও প্যাটার্ন প্রকাশ না হওয়া পর্যন্ত এই ডেটাটি দেখার জন্য 5 মিনিট অতিবাহিত করেছি (ও (এন) গৃহীত সমাধানটি কেবল অল্প সময়ের জন্য দেখার পরে পরিষ্কার হয়ে গেছে), তারপরে আমি ও (এন) অ্যালগরিদমের কোডিংয়ে 5 মিনিট ব্যয় করেছি।

— বেন লি

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

— বেন লি

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

— বেন লি

Answer 1

আপনি এটির মতো O(n)( nসংখ্যার সংখ্যাটি কোথায় ) এটি করতে পারেন:

ডান থেকে শুরু করে আপনি প্রথম সংখ্যার অঙ্কটি খুঁজে পাবেন যাতে বাম সংখ্যাটি ডান-অঙ্কের চেয়ে ছোট is বাম-অঙ্কটি "অঙ্ক-এক্স" দ্বারা উল্লেখ করা যাক। অঙ্ক-x এর ডান থেকে অঙ্ক-x এর চেয়ে বৃহততম সংখ্যাটি সন্ধান করুন এবং এটি অবিলম্বে অঙ্ক-এক্স এর বামে রাখুন। অবশেষে, বাকী অঙ্কগুলি আরোহণের ক্রমে বাছাই করুন - যেহেতু সেগুলি ইতিমধ্যে ছিল অবতরণ ক্রমে আপনাকে যা করা দরকার তা হ'ল তাদের বিপরীত করা উচিত (অঙ্ক-এক্সের জন্য সংরক্ষণO(n) করুন , যাতে সঠিক জায়গায় স্থাপন করা যেতে পারে ) ।

একটি উদাহরণ এটি আরও স্পষ্ট করে তুলবে:

123456784987654321
একটি সংখ্যা দিয়ে শুরু করুন

123456784 987654321
         right ডান দিক থেকে প্রথম স্থান যেখানে বাম সংখ্যাটি ডানের চেয়ে কম  
         অঙ্ক "এক্স" 4 হয়

123456784 987654321
              4 4 থেকে ডানদিকে বৃহত্তরতম সংখ্যার সন্ধান করুন

123456785 4 98764321
        it এটি 4 এর বামে রাখুন

123456785 4 12346789
123456785123446789
         5. টির ডান দিকে বাছাই করুন, যেহেতু এগুলি বাদে সবগুলিই all 
         '4' ইতিমধ্যে অবতরণে ছিল, আমাদের যা করা দরকার তা হ'ল 
         তাদের ক্রমটি বিপরীত করুন এবং '4' এর জন্য সঠিক জায়গাটি আবিষ্কার করুন

---

সঠিকতার প্রমাণ:

আসুন অঙ্কের স্ট্রিংগুলি এবং সংখ্যার জন্য লোয়ার-কেস নির্ধারণ করতে বড় হাতের অক্ষর ব্যবহার করুন। বাক্য গঠনটির ABঅর্থ "স্ট্রিংগুলির সংমিশ্রণ Aএবং B" । <ডিক্সোগ্রাফিকাল অর্ডারিং, যা অঙ্ক-স্ট্রিং সমান দৈর্ঘ্যের হয় যখন পূর্ণসংখ্যার ক্রম হিসাবে সমান।

আমাদের আসল নম্বর এন সেই ফর্মের AxB, যেখানে xএকক অঙ্ক এবং Bউতরাই সাজানো।
সংখ্যা আমাদের এলগরিদম দ্বারা পাওয়া যায় AyC, যেখানে y ∈ Bক্ষুদ্রতম ডিজিট > x (এটা থাকা আবশ্যক কারণে পথ xনির্বাচিত হয়েছে, উপরোক্ত দেখুন) , এবং Cসাজানো আরোহী হয়।

ধরুন এখানে কিছু নম্বর রয়েছে (একই অঙ্কগুলি ব্যবহার করে) N'যেমন AxB < N' < AyC। N'অবশ্যই Aএটি দিয়ে শুরু করা উচিত অন্যথায় এটি তাদের মধ্যে পড়তে পারে না, তাই আমরা এটি ফর্মটিতে লিখতে পারি AzD। এখন আমাদের বৈষম্যটি AxB < AzD < AyCযা xB < zD < yCতিনটি ডিজিট-স্ট্রিংয়ে একই অঙ্ক রয়েছে তার সমান।

এটি সত্য হওয়ার জন্য আমাদের অবশ্যই থাকা উচিত x <= z <= y। যেহেতু yক্ষুদ্রতম সংখ্যা > x, zতাদের মধ্যে হতে পারে না, তাই হয় হয় z = xবা হয় z = y। বলুন z = x। তারপরে আমাদের অসমতা xB < xD < yC, যার অর্থ B < Dযেখানে উভয় Bএবং Dএকই অঙ্ক রয়েছে digit যাইহোক, বি, সাজানো সাজানো হয় তাই হল যারা সংখ্যা এটা চেয়ে বড় কোন স্ট্রিং। এভাবে আমরা থাকতে পারি না B < D। একই পদক্ষেপগুলি অনুসরণ করে, আমরা দেখতে পাই যে, যদি z = yআমাদের না পারে D < C।

সুতরাং N'অস্তিত্ব থাকতে পারে না, যার অর্থ আমাদের অ্যালগরিদম সঠিকভাবে পরবর্তী বৃহত্তম সংখ্যাটি খুঁজে পায়।

Comments

চমৎকার সমাধান! একটি প্রশ্ন আছে। "x এর চেয়ে ক্ষুদ্রতম সংখ্যা" বলে y বলে। আমরা কি কেবল x এবং y অদলবদল করতে পারি, তারপরে x.index + 1 -> শেষ করতে পারি?

— কেন্ট

99999 নম্বরটি কী হয়?

— স্টেরেক্স

@ স্টেরেক্স, এটি কেবল 99999 নয়; যার অঙ্কগুলি ইতিমধ্যে পুরোপুরি অবতরণ ক্রমে সাজানো হয়েছে তার কোনও সংখ্যা সর্বাধিক (সুতরাং 98765 এরও কোনও সমাধান নেই, উদাহরণস্বরূপ)। এটি অগ্রগামীভাবে সনাক্ত করা সহজ কারণ অ্যালগরিদমের প্রথম ধাপটি ব্যর্থ হবে (একটানা সংখ্যার কোনও জুড়ি নেই যেমন "বাম-অঙ্কটি ডান-অঙ্কের চেয়ে ছোট")।

— বেন লি

@ টিএমএন: 9 টি 8 এর চেয়ে বড়, সুতরাং আপনি 9 টি 8 এর বাম দিকে সরিয়ে নিয়ে যাবেন: 9 832তারপরে 9 এর ডানদিকে সবকিছু সাজান:9238

— ব্লুরাজা - ড্যানি পিফ্লুঘুফুট

@Kent আপনি পরিবর্তন করতে হবে কাজ করার জন্য আপনার সমাধান জন্য ক্ষুদ্রতম অঙ্ক 4 চেয়ে বড় এটি করার অধিকার করার ক্ষুদ্রতম অঙ্ক 4 চেয়ে বড় এটি থেকে ডান । অন্যথায়, উদাহরণস্বরূপ, 1234567849876 55 4321 এর ফলাফল 1234567851234 54 6789 (1234567851234 45 6789 এর পরিবর্তে ) হবে। একটি নাইটপিক :-)

— ওসুন্ডব্ল্যাড

Answer 2

একটি প্রায়-অভিন্ন সমস্যা কোড জ্যাম সমস্যা হিসাবে উপস্থিত হয়েছিল এবং এর একটি সমাধান এখানে রয়েছে:

http://code.google.com/codejam/contest/dashboard?c=186264#s=a&a=1

একটি উদাহরণ ব্যবহার করে পদ্ধতির সংক্ষিপ্তসার এখানে:

34722641

উ: অঙ্কগুলির ক্রম দুটিতে বিভক্ত করুন, যাতে ক্রমহ্রাসমান ক্রমে থাকা অবস্থায় ডান অংশ যতটা সম্ভব দীর্ঘ হয়:

34722 641

(যদি পুরো সংখ্যাটি যদি ক্রম হ্রাসে থাকে তবে অঙ্কগুলি যোগ না করে বড় সংখ্যা তৈরি করা যায় না))

B.1। প্রথম অনুক্রমের শেষ সংখ্যাটি নির্বাচন করুন:

3472(2) 641

B.2। দ্বিতীয় ক্রমের সবচেয়ে ছোট অঙ্কটি এটির চেয়ে বড় এটি সন্ধান করুন:

3472(2) 6(4)1

B.3। এগুলি অদলবদল করুন:

3472(2) 6(4)1
->
3472(4) 6(2)1
->
34724 621

গ। দ্বিতীয় ক্রমটিকে ক্রমবর্ধমান ক্রমে বাছাই করুন:

34724 126

ডি। হয়ে গেল!

34724126

Comments

সেখানে টাইপ করুন: আমি মনে করি "-> 34721 621" "-> 34724 621" হওয়া উচিত?

— বিজেএনর্ড

@bjnord ভাল ক্যাচ সংশোধন করা হয়েছে। আমি কীভাবে এটি পরিচালনা করেছি তা নিশ্চিত নয় - এটি পরবর্তী লাইনে সঠিক ছিল।

— ওয়েবেল

এখানে +1 সেরা উত্তর। স্বজ্ঞাত এবং দ্রুত। (এটি যখন আমি যখন কাগজে কাজটি করতাম তখন এটিই আমি ভেবেছিলাম;))

— মুহাদ

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

— ওয়েবেল

@ ধাওয়ালদভে সমস্যা কি? পদক্ষেপ A এ আপনি "12" এবং "3" পান। বি ধাপে আপনি "13" এবং "2" পান। সি ধাপে কিছুই পরিবর্তন হয় না। ধাপে ডি আপনি "132" পাবেন। একমাত্র ক্ষেত্রে যেখানে আপনি উত্তর পাবেন না তা হ'ল যখন সংখ্যাটি ইতিমধ্যে সর্বাধিক সম্ভব, যেমন "321"। সেক্ষেত্রে, পদক্ষেপ এ আপনাকে "" এবং "321" দেয় এবং আপনি বিভাজনের বাম দিকে খালি ক্রম দিয়ে এগিয়ে যেতে পারবেন না।

— উইবল

Answer 3

পাইথনে এখানে একটি কমপ্যাক্ট (তবে আংশিক বর্বর শক্তি) সমাধান রয়েছে

def findnext(ii): return min(v for v in (int("".join(x)) for x in
    itertools.permutations(str(ii))) if v>ii)

সি ++ তে আপনি এর মতো অনুমতি দিতে পারেন: https://stackoverflow.com/a/9243091/1149664 অনুমানগুলি (এটি এরটোলগুলির মতো একই অ্যালগরিদম)

এখানে ওয়েবেল এবং ব্লুরাজ দ্বারা বর্ণিত শীর্ষ উত্তরের একটি বাস্তবায়ন , (অন্যান্য উত্তর)। আমার সন্দেহ আছে এর চেয়ে ভাল আর কিছু আছে।

def findnext(ii):
    iis=list(map(int,str(ii)))
    for i in reversed(range(len(iis))):
        if i == 0: return ii
        if iis[i] > iis[i-1] :
            break        
    left,right=iis[:i],iis[i:]
    for k in reversed(range(len(right))):
        if right[k]>left[-1]:
           right[k],left[-1]=left[-1],right[k]
           break
    return int("".join(map(str,(left+sorted(right)))))

Comments

এই সুযোগটি যে কেউ আপডেট করতে পারে? পাইথন 3 তে এটি কাজ করার মতো বলে মনে হচ্ছে না type 'map' has no len()। আমি কেবল ২ য় লাইনটি পরিবর্তন করব iis=list(map(int,str(ii)))। এবং কেউ if i == 0: return iiদয়া করে লাইনটি ব্যাখ্যা করতে পারেন ? কেন এটি 111 বা 531 এর মতো ইনপুট নিয়ে কাজ করবে? ধন্যবাদ।

— বোভেন লিউ

আমি এখন এটি আইস = ... to এ লিস্ট () যোগ করে পাইথন 3 এর জন্য ঠিক করেছি fixed 111 এবং 531 কেসগুলির কোনও সমাধান নেই তবে আমার বাস্তবায়ন 111 এবং 531 এর জন্য দেয়। I == 0 লাইন পরিবর্তন করে আপনি যা খুঁজে পান তার ব্যতিক্রম আপনি এটি পরিবর্তন করতে পারেন।

— জোহান লন্ডবার্গ

ধন্যবাদ। আমি আসলে অন্য দিকে লুপ করেছিলাম তাই আমি == 0 দ্বারা বিভ্রান্ত হয়ে পড়েছিলাম, আমার অবস্থাতেও এটি হবে i == len(iis)।

— বোভেন লিউ

Answer 4

সর্বনিম্ন, এখানে বেশ কয়েকটি উদাহরণ ব্রেস্ট ফোর্স স্ট্রিং ভিত্তিক সমাধান রয়েছে যা আপনি আপনার মাথার উপরের অংশে ডানদিকে আসতে সক্ষম হবেন:

38276বাছাই করা অঙ্কগুলির তালিকা23678

38627বাছাই করা অঙ্কগুলির তালিকা23678

নিষ্ঠুর বল বৃদ্ধি, সাজান এবং তুলনা

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

এগুলির মধ্যে অন্তরগুলি তৈরি করুন, এগুলি একটি তালিকায় রাখুন এবং এটি বাছাই করুন, লক্ষ্য প্রবেশের পরে পরবর্তী এন্ট্রি পান।

আপনি যদি এটিতে 30 মিনিট সময় ব্যয় করেন এবং কমপক্ষে কমপক্ষে একটি জোরদার পদ্ধতির সাথে না উপস্থিত হন তবে আমি আপনাকেও ভাড়া দেব না।

ব্যবসা বিশ্বে একটি সমাধান যে অসুন্দর ধীর এবং clunky কিন্তু কাজ পায় সবসময় সত্য যে প্রায় কাছাকাছি বর্ণনা ব্যাপারে এ সব কোন সমাধান চেয়ে মূল্যবান হয়, সব ব্যবসা সফটওয়্যার, অসুন্দর, ধীর এবং clunky।

Comments

ব্যাটে আমার প্রথম মন্তব্যটি ছিল "আমি এটি জোর করে ফেলতে পারি তবে ..."। যদি সত্যিই কোনও অ্যালগরিদমিক সমাধান না হয় তবে আমি একরকম হতাশ

— bhan

আমি যদি সাক্ষাত্কার গ্রহণকারী হয়ে থাকি, তবে আমি একটি দৃ force় শক্তি পদ্ধতির সাথে এত খুশি হতাম না।

— আহমদ ওয়াই সালেহ

@ বেঞ্জামিন হ্যান, অ্যালগরিদমিক সমাধান আছে। আপনি ফলাফলটি না পাওয়া পর্যন্ত ডান দিক থেকে শুরু করে অদলবদল অবিরত রাখুন। এর আগে সমস্ত পারমুটিটনিও গণনা করার দরকার নেই।

— ডান্টুচ

নিষ্ঠুর বলয়ের

— ব্রোকেনগ্লাস

@ ব্রোকেনগ্লাস অবশ্যই আরও অনেক ভাল সমাধান। আমি ঠিক এই ধারণাটি নিয়ে আসছিলাম এবং তারপরে আপনি অ্যালগরিদম পোস্ট করলেন।

— onit

Answer 5

function foo(num){
 sortOld = num.toString().split("").sort().join('');
 do{
    num++;
   sortNew = num.toString().split("").sort().join('');
 }while(sortNew!==sortOld);
 return num;
}

Comments

আমি এই সমাধান নিয়ে এসেছি। আপনার যদি কোন প্রশ্ন থাকে, দয়া করে জিজ্ঞাসা করুন।

— আশিকোদি

Answer 6

আপনার ধারণা

আমি প্রথম অঙ্কটির সূচকটি (ডান দিক থেকে) যে সংখ্যার চেয়ে কম ছিল তা আবিষ্কার করে সূচনা করতে চেয়েছিলাম। তারপরে আমি সাবসেটের শেষ অঙ্কগুলি এমনভাবে ঘুরিয়ে দেব যে এটি একই অঙ্কের সমন্বিত পরবর্তী বৃহত্তম সংখ্যা ছিল তবে আটকে গেল।

আসলে বেশ ভাল। আপনাকে কেবলমাত্র সর্বশেষ সংখ্যাটিই নয় বরং বর্তমানে বিবেচিত সমস্ত তুলনায় কম তাত্পর্যপূর্ণ সমস্ত সংখ্যা বিবেচনা করতে হবে। যেহেতু এটি পৌঁছানোর আগেই আমাদের সংখ্যার মনোটোনিক ক্রম রয়েছে, এটিই তার ডান প্রতিবেশীর চেয়ে ডানদিকের ছোট smaller বিবেচনা

1234675
    ^

পরের বৃহত্তর সংখ্যাটি একই অঙ্কযুক্ত having

1234756

প্রাপ্ত অঙ্কটি শেষ অঙ্কের জন্য বিনিময় হয় - বিবেচিত অঙ্কগুলির মধ্যে সবচেয়ে ছোট - এবং বাকী অঙ্কগুলি ক্রমবর্ধমান ক্রমে সাজানো হয়।

Answer 7

আমি মোটামুটি নিশ্চিত যে আপনার সাক্ষাত্কারকারক আপনাকে এমন কোনও কিছুর দিকে ধীরে ধীরে ধাক্কা দেওয়ার চেষ্টা করছেন:

local number = 564321;

function split(str)
    local t = {};
    for i = 1, string.len(str) do
        table.insert(t, str.sub(str,i,i));
    end
    return t;
end

local res = number;
local i = 1;
while number >= res do
    local t = split(tostring(res));
    if i == 1 then
        i = #t;
    end
    t[i], t[i-1] = t[i-1], t[i];
    i = i - 1;
    res = tonumber(table.concat(t));
end

print(res);

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

Answer 8

একটি সংখ্যা নিন এবং এটি অঙ্কগুলিতে বিভক্ত করুন। সুতরাং যদি আমাদের 5 সংখ্যার নম্বর থাকে তবে আমাদের 5 টি সংখ্যা রয়েছে: অ্যাবসিডি

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

যদি এটি বৃহত্তর না হয় তবে ই এবং সি পরিবর্তন করুন। এখন তুলনা করুন এবং যদি এটি আবার ছোট অদলবদল এবং ই আবার হয় (বিজ্ঞপ্তি পুনরাবৃত্তি), সবচেয়ে ছোট নিন।

যতক্ষণ না আপনি একটি বৃহত সংখ্যা খুঁজে পান ততক্ষণ চালিয়ে যান। পুনরাবৃত্তির সাথে এটি স্কিমের প্রায় 9 টি লাইন, অথবা 20 # সি হিসাবে কাজ করা উচিত।

Answer 9

এটা খুব আকর্ষণীয় প্রশ্ন।

এই আমার জাভা সংস্করণ। অন্যান্য অবদানকারীদের মন্তব্য পরীক্ষা করার আগে কোডটি পুরোপুরি শেষ করতে প্যাটার্নটি নির্ণয় করতে আমাকে প্রায় 3 ঘন্টা সময় নিন Take আমার ধারণাটি অন্যের সাথে বেশ একই রকম দেখতে পেরে আনন্দিত।

ও (এন) সমাধান সত্য, আমি এই সাক্ষাত্কারটি ব্যর্থ করব যদি সময়টি কেবল 15 মিনিটের হয় এবং হোয়াইট বোর্ডে সম্পূর্ণ কোড ফিনিস প্রয়োজন।

আমার সমাধানের জন্য আকর্ষণীয় কিছু বিষয় এখানে:

• কোনও বাছাই এড়ানো।
• স্ট্রিং অপারেশন সম্পূর্ণভাবে এড়িয়ে চলুন
• ও (লগএন) স্থান জটিলতা অর্জন করুন

আমি আমার কোডে বিশদ মন্তব্য রেখেছি এবং প্রতিটি পদক্ষেপে বিগ হে।

  public int findNextBiggestNumber(int input  )   {
    //take 1358642 as input for example.
    //Step 1: split the whole number to a list for individual digital   1358642->[2,4,6,8,5,3,1]
    // this step is O(n)
    int digitalLevel=input;

    List<Integer> orgNumbersList=new ArrayList<Integer>()   ;

    do {
        Integer nInt = new Integer(digitalLevel % 10);
        orgNumbersList.add(nInt);

        digitalLevel=(int) (digitalLevel/10  )  ;


    } while( digitalLevel >0)    ;
    int len= orgNumbersList.size();
    int [] orgNumbers=new int[len]  ;
    for(int i=0;i<len;i++){
        orgNumbers[i ]  =  orgNumbersList.get(i).intValue();
    }
    //step 2 find the first digital less than the digital right to it
    // this step is O(n)


    int firstLessPointer=1;
    while(firstLessPointer<len&&(orgNumbers[firstLessPointer]>orgNumbers[ firstLessPointer-1 ])){
        firstLessPointer++;
    }
     if(firstLessPointer==len-1&&orgNumbers[len-1]>=orgNumbers[len-2]){
         //all number is in sorted order like 4321, no answer for it, return original
         return input;
     }

    //when step 2 step finished, firstLessPointer  pointing to number 5

     //step 3 fristLessPointer found, need to find  to  first number less than it  from low digital in the number
    //This step is O(n)
    int justBiggerPointer=  0 ;

    while(justBiggerPointer<firstLessPointer&& orgNumbers[justBiggerPointer]<orgNumbers[firstLessPointer]){
        justBiggerPointer++;
    }
    //when step 3 finished, justBiggerPointer  pointing to 6

    //step 4 swap the elements  of justBiggerPointer and firstLessPointer .
    // This  is O(1) operation   for swap

   int tmp=  orgNumbers[firstLessPointer] ;

    orgNumbers[firstLessPointer]=  orgNumbers[justBiggerPointer]  ;
     orgNumbers[justBiggerPointer]=tmp ;


     // when step 4 finished, the list looks like        [2,4,5,8,6,3,1]    the digital in the list before
     // firstLessPointer is already sorted in our previous operation
     // we can return result from this list  but  in a differrent way
    int result=0;
    int i=0;
    int lowPointer=firstLessPointer;
    //the following pick number from list from  the position just before firstLessPointer, here is 8 -> 5 -> 4 -> 2
    //This Operation is O(n)
    while(lowPointer>0)        {
        result+= orgNumbers[--lowPointer]* Math.pow(10,i);
        i++;
    }
    //the following pick number from list   from position firstLessPointer
    //This Operation is O(n)
    while(firstLessPointer<len)        {
        result+= orgNumbers[firstLessPointer++ ]* Math.pow(10,i);
        i++;
    }
     return  result;

}

ফলাফলটি ইন্টেলজে চলছে:

959879532-->959892357
1358642-->1362458
1234567-->1234576
77654321-->77654321
38276-->38627
47-->74

Comments

123 ক্ষেত্রে উত্তর কি হবে? ব্যবহারিকভাবে ইউলিং কোডটি আউটপুট তৈরি করে না যখন এটি আসে 132

— ধাভাল দ্যাভ

Answer 10

@ ব্লু রাজার আলগোরিদিম একটি জাভাস্ক্রিপ্ট বাস্তবায়ন।

var Bar = function(num){ 
  num = num.toString();
  var max = 0;
  for(var i=num.length-2; i>0; i--){
    var numArray = num.substr(i).split("");
    max = Math.max.apply(Math,numArray);
    if(numArray[0]<max){
        numArray.sort(function(a,b){return a-b;});
        numArray.splice(-1);
        numArray = numArray.join("");
        return Number(num.substr(0,i)+max+numArray);
    }
  }
  return -1;
};

Answer 11

একটি সমাধান (জাভাতে) নিম্নলিখিত হতে পারে (আমি নিশ্চিত যে এখানে বন্ধুরা আরও ভালভাবে সন্ধান করতে পারে):
আপনি উচ্চতর নম্বর না পাওয়া পর্যন্ত স্ট্রিংয়ের শেষে থেকে অঙ্কগুলি অদলবদল করা শুরু করুন।
অর্থাত্ প্রথমে নিম্নের অঙ্কটি উপরে নিয়ে যাওয়া শুরু করুন hen তারপরে পরবর্তী উচ্চতর ইত্যাদি you যতক্ষণ না আপনি পরের উচ্চতমটিকে আঘাত করেন।
তারপরে বাকী বাছাই করুন। আপনার উদাহরণে আপনি পাবেন:

38276 --> 38267 (smaller) --> 38627 Found it    
    ^        ^                  ^        

 public static int nextDigit(int number){
    String num = String.valueOf(number);        
    int stop = 0;       
    char [] chars = null;
    outer:
        for(int i = num.length() - 1; i > 0; i--){          
            chars = num.toCharArray();
            for(int j = i; j > 0; j--){
                char temp = chars[j];
                chars[j] = chars[j - 1];
                chars[j - 1] = temp;
                if(Integer.valueOf(new String(chars)) > number){
                    stop = j;                   
                    break outer;                                
                }               
            }               
        }

    Arrays.sort(chars, stop, chars.length); 
    return Integer.valueOf(new String(chars));
}

Comments

@ আইআইএইচএইচ: আউটপুট হল। 63872কেন, এটি কী হওয়া উচিত?

— ক্র্যাটিলাস

ভাল .. পরবর্তী উচ্চ সংখ্যা? :) যে প্রয়োজন ছিল, তাই না?

— করলি হরভাথ

@BlueRaja - ড্যানি Pflughoeft: আপনার help.I জন্য ধন্যবাদ কোড নিম্নরূপ পরিবর্তিত হয়েছে: অন্তত অঙ্ক আপফ্রন্ট (যা কখনও একটি উচ্চতর সংখ্যা উৎপাদ) এবং সরান সাজানোর বাকি

— Cratylus

Answer 12

আপনি যদি সি ++ তে প্রোগ্রামিং করে থাকেন তবে আপনি ব্যবহার করতে পারেন next_permutation:

#include <algorithm>
#include <string>
#include <iostream>

int main(int argc, char **argv) {
  using namespace std; 
   string x;
   while (cin >> x) {
    cout << x << " -> ";
    next_permutation(x.begin(),x.end());
    cout << x << "\n";
  }
  return 0;
}

Comments

আমি ইনপুট দিলে কি হবে 100? :-)

— jweyrich

Answer 13

এই প্রশ্নের উত্তর দেওয়ার সময় আমি ব্রুট ফোর্স অ্যালগরিদম সম্পর্কে কিছুই জানতাম না, তাই আমি এটি অন্য একটি কোণ থেকে কাছে এসেছি। আমি সম্ভাব্য সমাধানগুলির পুরো পরিসীমা অনুসন্ধান করার সিদ্ধান্ত নিয়েছি যা এই সংখ্যাটি সম্ভবত পুনরায় সাজানো যেতে পারে, সংখ্যা_জিভেন + 1 থেকে শুরু করে সর্বাধিক সংখ্যার (3 অঙ্কের সংখ্যার জন্য 999, 4 অঙ্কের জন্য 9999 ইত্যাদি) শুরু করে। আমি এই জাতীয় শব্দগুলির সাথে একটি প্যালিনড্রোম সন্ধান করার মতো করেছি, প্রতিটি সমাধানের সংখ্যা বাছাই করে এবং প্যারামিটার হিসাবে প্রদত্ত বাছাই করা সংখ্যার সাথে তুলনা করে। আমি তখনই সমাধানগুলির অ্যারেতে প্রথম সমাধানটি সহজভাবে ফিরে আসি, কারণ এটি পরবর্তী সম্ভাব্য মান হবে।

রুবিতে আমার কোডটি এখানে:

def PermutationStep(num)

    a = []
    (num.to_s.length).times { a.push("9") }
    max_num = a.join('').to_i
    verify = num.to_s.split('').sort
    matches = ((num+1)..max_num).select {|n| n.to_s.split('').sort == verify }

    if matches.length < 1
      return -1
    else
      matches[0]
    end
end

Comments

এই সমাধান সময় জটিলতা কি?

— নীতীশ উপ্রেতি

@ মিথ 17 আমি নিশ্চিত নই যেহেতু আমি কখনই এটি পরীক্ষা করে দেখিনি। আপনি যদি এটি বের করতে চান তবে এই পোস্টটি দেখুন: stackoverflow.com/questions/9958299/…

— জেরেমিয়া ম্যাককুরডি

Answer 14

পিএইচপি কোড

function NextHigherNumber($num1){
$num = strval($num1);
$max = 0;
for($i=(strlen($num)-2); $i>=0; $i--){
    $numArrayRaw = substr($num, $i);
    $numArray = str_split($numArrayRaw);
    $max = max($numArray);
    if ($numArray[0] < $max){
        sort( $numArray, SORT_NUMERIC );
        array_pop($numArray);
        $numarrstr = implode("",$numArray);
        $rt = substr($num,0,$i) . $max . $numarrstr;
        return $rt;
    }
}
return "-1";
}
echo NextHigherNumber(123);

Answer 15

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

ওমর, শুভকামনা এগিয়ে যাচ্ছেন।

Sub Main()

Dim Base(0 To 9) As Long
Dim Test(0 To 9) As Long

Dim i As Long
Dim j As Long
Dim k As Long
Dim ctr As Long

Const x As Long = 776914648
Dim y As Long
Dim z As Long

Dim flag As Boolean

' Store the digit count for the original number in the Base vector.
    For i = 0 To 9
        ctr = 0
        For j = 1 To Len(CStr(x))
            If Mid$(CStr(x), j, 1) = i Then ctr = ctr + 1
        Next j
        Base(i) = ctr
    Next i

' Start comparing from the next highest number.
    y = x + 1
    Do

' Store the digit count for the each new number in the Test vector.
        flag = False
        For i = 0 To 9
            ctr = 0
            For j = 1 To Len(CStr(y))
                If Mid$(CStr(y), j, 1) = i Then ctr = ctr + 1
            Next j
            Test(i) = ctr
        Next i

' Compare the digit counts.
        For k = 0 To 9
            If Test(k) <> Base(k) Then flag = True
        Next k

' If no match, INC and repeat.
        If flag = True Then
            y = y + 1
            Erase Test()
        Else
            z = y ' Match.
        End If

    Loop Until z > 0

    MsgBox (z), , "Solution"

End Sub

Answer 16

কীভাবে এটি করা যায় তার একটি সুন্দর লেখার জন্য, নুথের " কম্পিউটার প্রোগ্রামিং: আর্ট অফ কম্পিউটার প্রোগ্রামিং: সমস্ত পারমিটেশন জেনারেট করা" (.ps.gz) এ " অ্যালগরিদম এল " দেখুন ।

Answer 17

এখানে আমার কোড, এটি এই উদাহরণের পরিবর্তিত সংস্করণ

লাইব্রেরী:

class NumPermExample
{
    // print N! permutation of the characters of the string s (in order)
    public  static void perm1(String s, ArrayList<String> perm)
    {
        perm1("", s);
    }

    private static void perm1(String prefix, String s, ArrayList<String> perm)
    {
        int N = s.length();
        if (N == 0)
        {
            System.out.println(prefix);
            perm.add(prefix);
        }
        else
        {
            for (int i = 0; i < N; i++)
                perm1(prefix + s.charAt(i), s.substring(0, i)
                    + s.substring(i+1, N));
        }

    }

    // print N! permutation of the elements of array a (not in order)
    public static void perm2(String s, ArrayList<String> perm)
    {
       int N = s.length();
       char[] a = new char[N];
       for (int i = 0; i < N; i++)
           a[i] = s.charAt(i);
       perm2(a, N);
    }

    private static void perm2(char[] a, int n, ArrayList<String> perm)
    {
        if (n == 1)
        {
            System.out.println(a);
            perm.add(new String(a));
            return;
        }

        for (int i = 0; i < n; i++)
        {
            swap(a, i, n-1);
            perm2(a, n-1);
            swap(a, i, n-1);
        }
    }  

    // swap the characters at indices i and j
    private static void swap(char[] a, int i, int j)
    {
        char c;
        c = a[i]; a[i] = a[j]; a[j] = c;
    }

    // next higher permutation
    public static int nextPermutation (int number)
    {
        ArrayList<String> perm = new ArrayList<String>();

        String cur = ""+number;

        int nextPerm = 0;

        perm1(cur, perm);

        for (String s : perm)
        {
            if (Integer.parseInt(s) > number
                        && (nextPerm == 0 ||
                            Integer.parseInt(s) < nextPerm))
            {
                nextPerm = Integer.parseInt(s);
            }
        }

            return nextPerm;
    }
}

টেস্ট:

public static void main(String[] args) 
{
    int a = 38276;

    int b = NumPermExample.nextPermutation(a);

    System.out.println("a: "+a+", b: "+b);
}

Answer 18

প্রদত্ত এন অঙ্কের সংখ্যাটিতে 9 যুক্ত করুন। তারপরে এটি সীমা (প্রথম (এন + 1) সংখ্যা নম্বর) এর মধ্যে আছে কিনা তা পরীক্ষা করে দেখুন। এটি যদি হয় তবে নতুন সংখ্যায় অঙ্কগুলি মূল সংখ্যার মতো একই কিনা তা পরীক্ষা করে দেখুন। উভয় শর্ত সত্য না হওয়া পর্যন্ত 9 যোগ করার পুনরাবৃত্তি করুন। সংখ্যা সীমা ছাড়িয়ে গেলে আলগো বন্ধ করুন।

আমি এই পদ্ধতির জন্য একটি বিরোধী পরীক্ষার মামলা নিয়ে আসতে পারিনি।

Comments

এটি কাজ করে, তবে অত্যন্ত ধীরে ধীরে। এটি একটি ক্ষতিকারক সময় অ্যালগোরিদম যেখানে রৈখিক সময়ে এটি সমাধান করা যেতে পারে।

— ইন্টারজয়

Answer 19

পাইথন ব্যবহার করে অন্য একটি সমাধান:

def PermutationStep(num):
    if sorted(list(str(num)), reverse=True) == list(str(num)):
        return -1
    ls = list(str(num))
    n = 0
    inx = 0
    for ind, i in enumerate(ls[::-1]):
        if i < n:
            n = i
            inx = -(ind + 1)
            break
        n = i
    ls[inx], ls[inx + 1] = ls[inx + 1], ls[inx]

    nl = ls[inx::-1][::-1]
    ln = sorted(ls[inx+1:])
    return ''.join(nl) + ''.join(ln)

print PermutationStep(23514)

আউটপুট:

23541

Answer 20

public static void findNext(long number){

        /* convert long to string builder */    

        StringBuilder s = new StringBuilder();
        s.append(number);
        int N = s.length();
        int index=-1,pivot=-1;

/* from tens position find the number (called pivot) less than the number in right */ 

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

             int a = s.charAt(i)-'0';
             int b = s.charAt(i+1)-'0';

             if(a<b){
                pivot = a;
                index =i;
                break;
            }
        }

      /* if no such pivot then no solution */   

        if(pivot==-1) System.out.println(" No such number ")

        else{   

     /* find the minimum highest number to the right higher than the pivot */

            int nextHighest=Integer.MAX_VALUE, swapIndex=-1;

            for(int i=index+1;i<N;i++){

            int a = s.charAt(i)-'0';

            if(a>pivot && a<nextHighest){
                    nextHighest = a;
                    swapIndex=i;
                }
            }


     /* swap the pivot and next highest number */

            s.replace(index,index+1,""+nextHighest);
            s.replace(swapIndex,swapIndex+1,""+pivot);

/* sort everything to right of pivot and replace the sorted answer to right of pivot */

            char [] sort = s.substring(index+1).toCharArray();
            Arrays.sort(sort);

            s.replace(index+1,N,String.copyValueOf(sort));

            System.out.println("next highest number is "+s);
        }

    }

Answer 21

নীচে একটি সংখ্যার সমস্ত ক্রম উত্পাদনের জন্য কোড দেওয়া হয় .. যদিও প্রথমে স্ট্রিং.ভ্যালুওফ (পূর্ণসংখ্যা) ব্যবহার করে সেই সংখ্যাকে স্ট্রিংয়ে রূপান্তর করতে হয়।

/**
 * 
 * Inserts a integer at any index around string.
 * 
 * @param number
 * @param position
 * @param item
 * @return
 */
public String insertToNumberStringAtPosition(String number, int position,
        int item) {
    String temp = null;
    if (position >= number.length()) {
        temp = number + item;
    } else {
        temp = number.substring(0, position) + item
                + number.substring(position, number.length());
    }
    return temp;
}

/**
 * To generate permutations of a number.
 * 
 * @param number
 * @return
 */
public List<String> permuteNumber(String number) {
    List<String> permutations = new ArrayList<String>();
    if (number.length() == 1) {
        permutations.add(number);
        return permutations;
    }
    // else
    int inserterDig = (int) (number.charAt(0) - '0');
    Iterator<String> iterator = permuteNumber(number.substring(1))
            .iterator();
    while (iterator.hasNext()) {
        String subPerm = iterator.next();
        for (int dig = 0; dig <= subPerm.length(); dig++) {
            permutations.add(insertToNumberStringAtPosition(subPerm, dig,
                    inserterDig));
        }
    }
    return permutations;
}

Answer 22

#include<bits/stdc++.h>
using namespace std;
int main() 
{
    int i,j,k,min,len,diff,z,u=0,f=0,flag=0;
    char temp[100],a[100]`enter code here`,n;
    min=9999;
    //cout<<"Enter the number\n";
    cin>>a;
    len=strlen(a);
    for(i=0;i<len;i++)
    {
        if(a[i]<a[i+1]){flag=1;break;}
    }
    if(flag==0){cout<<a<<endl;}
    else
    {
        for(i=len-1;i>=0;i--)if(((int)a[i-1])<((int)a[i]))break;
        for(k=0;k<i-1;k++)cout<<a[k];
        for(j=i;j<len;j++)
        {
            if(((int)a[j]-48)-((int)a[i-1]-48)>0)
            {
                diff=((int)a[j]-48)-((int)a[i-1]-48);
                if(diff<min){n=a[j];min=diff;}
            }
        }
        cout<<n;
        for(z=i-1;z<len;z++)
        {
            temp[u]=a[z];
            u++;
        }
        temp[u]='\0';
        sort(temp,temp+strlen(temp));
        for(z=0;z<strlen(temp);z++){if(temp[z]==n&&f==0){f=1;continue;}cout<<temp[z];}
    }
    return 0;
}

Answer 23

তবুও আরেকটি জাভা বাস্তবায়ন, বাক্সের বাইরে চলে এবং পরীক্ষার সাথে সমাপ্ত। এই সমাধানটি হ'ল পুরাতন গতিশীল প্রোগ্রামিং ব্যবহার করে ও (এন) স্থান এবং সময়।

কেউ যদি ব্রুটফোর্স করতে চায় তবে 2 প্রকারের ব্রুটফোর্স রয়েছে:

1. সমস্ত জিনিস পারমিট করুন, তারপরে কম উচ্চতর চয়ন করুন: ও (এন!)

2. এই বাস্তবায়নের অনুরূপ, তবে ডিপির পরিবর্তে সূচকের জনপ্রিয়করণের পদক্ষেপের প্রতিফলন ঘটবে ইন্ডেক্সটেক্সএন্ডফেক্সেক্সটালমালিকা মানচিত্রটি ও (এন ^ 2) এ চলবে।

---

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

import org.junit.Test;

import static org.junit.Assert.assertEquals;

public class NextHigherSameDigits {

    public long next(final long num) {
        final char[] chars = String.valueOf(num).toCharArray();
        final int[] digits = new int[chars.length];
        for (int i = 0; i < chars.length; i++) {
            digits[i] = Character.getNumericValue(chars[i]);
        }

        final Map<Integer, Integer> indexToIndexOfNextSmallerLeft = new HashMap<>();
        indexToIndexOfNextSmallerLeft.put(1, digits[1] > digits[0] ? 0 : null);
        for (int i = 2; i < digits.length; i++) {
            final int left = digits[i - 1];
            final int current = digits[i];
            Integer indexOfNextSmallerLeft = null;
            if (current > left) {
                indexOfNextSmallerLeft = i - 1;
            } else {
                final Integer indexOfnextSmallerLeftOfLeft = indexToIndexOfNextSmallerLeft.get(i - 1);
                final Integer nextSmallerLeftOfLeft = indexOfnextSmallerLeftOfLeft == null ? null : 
                    digits[indexOfnextSmallerLeftOfLeft];

                if (nextSmallerLeftOfLeft != null && current > nextSmallerLeftOfLeft) {
                    indexOfNextSmallerLeft = indexOfnextSmallerLeftOfLeft;
                } else {
                    indexOfNextSmallerLeft = null;
                }
            }

            indexToIndexOfNextSmallerLeft.put(i, indexOfNextSmallerLeft);
        }

        Integer maxOfindexOfNextSmallerLeft = null;
        Integer indexOfMinToSwapWithNextSmallerLeft = null;
        for (int i = digits.length - 1; i >= 1; i--) {
            final Integer indexOfNextSmallerLeft = indexToIndexOfNextSmallerLeft.get(i);
            if (maxOfindexOfNextSmallerLeft == null ||
                    (indexOfNextSmallerLeft != null && indexOfNextSmallerLeft > maxOfindexOfNextSmallerLeft)) {

                maxOfindexOfNextSmallerLeft = indexOfNextSmallerLeft;
                if (maxOfindexOfNextSmallerLeft != null && (indexOfMinToSwapWithNextSmallerLeft == null || 
                        digits[i] < digits[indexOfMinToSwapWithNextSmallerLeft])) {

                    indexOfMinToSwapWithNextSmallerLeft = i;
                }
            }
        }

        if (maxOfindexOfNextSmallerLeft == null) {
            return -1;
        } else {
            swap(digits, indexOfMinToSwapWithNextSmallerLeft, maxOfindexOfNextSmallerLeft);
            reverseRemainingOfArray(digits, maxOfindexOfNextSmallerLeft + 1);
            return backToLong(digits);
        }
    }

    private void reverseRemainingOfArray(final int[] digits, final int startIndex) {
        final int[] tail = Arrays.copyOfRange(digits, startIndex, digits.length);
        for (int i = tail.length - 1; i >= 0; i--) {
            digits[(digits.length - 1)  - i] = tail[i];                 
        }
    }

    private void swap(final int[] digits, final int currentIndex, final int indexOfNextSmallerLeft) {
        int temp = digits[currentIndex];
        digits[currentIndex] = digits[indexOfNextSmallerLeft];
        digits[indexOfNextSmallerLeft] = temp;
    }

    private long backToLong(int[] digits) {     
        StringBuilder sb = new StringBuilder();
        for (long i : digits) {
            sb.append(String.valueOf(i));
        }

        return Long.parseLong(sb.toString());
    }

    @Test
    public void test() {
        final long input1 =    34722641;
        final long expected1 = 34724126;
        final long output1 = new NextHigherSameDigits().next(input1);
        assertEquals(expected1, output1);

        final long input2 =    38276;
        final long expected2 = 38627;
        final long output2 = new NextHigherSameDigits().next(input2);
        assertEquals(expected2, output2);

        final long input3 =    54321;
        final long expected3 = -1;
        final long output3 = new NextHigherSameDigits().next(input3);
        assertEquals(expected3, output3);

        final long input4 =    123456784987654321L;
        final long expected4 = 123456785123446789L;
        final long output4 = new NextHigherSameDigits().next(input4);
        assertEquals(expected4, output4);

        final long input5 =    9999;
        final long expected5 = -1;
        final long output5 = new NextHigherSameDigits().next(input5);
        assertEquals(expected5, output5);
    }

}

Answer 24

আমাদের ডানদিকে সবচেয়ে বিট 0 খুঁজে বের করতে হবে তার পরে 1 টি এবং এই ডানটিকে সর্বাধিক 0 বিটটিতে 1 এ ফ্লিপ করতে হবে।

উদাহরণস্বরূপ বলা যাক আমাদের ইনপুটটি 487, যা বাইনারিতে 111100111।

আমরা নীচে সবচেয়ে বেশি 0 টি ফ্লিপ করি যা এর অনুসরণ করে 1 রয়েছে

সুতরাং আমরা 111101111 পাই

তবে এখন আমাদের অতিরিক্ত 1 এবং একটি কম 0 রয়েছে, তাই আমরা ফ্লিপ বিটের ডানদিকে 1 এর সংখ্যা 1 দ্বারা কমাতে এবং 0 বিটের সংখ্যাকে 1 দ্বারা বাড়িয়ে ফলন দিচ্ছি

111101011 - বাইনারি 491

int getNextNumber(int input)
{
    int flipPosition=0;
    int trailingZeros=0;
    int trailingOnes=0;
    int copy = input;

    //count trailing zeros
    while(copy != 0 && (copy&1) == 0 )
    {
        ++trailingZeros;

        //test next bit
        copy = copy >> 1;
    }

    //count trailing ones
    while(copy != 0 && (copy&1) == 1 )
    {
        ++trailingOnes;

        //test next bit
        copy = copy >> 1;
    }

    //if we have no 1's (i.e input is 0) we cannot form another pattern with 
    //the same number of 1's which will increment the input, or if we have leading consecutive
    //ones followed by consecutive 0's up to the maximum bit size of a int
    //we cannot increase the input whilst preserving the original no of 0's and
    //1's in the bit pattern
    if(trailingZeros + trailingOnes  == 0 || trailingZeros + trailingOnes == 31)
        return -1;

    //flip first 0 followed by a 1 found from the right of the bit pattern
    flipPosition = trailingZeros + trailingOnes+1;
    input |= 1<<(trailingZeros+trailingOnes);

    //clear fields to the right of the flip position
    int mask = ~0 << (trailingZeros+trailingOnes);
    input &= mask;

    //insert a bit pattern to the right of the flip position that will contain
    //one less 1 to compensate for the bit we switched from 0 to 1
    int insert = flipPosition-1;
    input |= insert;

    return input;
}

Answer 25

int t,k,num3,num5;
scanf("%d",&t);
int num[t];
for(int i=0;i<t;i++){
    scanf("%d",&num[i]);   
}
for(int i=0;i<t;i++){
    k=(((num[i]-1)/3)+1); 
    if(k<0)
        printf("-1");
    else if(num[i]<3 || num[i]==4 || num[i]==7)
        printf("-1");
    else{
        num3=3*(2*num[i] - 5*k);
        num5=5*(3*k -num[i]);
        for(int j=0;j<num3;j++)
            printf("5");
        for(int j=0;j<num5;j++)
            printf("3");
    }
    printf("\n");
}

Answer 26

এখানে জাভা বাস্তবায়ন রয়েছে

public static int nextHigherNumber(int number) {
    Integer[] array = convertToArray(number);
    int pivotIndex = pivotMaxIndex(array);
    int digitInFirstSequence = pivotIndex -1;
    int lowerDigitIndexInSecondSequence = lowerDigitIndex(array[digitInFirstSequence], array, pivotIndex);
    swap(array, digitInFirstSequence, lowerDigitIndexInSecondSequence);
    doRercursiveQuickSort(array, pivotIndex, array.length - 1);
    return arrayToInteger(array);
}

public static Integer[] convertToArray(int number) {
    int i = 0;
    int length = (int) Math.log10(number);
    int divisor = (int) Math.pow(10, length);
    Integer temp[] = new Integer[length + 1];

    while (number != 0) {
        temp[i] = number / divisor;
        if (i < length) {
            ++i;
        }
        number = number % divisor;
        if (i != 0) {
            divisor = divisor / 10;
        }
    }
    return temp;
}

private static int pivotMaxIndex(Integer[] array) {
    int index = array.length - 1;
    while(index > 0) {
        if (array[index-1] < array[index]) {
            break;
        }
        index--;
    }       
    return index;
}

private static int lowerDigitIndex(int number, Integer[] array, int fromIndex) {
    int lowerMaxIndex = fromIndex;
    int lowerMax = array[lowerMaxIndex];
    while (fromIndex < array.length - 1) {
        if (array[fromIndex]> number && lowerMax > array[fromIndex]) {
            lowerMaxIndex = fromIndex; 
        }
        fromIndex ++;
    }
    return lowerMaxIndex;
}

public static int arrayToInteger(Integer[] array) {
    int number = 0;
    for (int i = 0; i < array.length; i++) {
        number+=array[i] * Math.pow(10, array.length-1-i);
    }
    return number;
}

এখানে ইউনিট টেস্ট রয়েছে

@Test
public void nextHigherNumberTest() {
    assertThat(ArrayUtils.nextHigherNumber(34722641), is(34724126));
    assertThat(ArrayUtils.nextHigherNumber(123), is(132));
}

Answer 27

আমি জানি এটি খুব পুরানো প্রশ্ন তবে তবুও আমি সি # তে সহজ কোড পাইনি। এটি সাক্ষাত্কারে অংশ নেওয়া ছেলেদের সহায়তা করতে পারে।

class Program
{
    static void Main(string[] args)
    {

        int inputNumber = 629;
        int i, currentIndexOfNewArray = 0;

        int[] arrayOfInput = GetIntArray(inputNumber);
        var numList = arrayOfInput.ToList();

        int[] newArray = new int[arrayOfInput.Length];

        do
        {
            int temp = 0;
            int digitFoundAt = 0;
            for (i = numList.Count; i > 0; i--)
            {
                if (numList[i - 1] > temp)
                {
                    temp = numList[i - 1];
                    digitFoundAt = i - 1;
                }
            }

            newArray[currentIndexOfNewArray] = temp;
            currentIndexOfNewArray++;
            numList.RemoveAt(digitFoundAt);
        } while (arrayOfInput.Length > currentIndexOfNewArray);



        Console.WriteLine(GetWholeNumber(newArray));

        Console.ReadKey();


    }

    public static int[] GetIntArray(int num)
    {
        IList<int> listOfInts = new List<int>();
        while (num > 0)
        {
            listOfInts.Add(num % 10);
            num = num / 10;
        }
        listOfInts.Reverse();
        return listOfInts.ToArray();
    }

    public static double GetWholeNumber(int[] arrayNumber)
    {
        double result = 0;
        double multiplier = 0;
        var length = arrayNumber.Count() - 1;
        for(int i = 0; i < arrayNumber.Count(); i++)
        {
            multiplier = Math.Pow(10.0, Convert.ToDouble(length));
            result += (arrayNumber[i] * multiplier);
            length = length - 1;
        }

        return result;
    }
}

Answer 28

জাভাস্ক্রিপ্ট ব্যবহার করে খুব সাধারণ বাস্তবায়ন, একই সংখ্যা সহ পরবর্তী সর্বোচ্চ সংখ্যা

/*
Algorithm applied
I) Traverse the given number from rightmost digit, keep traversing till you find a digit which is smaller than the previously traversed digit. For example, if the input number is “534976”, we stop at 4 because 4 is smaller than next digit 9. If we do not find such a digit, then output is “Not Possible”.

II) Now search the right side of above found digit ‘d’ for the smallest digit greater than ‘d’. For “534976″, the right side of 4 contains “976”. The smallest digit greater than 4 is 6.

III) Swap the above found two digits, we get 536974 in above example.

IV) Now sort all digits from position next to ‘d’ to the end of number. The number that we get after sorting is the output. For above example, we sort digits in bold 536974. We get “536479” which is the next greater number for input 534976.

*/

function findNext(arr)
{
  let i;
  //breaking down a digit into arrays of string and then converting back that array to number array
  let arr1=arr.toString().split('').map(Number) ;
  //started to loop from the end of array 
  for(i=arr1.length;i>0;i--)
  {
    //looking for if the current number is greater than the number next to it
    if(arr1[i]>arr1[i-1])
    {// if yes then we break the loop it so that we can swap and sort
      break;}
  }

  if(i==0)
  {console.log("Not possible");}

   else
  {
   //saving that big number and smaller number to the left of it
   let smlNum =arr1[i-1];
    let bigNum =i;
   /*now looping again and checking if we have any other greater number, if we have one AFTER big number and smaller number to the right. 
     A greater number that is of course greater than that smaller number but smaller than the first number we found.
     Why are doing this? Because that is an algorithm to find next higher number with same digits. 
   */
    for(let j=i+1;j<arr1.length;j++)
      {//What if there are no digits afters those found numbers then of course loop will not be initiated otherwise...
        if(arr1[j]> smlNum && arr1[j]<arr1[i])
        {// we assign that other found number here and replace it with the one we found before
          bigNum=j;

        }
      } //now we are doing swapping of places the small num and big number , 3rd part of alogorithm
    arr1[i-1]=arr1[bigNum];
          arr1[bigNum]=smlNum;
    //returning array 
    //too many functions applied sounds complicated right but no, here is the  trick
    //return arr first then apply each function one by one to see output and then further another func to that output to match your needs
    // so here after swapping , 4th part of alogorithm is to sort the array right after the 1st small num we found
    // to do that first we simple take part of array, we splice it and then we apply sort fucntion, then check output (to check outputs, pls use chrome dev console)
    //and then  simply the rest concat and join to main one digit again.
     return arr1.concat((arr1.splice(i,arr1.length)).sort(function(a, b){return a-b})).join('');



    // Sorry to make it too long but its fun explaining things in much easier ways as much as possible!!
  }

}


findNext(1234);

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

Answer 29

অনেক ভাল উত্তর আছে কিন্তু আমি একটি শালীন জাভা বাস্তবায়ন পাইনি। আমার দুটি সেন্ট এখানে:

public void findNext(int[] nums) {
    int i = nums.length - 1;
    // nums[i - 1] will be the first non increasing number
    while (i > 0 && nums[i] <= nums[i - 1]) {
        i--;
    }
    if (i == 0) {
        System.out.println("it has been the greatest already");
    } else {
        // Find the smallest digit in the second sequence that is larger than it:
        int j = nums.length - 1;
        while (j >= 0 && nums[j] < nums[i - 1]) {
            j--;
        }
        swap(nums, i - 1, j);
        Arrays.sort(nums, i, nums.length);
        System.out.println(Arrays.toString(nums));
    }
}

public void swap(int[] nums, int i, int j) {
    int tmp = nums[i];
    nums[i] = nums[j];
    nums[j] = tmp;
}

Answer 30

#include<stdio.h>
#include<cstring>
#include<iostream>
#include<string.h>
#include<sstream>
#include<iostream>

using namespace std;
int compare (const void * a, const void * b)
{
    return *(char*)a-*(char*)b;
}

/*-----------------------------------------------*/

int main()
{
    char number[200],temp;
    cout<<"please enter your number?"<<endl;
    gets(number);
    int n=strlen(number),length;
    length=n;
    while(--n>0)
    {
        if(number[n-1]<number[n])
        {
            for(int i=length-1;i>=n;i--)
            {
                if(number[i]>number[n-1])
                {
                    temp=number[i];
                    number[i]=number[n-1];
                    number[n-1]=temp;
                    break;
                }
            }
            qsort(number+n,length-n,sizeof(char),compare);
            puts(number); 
            return 0;
        }
    }
    cout<<"sorry itz the greatest one :)"<<endl;
}