অ্যালগরিদম: একটি অ্যারের থেকে সদৃশ পূর্ণসংখ্যার অপসারণের কার্যকর উপায়

Question 1

আমি এই সমস্যাটি মাইক্রোসফ্টের সাথে একটি সাক্ষাত্কার থেকে পেয়েছি।

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

উদাহরণস্বরূপ ইনপুট: {4, 8, 4, 1, 1, 2, 9} আউটপুট:{4, 8, 1, 2, 9, ?, ?}

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

আপডেট: ফলাফলটি অবশ্যই মূল অ্যারেতে ফিরে আসতে হবে এবং সহায়তাকারী ডেটা স্ট্রাকচার (যেমন হ্যাশটেবল) ব্যবহার করা উচিত নয়। তবে, আমার ধারণা অর্ডার সংরক্ষণ প্রয়োজনীয় নয় necessary

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

Question 2

কেমন:

void rmdup(int *array, int length)
{
    int *current , *end = array + length - 1;

    for ( current = array + 1; array < end; array++, current = array + 1 )
    {
        while ( current <= end )
        {
            if ( *current == *array )
            {
                *current = *end--;
            }
            else
            {
                current++;
            }
        }
    }
}

ও (এন ^ 2) বা তার চেয়ে কম হওয়া উচিত।

Question 3

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

Question 4

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

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

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

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

ডি প্রোগ্রামিং ভাষায় এখানে একটি বাস্তবায়ন রয়েছে:

void uniqueInPlace(T)(ref T[] dataIn) {
    uniqueInPlaceImpl(dataIn, 0);
}

void uniqueInPlaceImpl(T)(ref T[] dataIn, size_t start) {
    if(dataIn.length - start < 2)
        return;

    invariant T sentinel = dataIn[start];
    T[] data = dataIn[start + 1..$];

    static hash_t getHash(T elem) {
        static if(is(T == uint) || is(T == int)) {
            return cast(hash_t) elem;
        } else static if(__traits(compiles, elem.toHash)) {
            return elem.toHash;
        } else {
            static auto ti = typeid(typeof(elem));
            return ti.getHash(&elem);
        }
    }

    for(size_t index = 0; index < data.length;) {
        if(data[index] == sentinel) {
            index++;
            continue;
        }

        auto hash = getHash(data[index]) % data.length;
        if(index == hash) {
            index++;
            continue;
        }

        if(data[index] == data[hash]) {
            data[index] = sentinel;
            index++;
            continue;
        }

        if(data[hash] == sentinel) {
            swap(data[hash], data[index]);
            index++;
            continue;
        }

        auto hashHash = getHash(data[hash]) % data.length;
        if(hashHash != hash) {
            swap(data[index], data[hash]);
            if(hash < index)
                index++;
        } else {
            index++;
        }
    }


    size_t swapPos = 0;
    foreach(i; 0..data.length) {
        if(data[i] != sentinel && i == getHash(data[i]) % data.length) {
            swap(data[i], data[swapPos++]);
        }
    }

    size_t sentinelPos = data.length;
    for(size_t i = swapPos; i < sentinelPos;) {
        if(data[i] == sentinel) {
            swap(data[i], data[--sentinelPos]);
        } else {
            i++;
        }
    }

    dataIn = dataIn[0..sentinelPos + start + 1];
    uniqueInPlaceImpl(dataIn, start + swapPos + 1);
}

Question 5

আরও একটি কার্যকর বাস্তবায়ন

int i, j;

/* new length of modified array */
int NewLength = 1;

for(i=1; i< Length; i++){

   for(j=0; j< NewLength ; j++)
   {

      if(array[i] == array[j])
      break;
   }

   /* if none of the values in index[0..j] of array is not same as array[i],
      then copy the current value to corresponding new position in array */

  if (j==NewLength )
      array[NewLength++] = array[i];
}

এই প্রয়োগে অ্যারে বাছাই করার প্রয়োজন নেই। এছাড়াও যদি কোনও সদৃশ উপাদান পাওয়া যায় তবে এর পরে সমস্ত উপাদানকে একটি অবস্থানের সাথে স্থানান্তর করার দরকার নেই।

এই কোডটির আউটপুট অ্যারে [] মাপের নতুন দৈর্ঘ্য সহ is

এখানে আমরা অ্যারের মধ্যে দ্বিতীয় এলেমেট থেকে শুরু করছি এবং অ্যারের সমস্ত উপাদানগুলির সাথে এই অ্যারে পর্যন্ত তুলনা করছি। ইনপুট অ্যারে সংশোধন করার জন্য আমরা একটি অতিরিক্ত সূচক ভেরিয়েবল 'NewLength' ধারণ করছি। নিউলেন্থ ভেরিয়েবেল 0 এ শুরু করা হয়েছে।

অ্যারেতে উপাদানটি [1] অ্যারের সাথে তুলনা করা হবে [0]। যদি সেগুলি পৃথক হয়, তবে অ্যারের মান [NewLength] অ্যারে [1] এবং ইনক্রিমেন্ট NewLength দ্বারা সংশোধিত হবে। যদি সেগুলি একই হয় তবে নিউলেন্থ পরিবর্তন করা হবে না।

সুতরাং আমাদের যদি একটি অ্যারে থাকে [1 2 1 3 1], তবে

'জ' লুপের প্রথম পাসে, অ্যারে [1] (2) এর সাথে অ্যারের 0 এর সাথে তুলনা করা হবে, তারপরে 2 অ্যারেতে লিখিত হবে [নিউলেন্থ] = অ্যারে [1] সুতরাং অ্যারে [1 2] হবে নিউ লেন্থ = 2 থেকে

'জ' লুপের দ্বিতীয় পাসে অ্যারে [2] (1) অ্যারে 0 এবং অ্যারে 1 এর সাথে তুলনা করা হবে। এখানে অ্যারে [2] (1) এবং অ্যারে 0 একই লুপটি এখানে ভেঙে যাবে। নিউ অ্যারেথ = 2 থেকে অ্যারে [1 2] হবে

ইত্যাদি

Question 6

আপনি যদি উচ্চতর ও-স্বীকৃতি সন্ধান করছেন তবে তারপরে একটি ও (এন লগ এন) বাছাই করে অ্যারে বাছাই করলে একটি হে (এন) ট্র্যাভারসাল করা সর্বোত্তম পথ হতে পারে। বাছাই না করে আপনি ও (এন ^ 2) এর দিকে তাকিয়ে আছেন।

সম্পাদনা করুন: আপনি যদি কেবল পূর্ণসংখ্যা করছেন তবে ও (এন) পেতে আপনি রডিক্স বাছাইও করতে পারেন।

Question 7

1. ও (1) অতিরিক্ত স্থান, ও (এন লগ এন) সময় ব্যবহার করে

এটি সম্ভব, উদাহরণস্বরূপ:

প্রথমে একটি ইন-প্লেস ও (এন লগ এন) বাছাই করুন
তারপরে তালিকার শুরুতে প্রতিটি পিঠের প্রথম উদাহরণটি লিখে একবারে তালিকাটি চলুন

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

2. ও (প্রচুর) অতিরিক্ত স্থান, ও (এন) সময়ে ব্যবহার করা

সমস্ত পূর্ণসংখ্যা ধরে রাখতে যথেষ্ট বড় শূন্যের অ্যারে ঘোষণা করুন
অ্যারে দিয়ে একবার হাঁটুন
প্রতিটি পূর্ণসংখ্যার জন্য সংশ্লিষ্ট অ্যারে উপাদানকে 1 তে সেট করুন।
যদি এটি ইতিমধ্যে 1 হয় তবে পূর্ণসংখ্যাটি এড়িয়ে যান।

এটি কেবল তখনই কার্যকর হয় যদি বেশ কয়েকটি সন্দেহজনক ধারণা অনুমান করে:

সস্তার সাথে মেমরি শূন্য করা সম্ভব বা তাদের সংখ্যার তুলনায় ইনটসের আকার ছোট are
আপনি আপনার ওএসকে 256 ^ সিজেপফ (ইনট) মেমরির জন্য জিজ্ঞাসা করে খুশি
এবং এটি আপনার পক্ষে সত্যিই দক্ষতার সাথে এটি ক্যাশে দেবে যদি এটি বিশাল

এটি একটি খারাপ উত্তর, তবে আপনার কাছে যদি প্রচুর ইনপুট উপাদান থাকে তবে সেগুলি 8-বিট পূর্ণসংখ্যার (অথবা সম্ভবত 16-বিট পূর্ণসংখ্যার) হয় এটি সর্বোত্তম উপায় হতে পারে।

৩. ও (অল্প) -শক্তি অতিরিক্ত স্থান, ও (এন) - সময়

# 2 হিসাবে, তবে একটি হ্যাশ টেবিল ব্যবহার করুন।

4. পরিষ্কার উপায়

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

যেমন প্রতিটি অভিন্ন উপাদান (যেমন প্রথম উপাদান, দ্বিতীয় উপাদান (প্রথমটির নকলগুলি সরানো হয়েছে ইত্যাদি) ইত্যাদির জন্য অ্যারের মধ্য দিয়ে চলুন all ও (1) অতিরিক্ত স্থান, হে (n ^ 2) সময়।

যেমন এটি করে গ্রন্থাগার ফাংশন ব্যবহার করুন। দক্ষতা নির্ভর করে যা আপনি সহজেই উপলব্ধ।

Question 8

ভাল, এটি বেসিক বাস্তবায়ন বেশ সহজ। সমস্ত উপাদানগুলির মধ্যে যান, বাকীগুলিতে নকল রয়েছে কিনা তা পরীক্ষা করে দেখুন এবং তার উপরের অংশটি শিফট করুন।

এটি মারাত্মক অদক্ষ এবং আপনি আউটপুট বা বাছাই / বাইনারি গাছগুলির জন্য সহায়ক-অ্যারে দ্বারা এটি বাড়িয়ে দিতে পারেন তবে এটি অনুমোদিত হবে বলে মনে হয় না।

Question 9

যদি আপনাকে সি ++ ব্যবহার করার অনুমতি দেওয়া হয় তবে তার std::sortপরে একটি কল আপনাকে std::uniqueউত্তর দিবে। সময়ের জটিলতাটি বাছাইয়ের জন্য ও (এন লগ এন) এবং অনন্য ট্র্যাভারসালের জন্য ও (এন)।

এবং সি ++ যদি টেবিলের বাইরে থাকে তবে এমন কিছু নেই যা এই একই অ্যালগরিদমগুলিকে সি-তে লেখা থেকে রক্ষা করে keeps

Question 10

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

পার্লে:

foreach $i (@myary) {
    if(!defined $seen{$i}) {
        $seen{$i} = 1;
        push @newary, $i;
    }
}

Question 11

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

বাইরের লুপের প্রতিটি পুনরাবৃত্তি অ্যারের একটি উপাদানকে প্রক্রিয়া করে। যদি এটি অনন্য হয় তবে এটি অ্যারের সামনের অংশে থেকে যায় এবং যদি এটি সদৃশ হয় তবে এটি অ্যারের শেষ অপসারণযুক্ত উপাদান দ্বারা ওভাররাইট করা হয়। এই সমাধানটি ও (এন ^ 2) সময়ে চলে।

#include <stdio.h>
#include <stdlib.h>

size_t rmdup(int *arr, size_t len)
{
  size_t prev = 0;
  size_t curr = 1;
  size_t last = len - 1;
  while (curr <= last) {
    for (prev = 0; prev < curr && arr[curr] != arr[prev]; ++prev);
    if (prev == curr) {
      ++curr;
    } else {
      arr[curr] = arr[last];
      --last;
    }
  }
  return curr;
}

void print_array(int *arr, size_t len)
{
  printf("{");
  size_t curr = 0;
  for (curr = 0; curr < len; ++curr) {
    if (curr > 0) printf(", ");
    printf("%d", arr[curr]);
  }
  printf("}");
}

int main()
{
  int arr[] = {4, 8, 4, 1, 1, 2, 9};
  printf("Before: ");
  size_t len = sizeof (arr) / sizeof (arr[0]);
  print_array(arr, len);
  len = rmdup(arr, len);
  printf("\nAfter: ");
  print_array(arr, len);
  printf("\n");
  return 0;
}

Question 12

এটি একটি জাভা সংস্করণ।

int[] removeDuplicate(int[] input){

        int arrayLen = input.length;
        for(int i=0;i<arrayLen;i++){
            for(int j = i+1; j< arrayLen ; j++){
                if(((input[i]^input[j]) == 0)){
                    input[j] = 0;
                }
                if((input[j]==0) && j<arrayLen-1){
                        input[j] = input[j+1];
                        input[j+1] = 0;
                    }               
            }
        }       
        return input;       
    }

Question 13

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

///// find duplicates in an array and remove them

void unique(int* input, int n)
{
     merge_sort(input, 0, n) ;

     int prev = 0  ;

     for(int i = 1 ; i < n ; i++)
     {
          if(input[i] != input[prev])
               if(prev < i-1)
                   input[prev++] = input[i] ;                         
     }
}

Question 14

একটি অ্যারে স্পষ্টতই "ট্র্যাভার্সড" ডান থেকে বামে হওয়া উচিত মানগুলি পিছনে পিছনে অনুলিপি করা এড়াতে।

আপনার যদি সীমাহীন মেমরি থাকে তবে আপনি sizeof(type-of-element-in-array) / 8ইতিমধ্যে সংশ্লিষ্ট মানটির মুখোমুখি হয়েছেন কি না তা প্রতিটি বিটকে বোঝানোর জন্য আপনি কিছুটা অ্যারে বরাদ্দ করতে পারেন ।

যদি আপনি এটি না করেন তবে আমি কোনও অ্যারে ট্র্যাভার করা এবং প্রতিটি মানকে অনুসরণ করে আসা মানগুলির সাথে তুলনা করার চেয়ে ভাল কিছু ভাবতে পারি না এবং তারপরে যদি সদৃশ পাওয়া যায় তবে এই মানগুলি পুরোপুরি সরিয়ে ফেলুন। এটি O (n ^ 2) (বা ও ((n ^ 2-n) / 2) ) এর কাছাকাছি কোথাও ।

আইবিএম-এর কাছাকাছি বিষয় সম্পর্কিত একটি নিবন্ধ রয়েছে ।

Question 15

দেখা যাক:

সর্বনিম্ন / সর্বাধিক বরাদ্দ সন্ধান করতে ও (এন) পাস করুন
বিট-অ্যারে পাওয়া গেছে
ও (এন) পাসের অদলবদলের ডুপ্লিকেট শেষ হবে।

Question 16

এটি একটি পাসে একটি ও (এন লগ এন) অ্যালগরিদম এবং কোনও অতিরিক্ত স্টোরেজ সহ করা যায়।

উপাদান থেকে এগিয়ে a[1]যান a[N]। প্রতিটি পর্যায়ে i, বাম a[i]দিকে সমস্ত উপাদান উপাদানগুলির a[0]মাধ্যমে একটি সাজানো গাদা থাকে a[j]। ইতিমধ্যে, দ্বিতীয় সূচক j, প্রাথমিকভাবে 0, গাদা আকারের উপর নজর রাখে।

পরীক্ষা a[i]এবং গাদা, যা এখন উপাদানের দখল মধ্যে এটি সন্নিবেশ a[0]করতে a[j+1]। উপাদানটি সন্নিবেশ করানোর সাথে সাথে, যদি কোনও সদৃশ উপাদানটির a[k]একই মান রয়েছে, a[i]তবে গাদাতে ,োকানো হবে না (অর্থাত্, এটি বাতিল করুন); অন্যথায় গাদা, যা এখন এক উপাদান দ্বারা বৃদ্ধি মধ্যে এটি সন্নিবেশ এবং এখন গঠিত a[0]করার a[j+1], এবং বৃদ্ধি j।

এই পদ্ধতিতে চালিয়ে যান, বৃদ্ধিশীল iপর্যন্ত অ্যারে উপাদানের সব পরীক্ষা করা হয়েছে এবং গাদা, যা অধিষ্ঠিত শেষ পর্যন্ত ঢোকানো a[0]করতে a[j]। jহিপের শেষ উপাদানটির সূচক এবং হিপটিতে কেবল অনন্য উপাদান মান থাকে।

int algorithm(int[] a, int n)
{
    int   i, j;  

    for (j = 0, i = 1;  i < n;  i++)
    {
        // Insert a[i] into the heap a[0...j]
        if (heapInsert(a, j, a[i]))
            j++;
    }
    return j;
}  

bool heapInsert(a[], int n, int val)
{
    // Insert val into heap a[0...n]
    ...code omitted for brevity...
    if (duplicate element a[k] == val)
        return false;
    a[k] = val;
    return true;
}

উদাহরণের দিকে তাকালে, ফলস্বরূপ অ্যারেটি মূল উপাদান ক্রমটি সংরক্ষণ করে যেহেতু এটি ঠিক তেমনটিই চাওয়া হয়নি। তবে যদি এই প্রয়োজনীয়তাটি শিথিল হয় তবে উপরের অ্যালগরিদমটি কৌশলটি করা উচিত।

Question 17

জাভাতে আমি এটি এর মতো সমাধান করব। সি তে এটি কীভাবে লিখতে হয় তা জানেন না

   int length = array.length;
   for (int i = 0; i < length; i++) 
   {
      for (int j = i + 1; j < length; j++) 
      {
         if (array[i] == array[j]) 
         {
            int k, j;
            for (k = j + 1, l = j; k < length; k++, l++) 
            {
               if (array[k] != array[i]) 
               {
                  array[l] = array[k];
               }
               else
               {
                  l--;
               }
            }
            length = l;
         }
      }
   }

Question 18

নিম্নলিখিত সম্পর্কে কীভাবে?

int* temp = malloc(sizeof(int)*len);
int count = 0;
int x =0;
int y =0;
for(x=0;x<len;x++)
{
    for(y=0;y<count;y++)
    {
        if(*(temp+y)==*(array+x))
        {
            break;
        }
    }
    if(y==count)
    {
        *(temp+count) = *(array+x);
        count++;
    }
}
memcpy(array, temp, sizeof(int)*len);

আমি একটি অস্থায়ী অ্যারে ঘোষণা করার চেষ্টা করি এবং সমস্ত উপাদানকে মূল অ্যারেতে অনুলিপি করার আগে উপাদানগুলিকে এতে .োকাতে পারি।

Question 19

সমস্যাটি পর্যালোচনা করার পরে, এখানে আমার ডেলফি উপায়, এটি সাহায্য করতে পারে

var
A: Array of Integer;
I,J,C,K, P: Integer;
begin
C:=10;
SetLength(A,10);
A[0]:=1; A[1]:=4; A[2]:=2; A[3]:=6; A[4]:=3; A[5]:=4;
A[6]:=3; A[7]:=4; A[8]:=2; A[9]:=5;

for I := 0 to C-1 do
begin
  for J := I+1 to C-1 do
    if A[I]=A[J] then
    begin
      for K := C-1 Downto J do
        if A[J]<>A[k] then
        begin
          P:=A[K];
          A[K]:=0;
          A[J]:=P;
          C:=K;
          break;
        end
        else
        begin
          A[K]:=0;
          C:=K;
        end;
    end;
end;

//tructate array
setlength(A,C);
end;

Question 20

নিম্নলিখিত উদাহরণটি আপনার সমস্যার সমাধান করা উচিত:

def check_dump(x):
   if not x in t:
      t.append(x)
      return True

t=[]

output = filter(check_dump, input)

print(output)
True

Question 21

import java.util.ArrayList;


public class C {

    public static void main(String[] args) {

        int arr[] = {2,5,5,5,9,11,11,23,34,34,34,45,45};

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

        for(int i=0;i<arr.length-1;i++){

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

        for(int i=0;i<arr.length;i++){
            if(arr[i] != 99999){

                arr1.add(arr[i]);
            }
        }

        System.out.println(arr1);
}
    }

Question 22

এটি নিষ্পাপ (এন * (এন -1) / 2) সমাধান। এটি ধ্রুবক অতিরিক্ত স্থান ব্যবহার করে এবং মূল ক্রম বজায় রাখে। এটি @ বাইজু দ্বারা সমাধানের মতো, তবে কোনও if(){}ব্লক ব্যবহার করে না । এটি নিজের উপর কোনও উপাদান অনুলিপি করা এড়িয়ে যায়।

#include <stdio.h>
#include <stdlib.h>

int numbers[] = {4, 8, 4, 1, 1, 2, 9};
#define COUNT (sizeof numbers / sizeof numbers[0])

size_t undup_it(int array[], size_t len)
{
size_t src,dst;

  /* an array of size=1 cannot contain duplicate values */
if (len <2) return len; 
  /* an array of size>1 will cannot at least one unique value */
for (src=dst=1; src < len; src++) {
        size_t cur;
        for (cur=0; cur < dst; cur++ ) {
                if (array[cur] == array[src]) break;
                }
        if (cur != dst) continue; /* found a duplicate */

                /* array[src] must be new: add it to the list of non-duplicates */
        if (dst < src) array[dst] = array[src]; /* avoid copy-to-self */
        dst++;
        }
return dst; /* number of valid alements in new array */
}

void print_it(int array[], size_t len)
{
size_t idx;

for (idx=0; idx < len; idx++)  {
        printf("%c %d", (idx) ? ',' :'{' , array[idx] );
        }
printf("}\n" );
}

int main(void) {    
    size_t cnt = COUNT;

    printf("Before undup:" );    
    print_it(numbers, cnt);    

    cnt = undup_it(numbers,cnt);

    printf("After undup:" );    
    print_it(numbers, cnt);

    return 0;
}

Question 23

এটি ইনপুট তালিকার পূর্ণসংখ্যার সংখ্যার ক্ষেত্রে ও (এন) সময়ে এবং একক পাসে অনন্য পূর্ণসংখ্যার সংখ্যায় ও (এন) স্টোরেজ করা যেতে পারে।

"ডিস্ট" এবং "এসসিআর" দুটি আইটেমটি প্রথম আইটেমটির সাথে শুরু করে সামনে থেকে পিছনে তালিকার মধ্য দিয়ে যান। "পূর্ণসংখ্যার দেখা" এর খালি হ্যাশ টেবিল দিয়ে শুরু করুন। যদি এসআরসি-তে পূর্ণসংখ্যা হ্যাশটিতে উপস্থিত না থাকে, তবে এটি ডিএসটি এবং বর্ধিত ডিএসটিতে স্লটে লিখুন। এসআরসি-তে পূর্ণসংখ্যার সাথে হ্যাশ যুক্ত করুন, তারপরে এনক্রিমেন্ট এসসিআর করুন। এসসিআর ইনপুট তালিকার শেষ না হওয়া পর্যন্ত পুনরাবৃত্তি করুন।

Question 24

একটি binary tree the disregards duplicates- তে সমস্ত উপাদান sertোকান O(nlog(n))। তারপরে ট্র্যাভারসাল করে সমস্তটি আবার অ্যারেতে বের করুন O(n)। আমি ধরে নিচ্ছি যে আপনার অর্ডার সংরক্ষণের দরকার নেই।

Question 25

হ্যাশিংয়ের জন্য ব্লুম ফিল্টার ব্যবহার করুন। এটি মেমরির ওভারহেডকে খুব উল্লেখযোগ্যভাবে হ্রাস করবে।

Question 26

জাভাতে,

    Integer[] arrayInteger = {1,2,3,4,3,2,4,6,7,8,9,9,10};

    String value ="";

    for(Integer i:arrayInteger)
    {
        if(!value.contains(Integer.toString(i))){
            value +=Integer.toString(i)+",";
        }

    }

    String[] arraySplitToString = value.split(",");
    Integer[] arrayIntResult = new Integer[arraySplitToString.length];
    for(int i = 0 ; i < arraySplitToString.length ; i++){
        arrayIntResult[i] = Integer.parseInt(arraySplitToString[i]);
    }

আউটপুট: {1, 2, 3, 4, 6, 7, 8, 9, 10}

আশা করি এটি সাহায্য করবে

Question 27

BinarySearchTreeও (এন) জটিলতা রয়েছে এমন একটি তৈরি করুন ।

Question 28

প্রথমে, আপনার এমন একটি অ্যারে তৈরি করা উচিত check[n]যেখানে এনটি নকল মুক্ত করতে চান এমন অ্যারের উপাদানগুলির সংখ্যা এবং প্রতিটি উপাদান (চেক অ্যারের) সমান 1 নির্ধারণ করতে চান। লুপের জন্য একটি অ্যারে ব্যবহার করে অ্যারেটি অ্যারো করে ফেলুন সদৃশ, এটির নামটি বলুন arrএবং ফোর-লুপে এটি লিখুন:

{
    if (check[arr[i]] != 1) {
        arr[i] = 0;
    }
    else {
        check[arr[i]] = 0;
    }
}

এটির সাথে আপনি প্রতিটি নকল শূন্যের সমান করে রেখেছেন। সুতরাং কেবলমাত্র কাজটি বাকি থাকে arrঅ্যারেটিকে অতিক্রম করা এবং এটি শূন্যের সমান নয় এমন সমস্ত কিছু মুদ্রণ করা। অর্ডার স্থির থাকে এবং এটি রৈখিক সময় নেয় (3 * এন)।

Question 29

এন উপাদানগুলির একটি অ্যারে দেওয়া, সময়যুক্ত অ্যারে থেকে সমস্ত সদৃশ অপসারণ করতে একটি অ্যালগরিদম লিখুন O (nlogn)

Algorithm delete_duplicates (a[1....n])
//Remove duplicates from the given array 
//input parameters :a[1:n], an array of n elements.

{

temp[1:n]; //an array of n elements. 

temp[i]=a[i];for i=1 to n

 temp[i].value=a[i]

temp[i].key=i

 //based on 'value' sort the array temp.

//based on 'value' delete duplicate elements from temp.

//based on 'key' sort the array temp.//construct an array p using temp.

 p[i]=temp[i]value

  return p.

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

Question 30

এটিই আমি পেয়েছি, যদিও এটি ঠিক করার জন্য আরোহণ বা উতরাই বাছাই করা ক্রমটি ভুলভাবে আবিষ্কার করে।

#include <stdio.h>
int main(void){
int x,n,myvar=0;
printf("Enter a number: \t");
scanf("%d",&n);
int arr[n],changedarr[n];

for(x=0;x<n;x++){
    printf("Enter a number for array[%d]: ",x);
    scanf("%d",&arr[x]);
}
printf("\nOriginal Number in an array\n");
for(x=0;x<n;x++){
    printf("%d\t",arr[x]);
}

int i=0,j=0;
// printf("i\tj\tarr\tchanged\n");

for (int i = 0; i < n; i++)
{
    // printf("%d\t%d\t%d\t%d\n",i,j,arr[i],changedarr[i] );
    for (int j = 0; j <n; j++)
    {   
        if (i==j)
        {
            continue;

        }
        else if(arr[i]==arr[j]){
            changedarr[j]=0;

        }
        else{
            changedarr[i]=arr[i];

        }
    // printf("%d\t%d\t%d\t%d\n",i,j,arr[i],changedarr[i] );
    }
    myvar+=1;
}
// printf("\n\nmyvar=%d\n",myvar);
int count=0;
printf("\nThe unique items:\n");
for (int i = 0; i < myvar; i++)
{
        if(changedarr[i]!=0){
            count+=1;
            printf("%d\t",changedarr[i]);   
        }
}
    printf("\n");
}

Question 31

আপনার যদি একটি ভাল ডেটা স্ট্রাকচার থাকে তবে এটিতে কোনও পূর্ণসংখ্যা রয়েছে কিনা তা তাড়াতাড়ি বলতে পারত এটি দুর্দান্ত। সম্ভবত কোনও ধরণের গাছ।

DataStructure elementsSeen = new DataStructure();
int elementsRemoved = 0;
for(int i=0;i<array.Length;i++){
  if(elementsSeen.Contains(array[i])
    elementsRemoved++;
  else
    array[i-elementsRemoved] = array[i];
}
array.Length = array.Length - elementsRemoved;