একটি তালিকাতে না হলেও ক্ষুদ্রতম পূর্ণসংখ্যার সন্ধান করুন

Question 1

একটি আকর্ষণীয় সাক্ষাত্কার প্রশ্ন যা আমার সহকর্মী ব্যবহার করে:

মনে করুন যে আপনাকে স্বাক্ষরযুক্ত স্বাক্ষরিত 64-বিট পূর্ণসংখ্যার একটি খুব দীর্ঘ, অরসামুক্ত তালিকা দেওয়া হয়েছে। তালিকায় যে ক্ষুদ্রতম অ-নেতিবাচক পূর্ণসংখ্যার সংঘটিত হয় না তা কীভাবে খুঁজে পাবেন ?

অনুসরণ-উত্তর: এখন বাছাইয়ের মাধ্যমে সুস্পষ্ট সমাধানের প্রস্তাব দেওয়া হয়েছে, আপনি ও (এন লগ এন) এর চেয়ে দ্রুত এটি করতে পারেন?

অনুসরণ-উত্তর: আপনার অ্যালগরিদমটি একটি কম্পিউটারে চালাতে হবে, বলুন, 1 গিগাবাইট মেমরি রয়েছে

স্পষ্টকরণ: তালিকাটি র‍্যামে রয়েছে, যদিও এটি এটির প্রচুর পরিমাণে গ্রাস করতে পারে। আপনাকে তালিকার আকার দেওয়া হবে, আগে এন বলে।

Question 2

যদি ডেটাস্ট্রাকচারটি জায়গায় পরিবর্তিত হতে পারে এবং এলোমেলো অ্যাক্সেস সমর্থন করে তবে আপনি ও (এন) সময় এবং ও (1) অতিরিক্ত জায়গায় এটি করতে পারেন। কেবল ক্রমানুসারে অ্যারের মধ্য দিয়ে যান এবং প্রতিটি সূচকের জন্য সূচকে মান অনুসারে সূচকটিতে মান লিখুন, পুনরাবৃত্তভাবে যে কোনও স্থানে তার স্থানে রেখে মানগুলি ছুঁড়ে দিয়ে দিন> N. তারপরে অ্যারের মধ্য দিয়ে আবার স্পটটি সন্ধান করুন যেখানে মান সূচকের সাথে মেলে না - এটি অ্যারেতে নয় সর্বকনিষ্ঠতম মান। এটি সর্বাধিক 3 এন তুলনাতে ফলাফল দেয় এবং অস্থায়ী স্থানের জন্য কয়েকটি মান ব্যবহার করে।

# Pass 1, move every value to the position of its value
for cursor in range(N):
    target = array[cursor]
    while target < N and target != array[target]:
        new_target = array[target]
        array[target] = target
        target = new_target

# Pass 2, find first location where the index doesn't match the value
for cursor in range(N):
    if array[cursor] != cursor:
        return cursor
return N

Question 3

এখানে একটি সহজ O(N)সমাধান যা O(N)স্থান ব্যবহার করে। আমি ধরে নিচ্ছি যে আমরা ইনপুট তালিকাটি অ-নেতিবাচক সংখ্যাগুলিতে সীমাবদ্ধ করছি এবং আমরা প্রথম অ-নেতিবাচক সংখ্যাটি খুঁজতে চাই যা তালিকায় নেই।

তালিকার দৈর্ঘ্য সন্ধান করুন; যাক এটি হয় N।
Nসকলের কাছে আরম্ভ করে বুলিয়ানগুলির একটি অ্যারে বরাদ্দ করুন false।
Xতালিকার প্রতিটি সংখ্যার জন্য , যদি এর Xচেয়ে কম হয় তবে অ্যারের উপাদানটি Nসেট করুন ।X'thtrue
সূচক থেকে শুরু করে অ্যারের স্ক্যান করুন 0, এটি প্রথম উপাদানটির সন্ধান করুন false। আপনি যদি falseসূচকে প্রথমটি খুঁজে পান Iতবে Iতার উত্তর। অন্যথায় (অর্থাত্ যখন সমস্ত উপাদান থাকে true) উত্তরটি N।

বাস্তবে, "অ্যারে NBooleans" সম্ভবত একটি "বিটম্যাপ" বা "bitset" একটি হিসাবে প্রতিনিধিত্ব হিসাবে এনকোডেড হবে byteবা intঅ্যারে। এটি সাধারণত কম স্থান ব্যবহার করে (প্রোগ্রামিং ভাষার উপর নির্ভর করে) এবং প্রথমটির জন্য স্ক্যানটি falseআরও দ্রুত সম্পন্ন করার অনুমতি দেয় ।

এইভাবে / কেন অ্যালগোরিদম কাজ করে।

ধরুন যে তালিকার Nসংখ্যাগুলি পৃথক নয় বা তাদের এক বা একাধিকের চেয়ে বেশি N। এর অর্থ হল যে তালিকাতে নেই এমন ব্যাপ্তিতে কমপক্ষে একটি সংখ্যা থাকতে হবে 0 .. N - 1। সমস্যা ক্ষুদ্রতম অনুপস্থিত সংখ্যা অতএব ক্ষুদ্রতম অনুপস্থিত সংখ্যা খুঁজে বের করার সমস্যা কমাতে হবে এটি তাই কমN । এর অর্থ হ'ল আমাদের বৃহত্তর বা সমান সংখ্যার ট্র্যাক রাখতে Nহবে না ... কারণ সেগুলির উত্তর হবে না।

পূর্ববর্তী অনুচ্ছেদের বিকল্পটি হ'ল তালিকাগুলিটি সংখ্যার একটি ক্রমশক্তি 0 .. N - 1। এই ক্ষেত্রে, পদক্ষেপ 3 অ্যারের সমস্ত উপাদানকে সেট করে trueএবং চতুর্থ ধাপ আমাদের জানায় যে প্রথম "অনুপস্থিত" নম্বরটি রয়েছে N।

অ্যালগরিদমের গণ্য জটিলতা O(N)তুলনামূলক তুলনামূলকভাবে ছোট ধ্রুবক সহ। এটি তালিকার মধ্য দিয়ে দুটি লিনিয়ার পাস করে বা তালিকার দৈর্ঘ্য শুরু হওয়ার সাথে পরিচিত হলে কেবল একটি পাস করে। স্মৃতিতে পুরো তালিকাটি ধরে রাখার দরকার নেই, সুতরাং অ্যালগরিদমের অ্যাসিম্পটোটিক মেমরির ব্যবহার বুলিয়ানগুলির অ্যারের প্রতিনিধিত্ব করার জন্য যা প্রয়োজন; অর্থাত্ O(N)বিটস

(বিপরীতে, অ্যালগরিদমগুলি যা মেমোরি অনুসারে বাছাই বা বিভাজনের উপর নির্ভর করে আপনি ধরে রাখেন যে আপনি মেমরির মধ্যে পুরো তালিকাটি উপস্থাপন করতে পারেন the ফর্মটিতে প্রশ্নটি জিজ্ঞাসা করা হয়েছিল, এর জন্য প্রয়োজন O(N)64৪-বিট শব্দ require

@ জর্ন মন্তব্য করেছেন যে 1 থেকে 3 ধাপে ধাপগুলি গণনা বাছাইয়ের ক্ষেত্রে ভিন্নতা। এক অর্থে তিনি সঠিক, তবে পার্থক্যগুলি উল্লেখযোগ্য:

একটি গণনা বাছাইয়ের জন্য (কমপক্ষে) Xmax - Xminকাউন্টারগুলির একটি অ্যারে প্রয়োজন যেখানে Xmaxতালিকার বৃহত্তম সংখ্যা এবং তালিকার Xminসবচেয়ে ছোট সংখ্যা। প্রতিটি কাউন্টারে এন রাজ্যগুলির প্রতিনিধিত্ব করতে সক্ষম হতে হবে; অর্থাত্ বাইনারি উপস্থাপনা ধরে নিয়ে এটিতে একটি পূর্ণসংখ্যা টাইপ (কমপক্ষে) ceiling(log2(N))বিট থাকতে হবে।
অ্যারের আকার নির্ধারণ করতে, একটি গণনা বাছাইয়ের জন্য নির্ধারণের জন্য তালিকার মধ্য দিয়ে একটি প্রাথমিক পাস করা প্রয়োজন Xmaxএবং Xmin।
সর্বনিম্ন সবচেয়ে খারাপ ক্ষেত্রে স্থান প্রয়োজন তাই ceiling(log2(N)) * (Xmax - Xmin)বিট।

বিপরীতে, উপরে উপস্থাপিত অ্যালগরিদমের জন্য Nসবচেয়ে খারাপ এবং সেরা ক্ষেত্রে বিটগুলির প্রয়োজন ।

যাইহোক, এই বিশ্লেষণটি স্বজ্ঞাততার দিকে নিয়ে যায় যে অ্যালগরিদম যদি শূন্যের সন্ধানের জন্য তালিকার মধ্য দিয়ে প্রাথমিক পাস করে (এবং প্রয়োজনে তালিকার উপাদানগুলি গণনা করছে) তবে শূন্যটি পাওয়া গেলে এটি কোনও স্থান ব্যবহার না করে একটি দ্রুত উত্তর দেবে। তালিকায় কমপক্ষে একটি শূন্য খুঁজে পাওয়ার উচ্চ সম্ভাবনা থাকলে এটি অবশ্যই করা উচিত worth এবং এই অতিরিক্ত পাস সামগ্রিক জটিলতা পরিবর্তন করে না।

সম্পাদনা: আমি "বুলিয়ান্সের অ্যারে" ব্যবহার করার জন্য অ্যালগরিদমের বিবরণ পরিবর্তন করেছি যেহেতু লোকেরা বিট এবং বিটম্যাপগুলি বিভ্রান্ত হওয়ার জন্য দৃশ্যত আমার মূল বিবরণটি পেয়েছে।

Question 4

যেহেতু ওপি এখন সুনির্দিষ্টভাবে জানিয়েছে যে মূল তালিকাটি র‌্যামে রয়েছে এবং কম্পিউটারটি কেবলমাত্র 1 গিগাবাইট মেমরি বলে, আমি একটি অঙ্গ নিয়ে বেরিয়ে যাচ্ছি এবং উত্তরটি শূন্য বলে অনুমান করে।

1 জিবি র‌্যামের অর্থ তালিকার এতে সর্বাধিক 134,217,728 নম্বর থাকতে পারে। তবে সম্ভাব্য সংখ্যা 2 ⁶⁴ = 18,446,744,073,709,551,616। সুতরাং তালিকায় শূন্য হওয়ার সম্ভাবনাটি 137,438,953,472 এ 1।

বিপরীতে, এই বছর বজ্রপাতের ফলে আমার প্রতিক্রিয়া 700,000 এর মধ্যে 1 are এবং আমার প্রতিক্রিয়া একটি উল্কাপিণ্ডের দ্বারা আঘাত হানার প্রতিক্রিয়া প্রায় 10 ট্রিলিয়ন মধ্যে 1। সুতরাং উত্তরটি শূন্য না হওয়ার চেয়ে এক মহাকাশীয় বস্তুর দ্বারা আমার অকাল মৃত্যুর কারণে আমি বৈজ্ঞানিক জার্নালে প্রায় দশগুণ বেশি লিখিত হওয়ার সম্ভাবনা পেয়েছি।

Question 5

অন্যান্য উত্তরে যেমন নির্দেশিত হয়েছে আপনি কোনও বাছাই করতে পারেন এবং তারপরে কোনও ফাঁক না পাওয়া পর্যন্ত কেবল স্ক্যান আপ করুন।

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

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

এটি প্রচুর পরিমাণে গণনা সংরক্ষণ করে।

Question 6

O(N)চিন্তাভাবনার অন্যতম ক্ষতি চিত্রিত করার জন্য , এখানে একটি O(N)অ্যালগরিদম যা O(1)স্থান ব্যবহার করে।

for i in [0..2^64):
  if i not in list: return i

print "no 64-bit integers are missing"

Question 7

যেহেতু সংখ্যাগুলি সমস্ত b৪ বিট দীর্ঘ, তাই আমরা তাদের উপর রেডিক্স বাছাই করতে পারি যা ও (এন)। 'Em' বাছাই করুন, তারপরে আপনার স্ক্যান করুন যতক্ষণ না আপনি যা সন্ধান করছেন।

যদি ক্ষুদ্রতম সংখ্যাটি শূন্য হয় তবে কোনও ফাঁক না পাওয়া পর্যন্ত এগিয়ে স্ক্যান করুন। ক্ষুদ্রতম সংখ্যাটি যদি শূন্য না হয় তবে উত্তরটি শূন্য।

Question 8

একটি স্থান দক্ষ পদ্ধতির জন্য এবং সমস্ত মান পৃথক পৃথক আপনি স্থান O( k )এবং সময় এটি করতে পারেন O( k*log(N)*N )। এটি স্পেস দক্ষ এবং কোনও ডেটা চলমান নেই এবং সমস্ত ক্রিয়াকলাপ প্রাথমিক (বিয়োগফল যোগ করে)।

সেট U = N; L=0
প্রথমে kঅঞ্চলগুলিতে নম্বর স্থানকে বিভক্ত করুন । এটার মত:
- 0->(1/k)*(U-L) + L, 0->(2/k)*(U-L) + L, 0->(3/k)*(U-L) + L...0->(U-L) + L
count{i}প্রতিটি অঞ্চলে কত সংখ্যক ( ) রয়েছে তা সন্ধান করুন। ( N*kপদক্ষেপ)
প্রথম অঞ্চলটি ( h) পূরণ করুন যা পূর্ণ নয়। তার মানে count{h} < upper_limit{h}। ( kপদক্ষেপ)
যদি h - count{h-1} = 1তোমার উত্তর পেয়ে থাকে
সেট U = count{h}; L = count{h-1}
গোটো 2

এটি হ্যাশিং ব্যবহার করে উন্নত করা যেতে পারে (নিক এই ধারণার জন্য ধন্যবাদ)।

একই
প্রথমে kঅঞ্চলগুলিতে নম্বর স্থানকে বিভক্ত করুন । এটার মত:
- L + (i/k)->L + (i+1/k)*(U-L)
inc count{j} ব্যবহার j = (number - L)/k (if L < number < U)
প্রথম অঞ্চল ( h) সন্ধান করুন যাতে এতে কে উপাদান নেই
যদি count{h} = 1এইচ আপনার উত্তর হয়
সেট U = maximum value in region h L = minimum value in region h

এটি চলবে O(log(N)*N)।

Question 9

আমি কেবল এগুলি সাজিয়েছি তারপরেই আমি ক্রমটি চালাচ্ছি যতক্ষণ না আমি একটি ফাঁক (শূন্য এবং প্রথম সংখ্যার মধ্যবর্তী শূন্যতা সহ) খুঁজে পাই।

অ্যালগরিদমের ক্ষেত্রে, এর মতো কিছু এটি করবে:

def smallest_not_in_list(list):
    sort(list)
    if list[0] != 0:
        return 0
    for i = 1 to list.last:
        if list[i] != list[i-1] + 1:
            return list[i-1] + 1
    if list[list.last] == 2^64 - 1:
        assert ("No gaps")
    return list[list.last] + 1

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

আমি সন্দেহ করি যে আপনি ও (এন) এর উপরে উন্নতি করতে পারেন যেহেতু আমি এটি করার কোনও উপায় দেখতে পাচ্ছি না যাতে প্রতিটি সংখ্যার দিকে একবার অন্তত একবার দেখার অন্তর্ভুক্ত থাকে না।

এটির জন্য অ্যালগরিদম এর লাইনের সাথে থাকবে:

def smallest_not_in_list(list):
    bitmask = mask_make(2^64) // might take a while :-)
    mask_clear_all (bitmask)
    for i = 1 to list.last:
        mask_set (bitmask, list[i])
    for i = 0 to 2^64 - 1:
        if mask_is_clear (bitmask, i):
            return i
    assert ("No gaps")

Question 10

তালিকাটি বাছাই করুন, প্রথম এবং দ্বিতীয় উপাদানগুলি দেখুন এবং কোনও ফাঁক না হওয়া পর্যন্ত উপরে যেতে শুরু করুন।

Question 11

লুকানো ফ্যাক্টরটি বেশ বড় হলেও আপনি ও (এন) সময় এবং ও (1) অতিরিক্ত জায়গায় এটি করতে পারেন। সমস্যাটি সমাধান করার এটি কোনও ব্যবহারিক উপায় নয়, তবে তা তবে এটি আকর্ষণীয় হতে পারে।

প্রতিটি স্বাক্ষরবিহীন -৪-বিট পূর্ণসংখ্যার জন্য (আরোহী ক্রমে) তালিকার উপরে পুনরাবৃত্তি করুন যতক্ষণ না আপনি লক্ষ্য পূর্ণসংখ্যার সন্ধান পান বা আপনি তালিকার শেষের দিকে না পৌঁছান। আপনি যদি তালিকার শেষে পৌঁছে যান, লক্ষ্য পূর্ণসংখ্যা হল ক্ষুদ্রতম পূর্ণসংখ্যার তালিকায় নয়। আপনি যদি 64-বিট পূর্ণসংখ্যার শেষে পৌঁছে থাকেন তবে প্রতিটি 64-বিট পূর্ণসংখ্যার তালিকায় রয়েছে।

এখানে এটি পাইথন ফাংশন হিসাবে রয়েছে:

def smallest_missing_uint64(source_list):
    the_answer = None

    target = 0L
    while target < 2L**64:

        target_found = False
        for item in source_list:
            if item == target:
                target_found = True

        if not target_found and the_answer is None:
            the_answer = target

        target += 1L

    return the_answer

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

Question 12

আমার অনুপ্রেরণার জন্য ইওন, সোয়েডেন এবং স্টিফেন সিকে ধন্যবাদ। প্রথমত, আমরা লক্ষ্য মানের সীমানা জানি কারণ এটি তালিকার আকারের চেয়ে বড় হতে পারে না। এছাড়াও, 1 জিবি তালিকায় সর্বাধিক 134217728 (128 * 2 ^ 20) -৪-বিট পূর্ণসংখ্যা থাকতে পারে।

হ্যাশিং অংশটি হ্যাশিং
ব্যবহার করে আমাদের অনুসন্ধানের স্থানটি নাটকীয়ভাবে হ্রাস করার প্রস্তাব করছি। প্রথমে তালিকাটির আকার বর্গমূল করুন। 1 জিবি তালিকার জন্য, এটি এন = 11,586। আকারের একটি পূর্ণসংখ্যার অ্যারে সেট করুন N. তালিকার মাধ্যমে আইট্রেট করুন এবং আপনার হ্যাশ হিসাবে খুঁজে পাওয়া প্রতিটি সংখ্যার বর্গমূল নিন take আপনার হ্যাশ টেবিলে, সেই হ্যাশের জন্য কাউন্টারটি বাড়িয়ে দিন। এর পরে, আপনার হ্যাশ টেবিলটি দিয়ে পুনরাবৃত্তি করুন। আপনি যে প্রথম বালতিটি খুঁজে পান এটি সর্বাধিক আকারের সমান নয় আপনার নতুন অনুসন্ধানের স্থানটি সংজ্ঞায়িত করে।

বিটম্যাপ অংশ
এখন আপনার নতুন অনুসন্ধানের জায়গার আকারের সমান নিয়মিত বিট ম্যাপ সেটআপ করুন এবং উত্স তালিকার মাধ্যমে পুনরাবৃত্তি করুন, আপনার অনুসন্ধানের জায়গার প্রতিটি সংখ্যা খুঁজে পাওয়ার সাথে সাথে বিটম্যাপটি পূরণ করুন। আপনি যখন সম্পন্ন করবেন, আপনার বিটম্যাপে প্রথম আনসেট বিট আপনাকে আপনার উত্তর দেবে।

এটি ও (এন) সময় এবং ও (স্কয়ার্ট (এন)) স্পেসে সম্পন্ন হবে।

(* আপনি আরও বেশি দক্ষতার সাথে এটি করার জন্য বিট শিফটিংয়ের মতো কিছু ব্যবহার করতে পারেন এবং সেই অনুযায়ী বালতির সংখ্যা এবং আকারের পরিমাণও পরিবর্তিত হতে পারে))

Question 13

ঠিক আছে যদি সংখ্যার তালিকায় একটি মাত্র অনুপস্থিত নম্বর থাকে তবে অনুপস্থিত নম্বরটি খুঁজে পাওয়ার সহজতম উপায় হল সিরিজটি যোগ করা এবং তালিকার প্রতিটি মান বিয়োগ করা। চূড়ান্ত মানটি অনুপস্থিত নম্বর।

Question 14

 int i = 0;
            while ( i < Array.Length)
            {

                if (Array[i] == i + 1)
                {
                    i++;
                }

                if (i < Array.Length)
                {
                    if (Array[i] <= Array.Length)
                    {//SWap

                        int temp = Array[i];
                        int AnoTemp = Array[temp - 1];
                        Array[temp - 1] = temp;
                        Array[i] = AnoTemp;

                    }
                    else
                       i++;



                }
            }

            for (int j = 0; j < Array.Length; j++)
            {
                if (Array[j] > Array.Length)
                {
                    Console.WriteLine(j + 1);
                    j = Array.Length;
                }
                else
                    if (j == Array.Length - 1)
                        Console.WriteLine("Not Found !!");

            }
        }

Question 15

সংখ্যাগুলি ধরে রাখতে আমরা একটি হ্যাশ টেবিল ব্যবহার করতে পারি। সমস্ত সংখ্যা শেষ হয়ে গেলে, 0 থেকে একটি পাল্টা চালান যতক্ষণ না আমরা সবচেয়ে কম খুঁজে পাই। একটি যুক্তিসঙ্গতভাবে ভাল হ্যাশ স্থির সময়ে হ্যাশ এবং সঞ্চয় করা হবে, এবং ধ্রুবক সময়ে পুনরুদ্ধার।

for every i in X         // One scan Θ(1)
   hashtable.put(i, i);  // O(1)

low = 0;

while (hashtable.get(i) <> null)   // at most n+1 times
   low++;

print low;

সবচেয়ে খারাপ ক্ষেত্রে যদি nঅ্যারেতে উপাদান থাকে এবং {0, 1, ... n-1}যদি হয় তবে উত্তরটি nএখনও পাওয়া যাচ্ছে O(n)।

Question 16

জাভাতে আমার উত্তরটি এখানে লেখা:

বেসিক আইডিয়া: 1- অ্যারের মাধ্যমে লুপটি ডুপ্লিকেট পজিটিভ, জিরো এবং নেগেটিভ সংখ্যাগুলি ফেলে রেখে বাকী সংখ্যার সর্বাধিক ধনাত্মক সংখ্যা পেয়ে যায় এবং মানচিত্রে অনন্য ধনাত্মক সংখ্যা রাখে।

2- যোগফলকে সর্বোচ্চ * (সর্বোচ্চ + 1) / 2 হিসাবে গণনা করুন।

3- পদক্ষেপ 1 এবং 2 তে গণনা করা অঙ্কের মধ্যে পার্থক্যটি সন্ধান করুন

4- আবার 1 থেকে সর্বনিম্ন [অঙ্কের পার্থক্য, সর্বাধিক] এ লুপ করুন এবং প্রথম নম্বরে ফিরে যান যা ম্যাপে নেই 1 ধাপে জনবহুল।

public static int solution(int[] A) {
    if (A == null || A.length == 0) {
        throw new IllegalArgumentException();
    }

    int sum = 0;
    Map<Integer, Boolean> uniqueNumbers = new HashMap<Integer, Boolean>();
    int max = A[0];
    for (int i = 0; i < A.length; i++) {
        if(A[i] < 0) {
            continue;
        }
        if(uniqueNumbers.get(A[i]) != null) {
            continue;
        }
        if (A[i] > max) {
            max = A[i];
        }
        uniqueNumbers.put(A[i], true);
        sum += A[i];
    }
    int completeSum = (max * (max + 1)) /  2;
    for(int j = 1; j <= Math.min((completeSum - sum), max); j++) {
        if(uniqueNumbers.get(j) == null) { //O(1)
            return j;
        }
    }
    //All negative case
    if(uniqueNumbers.isEmpty()) {
        return 1;
    }
    return 0;
}

Question 17

স্টিফেন সি স্মার্টভাবে উল্লেখ করেছেন যে, উত্তরটি অ্যারের দৈর্ঘ্যের চেয়ে ছোট একটি সংখ্যা হতে হবে। আমি তখন বাইনারি অনুসন্ধান করে উত্তরটি খুঁজে পাব। এটি সবচেয়ে খারাপ ক্ষেত্রে অনুকূল করে (যাতে সাক্ষাত্কারকারীর আপনাকে 'যদি তবে' প্যাথলজিকাল দৃশ্যে ধরতে না পারে)। একটি সাক্ষাত্কারে, উল্লেখ করুন যে আপনি সবচেয়ে খারাপ ক্ষেত্রে অনুকূল করতে এটি করছেন।

বাইনারি অনুসন্ধান ব্যবহারের উপায় হ'ল অ্যারের প্রতিটি উপাদান থেকে আপনি যে নম্বরটি সন্ধান করছেন তা বিয়োগ করা এবং নেতিবাচক ফলাফলগুলি পরীক্ষা করা।

Question 18

আমি "অনুমান শূন্য" অ্যাপ্র্যাচ পছন্দ করি। যদি সংখ্যাগুলি এলোমেলো হয় তবে শূন্যটি অত্যন্ত সম্ভাব্য। যদি "পরীক্ষক" একটি নন-র্যান্ডম তালিকা সেট করে থাকেন, তবে একটি যুক্ত করুন এবং আবার অনুমান করুন:

LowNum=0
i=0
do forever {
  if i == N then leave /* Processed entire array */
  if array[i] == LowNum {
     LowNum++
     i=0
     }
   else {
     i++
   }
}
display LowNum

সবচেয়ে খারাপ পরিস্থিতি হল এন * এন এর সাথে এন = এন, তবে অনুশীলনে এন খুব কম সংখ্যক হওয়ার সম্ভাবনা রয়েছে (উদাঃ 1)

Question 19

আমি প্রশ্ন পেয়েছি কিনা তা নিশ্চিত নই। তবে যদি 1,2,3,5,6 তালিকার জন্য এবং নিখোঁজ সংখ্যা 4 হয় তবে অনুপস্থিত নম্বরটি ও (এন) এর মাধ্যমে পাওয়া যাবে: (এন + 2) (এন + 1) / 2- (এন + 1) এন / 2

সম্পাদনা: দুঃখিত, আমি অনুমান করি গত রাতে খুব দ্রুত ভাবছিলাম। যাইহোক, দ্বিতীয় অংশটি আসলে যোগফল (তালিকা) দ্বারা প্রতিস্থাপন করা উচিত, যেখানে ও (এন) আসে। সূত্রটি এর পেছনের ধারণাটি প্রকাশ করে: এন সিক্যুয়াল পূর্ণ সংখ্যার জন্য, যোগফলটি (n + 1) * n / 2 হওয়া উচিত। যদি কোনও অনুপস্থিত নম্বর থাকে তবে যোগফলটি (n + 1) অনুক্রমিক পূর্ণসংখ্যার বিয়োগের অনুপাতের যোগফলের সমান হবে।

আমি মনে মনে কিছু মাঝখানে টুকরো টুকরো করছিলাম তা উল্লেখ করার জন্য ধন্যবাদ।

Question 20

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

#define SWAP(x,y) { numerictype_t tmp = x; x = y; y = tmp; }
int minNonNegativeNotInArr (numerictype_t * a, size_t n) {
    int m = n;
    for (int i = 0; i < m;) {
        if (a[i] >= m || a[i] < i || a[i] == a[a[i]]) {
            m--;
            SWAP (a[i], a[m]);
            continue;
        }
        if (a[i] > i) {
            SWAP (a[i], a[a[i]]);
            continue;
        }
        i++;
    }
    return m;
}

মি "বর্তমান প্রথম সর্বাধিক সম্ভাব্য আউটপুট উপস্থাপন করে যা আমি প্রথম ইনপুট সম্পর্কে জানি এবং এম -1 এ এন্ট্রি না হওয়া পর্যন্ত মানগুলি সম্পর্কে কিছুই ধরে নি"।

মিটার এই মানটি কেবল তখনই ফিরে আসবে (a [i], ..., a [m-1]) মানগুলির একটি অনুচ্ছেদ হলে (i, ..., m-1)। সুতরাং যদি একটি [i]> = মি বা যদি একটি [আই] <আই বা যদি একটি [আই] == এ [এ [আই]] আমরা জানি যে এমটি ভুল আউটপুট এবং অবশ্যই কমপক্ষে একটি উপাদান কম থাকবে। সুতরাং এম হ্রাস এবং একটি [আমি] একটি [এম] দিয়ে আমরা পুনরাবৃত্তি করতে পারব app

যদি এটি সত্য না হয় তবে একটি [i]> আমি তখন জেনেছি যে একটি [i]! = ক [একটি [আমি]] আমরা জানি যে একটি [আমি] একটি [একটি [আমি]] দিয়ে অদলবদল করার ফলে উপাদানগুলির সংখ্যা বাড়বে তাদের নিজস্ব জায়গায়।

অন্যথায় একটি [i] অবশ্যই আমার সমান হবে যে ক্ষেত্রে আমরা এই বর্ধিত করতে পারি যে জেনেছি যে এই সূচকগুলি পর্যন্ত এবং এর সমস্ত মানগুলি তাদের সূচকের সমান।

এটি যে অসীম লুপটিতে প্রবেশ করতে পারে না তার প্রমাণ পাঠকের কাছে অনুশীলন হিসাবে রেখে গেছে। :)

Question 21

Dafny পিঁপড়া 'উত্তর শো থেকে টুকরা কেন ইন-জায়গা অ্যালগরিদম বিফল হতে পারে। requiresপূর্বশর্ত বর্ণনা প্রতিটি আইটেমের মান অ্যারের সীমার অতিক্রম না।

method AntsAasma(A: array<int>) returns (M: int)
  requires A != null && forall N :: 0 <= N < A.Length ==> 0 <= A[N] < A.Length;
  modifies A; 
{
  // Pass 1, move every value to the position of its value
  var N := A.Length;
  var cursor := 0;
  while (cursor < N)
  {
    var target := A[cursor];
    while (0 <= target < N && target != A[target])
    {
        var new_target := A[target];
        A[target] := target;
        target := new_target;
    }
    cursor := cursor + 1;
  }

  // Pass 2, find first location where the index doesn't match the value
  cursor := 0;
  while (cursor < N)
  {
    if (A[cursor] != cursor)
    {
      return cursor;
    }
    cursor := cursor + 1;
  }
  return N;
}

forall ...যাচাইকরণের ত্রুটিটি দেখতে ক্লজটি সহ এবং ছাড়াই কোডটি ভ্যালিটারে পেস্ট করুন । দ্বিতীয় ত্রুটিটি যাচাইকারী পাস 1 লুপের জন্য একটি সমাপ্ত শর্ত প্রতিষ্ঠা করতে সক্ষম না হওয়ার ফলাফল। এটি প্রমাণ করে এমন কাউকে রেখে দেওয়া হয়েছে যে সরঞ্জামটি আরও ভাল বোঝে।

Question 22

জাভাতে এখানে একটি উত্তর যা ইনপুটটি পরিবর্তন করে না এবং ও (এন) সময় এবং এন বিট প্লাসের সাথে মেমরির একটি ছোট ধ্রুবক ওভারহেড ব্যবহার করে (যেখানে এন তালিকার আকার):

int smallestMissingValue(List<Integer> values) {
    BitSet bitset = new BitSet(values.size() + 1);
    for (int i : values) {
        if (i >= 0 && i <= values.size()) {
            bitset.set(i);
        }
    }
    return bitset.nextClearBit(0);
}

Question 23

def solution(A):

index = 0
target = []
A = [x for x in A if x >=0]

if len(A) ==0:
    return 1

maxi = max(A)
if maxi <= len(A):
    maxi = len(A)

target = ['X' for x in range(maxi+1)]
for number in A:
    target[number]= number

count = 1
while count < maxi+1:
    if target[count] == 'X':
        return count
    count +=1
return target[count-1] + 1

উপরের সমাধানের জন্য 100% পেয়েছি।

Question 24

1) ফিল্টার নেতিবাচক এবং জিরো

2) বাছাই / স্বতন্ত্র

3) অ্যারে দেখুন

জটিলতা : ও (এন) বা ও (এন * লগ (এন))

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

public int solution(int[] A) {
            int result = 1;
    boolean found = false;
    A = Arrays.stream(A).filter(x -> x > 0).sorted().distinct().toArray();
    //System.out.println(Arrays.toString(A));
    for (int i = 0; i < A.length; i++) {
        result = i + 1;
        if (result != A[i]) {
            found = true;
            break;
        }
    }
    if (!found && result == A.length) {
        //result is larger than max element in array
        result++;
    }
    return result;
}

Question 25

একটি আনর্ডারড_সেটটি সমস্ত ধনাত্মক সংখ্যাগুলি সঞ্চয় করতে ব্যবহার করা যেতে পারে এবং তারপরে আমরা 1 থেকে দৈর্ঘ্যের অনর্ডার্ড_সেটের পুনরাবৃত্তি করতে পারি এবং প্রথম সংখ্যাটি ঘটে যা না ঘটে see

int firstMissingPositive(vector<int>& nums) {

    unordered_set<int> fre;
    // storing each positive number in a hash.
    for(int i = 0; i < nums.size(); i +=1)
    {
        if(nums[i] > 0)
            fre.insert(nums[i]);
     }

    int i = 1;
    // Iterating from 1 to size of the set and checking 
    // for the occurrence of 'i'

    for(auto it = fre.begin(); it != fre.end(); ++it)
    {
        if(fre.find(i) == fre.end())
            return i;
        i +=1;
    }

    return i;
}

Question 26

বেসিক জাভাস্ক্রিপ্ট মাধ্যমে সমাধান

var a = [1, 3, 6, 4, 1, 2];

function findSmallest(a) {
var m = 0;
  for(i=1;i<=a.length;i++) {
    j=0;m=1;
    while(j < a.length) {
      if(i === a[j]) {
        m++;
      }
      j++;
    }
    if(m === 1) {
      return i;
    }
  }
}

console.log(findSmallest(a))

স্নিপেট প্রসারিত করুন

আশা করি এটি কারওর জন্য সহায়তা করবে।

Question 27

অজগর দিয়ে এটি সবচেয়ে দক্ষ নয়, তবে সঠিক

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
import datetime

# write your code in Python 3.6

def solution(A):
    MIN = 0
    MAX = 1000000
    possible_results = range(MIN, MAX)

    for i in possible_results:
        next_value = (i + 1)
        if next_value not in A:
            return next_value
    return 1

test_case_0 = [2, 2, 2]
test_case_1 = [1, 3, 44, 55, 6, 0, 3, 8]
test_case_2 = [-1, -22]
test_case_3 = [x for x in range(-10000, 10000)]
test_case_4 = [x for x in range(0, 100)] + [x for x in range(102, 200)]
test_case_5 = [4, 5, 6]
print("---")
a = datetime.datetime.now()
print(solution(test_case_0))
print(solution(test_case_1))
print(solution(test_case_2))
print(solution(test_case_3))
print(solution(test_case_4))
print(solution(test_case_5))

Question 28

def solution(A):
    A.sort()
    j = 1
    for i, elem in enumerate(A):
        if j < elem:
            break
        elif j == elem:
            j += 1
            continue
        else:
            continue
    return j

Question 29

এটি সাহায্য করতে পারে:

0- A is [5, 3, 2, 7];
1- Define B With Length = A.Length;                            (O(1))
2- initialize B Cells With 1;                                  (O(n))
3- For Each Item In A:
        if (B.Length <= item) then B[Item] = -1                (O(n))
4- The answer is smallest index in B such that B[index] != -1  (O(n))