एक संख्या को देखते हुए, अगली उच्च संख्या ज्ञात करें जिसमें मूल संख्या के समान अंकों का सटीक सेट है

Question

मैंने सिर्फ एक साक्षात्कार पर बमबारी की और अपने साक्षात्कार प्रश्न पर बहुत अधिक शून्य प्रगति की। क्या कोई मुझे बता सकता है कि यह कैसे करना है? मैंने ऑनलाइन खोज करने की कोशिश की, लेकिन कुछ भी नहीं मिला:

किसी संख्या को देखते हुए, अगली उच्च संख्या ज्ञात करें जिसमें मूल संख्या के समान अंकों का सटीक सेट है। उदाहरण के लिए: 38276 रिटर्न 38627 दिया गया

मैं पहले अंक (दाईं ओर से) के सूचकांक को खोजने के द्वारा शुरू करना चाहता था जो कि अंकों से कम था। फिर मैं अंतिम अंकों को सबसेट में घुमाऊंगा, यह एक ही अंक में शामिल होने वाली अगली सबसे बड़ी संख्या थी, लेकिन अटक गई।

साक्षात्कारकर्ता ने एक समय में अंकों को स्वैप करने की कोशिश करने का भी सुझाव दिया, लेकिन मैं एल्गोरिथ्म का पता नहीं लगा सका और सिर्फ 20-30 मिनट के लिए स्क्रीन पर देखा। कहने की जरूरत नहीं है, मुझे लगता है कि मुझे नौकरी का शिकार जारी रखना होगा।

संपादित करें: इसके लायक क्या है, मुझे साक्षात्कार के अगले दौर के लिए आमंत्रित किया गया था

Comments

इसके बारे में बिना सोचे-समझे एक शुरुआत में कम से कम ब्रूट बल अंकों की सभी क्रमपरिवर्तन की गणना करेगा और इनपुट संख्या से बड़ी न्यूनतम संख्या को

— हड़प लेगा

C ++ में आप बस इस्तेमाल कर सकते हैं next_permutation;-)

— thedayturns

FYI करें, यहां मैंने इसे लगभग 15 मिनट में हल कर दिया, जबकि मुश्किल से समस्या के बारे में भी सोचते हुए: मैंने पहली बार 5 मिनट बिताए एक बल-बल एल्गोरिथ्म लिखने में जो कि अंकों के एक सेट के सभी संभावित क्रमों को बनाया, उन्हें हल किया और उन्हें प्रदर्शित किया। मैंने उस डेटा को देखने में 5 मिनट बिताए, जब तक कि सूची से एक पैटर्न नहीं निकला (O (n) यहाँ स्वीकृत समाधान थोड़े समय के बाद ही स्पष्ट हो गया), तब मैंने O (n) एल्गोरिथ्म को कोड करने में 5 मिनट बिताए।

— बेन ली

सामान्य तौर पर, इस प्रकार की समस्या को हल करने के लिए एल्गोरिदम के साथ आने के लिए यह एक बुरा तरीका नहीं है जब आप फंस जाते हैं - बहुत सारे डेटा बनाने के लिए कुछ छोटे नमूने पर ब्रूट बल का उपयोग करें जिसे आप तब पैटर्न को अधिक आसानी से देखने के लिए उपयोग कर सकते हैं।

— बेन ली

मैं यह भी बताना चाहता हूं, यदि आप वास्तव में ऐसा करने के लिए एक कुशल तरीका नहीं निकाल सकते हैं , तो साक्षात्कार को विफल करने का कुछ भी निश्चित तरीका नहीं है (और व्यापार की दुनिया में, यह एक उत्पाद समय सीमा याद करने का एक निश्चित तरीका है) । जब आप फंस गए, तो हार मानने के बजाय, आपको सिर्फ इस बात पर मजबूर होना चाहिए और "TODO: Refactor for performance" या कुछ इस तरह की टिप्पणी करनी चाहिए। अगर मैं साक्षात्कार कर रहा था और किसी ने ऐसा किया, तो मैं जरूरी नहीं कि उन्हें विफल कर दूं। कम से कम वे कुछ के साथ आए जो काम करते थे और मान्यता देते थे कि कुछ बेहतर है, भले ही वे इसे नहीं पा सकते।

— बेन ली

Answer 1

आप इसे O(n)(जहाँ) कर सकते हैंn अंकों की संख्या है) इस तरह से कर सकते हैं:

दाईं ओर से शुरू करते हुए, आप पहले जोड़े के अंकों को ऐसे पाते हैं कि बायां अंक दाएं अंकों से छोटा होता है। आइए "अंक-एक्स" द्वारा बाईं ओर के अंक को देखें। अंक-x के दाईं ओर अंक-x की तुलना में सबसे बड़ी संख्या ज्ञात करें, और इसे तुरंत अंक-x के बाईं ओर रखें। अंत में, शेष अंकों को आरोही क्रम में क्रमबद्ध करें - चूंकि वे पहले से ही अवरोही क्रम में थे , इसलिए आपको केवल उन्हें उल्टा करने की आवश्यकता है (अंक-एक्स के लिए सहेजें, जिसे सही जगह पर रखा जा सकता है।O(n) ) ।

एक उदाहरण इसे और अधिक स्पष्ट करेगा:

123456784987654321
एक नंबर से शुरू करें

123456784 987654321
         ^ दाएं से पहला स्थान जहां बाएं-अंक दाएं से कम है  
         अंक "x" 4 है

123456784 987654321
              ^ सबसे छोटे अंक को दाईं ओर 4 से बड़ा पाते हैं

123456785 4 98764321
        ^ इसे 4 के बाईं ओर रखें

123456785 4 12346789
123456785123446789
         ^ अंकों को दायीं ओर छाँटें 5. चूंकि उनमें से सभी को छोड़कर 
         '4' पहले से ही अवरोही क्रम में थे, हमें बस इतना करना चाहिए 
         उनके आदेश को उल्टा करें, और '4' के लिए सही जगह ढूंढें।

---

शुद्धता का प्रमाण:

अंकों के लिए अंक और निचले मामले को परिभाषित करने के लिए पूंजी अक्षरों का उपयोग करें। वाक्यविन्यास का ABअर्थ है "तार का संघात Aऔर B" । <लेक्सोग्राफिक ऑर्डरिंग है, जो पूर्णांक क्रम के समान है जब अंक-स्ट्रिंग्स समान लंबाई के होते हैं।

हमारा मूल नंबर N फॉर्म का है 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समान अंक हैं। हालांकि, बी, अवरोही क्रम में क्रमित है तो वहाँ है उन अंकों यह से बड़ा के साथ कोई स्ट्रिंग। इस प्रकार हम नहीं कर सकते B < D। उसी चरणों का पालन करते हुए, हम देखते हैं कि यदि z = y, हमारे पास नहीं है D < C।

इसलिए N'मौजूद नहीं हो सकता है, जिसका अर्थ है कि हमारा एल्गोरिथ्म अगले सबसे बड़ी संख्या को सही ढंग से ढूंढता है।

Comments

अच्छा समाधान! एक सवाल है। "x से छोटा सबसे बड़ा अंक" y है। क्या हम केवल x और y स्वैप कर सकते हैं, फिर x.index + 1 -> अंत को उल्टा कर सकते हैं?

— केंट

क्या होता है नंबर 99999?

— स्टीरियो

@Sterex, यह सिर्फ 99999 नहीं है; कोई भी संख्या जिसका अंक पहले से ही पूरी तरह से अवरोही क्रम में है (अधिकतम 98765 का भी कोई हल नहीं है, उदाहरण के लिए)। यह प्रोग्रामेटिक रूप से पता लगाना आसान है क्योंकि एल्गोरिथम का चरण 1 विफल हो जाएगा (लगातार अंकों की कोई जोड़ी नहीं है, जैसे कि "बाएं अंक दाएं अंक से छोटा है")।

— बेन ली

@TMN: 9 8 से बड़ा है, इसलिए आप 9 को 8 के बाईं ओर ले जाएंगे: 9 832फिर सब कुछ 9 के दाईं ओर क्रमबद्ध करें:9238

— BlueRaja - Danny Pflughoeft

@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

A. अंकों के अनुक्रम को दो में विभाजित करें, ताकि दायां भाग घटते क्रम में शेष रहते हुए जितना संभव हो सके:

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

C. बढ़ते क्रम में दूसरे क्रम को क्रमबद्ध करें:

34724 126

डी। हो गया!

34724126

Comments

टाइपो वहाँ: मुझे लगता है "-> 34721 621" "-> 34724 621" होना चाहिए?

— bjnord

@bjnord अच्छा कैच। फिक्स्ड। निश्चित नहीं है कि मैंने कैसे प्रबंधित किया - यह बाद की लाइनों में सही था।

— 16

+1 सबसे अच्छा जवाब यहाँ। सहज और तेज। (यह भी एक है जो मैंने सोचा था कि जब मैंने इसे कागज पर काम किया था;))

— मुहम्मद

@ नील - चरण C में, हम जो अंकों को क्रमबद्ध करना चाहते हैं, वे अवरोही क्रम में हैं, अंकों को छोड़कर, जिन्हें हमने चरण बी में स्वैप किया था। उन्हें क्रमबद्ध करने के लिए हमें वास्तव में उन्हें उल्टा करना होगा और स्वैप किए गए अंक को सही स्थिति में लाना होगा। यह ब्लूराज का वर्णन करता है।

— वेबल

@Dhavaldave क्या समस्या है? चरण ए में आपको "12" और "3" मिलता है। चरण बी में आपको "13" और "2" मिलता है। चरण C में कुछ भी नहीं बदलता है। स्टेप डी में आपको "132" मिलता है। एकमात्र ऐसा मामला जहां आपको जवाब नहीं मिलेगा जब संख्या पहले से ही अधिकतम संभव है, उदाहरण के लिए "321"। उस स्थिति में, चरण A आपको "" और "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)

C ++ में आप इस तरह के क्रमपरिवर्तन कर सकते हैं: 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 जैसे इनपुट के साथ क्यों काम करेगा? धन्यवाद।

— बोवेन लियू

मैंने इसे अजगर 3 के लिए अब thlist () से iis = ... it में जोड़कर तय किया। 111 और 531 मामलों का कोई हल नहीं है, लेकिन मेरा कार्यान्वयन उन लोगों के लिए 111 और 531 रिटर्न करता है। आप इसे बदल सकते हैं जो आपको लगता है कि i == 0 लाइन को बदलने से बेहतर है।

— जोहान लुंडबर्ग

धन्यवाद। मैं वास्तव में दूसरी दिशा में लूप करता हूं इसलिए मैं i == 0 से भ्रमित था, जबकि मेरी स्थिति में यह होगा i == len(iis)।

— बोवेन लियू

Answer 4

कम से कम, यहाँ कुछ उदाहरण हैं brute force String आधारित समाधान, जो आपको अपने सिर के ऊपर से दाईं ओर आने में सक्षम होना चाहिए:

38276क्रमबद्ध अंकों की सूची है23678

38627क्रमबद्ध अंकों की सूची है23678

जानवर बल वृद्धि, प्रकार और तुलना

ब्रूट बल समाधानों के साथ एक स्ट्रिंग में परिवर्तित हो जाएगा और उन अंकों का उपयोग करके सभी संभव संख्याओं को ब्रूट बल प्रदान करेगा।

उन सभी से इन्टस बनाएं, उन्हें एक सूची में डालें और इसे सॉर्ट करें, लक्ष्य प्रविष्टि के बाद अगली प्रविष्टि प्राप्त करें।

यदि आप इस पर 30 मिनट बिताते हैं और कम से कम एक क्रूर बल दृष्टिकोण के साथ नहीं आते हैं, तो मैं आपको किराए पर नहीं दूंगा।

व्यापार की दुनिया में, एक ऐसा समाधान, जो अयोग्य, धीमा और स्पष्ट होता है, लेकिन काम हमेशा बिना किसी समाधान के अधिक मूल्यवान होता है, इस तथ्य की बात है कि सभी व्यवसाय सॉफ्टवेयर का बहुत वर्णन करते हैं, अपात्र, धीमे और भद्दे।

Comments

खैर मेरी बल्ले से पहली टिप्पणी थी "मैं इसे बाध्य कर सकता था लेकिन ..."। अगर वास्तव में एक एल्गोरिथम समाधान नहीं है, तो मैं निराश हूँ

— bhan

यदि मैं साक्षात्कारकर्ता होता, तो मैं एक क्रूर बल दृष्टिकोण से इतना खुश नहीं होता।

— अहमद वाई। सलेह

@ हेब्जामिन हेंन, एल्गोरिथम समाधान है जब तक आपको परिणाम नहीं मिल जाता, तब तक सही से शुरू होने वाले अंकों को स्वैप करते रहें। इससे पहले सभी permutatnios की गणना करने की कोई आवश्यकता नहीं है।

— डंटूच

ब्रूट फोर्स की तुलना में निश्चित रूप से बहुत बेहतर समाधान हैं, उदाहरण के लिए ardendertat.com/2012/01/02/…

— BrokenGlass

@ ब्रोकनग्लास निश्चित रूप से एक बेहतर समाधान है। मैं बस उस विचार के साथ आ रहा था और फिर आपने एल्गोरिथ्म पोस्ट किया।

— 21

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

आपका विचार

मैं पहले अंक (दाईं ओर से) के सूचकांक को खोजने के द्वारा शुरू करना चाहता था जो कि अंकों से कम था। फिर मैं अंतिम अंकों को सबसेट में घुमाऊंगा, यह एक ही अंक में शामिल होने वाली अगली सबसे बड़ी संख्या थी, लेकिन अटक गई।

वास्तव में बहुत अच्छा है। आपको केवल पिछले अंक ही नहीं बल्कि वर्तमान में माने जाने वाले सभी अंकों के कम महत्व पर विचार करना होगा। चूँकि इससे पहले कि हम पहुँच चुके हैं, हमारे पास अंकों का एक मोनोटोनिक अनुक्रम है, जो कि सही पड़ोसी से छोटा सबसे छोटा अंक है। सम्मान

1234675
    ^

अगली बड़ी संख्या में समान अंक होते हैं

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 अंक हैं: abcde

अब d और e को स्वैप करें और मूल संख्या के साथ तुलना करें, यदि यह बड़ा है, तो आपके पास आपका उत्तर है।

यदि यह बड़ा नहीं है, तो e और c स्वैप करें। अब तुलना करें और यदि यह छोटा स्वैप है d और e फिर से (नोटिस पुनरावर्तन), सबसे छोटा लें।

जब तक आप एक बड़ी संख्या नहीं पा लेते हैं पुनरावृत्ति के साथ इसे योजना की लगभग 9 पंक्तियों, या 20 सी # के रूप में काम करना चाहिए।

Answer 9

यह बहुत ही दिलचस्प सवाल है।

यहाँ मेरा जावा संस्करण है। इससे पहले कि मैं अन्य योगदानकर्ताओं की टिप्पणियों की जांच करूं, कोड को पूरी तरह से समाप्त करने के लिए पैटर्न का पता लगाने से मुझे लगभग 3 घंटे लगते हैं। मुझे खुशी है कि मेरा विचार दूसरों के साथ समान है।

ओ (एन) समाधान। ईमानदारी से, मैं इस साक्षात्कार को विफल कर दूंगा यदि समय केवल 15 मिनट है और सफेद बोर्ड पर पूर्ण कोड खत्म करने की आवश्यकता है।

यहाँ मेरे समाधान के लिए दिलचस्प के कुछ बिंदु हैं:

• किसी भी छँटाई से बचें।
• स्ट्रिंग ऑपरेशन से पूरी तरह बचें
• O (logN) अंतरिक्ष जटिलता प्राप्त करें

मैंने अपने कोड में विस्तार से टिप्पणी की, और प्रत्येक चरण में बिग ओ।

  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;

}

यहाँ परिणाम Intellj में चल रहा है:

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

एक समाधान (जावा में) निम्नलिखित हो सकता है (मुझे यकीन है कि दोस्तों को यहां एक बेहतर मिल सकता है):
स्ट्रिंग के अंत से अंक स्वैप करना शुरू करें जब तक कि आप एक उच्च संख्या प्राप्त नहीं करते।
यानी जब आप अगली उच्च हिट करते हैं, तो पहले निचले अंक को आगे बढ़ाना शुरू करें।
फिर बाकी को छांटें। आपके उदाहरण में आपको मिलेगा:

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: आपकी मदद के लिए धन्यवाद। मैंने कोड को निम्नानुसार बदल दिया है: कम से कम डिजिट अपफ्रंट (जो कभी अधिक संख्या में उपज देता है) को स्थानांतरित करें और बाकी को

— छाँटें

Answer 12

यदि आप C ++ में प्रोग्रामिंग कर रहे हैं, तो आप उपयोग कर सकते हैं 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? :-)

— ज्वेरीच

Answer 13

मुझे इस सवाल का जवाब देते समय जानवर बल एल्गोरिथ्म के बारे में कुछ नहीं पता था, इसलिए मैंने इसे दूसरे कोण से संपर्क किया। मैंने संभावित समाधानों की पूरी श्रृंखला की खोज करने का निर्णय लिया है कि इस संख्या को संभवतः पुनर्व्यवस्थित किया जा सकता है, जो कि नंबर_given + 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

PHP कोड

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

मैंने केवल दो नंबरों से इसका परीक्षण किया है। उन्होंने काम किया। पिछले दिसंबर तक रिटायर होने तक 8 साल तक आईटी मैनेजर के रूप में, मैंने तीन चीजों की परवाह की: 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

दिए गए n अंक संख्या में 9 जोड़ें। फिर जांचें कि क्या यह सीमा के भीतर है (पहला (n + 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

नीचे एक संख्या के सभी क्रमचय उत्पन्न करने के लिए कोड है .. हालांकि किसी को पहले उस स्ट्रिंग को स्ट्रिंग में परिवर्तित करना होगा। पहले String.valueOf (पूर्णांक) का उपयोग करके।

/**
 * 
 * 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. इस कार्यान्वयन के समान है, लेकिन DP के बजाय, indexToIndexOfNextSmallerLeft मानचित्र को पॉप करने के कदम को bruteforcing O (n ^ 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

हमें 1 के बाद सबसे सही 0 बिट को खोजने की आवश्यकता है और इस सही 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

मुझे पता है कि यह बहुत पुराना सवाल है लेकिन फिर भी मुझे c # में आसान कोड नहीं मिला। यह उन लोगों की मदद कर सकता है जो साक्षात्कार में भाग ले रहे हैं।

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;
}