ইনপুট: 0 টি থেকে এন -1 পর্যন্ত উপাদান রয়েছে এমন এন উপাদানগুলির একটি অ্যারে দেওয়া হয়েছে, এর মধ্যে যে কোনও সংখ্যক বার সংখ্যার প্রদর্শিত হয়।
লক্ষ্য: এই পুনরাবৃত্তি সংখ্যাগুলি ও (এন) এ খুঁজে পেতে এবং কেবল ধ্রুবক মেমরি স্পেস ব্যবহার করে।
উদাহরণস্বরূপ, এন 7 হতে হবে এবং অ্যারে হতে হবে, 1, 2, 3, 1, 3, 0, 6 the, উত্তর 1 এবং 3 হওয়া উচিত আমি এখানে অনুরূপ প্রশ্নগুলি পরীক্ষা করেছি তবে উত্তরগুলি কিছু ডেটা স্ট্রাকচারের মতো ব্যবহার করেছে HashSetইত্যাদি etc.
এর জন্য কোনও দক্ষ অ্যালগরিদম?
উত্তর:
এটিই আমি নিয়ে এসেছি, যার জন্য অতিরিক্ত সাইন বিটের প্রয়োজন নেই:
for i := 0 to n - 1
while A[A[i]] != A[i]
swap(A[i], A[A[i]])
end while
end for
for i := 0 to n - 1
if A[i] != i then
print A[i]
end if
end forপ্রথম লুপটি অ্যারেটিকে অনুমতি দেয় যাতে যদি উপাদানটি xঅন্তত একবার উপস্থিত হয় তবে those প্রবেশদ্বারগুলির মধ্যে একটিতে অবস্থান থাকবে A[x]।
মনে রাখবেন এটি প্রথম ব্লাশে ও (এন) না দেখায় তবে এটি হ'ল - যদিও এটিতে নেস্টেড লুপ রয়েছে, এটি এখনও O(N)সময়ে চলমান runs যদি একজন একটি swap শুধুমাত্র ঘটে iযেমন যে A[i] != i, এবং প্রতিটি বিনিময় সেট অন্তত একটি উপাদান যেমন যে A[i] == i, যেখানে তার আগে সত্য ছিল না। এর অর্থ হ'ল মোট অদলবদলের সংখ্যা (এবং এইভাবে whileলুপের দেহের মোট মৃত্যুদন্ড কার্যকর হওয়া সংখ্যা ) সর্বাধিক N-1।
দ্বিতীয় লুপের মানগুলি প্রিন্ট করে xযার জন্য এটি A[x]সমান হয় না x- যেহেতু প্রথম লুপটি গ্যারান্টি দেয় যে যদি xঅ্যারেতে অন্তত একবার উপস্থিত হয় তবে সেই উদাহরণগুলির মধ্যে একটি উপস্থিত থাকবে A[x], এর অর্থ এটি সেই মানগুলিকে মুদ্রণ করে xযা উপস্থিত নেই অ্যারে।
5পরিসরে নেই 0..N-1( Nএই ক্ষেত্রে রয়েছে 5)।
printকরার জন্য বিবৃতি print iএকটি সমাধান এই পালাক্রমে করার stackoverflow.com/questions/5249985/... এবং (অভিমানী "ব্যাগ" একটি সংশোধনযোগ্য অ্যারে) এর QK stackoverflow.com/questions/3492302/... ।
ক্যাফের উজ্জ্বল উত্তর প্রতিটি নম্বর মুদ্রণ করে যা অ্যারে কে -1 বারে কে বার প্রদর্শিত হয়। এটি কার্যকর আচরণ, তবে প্রশ্নটি যুক্তিযুক্তভাবে প্রতিটি ডুপ্লিকেট কেবল একবার মুদ্রিত হওয়ার জন্য আহ্বান জানিয়েছে এবং তিনি লিনিয়ার সময় / ধ্রুবক স্পেস সীমা ছাড়াই এটি করার সম্ভাবনা সম্পর্কে জোর দেন। নিম্নলিখিত সিউডোকোডের সাহায্যে তার দ্বিতীয় লুপটি প্রতিস্থাপন করে এটি করা যেতে পারে:
for (i = 0; i < N; ++i) {
if (A[i] != i && A[A[i]] == A[i]) {
print A[i];
A[A[i]] = i;
}
}এটি সেই সম্পত্তিটি শোষণ করে যে প্রথম লুপটি চলার পরে যদি কোনও মান mএকাধিকবার প্রদর্শিত হয় , তবে সেই উপস্থিতিগুলির মধ্যে একটির অবশ্যই সঠিক অবস্থানে থাকার নিশ্চয়তা রয়েছে A[m]। আমরা যদি সাবধান হন তবে কোনও নকল ছাপানো হয়েছে কি না সে সম্পর্কে তথ্য সংরক্ষণের জন্য আমরা সেই "হোম" অবস্থানটি ব্যবহার করতে পারি।
ক্যাফের সংস্করণে, আমরা অ্যারের মধ্য দিয়ে যাচ্ছিলাম, তা A[i] != iবোঝা গেল A[i]এটি একটি সদৃশ। আমার সংস্করণে, আমি কিছুটা পৃথক আক্রমণকারী উপর নির্ভর করি: এর দ্বারা A[i] != i && A[A[i]] == A[i]বোঝা যায় এটি A[i]এমন একটি নকল যা আমরা আগে দেখিনি । (যদি আপনি "যা আমরা আগে দেখিনি" অংশটি ফেলে রাখেন তবে বাকীটিকে ক্যাফের আক্রমণকারী সত্যের দ্বারা বোঝানো যেতে পারে, এবং সমস্ত নকলের কোনও ঘরের কোনও কপি রয়েছে বলে গ্যারান্টি দেওয়া হয়)) এই সম্পত্তিটি এখানে রয়েছে শুরু (ক্যাফের 1 ম লুপ শেষ হওয়ার পরে) এবং আমি নীচে দেখাব যে এটি প্রতিটি পদক্ষেপের পরে রক্ষণাবেক্ষণ করা হচ্ছে।
যখন আমরা অ্যারের মধ্য দিয়ে যাব, A[i] != iপরীক্ষার অংশে সাফল্য বোঝায় যে A[i] এমন একটি নকল হতে পারে যা আগে দেখা যায় নি। যদি আমরা এটি আগে না দেখে থাকি, তবে আমরা A[i]নিজের বাড়ির অবস্থানটি নিজের দিকে নির্দেশ করার প্রত্যাশা করি - যা ifশর্তের দ্বিতীয়ার্ধে পরীক্ষা করা হয়েছে । যদি তা কেস হয় তবে আমরা এটি মুদ্রণ করি এবং বাড়ির অবস্থানটিকে এই প্রথম পাওয়া নকলের দিকে ফিরে নির্দেশ দিয়ে একটি 2-পদক্ষেপ "চক্র" তৈরি করি।
এই অপারেশনটি আমাদের আক্রমণকারীকে পরিবর্তন করে না তা দেখতে, ধরুন সন্তোষজনক m = A[i]কোনও নির্দিষ্ট অবস্থানের জন্য । এটা সুস্পষ্ট যে আমরা যে পরিবর্তনটি করেছি তা অন্য গৃহ-পরিস্থিতিকে নকল হিসাবে আউটপুট হিসাবে আটকানো থেকে তাদের অবস্থার ২ য় অর্ধেক ব্যর্থ হয়ে কাজ করবে, তবে বাড়ির লোকেশনে পৌঁছালে কী তা কার্যকর হবে ,? হ্যাঁ এটি হবে, কারণ এখন, যদিও এই নতুনটিতে আমরা দেখতে পেলাম যে শর্তের প্রথম অর্ধেক , সত্য, দ্বিতীয়ার্ধটি এটি পরীক্ষা করে যে অবস্থানটি কোনও বাড়ির অবস্থান কিনা এবং তা খুঁজে পাওয়া যায় কিনা তা পরীক্ষা করে। এ অবস্থায় আমরা আর কিনা জানি বা ডুপ্লিকেট মান ছিল, কিন্তু আমরা জানি যে উপায় হয়,iA[i] != i && A[A[i]] == A[i]A[A[i]] = imifimiifA[i] != imA[m]এটি ইতিমধ্যে প্রতিবেদন করা হয়েছে , কারণ এই 2-চক্রটি ক্যাফের 1 ম লুপের ফলাফলটিতে উপস্থিত না হওয়ার গ্যারান্টিযুক্ত। (দ্রষ্টব্য যে যদি m != A[m]ঠিক তখনই একটি হয় mএবং A[m]একাধিকবার ঘটে এবং অন্যটি ঘটে না))
এখানে সিউডোকোড
for i <- 0 to n-1:
if (A[abs(A[i])]) >= 0 :
(A[abs(A[i])]) = -(A[abs(A[i])])
else
print i
end for-সঙ্গে ~শূন্য সমস্যার জন্য।
O(n)লুকানো জায়গা ব্যবহার করে - nসাইন বিট। অ্যারেরটি যদি এমনভাবে সংজ্ঞায়িত করা হয় যে প্রতিটি উপাদান কেবলমাত্র 0এবং এর মধ্যে মানগুলি ধরে রাখতে পারে n-1, তবে তা অবশ্যই কাজ করে না।
অপেক্ষাকৃত ছোট এন এর জন্য আমরা ডিভ / মোড অপারেশন ব্যবহার করতে পারি
n.times do |i|
e = a[i]%n
a[e] += n
end
n.times do |i|
count = a[i]/n
puts i if count > 1
endসি / সি ++ নয় তবে যাই হোক
সত্যই সুন্দর নয় তবে কমপক্ষে ও (এন) এবং ও (1) বৈশিষ্ট্যগুলি দেখতে সহজ। মূলত আমরা অ্যারেটি স্ক্যান করি এবং প্রতিটি সংখ্যার জন্য আমরা দেখতে পাই যে সংশ্লিষ্ট অবস্থানটি ইতিমধ্যে-একবার-দেখা (এন) বা ইতিমধ্যে দেখা-বহুবার-বার (এন + 1) পতাকাঙ্কিত হয়েছে কিনা। যদি এটি ইতিমধ্যে-একবারে পতাকাঙ্কিত হয় তবে আমরা এটিকে মুদ্রণ করব এবং একাধিকবার এটি ইতিমধ্যে দেখেছি flag যদি এটি পতাকাঙ্কিত না হয় তবে আমরা এটি ইতিমধ্যে-একবারে পতাকাঙ্কিত করেছি এবং আমরা সংশ্লিষ্ট সূচকের মূল মানটিকে বর্তমান অবস্থানে নিয়ে যাই (পতাকাঙ্কণ একটি ধ্বংসাত্মক ক্রিয়াকলাপ)।
for (i=0; i<a.length; i++) {
value = a[i];
if (value >= N)
continue;
if (a[value] == N) {
a[value] = N+1;
print value;
} else if (a[value] < N) {
if (value > i)
a[i--] = a[value];
a[value] = N;
}
}বা, আরও ভাল (দ্রুত, দ্বিগুণ লুপ সত্ত্বেও):
for (i=0; i<a.length; i++) {
value = a[i];
while (value < N) {
if (a[value] == N) {
a[value] = N+1;
print value;
value = N;
} else if (a[value] < N) {
newvalue = value > i ? a[value] : N;
a[value] = N;
value = newvalue;
}
}
}if (value > i) a[i--] = a[value];কাজ করে তা নির্ধারণ করার জন্য এটি কিছুটা চিন্তাভাবনা করেছিল : যদি value <= iতা হয় তবে আমরা ইতিমধ্যে মানটির উপর প্রক্রিয়া করেছি a[value]এবং এটি নিরাপদে ওভাররাইট করতে পারি। এছাড়াও আমি বলব না ও (এন) প্রকৃতি সুস্পষ্ট! এটির বানানটি: মূল লুপটি Nবহুবার চালিত হয়, তবে a[i--] = a[value];লাইনটি বহুবার চালায়। এই লাইনটি কেবল তখনই চলতে পারে a[value] < Nএবং প্রতিটি সময় এটি চালিত হলে অবিলম্বে একটি অ্যারে মান Nসেট করা থাকে যা ইতিমধ্যে সেট করা হয়নি N, তাই এটি বেশিরভাগ Nসময়ে চলতে পারে মোট 2Nলুপের পুনরাবৃত্তির জন্য মোট for
সি এর একটি সমাধান হল:
#include <stdio.h>
int finddup(int *arr,int len)
{
int i;
printf("Duplicate Elements ::");
for(i = 0; i < len; i++)
{
if(arr[abs(arr[i])] > 0)
arr[abs(arr[i])] = -arr[abs(arr[i])];
else if(arr[abs(arr[i])] == 0)
{
arr[abs(arr[i])] = - len ;
}
else
printf("%d ", abs(arr[i]));
}
}
int main()
{
int arr1[]={0,1,1,2,2,0,2,0,0,5};
finddup(arr1,sizeof(arr1)/sizeof(arr1[0]));
return 0;
}এটি ও (এন) সময় এবং ও (1) স্থান জটিলতা।
আসুন ধরে নেওয়া যাক আমরা এই অ্যারেটিকে একটি দ্বি-দিকনির্দেশক গ্রাফ ডেটা কাঠামো হিসাবে উপস্থাপন করি - প্রতিটি সংখ্যা একটি শীর্ষবিন্দু এবং এটির সূচকটি গ্রাফের একটি প্রান্ত গঠন করে অন্য একটি শীর্ষবিন্দুতে নির্দেশ করে।
আরও সরলতার জন্য আমাদের 0 থেকে এন -1 এবং 0..n-1 থেকে সংখ্যার পরিসর সূচক রয়েছে। যেমন
0 1 2 3 4
a[3, 2, 4, 3, 1]0 (3) -> 3 (3) একটি চক্র।
উত্তর: সূচকগুলিতে নির্ভর করে অ্যারেটি কেবল অতিক্রম করুন। যদি একটি [x] = a [y] হয় তবে এটি একটি চক্র এবং সুতরাং সদৃশ। পরবর্তী সূচীতে চলে যান এবং অ্যারের শেষ না হওয়া পর্যন্ত বার বার চালিয়ে যান। জটিলতা: ও (এন) সময় এবং ও (1) স্থান।
উপরে ক্যাফের পদ্ধতিটি দেখানোর জন্য একটি অল্প অজগর কোড:
a = [3, 1, 1, 0, 4, 4, 6]
n = len(a)
for i in range(0,n):
if a[ a[i] ] != a[i]: a[a[i]], a[i] = a[i], a[a[i]]
for i in range(0,n):
if a[i] != i: print( a[i] )iমানের জন্য অদলবদল একাধিকবার হতে পারে - whileআমার উত্তরে নোট করুন ।
অ্যালগরিদম নিম্নলিখিত সি ফাংশনে সহজেই দেখা যায়। মূল অ্যারের পুনরুদ্ধার করা হচ্ছে, যদিও প্রয়োজন নেই, প্রতিটি এন্ট্রি মডিউল গ্রহণ সম্ভব হবে এন ।
void print_repeats(unsigned a[], unsigned n)
{
unsigned i, _2n = 2*n;
for(i = 0; i < n; ++i) if(a[a[i] % n] < _2n) a[a[i] % n] += n;
for(i = 0; i < n; ++i) if(a[i] >= _2n) printf("%u ", i);
putchar('\n');
}static void findrepeat()
{
int[] arr = new int[7] {0,2,1,0,0,4,4};
for (int i = 0; i < arr.Length; i++)
{
if (i != arr[i])
{
if (arr[i] == arr[arr[i]])
{
Console.WriteLine(arr[i] + "!!!");
}
int t = arr[i];
arr[i] = arr[arr[i]];
arr[t] = t;
}
}
for (int j = 0; j < arr.Length; j++)
{
Console.Write(arr[j] + " ");
}
Console.WriteLine();
for (int j = 0; j < arr.Length; j++)
{
if (j == arr[j])
{
arr[j] = 1;
}
else
{
arr[arr[j]]++;
arr[j] = 0;
}
}
for (int j = 0; j < arr.Length; j++)
{
Console.Write(arr[j] + " ");
}
Console.WriteLine();
}0 (এন) সময়ের জটিলতা এবং ধ্রুবক অতিরিক্ত স্থানের অনুলিপি সন্ধানের জন্য আমি দ্রুত একটি নমুনা প্লেগ্রাউন্ড অ্যাপ তৈরি করেছি। অনুগ্রহ করে ডুপ্লিকেট সন্ধান করা ইউআরএল পরীক্ষা করুন
আইএমপি উপরের সলিউশনটি কাজ করে যখন একটি অ্যারেতে 0 থেকে এন -1 পর্যন্ত উপাদান থাকে তবে এই সংখ্যার যে কোনও সময় কোনও সংখ্যক বার উপস্থিত হয়।
private static void printRepeating(int arr[], int size) {
int i = 0;
int j = 1;
while (i < (size - 1)) {
if (arr[i] == arr[j]) {
System.out.println(arr[i] + " repeated at index " + j);
j = size;
}
j++;
if (j >= (size - 1)) {
i++;
j = i + 1;
}
}
}অ্যারে খুব বড় না হলে এই সমাধানটি সহজ, এটি টিকিংয়ের জন্য একই আকারের আর একটি অ্যারে তৈরি করে।
1 আপনার ইনপুট অ্যারে হিসাবে একই আকারের একটি বিটম্যাপ / অ্যারে তৈরি করুন
int check_list[SIZE_OF_INPUT];
for(n elements in checklist)
check_list[i]=0; //initialize to zero2 আপনার ইনপুট অ্যারে স্ক্যান করুন এবং উপরের অ্যারেতে এর সংখ্যা বাড়িয়ে তুলুন
for(i=0;i<n;i++) // every element in input array
{
check_list[a[i]]++; //increment its count
} 3 এখন চেক_লিস্ট অ্যারেটি স্ক্যান করুন এবং নকলটি একবারে বা বহুবার নকল হয়ে গেলে মুদ্রণ করুন
for(i=0;i<n;i++)
{
if(check_list[i]>1) // appeared as duplicate
{
printf(" ",i);
}
}অবশ্যই এটি উপরে প্রদত্ত সমাধানের দ্বারা গ্রাস করা স্থানের দ্বিগুণ গ্রহণ করে, তবে সময়ের দক্ষতা হ'ল (2 এন) যা মূলত ও (এন)।
O(1)স্থান নয় ।
a[a[i]]প্রতিবন্ধকতাগুলি সমাধানটির জন্য কিছুটা ক্লু দেয় - প্রতিটি বৈধ অ্যারে মানটি এটিতে একটি বৈধ অ্যারে সূচক ইঙ্গিতও এবংswap()অপারেশন- এ ও (1) স্থান সীমাবদ্ধতার ইঙ্গিতগুলি কী হিসাবে গুরুত্বপূর্ণ।