O (nlogn) অ্যালগরিদম - বাইনারি স্ট্রিংয়ের মধ্যে তিনটি সমান দুরত্বের সন্ধান করুন

Question

গতকাল একটি অ্যালগরিদম পরীক্ষায় আমার এই প্রশ্নটি ছিল এবং আমি উত্তরটি বের করতে পারি না। এটি আমাকে পুরোপুরি পাগল করছে, কারণ এটির প্রায় 40 পয়েন্ট ছিল। আমি অনুভব করেছি যে ক্লাসের বেশিরভাগ এটি সঠিকভাবে সমাধান করেনি, কারণ আমি গত 24 ঘন্টা কোনও সমাধান নিয়ে আসিনি।

দৈর্ঘ্য n এর একটি স্বেচ্ছাসেবী বাইনারি স্ট্রিং দেওয়া, স্ট্রিংয়ের মধ্যে উপস্থিত থাকলে তিনটি সমানভাবে ব্যবধানযুক্ত সন্ধান করুন। একটি অ্যালগরিদম লিখুন যা এটি ও (এন * লগ (এন)) সময়ে সমাধান করে।

11100000, 0100100100: এর মতো স্ট্রিংগুলির তিনটি "সমানভাবে দূরত্ব" রয়েছে

সম্পাদনা: এটি একটি এলোমেলো সংখ্যা, সুতরাং এটি কোনও সংখ্যার জন্য কাজ করতে সক্ষম হওয়া উচিত। আমি যে উদাহরণগুলি দিয়েছি তা হ'ল "সমান দুরত্ব" সম্পত্তি বর্ণনা করার জন্য। সুতরাং 1001011 একটি বৈধ সংখ্যা। 1, 4, এবং 7 সমানভাবে ব্যবধানযুক্ত একগুলি সহ।

Comments

নিম্নলিখিতটি কি সম্ভব: 10011010000? এটিতে তিনটি 1s রয়েছে (প্রথম, দ্বিতীয়, এগিয়ে) সমানভাবে ব্যবধানযুক্ত, তবে অতিরিক্ত 1s রয়েছে।

— আনা

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

— জেমস ম্যাকমাহন

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

— ldog

যদি আপনার প্রোফেসর কোনও সমাধান দেয় তবে দয়া করে একটি উত্তর হিসাবে পোস্ট করুন।

— ldog

ক্লাউস রথ 1958 এর জন্য (অন্যান্য জিনিসের মধ্যে) একটি ফিল্ডস মেডেল পেয়েছিলেন তা বিবেচনা করে প্রমাণ করুন যে প্রতিটি ঘনত্বের জন্য d> 0 একটি প্রাকৃতিক নম্বর এন রয়েছে যা কমপক্ষে ডি * সহ প্রতিটি উপসেট {1, ..., N of রয়েছে এন উপাদানগুলিতে দৈর্ঘ্য 3 এর একটি গাণিতিক অগ্রগতি রয়েছে, আমি অবাক হই না যে এখনও পর্যন্ত কেউ সমস্যার জন্য একটি দৃinc়প্রতিজ্ঞানিক অ্যালগরিদম খুঁজে পায়নি। আরও দেখুন en.wikedia.org/wiki/Szemer%C3%A9di%27s_theorem

— jp

Answer 1

অবশেষে! Sdcvvc এর উত্তরে নেতৃত্ব অনুসরণ করা , আমাদের কাছে এটি রয়েছে: সমস্যার জন্য ও (এন লগ এন) অ্যালগরিদম! এটি আপনার পক্ষে বোঝার পরেও সহজ। যারা এফএফটি অনুমান করেছিল তারা সঠিক ছিল।

সমস্যা: আমাদের Sদৈর্ঘ্য n এর একটি বাইনারি স্ট্রিং দেওয়া হয়েছে এবং আমরা এর মধ্যে তিনটি সমানভাবে ব্যবধানযুক্ত তিনটি সন্ধান করতে চাই। উদাহরণস্বরূপ, যেখানে এন = 9 Sহতে পারে । এটি সমানভাবে 1, 2, 5 এবং 8 অবস্থানগুলিতে স্পেস করেছে।110110010

1. Sবাম থেকে ডান স্ক্যান করুন এবং উপরের Lঅবস্থানগুলির একটি তালিকা তৈরি করুন 1. উপরেরগুলির জন্য S=110110010, আমাদের কাছে এল = [1, 2, 4, 5, 8] তালিকা রয়েছে। এই পদক্ষেপটি হ'ল (এন)। সমস্যাটি এখন 3 ইন্ দৈর্ঘ্যের পাটিগণিতের অগ্রগতি সন্ধান করতে L, যেমন বা = সিবি বা সমতুল্য পৃথক a, b, c সন্ধান Lকরতে একটি + C = 2b । উপরের উদাহরণের জন্য, আমরা অগ্রগতি (2, 5, 8) সন্ধান করতে চাই।

2. প্রতিটি কে- ইন-এর জন্য x ^k শর্তাবলী দিয়ে একটি বহুবচন তৈরি করুন । উপরের উদাহরণের জন্য, আমরা বহুপদী পি (এক্স) = (এক্স + এক্স ² + এক্স ⁴ + এক্স ⁵ + এক্স ⁸ ) করি । এই পদক্ষেপটি হ'ল (এন)।pL

3. দ্রুত ফুয়ুরি ট্রান্সফর্ম ব্যবহার করে বহুপদী q= পি ^{2 সন্ধান করুন} । উপরের উদাহরণের জন্য, আমরা বহুপদী q (x) = x ¹⁶ + 2x ¹³ + 2x ¹² + 3x ¹⁰ + 4x ⁹ + x ⁸ + 2x ⁷ + 4x ⁶ + 2x ⁵ + x ⁴ + 2x ³ + x ² পাই । এই পদক্ষেপটি হ'ল (এন লগ এন)।

4. কিছু কে- ইন এর জন্য x ^{2k এর} সাথে সম্পর্কিত সমস্ত শর্তাদি উপেক্ষা করুন । উপরের উদাহরণের জন্য, আমরা এক্স ¹⁶ , 3x ¹⁰ , এক্স ⁸ , এক্স ⁴ , এক্স ² পদগুলি পাই । এই পদক্ষেপটি হ'ল (এন), যদি আপনি এটি একেবারে করতে পছন্দ করেন।L

এখানে গুরুত্বপূর্ণ পয়েন্ট: কোন সহগ এক্স ^2b জন্য খ মধ্যে Lহয় অবিকল জোড়া সংখ্যা (ক, গ) মধ্যে Lযেমন যে একটি + C = 2b । [সিএলআরএস, প্রাক্তন 30.1-7] এই জাতীয় একটি জুড়ি সর্বদা (খ, খ) সর্বদা (সুতরাং সহগ কমপক্ষে 1 হয়) তবে অন্য কোনও জোড় (ক, গ) উপস্থিত থাকলে , সহগ কমপক্ষে 3 হয় (ক, সি) থেকে ) এবং (গ, ক) । উপরের উদাহরণস্বরূপ, এপি (2,5,8) এর কারণে আমাদের কাছে এক্স ^{10 এর} গুণাগুণটি 3 হতে হবে। (এই সহগ x ^{2 বি}উপরের কারণে সর্বদা বিজোড় সংখ্যা হবে be এবং q এর অন্যান্য সমস্ত সহগ সর্বদা সমান হবে will)

তারপরে, অ্যালগরিদমটি এই শর্তাবলী x ^{2b এর সহগগুলি} দেখতে হবে এবং তাদের ^{কোনওটি} 1 এর চেয়ে বড় কিনা তা দেখুন, যদি সেখানে কিছু না থাকে, তবে সমানভাবে ব্যবধানযুক্ত 1s নেই। যদি হয় একটি খ মধ্যে Lযার জন্য সহগ এক্স ^2b 1 তার চেয়ে অনেক বেশী হয়, তাহলে আমরা জানি কিছু যুগল নেই (ক, গ) - ছাড়া অন্য (খ, খ) জন্য যা - একটি + C = 2b । প্রকৃত যুগল এটি করার জন্য, আমরা কেবল প্রতিটি চেষ্টা একটি মধ্যে L(সংশ্লিষ্ট গ হবে 2b-একটি ) এবং যদি সেখানে একটি 1 অবস্থানে দেখতে 2b-একটি মধ্যে S। এই পদক্ষেপটি হ'ল (এন)।

লোকেরা, সব।

---

কেউ জিজ্ঞাসা করতে পারেন: আমাদের এফএফটি ব্যবহার করা দরকার? বিটা , ফ্লাইবায়ার এবং আরএসপি'র মতো অনেক উত্তর প্রস্তাব দেয় যে প্রতিটি পদ্ধতির 1 টি পরীক্ষা করে এবং "তৃতীয়" পজিশনে কোনও 1 আছে কিনা তা দেখতে পারা অভ্যাসের ভিত্তিতে ও (এন লগ এন) এ কাজ করতে পারে যে যদি খুব বেশি 1s থাকে তবে আমরা সহজেই একটি ট্রিপল পাই এবং যদি 1s খুব কম হয় তবে সমস্ত জোড়া পরীক্ষা করতে খুব কম সময় লাগে। দুর্ভাগ্যবশত, যখন এই অনুভূতি সঠিক এবং সহজ পদ্ধতি হল হে (ঢ বেশী ভালো ² ), তাই না উল্লেখযোগ্যভাবে উত্তম। Sdcvvc এর উত্তর হিসাবে , আমরা দৈর্ঘ্যের স্ট্রিংগুলির "ক্যান্টোরের মতো সেট" নিতে পারি n = 3 ^কে, 1 টি অবস্থানের সাথে যার ত্রৈমাসিক প্রতিনিধিত্বটিতে কেবল 0 এবং 2 এস (কোনও 1s নেই) রয়েছে। এ জাতীয় স্ট্রিংটিতে 2 ^কে = এন ^{(লগ 2) / (লগ 3) রয়েছে 0} n ^{0.63 টি} এতে এবং সমানভাবে ফাঁক করা 1s নেই, সুতরাং সমস্ত জোড় পরীক্ষা করা এটিতে 1s সংখ্যার বর্গের ক্রম হবে: এটি 4 ^কে 1. n ^1.26 যা দুর্ভাগ্যক্রমে asmptotically অনেক বড় (n লগ এন)। 1953 সালে লিও Moser: আসলে, সবচেয়ে খারাপ ক্ষেত্রে এমনকি খারাপ নির্মাণ (কার্যকরভাবে) যেমন স্ট্রিং যা এন ^{1-C / √ (লগ ঢ)} তাদের মধ্যে 1s কিন্তু কোন সমানভাবে ব্যবধানে 1s, যার মানে যে এই ধরনের স্ট্রিং উপর, সহজ পদ্ধতির জন্য। (এন লাগবে ^{2-2c / √ (লগ এন)} ) ^{লাগবে}- শুধুমাত্র একটি ছোটআশ্চর্যজনকভাবে Θ (n ² ) এর চেয়ে কিছুটা ভাল !

---

3 টি সমান দুরত্ববিহীন দৈর্ঘ্যের n এর স্ট্রিংয়ে সর্বাধিক সংখ্যক 1s (যা আমরা উপরে দেখলাম সহজ ক্যান্টোরের মতো নির্মাণ থেকে কমপক্ষে n ^0.63 ছিল , এবং কমপক্ষে n ^{1-c / √ (লগ এন) এর} সাথে মোসারের নির্মাণ) - এটি OEIS A003002 । এটি OEIS A065825 থেকে কে হিসাবে যেমন A065825 (কে) ≤ n <A065825 (কে + 1) হিসাবে সরাসরি গণনা করা যায় । এগুলি সন্ধান করার জন্য আমি একটি প্রোগ্রাম লিখেছিলাম এবং দেখা গেছে যে লোভী অ্যালগরিদম এ জাতীয় দীর্ঘতম স্ট্রিং দেয় না । উদাহরণস্বরূপ, এন = 9 এর আমরা 5 1s (110100011) পেতে পারি কিন্তু লোভী n এর জন্য কেবল 4 (110110000) দেয় = 26 এর জন্য আমরা 11 1s (11001010001000010110001101) পেতে পারি তবে লোভী কেবল 8 (11011000011011000000000000) দেয়, এবং এন এর জন্য= 74 আমরা 22 1s (11000010110001000001011010001000000000000000010001011010000010001101000011) পেতে পারি তবে লোভী কেবল 16 (110110000110110000000000000110110000110110000000000000000000000000000000) দিতে পারে। যদিও তারা 50 পর্যন্ত বেশ কয়েকটি জায়গায় একমত (যেমন 38 থেকে 50 এর সবকটি)। ওআইআইএসের উল্লেখ হিসাবে, দেখে মনে হচ্ছে যে জারোসলা ওবলেবউস্কি এই প্রশ্নে আগ্রহী এবং তিনি এই ওয়েবসাইটগুলি বজায় রাখেন না-গড়-গড় সেটগুলিতে । সঠিক সংখ্যাগুলি কেবল 194 অবধি জানা যায়।

Comments

খুব সুন্দর. চিত্তাকর্ষক। পরীক্ষায় কেউ এই নিয়ে আসবে বলে আশা করা কিছুটা মনে হয়।

— হুগড্রাউন 20

ঠিক আছে, পদক্ষেপ 1, কোনও সমস্যা সমাধানের জন্য এপি সন্ধান করা সহজবোধ্য। পদক্ষেপ 3, যে বহুবচনগুলি ও (এন লগ এন) সময়ে গুণিত করা যায়, এটি কেবল একটি সত্য। আসল কৌতুক, এবং সমস্যাটি কী কঠিন করে তোলে তা হল 11011 এর সহগের সাথে বহুবর্ষ হিসাবে চিন্তাভাবনা করা [1,1,0,1,1] ইত্যাদি। এটি একটি চতুর এবং প্রায়শই দরকারী ধারণা, যা সব কিছু করে uleলারের কাছে ফিরে আসার পথ। [আধুনিক প্রদর্শনের জন্য উইলফের দুর্দান্ত বই "জেনারেটিং ফাংশনোলজি " দেখুন: math.upenn.edu/~wilf/DownldGF.html ] সুতরাং শিক্ষার্থীরা সাম্প্রতিক স্মৃতিতে ফাংশন উত্পন্ন করার জন্য উন্মুক্ত হয়েছিল কিনা তার উপর নির্ভর করে। :-)

— শ্রীবতসার

দুঃখিত আমার গণনা সম্পূর্ণ ভুল হয়েছে। এটি 110110010 ^ 2 = 12124214302200100 হওয়া উচিত। কিন্তু ধারণা দাঁড়িয়েছে। কেবলমাত্র 3

— গিলারমো ফিলিপস

খুব চিত্তাকর্ষক. এই থ্রেড / প্রশ্নটি একত্রিত হয়ে সমাধান খুঁজে পাওয়া সত্যিই দুর্দান্ত। আমি ভাবতে শুরু করেছিলাম এটি সম্ভব ছিল না। এছাড়াও, এই অধ্যাপক মন্দ।

— কিংনেস্টর

@ রেক্সএ: পি যদি ডিগ্রি এন-1 এর হয় (এর এন শর্তাবলী রয়েছে), তবে কুই = পি ^ 2 ডিগ্রি 2 এন -2 এর (সর্বাধিক 2n-1 পদ আছে)। আপনি কীভাবে এন ^ 2 পেয়েছেন? (এছাড়াও, ও (এন লগ এন) এফএফটি ব্যবহারের সময় ডিগ্রি এন এর দুটি বহুভিত্তিক গুণকে গুণমানের মানসম্পন্ন ক্রিয়াকলাপ; উত্তরের লিঙ্কটিতে ক্লিক করুন বা উইকিপিডিয়া নিবন্ধটি দেখুন ।)

— শ্রীভাতসার

Answer 2

আপনার সমস্যাটিকে এই কাগজে (1999) এভারেজ বলা হয় :

সমস্যাটি যদি একটি উপ-চতুর্ভুজ হ্রাস হয় তবে 3SUM-হার্ড হয় 3SUM: একটি সেট এ এন পূর্ণসংখ্যার একটি সেট দেওয়া আছে, A তে একটি, বি, সি উপাদান রয়েছে এমন একটি + বি + সি = 0? AVERAGE 3SUM- শক্ত কিনা তা জানা যায়নি। তবে, AVERAGE থেকে 3SUM এ সরল রৈখিক-সময় হ্রাস রয়েছে, যার বর্ণনাটি আমরা বাদ দিই।

উইকিপিডিয়া :

যখন পূর্ণসংখ্যাগুলি পরিসীমাতে থাকে [...u ... u], 3SUM টি সময়ে O (n + u lg u) এ বিট ভেক্টর হিসাবে উপস্থাপন করে এবং এফএফটি ব্যবহার করে একটি সমাবর্তন সম্পাদন করে সমাধান করা যায়।

আপনার সমস্যা সমাধানের জন্য এটি যথেষ্ট :)

কি খুব গুরুত্বপূর্ণ (ঢ লগ ইন করুন ঢ) শূণ্যসমূহ এবং বেশী সংখ্যা পরিপ্রেক্ষিতে জটিলতা যে হে হয়, বেশী গণনা না (যা একটি অ্যারের হিসেবে দেওয়া যেতে পারে, মত [1,5,9,15])। কোনও সংখ্যার গাণিতিক অগ্রগতি আছে কিনা তা পরীক্ষা করা হচ্ছে, 1 এর সংখ্যার শর্তাবলী শক্ত এবং সেই কাগজ অনুসারে 1999 এর ও (এন ² ) এর চেয়ে দ্রুত কোন অ্যালগোরিদম জানা যায়নি এবং অনুমান করা হয় যে এটি বিদ্যমান নেই। যে কেউ এই বিষয়টি আমলে নেয় না তারা খোলা সমস্যা সমাধানের চেষ্টা করছে।

অন্যান্য আকর্ষণীয় তথ্য, বেশিরভাগ অপ্রত্যাশিত:

নিম্ন সীমা:

একটি সহজ নিম্ন বাঁধাই ক্যান্টোরের মতো সেট (সংখ্যা 1..3 ^ n-1 তাদের তিনটি প্রসারিত অংশে 1 টি নেই) - এর ঘনত্বটি n ^ (লগ_3 2) (প্রায় 0.631)। সুতরাং সেটটি খুব বড় নয় কিনা তা যাচাই করে নিন এবং তারপরে ও (এন লগ এন) পাওয়ার জন্য সমস্ত জোড়া পরীক্ষা করা যথেষ্ট নয়। আপনার সিকোয়েন্সটি স্মার্ট ভাল তদন্ত করতে হবে। আরও ভাল নিম্ন সীমাটি এখানে উদ্ধৃত করা হয়েছে - এটি এন ^{1-সি / (লগ (এন)) ^ (1/2)} । এর অর্থ ক্যান্টর সেটটি অনুকূল নয় ।

উপরের আবদ্ধ - আমার পুরানো অ্যালগরিদম:

এটি জানা যায় যে বড় এন এর জন্য, গাণিতিক অগ্রগতি না থাকায় {1,2, ..., n a এর একটি উপসেটের সর্বাধিক n / (লগ এন) ^ (1/20) উপাদান রয়েছে। গাণিতিক অগ্রগতিতে ট্রিপলগুলিতে কাগজটি আরও প্রমাণিত করে: সেটটিতে n * 2 ²⁸ * (লগ লগ এন / লগ এন) ^1/2 উপাদান বেশি থাকতে পারে না । সুতরাং আপনি পরীক্ষা করতে পারেন যে এই সীমাটি অর্জন করা হয়েছে কিনা এবং যদি না হয় তবে নির্লজ্জভাবে জোড়া পরীক্ষা করুন। এটি হে (এন ² * লগ লগ এন / লগ এন) অ্যালগরিদম, ও (এন ² ) এর চেয়ে দ্রুত । দুর্ভাগ্যক্রমে "ট্রিপলগুলিতে ..." স্প্রঞ্জারে রয়েছে - তবে প্রথম পৃষ্ঠাটি উপলভ্য, এবং বেন গ্রিনের প্রদর্শনটি এখানে 28 পৃষ্ঠায়, উপপাদ্য 24 এ উপলব্ধ।

যাইহোক, কাগজপত্রগুলি 1999-এর প্রথম বছর হিসাবে আমি উল্লেখ করেছি একই বছর, সুতরাং সম্ভবত প্রথম কারণটি সেই ফলাফলটি উল্লেখ করে না।

Comments

দুর্দান্ত উত্তর, প্রথম যা এই সমস্যা সম্পর্কে নির্দিষ্ট কিছু বলে। সুতরাং ক্যান্টোরের মতো সেটটিতে n ^ 0.63 1s রয়েছে, যার অর্থ হল "1s এর সমস্ত জোড়া পরীক্ষা করুন" অ্যালগরিদম সবচেয়ে খারাপ ক্ষেত্রে কমপক্ষে n ^ 1.26 (log n লগ এন)) Szemeredi এর কাগজে উদ্ধৃত নিচের দিকের আবদ্ধ (বিটিডাব্লু মজারের কাগজটি তিনি উদ্ধৃত করেছেন এখানে: book.google.com/books?id=Cvtwu5vVZF4C&pg=PA245 ) আসলে এন ^ (2-ও (1)) বোঝাচ্ছে, তবে আমাদের অবশ্যই কিছুটা সাবধান থাকুন কারণ সেখানে আমাদের numbers 1, ..., n numbers থেকে সংখ্যা আঁকা আছে তবে এখানে এটি n এর অনুক্রমের সংখ্যার যোগফল ।

— শ্রীভাতসারআর

হ্যাঁ, "ক্যান্টোরের মতো" বাইনারি ক্রমটি ঠিক কী যা এতে n ^ (লগ_3 2) 1 রয়েছে এবং তিনটি সমানভাবে ব্যবধানে 1s নেই?

— শ্রীভাতসারআর

উদাহরণ: 101000101000000000101000101. এর দৈর্ঘ্য 3 ^ n, এবং এতে 2 ^ n টি রয়েছে (সুতরাং এন ^ 0.63 ঘনত্ব)। আপনি যদি বাইনারিতে 1 এর স্থানগুলি লিখে রাখেন তবে এটি 0,2,20,22,200,202,220,222} হবে} এটি ভাবার আর একটি সম্ভাব্য উপায় হ'ল এটির ক্রম নেওয়া এবং ধারাবাহিকভাবে "মাঝারি "গুলি মুছে ফেলুন সাধারণ ক্যান্টর সেট নির্মানের মতো: 111111111 -> 111000111 -> 101000101। এটি গাণিতিক অগ্রগতি না রাখার কারণটি হ'ল: x , y, z একটি গঠন করে, তারপরে y = (x + z) / 2 এবং x এবং z এর কিছু বিস্তৃত স্থানে পৃথক। সবচেয়ে গুরুত্বপূর্ণ এক নিন। বলুন x এর 0 এবং z রয়েছে 2। তারপরে আপনার অবশ্যই 1 থাকতে হবে। অসঙ্গতি।

— sdcvvc

আবারও দুর্দান্ত গবেষণা! আমি 2008 3SUM পেপারে অনুসরণ করেছি এবং এটি সিএলআরএস অনুশীলনকে উল্লেখ করে। 30.1-7, আমি উত্তর পেয়েছিলাম যা দেখার পরে - ও (এন লগ এন) অ্যালগরিদম আসলে বেশ সহজ! (কেবল একটি বহুপদী / উত্পন্নকরণের স্কোয়ারিং।) আমি নীচে উত্তর পোস্ট করেছি। (এখন এর আগে চিন্তা না করার জন্য নিজেকে লাথি

— মারছি

সুতরাং, তার পরীক্ষার প্রশ্নের উত্তরটি ছিল এরকম কিছু, "এই সমস্যাটি 3-এসইএম হার্ড সমস্যা থেকে হ্রাসযোগ্য, এবং 3-এসইএম হার্ডের কোনও উপ-চতুর্ভুজ সমাধান নেই, সুতরাং এই সমস্যাটি ও (এন লগনে) সমাধান করা যায় না। " হ্যাঁ?

— হুগডব্রাউন

Answer 3

এটি কোনও সমাধান নয়, তবে ওলেক্সিয়া কী ভাবছেন তার সাথে একই চিন্তার একটি লাইন

আমি সর্বাধিক সংখ্যার সাথে ক্রম তৈরির সাথে ঘুরে বেড়াচ্ছিলাম, এবং সেগুলি বেশ আকর্ষণীয়, আমি 125 টি সংখ্যা পেয়েছি এবং এখানে প্রথম 'সংখ্যা' যতটা সম্ভব '1' বিট প্রবেশ করানোর চেষ্টা করে পাওয়া গেছে:

• 11011000011011000000000000001101100001101100000000000000000000000000000000000000000110110000110110000000000000011011000011011
• 10110100010110100000000000010110100010110100000000000000000000000000000000000000000101101000101101000000000000101101000101101
• 10011001010011001000000000010011001010011001000000000000000000000000000000000000010011001010011001000000000010011001010011001

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

এই সংখ্যাগুলি বর্ণনা করার জন্য আরও ভাল শব্দটির জন্য বিটা ধন্যবাদ।

আপডেট: হায় আফসোস দেখে মনে হচ্ছে একটি বড় পর্যাপ্ত প্রাথমিক স্ট্রিং দিয়ে শুরু করার সময় প্যাটার্নটি ভেঙে যায়, যেমন: 10000000000001:

100000000000011
10000000000001101
100000000000011011
10000000000001101100001
100000000000011011000011
10000000000001101100001101
100000000000011011000011010000000001
100000000000011011000011010000000001001
1000000000000110110000110100000000010011
1000000000000110110000110100000000010011001
10000000000001101100001101000000000100110010000000001
10000000000001101100001101000000000100110010000000001000001
1000000000000110110000110100000000010011001000000000100000100000000000001
10000000000001101100001101000000000100110010000000001000001000000000000011
1000000000000110110000110100000000010011001000000000100000100000000000001101
100000000000011011000011010000000001001100100000000010000010000000000000110100001
100000000000011011000011010000000001001100100000000010000010000000000000110100001001
100000000000011011000011010000000001001100100000000010000010000000000000110100001001000001
1000000000000110110000110100000000010011001000000000100000100000000000001101000010010000010000001
10000000000001101100001101000000000100110010000000001000001000000000000011010000100100000100000011
100000000000011011000011010000000001001100100000000010000010000000000000110100001001000001000000110001
100000000000011011000011010000000001001100100000000010000010000000000000110100001001000001000000110001000000001
10000000000001101100001101000000000100110010000000001000001000000000000011010000100100000100000011000100000000100000000000000000000000000000000000000001
100000000000011011000011010000000001001100100000000010000010000000000000110100001001000001000000110001000000001000000000000000000000000000000000000000010000001
100000000000011011000011010000000001001100100000000010000010000000000000110100001001000001000000110001000000001000000000000000000000000000000000000000010000001000000000000001
1000000000000110110000110100000000010011001000000000100000100000000000001101000010010000010000001100010000000010000000000000000000000000000000000000000100000010000000000000011
1000000000000110110000110100000000010011001000000000100000100000000000001101000010010000010000001100010000000010000000000000000000000000000000000000000100000010000000000000011000000001
10000000000001101100001101000000000100110010000000001000001000000000000011010000100100000100000011000100000000100000000000000000000000000000000000000001000000100000000000000110000000011
10000000000001101100001101000000000100110010000000001000001000000000000011010000100100000100000011000100000000100000000000000000000000000000000000000001000000100000000000000110000000011001
10000000000001101100001101000000000100110010000000001000001000000000000011010000100100000100000011000100000000100000000000000000000000000000000000000001000000100000000000000110000000011001000000001
10000000000001101100001101000000000100110010000000001000001000000000000011010000100100000100000011000100000000100000000000000000000000000000000000000001000000100000000000000110000000011001000000001001
100000000000011011000011010000000001001100100000000010000010000000000000110100001001000001000000110001000000001000000000000000000000000000000000000000010000001000000000000001100000000110010000000010010000000000001
100000000000011011000011010000000001001100100000000010000010000000000000110100001001000001000000110001000000001000000000000000000000000000000000000000010000001000000000000001100000000110010000000010010000000000001000000001
10000000000001101100001101000000000100110010000000001000001000000000000011010000100100000100000011000100000000100000000000000000000000000000000000000001000000100000000000000110000000011001000000001001000000000000100000000100001
10000000000001101100001101000000000100110010000000001000001000000000000011010000100100000100000011000100000000100000000000000000000000000000000000000001000000100000000000000110000000011001000000001001000000000000100000000100001000001
10000000000001101100001101000000000100110010000000001000001000000000000011010000100100000100000011000100000000100000000000000000000000000000000000000001000000100000000000000110000000011001000000001001000000000000100000000100001000001001
100000000000011011000011010000000001001100100000000010000010000000000000110100001001000001000000110001000000001000000000000000000000000000000000000000010000001000000000000001100000000110010000000010010000000000001000000001000010000010010001
100000000000011011000011010000000001001100100000000010000010000000000000110100001001000001000000110001000000001000000000000000000000000000000000000000010000001000000000000001100000000110010000000010010000000000001000000001000010000010010001001
100000000000011011000011010000000001001100100000000010000010000000000000110100001001000001000000110001000000001000000000000000000000000000000000000000010000001000000000000001100000000110010000000010010000000000001000000001000010000010010001001000001
10000000000001101100001101000000000100110010000000001000001000000000000011010000100100000100000011000100000000100000000000000000000000000000000000000001000000100000000000000110000000011001000000001001000000000000100000000100001000001001000100100000100000000000001
100000000000011011000011010000000001001100100000000010000010000000000000110100001001000001000000110001000000001000000000000000000000000000000000000000010000001000000000000001100000000110010000000010010000000000001000000001000010000010010001001000001000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000001
10000000000001101100001101000000000100110010000000001000001000000000000011010000100100000100000011000100000000100000000000000000000000000000000000000001000000100000000000000110000000011001000000001001000000000000100000000100001000001001000100100000100000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000001
100000000000011011000011010000000001001100100000000010000010000000000000110100001001000001000000110001000000001000000000000000000000000000000000000000010000001000000000000001100000000110010000000010010000000000001000000001000010000010010001001000001000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000011
100000000000011011000011010000000001001100100000000010000010000000000000110100001001000001000000110001000000001000000000000000000000000000000000000000010000001000000000000001100000000110010000000010010000000000001000000001000010000010010001001000001000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000011000001
1000000000000110110000110100000000010011001000000000100000100000000000001101000010010000010000001100010000000010000000000000000000000000000000000000000100000010000000000000011000000001100100000000100100000000000010000000010000100000100100010010000010000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000110000010000000000000000000001
1000000000000110110000110100000000010011001000000000100000100000000000001101000010010000010000001100010000000010000000000000000000000000000000000000000100000010000000000000011000000001100100000000100100000000000010000000010000100000100100010010000010000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000110000010000000000000000000001001
10000000000001101100001101000000000100110010000000001000001000000000000011010000100100000100000011000100000000100000000000000000000000000000000000000001000000100000000000000110000000011001000000001001000000000000100000000100001000001001000100100000100000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000001100000100000000000000000000010010000000000000000000000000000000000001
100000000000011011000011010000000001001100100000000010000010000000000000110100001001000001000000110001000000001000000000000000000000000000000000000000010000001000000000000001100000000110010000000010010000000000001000000001000010000010010001001000001000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000011000001000000000000000000000100100000000000000000000000000000000000011
100000000000011011000011010000000001001100100000000010000010000000000000110100001001000001000000110001000000001000000000000000000000000000000000000000010000001000000000000001100000000110010000000010010000000000001000000001000010000010010001001000001000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000011000001000000000000000000000100100000000000000000000000000000000000011001
10000000000001101100001101000000000100110010000000001000001000000000000011010000100100000100000011000100000000100000000000000000000000000000000000000001000000100000000000000110000000011001000000001001000000000000100000000100001000001001000100100000100000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000001100000100000000000000000000010010000000000000000000000000000000000001100100000000000000000000001
10000000000001101100001101000000000100110010000000001000001000000000000011010000100100000100000011000100000000100000000000000000000000000000000000000001000000100000000000000110000000011001000000001001000000000000100000000100001000001001000100100000100000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000001100000100000000000000000000010010000000000000000000000000000000000001100100000000000000000000001001
10000000000001101100001101000000000100110010000000001000001000000000000011010000100100000100000011000100000000100000000000000000000000000000000000000001000000100000000000000110000000011001000000001001000000000000100000000100001000001001000100100000100000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000001100000100000000000000000000010010000000000000000000000000000000000001100100000000000000000000001001000001
100000000000011011000011010000000001001100100000000010000010000000000000110100001001000001000000110001000000001000000000000000000000000000000000000000010000001000000000000001100000000110010000000010010000000000001000000001000010000010010001001000001000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000011000001000000000000000000000100100000000000000000000000000000000000011001000000000000000000000010010000010000001
1000000000000110110000110100000000010011001000000000100000100000000000001101000010010000010000001100010000000010000000000000000000000000000000000000000100000010000000000000011000000001100100000000100100000000000010000000010000100000100100010010000010000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000110000010000000000000000000001001000000000000000000000000000000000000110010000000000000000000000100100000100000011
10000000000001101100001101000000000100110010000000001000001000000000000011010000100100000100000011000100000000100000000000000000000000000000000000000001000000100000000000000110000000011001000000001001000000000000100000000100001000001001000100100000100000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000001100000100000000000000000000010010000000000000000000000000000000000001100100000000000000000000001001000001000000110000000000001

Comments

পবিত্র * @ !!, এগুলি ফ্র্যাক্টালস! যদি এটি ধরে থাকে তবে এটি 1 এর সংখ্যার উপর একটি উপরের আবদ্ধ রাখে এবং এটি O (n) এর চেয়ে কম।

— বিটা

ফ্র্যাক্টাল, এগুলি বর্ণনা করার জন্য এটি আরও ভাল শব্দ। ধন্যবাদ

— জেড -

মজার বিষয়, এই নিদর্শনগুলি ক্যান্টোরের তিনটি সেট ( en.wikedia.org/wiki/Cantor_set ) এর সাথে সাদৃশ্যপূর্ণ । যদি এটি হয় তবে তার অনুপাতের পরিমাণ শূন্য হতে থাকে ...

— ফ্লাইবায়ার

এটি কি সুস্পষ্ট যে ট্রিপল ছাড়াই সর্বাধিক সংখ্যক 1s এর ক্রমগুলি অ্যালগরিদমের সবচেয়ে খারাপ-চলমান সময়ের সাথে সরাসরি প্রাসঙ্গিক? এটি অনুমেয় যে আপনার প্রচুর 1 টি দিয়ে স্ট্রিং থাকতে পারে তবে এতে আপনি কেবল ট্রিপলগুলি খুব দেরীতে পেয়েছেন, কারণ সেই 1s সেই অবস্থানগুলিতে রয়েছে যা আপনার অ্যালগরিদম দ্বারা দেরিতে পরীক্ষা করা হয়।

— শ্রীভাতসারআর

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

— ওয়েলবোগ

Answer 4

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

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

Comments

হ্যাঁ, না আমি কোনও বক্তৃতা দিয়ে ঘুমাইনি। আমি কয়েক অন্যান্য শিক্ষার্থীর সাথে কথা বলেছি এবং এটি কীভাবে সমাধান করা যায় সে সম্পর্কে কারও স্পষ্ট ধারণা ছিল না। বেশিরভাগ বিএস লিখে কিছু আংশিক creditণ পাওয়ার জন্য আবেদনে বিভাজন এবং বিজয় সম্পর্কে লিখেছিলেন।

— রবার্ট পার্কার

Answer 5

পুনর্বিবেচনা: 2009-10-17 23:00

আমি এটি প্রচুর সংখ্যায় চালিয়েছি (যেমন, 2 মিলিয়ন স্ট্রিং) এবং আমি এখন বিশ্বাস করি যে এই অ্যালগরিদমটি ও (এন লগন) নয়। তবুও, এটি একটি দুর্দান্ত পর্যাপ্ত বাস্তবায়ন এবং এর মধ্যে বেশ কয়েকটি অপ্টিমাইজেশন রয়েছে যা এটি সত্যই দ্রুত চালিত করে তোলে। এটি 25 সেকেন্ডের নীচে বাইনারি স্ট্রিং 24 বা কম সংখ্যার সমস্ত ব্যবস্থার মূল্যায়ন করে।

আমি 0 <= L < M < U <= X-1আজ থেকে পর্যবেক্ষণটি অন্তর্ভুক্ত করার জন্য কোডটি আপডেট করেছি ।

---

মূল

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

using System;
using System.Collections.Generic;

namespace StackOverflow1560523
{
    class Program
    {
        public struct Pair<T>
        {
            public T Low, High;
        }
        static bool FindCandidate(int candidate, 
            List<int> arr, 
            List<int> pool, 
            Pair<int> pair, 
            ref int iterations)
        {
            int lower = pair.Low, upper = pair.High;
            while ((lower >= 0) && (upper < pool.Count))
            {
                int lowRange = candidate - arr[pool[lower]];
                int highRange = arr[pool[upper]] - candidate;
                iterations++;
                if (lowRange < highRange)
                    lower -= 1;
                else if (lowRange > highRange)
                    upper += 1;
                else
                    return true;
            }
            return false;
        }
        static List<int> BuildOnesArray(string s)
        {
            List<int> arr = new List<int>();
            for (int i = 0; i < s.Length; i++)
                if (s[i] == '1')
                    arr.Add(i);
            return arr;
        }
        static void BuildIndexes(List<int> arr, 
            ref List<int> even, ref List<int> odd, 
            ref List<Pair<int>> evenIndex, ref List<Pair<int>> oddIndex)
        {
            for (int i = 0; i < arr.Count; i++)
            {
                bool isEven = (arr[i] & 1) == 0;
                if (isEven)
                {
                    evenIndex.Add(new Pair<int> {Low=even.Count-1, High=even.Count+1});
                    oddIndex.Add(new Pair<int> {Low=odd.Count-1, High=odd.Count});
                    even.Add(i);
                }
                else
                {
                    oddIndex.Add(new Pair<int> {Low=odd.Count-1, High=odd.Count+1});
                    evenIndex.Add(new Pair<int> {Low=even.Count-1, High=even.Count});
                    odd.Add(i);
                }
            }
        }

        static int FindSpacedOnes(string s)
        {
            // List of indexes of 1s in the string
            List<int> arr = BuildOnesArray(s);
            //if (s.Length < 3)
            //    return 0;

            //  List of indexes to odd indexes in arr
            List<int> odd = new List<int>(), even = new List<int>();

            //  evenIndex has indexes into arr to bracket even numbers
            //  oddIndex has indexes into arr to bracket odd numbers
            List<Pair<int>> evenIndex = new List<Pair<int>>(), 
                oddIndex = new List<Pair<int>>(); 
            BuildIndexes(arr, 
                ref even, ref odd, 
                ref evenIndex, ref oddIndex);

            int iterations = 0;
            for (int i = 1; i < arr.Count-1; i++)
            {
                int target = arr[i];
                bool found = FindCandidate(target, arr, odd, oddIndex[i], ref iterations) || 
                    FindCandidate(target, arr, even, evenIndex[i], ref iterations);
                if (found)
                    return iterations;
            }
            return iterations;
        }
        static IEnumerable<string> PowerSet(int n)
        {
            for (long i = (1L << (n-1)); i < (1L << n); i++)
            {
                yield return Convert.ToString(i, 2).PadLeft(n, '0');
            }
        }
        static void Main(string[] args)
        {
            for (int i = 5; i < 64; i++)
            {
                int c = 0;
                string hardest_string = "";
                foreach (string s in PowerSet(i))
                {
                    int cost = find_spaced_ones(s);
                    if (cost > c)
                    {
                        hardest_string = s;
                        c = cost;
                        Console.Write("{0} {1} {2}\r", i, c, hardest_string);
                    }
                }
                Console.WriteLine("{0} {1} {2}", i, c, hardest_string);
            }
        }
    }
}

মূল পার্থক্যগুলি হ'ল:

1. সমাধানগুলির ক্লান্তিকর অনুসন্ধান
   এই কোডটি এই অ্যালগরিদমের সমাধান করার জন্য সবচেয়ে শক্ত ইনপুট সন্ধানের জন্য ডেটার একটি পাওয়ার সেট তৈরি করে।
2. কঠিন সমাধানের তুলনায় সমস্ত সমাধান
   পূর্ববর্তী প্রশ্নের কোডটি অজগর জেনারেটর ব্যবহার করে সমস্ত সমাধান তৈরি করে। এই কোডটি প্রতিটি প্যাটার্ন দৈর্ঘ্যের জন্য সবচেয়ে শক্ত প্রদর্শন করে।
3. স্কোরিং অ্যালগরিদম
   এই কোডটি মাঝারি উপাদান থেকে তার বাম এবং ডানদিকে প্রান্তের দূরত্বটি পরীক্ষা করে। পাইথন কোড পরীক্ষা করে একটি যোগফল 0 এর উপরে বা নীচে ছিল কিনা।
4. কোনও প্রার্থীর মধ্যে রূপান্তর
   বর্তমান প্রার্থী প্রার্থী সন্ধানের জন্য মাঝ থেকে প্রান্তের দিকে কাজ করে। পূর্ববর্তী সমস্যার কোডটি প্রান্ত থেকে মাঝের দিকে কাজ করেছিল। এই শেষ পরিবর্তনটি একটি বৃহত কর্মক্ষমতা উন্নতি দেয়।
5. সমান এবং বিজোড় পুলের
   ব্যবহার এই লেখার শেষের পর্যবেক্ষণের ভিত্তিতে, কোডটি এম এবং স্থির রেখে, ল এবং ইউ সন্ধানের জন্য বিজোড় সংখ্যার জোড় সংখ্যক জোড় জোড় অনুসন্ধান করে M এটি প্রাক-কম্পিউটিং তথ্যের সাহায্যে অনুসন্ধানের সংখ্যা হ্রাস করে। তদনুসারে, কোডটি FindCandidate এর প্রধান লুপটিতে দুটি স্তরের ইন্ডায়ারেশন ব্যবহার করে এবং প্রতিটি মাঝারি উপাদানটির জন্য FindCandidate এ দুটি কল প্রয়োজন: একবার এমনকি সংখ্যার জন্য এবং একবার বিজোড়ের জন্য।

সাধারণ ধারণাটি সূচীতে কাজ করা হয়, তথ্যের কাঁচা উপস্থাপনা নয়। 1 টি প্রদর্শিত হবে এমন একটি অ্যারের গণনা করা হলে অ্যালগরিদমটি ডেটার দৈর্ঘ্যের সাথে সমানুপাতিক সময়ের চেয়ে ডেটাতে 1 এর সংখ্যার সমানুপাতিক সময়ে চলতে দেয়। এটি একটি স্ট্যান্ডার্ড ট্রান্সফর্মেশন: এমন একটি ডেটা স্ট্রাকচার তৈরি করুন যা সমস্যার সমতুল্য রাখার সময় দ্রুত অপারেশন করতে দেয়।

ফলাফলগুলি পুরানো:

---

সম্পাদনা: 2009-10-16 18:48

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

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

---

সম্পাদনা: 2009-10-17 13:30

এ সম্পর্কে আরও পর্যবেক্ষণ।

প্রথমে 0 এবং 1 এর স্ট্রিংকে 1 এর প্রতিটি পদের জন্য সূচকের অ্যারে রূপান্তর করুন। বলুন যে অ্যারের A এর দৈর্ঘ্যটি এক্স Then তারপরে লক্ষ্যটি সন্ধান করা

0 <= L < M < U <= X-1

যেমন যে

A[M] - A[L] = A[U] - A[M]

অথবা

2*A[M] = A[L] + A[U]

যেহেতু A [L] এবং A [U] এর যোগফল একটি সংখ্যার সমান, সেগুলি (এমনকি, বিজোড়) বা (বিজোড়, এমনকি )ও হতে পারে না। A [] কে বিজোড় এবং এমনকি পুলগুলিতে বিভক্ত করে এবং A [M] এর সাথে বিজোড় এবং এমনকি পরীক্ষার্থীদের পুলগুলিতে ম্যাচগুলির সন্ধানের মাধ্যমে ম্যাচের সন্ধানের উন্নতি করা যেতে পারে।

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

---

2009-10-18 00:45 সম্পাদনা করুন

তবুও আরেকটি অপ্টিমাইজেশন আমার কাছে ঘটে, একই শিরাতে প্রার্থীদের আলাদা এবং বিজোড় করার মতো ting যেহেতু তিনটি সূচকে 3 (a, a + x, a + 2x - Mod 3 0, কোনও এবং x নির্বিশেষে) এর সাথে একাধিক যোগ করতে হয়, তাই আপনি L, M এবং U কে তাদের 3 মানের মধ্যে পৃথক করতে পারবেন :

M  L  U
0  0  0
   1  2
   2  1
1  0  2
   1  1
   2  0
2  0  1
   1  0
   2  2

প্রকৃতপক্ষে, আপনি এটি সমান / বিজোড় পর্যবেক্ষণের সাথে একত্রিত করতে এবং তাদের তাদের আধুনিক 6 মানগুলিতে পৃথক করতে পারেন:

M  L  U
0  0  0
   1  5
   2  4
   3  3
   4  2
   5  1

ইত্যাদি। এটি একটি আরও কার্যকারিতা অপ্টিমাইজেশন সরবরাহ করবে তবে একটি অ্যালগরিদমিক গতিবেগ নয়।

Answer 6

এখনও সমাধানটি নিয়ে আসতে সক্ষম হয়নি :( তবে কিছু ধারণা আছে।

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

Comments

ঠিক আছে, 1 এর সংখ্যা অবশ্যই ও (এন) দ্বারা উপরে আবদ্ধ। এটি ও (এন ** 2) হতে পারে না, ঠিক - 1 এর সংখ্যা ডেটার চেয়ে দ্রুত বৃদ্ধি পায়? উচ্চতর সীমাটি এর চেয়ে কম কিনা তা গুরুত্বপূর্ণ প্রশ্ন।

— হুগড্রাউনটি

আমি ছোট ও ব্যবহার করেছি,

— বড়টি

Answer 7

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

এই সমস্যাটি নিম্নলিখিতটি হ্রাস করে:

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

উদাহরণস্বরূপ, একটি ক্রম দেওয়া [ 3, 5, 1, 3, 6, 5, 2, 2, 3, 5, 6, 4 ], আমরা [ 3, 6, 5, 2, 2]একটি উপসর্গের [ 3, 6 ]উপসর্গের যোগফল 9এবং [ 5, 2, 2 ]প্রত্যয় যোগফল সহ একটি প্রত্যয় সহ একটি উপসর্গ খুঁজে পেতে হবে 9।

হ্রাস নিম্নরূপ:

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

উদাহরণস্বরূপ, একটি ক্রম দেওয়া [ 0, 1, 1, 0, 0, 1, 0, 0, 0, 1 0 ], আমরা হ্রাস খুঁজে পেতে হবে [ 1, 3, 4]। এই হ্রাস থেকে, আমরা [ 1, 3, 4]সংখ্যার অনুপাত, [ 1, 3]যোগফলের উপসর্গ 4, এবং [ 4 ]যোগফলের প্রত্যয় গণনা করি 4।

এই হ্রাস গণনা করা যেতে পারে O(n)।

দুর্ভাগ্যক্রমে, আমি এখান থেকে কোথায় যাব তা নিশ্চিত নই।

Comments

এটি আরও কমপ্যাক্ট স্বরলিপি, তবে এটি সময়ের জটিলতায় সহায়তা করবে না। "উপসর্গ" পার্টিশনগুলির সেটটি "1" এর সমস্ত উপস্থিতিতে সর্ব-জোড় অনুসন্ধানের জন্য বিচ্ছিন্ন, যা হে (এন ^ 2)।

— p00ya

সেখানে স্পষ্টতই অ্যালগরিদম রয়েছে যা সামঞ্জস্যপূর্ণ সাবকোয়েন্স যোগফলগুলি নিয়ে কাজ করে। দুর্ভাগ্যক্রমে তারা সকলেই O (n) এর সর্বাধিক যোগফলের সাথে সামঞ্জস্যপূর্ণ অনুচ্ছেদটি সন্ধান করার সাথে সম্পর্কিত বলে মনে হয়।

— yfeldblum

@ p00ya এটি সঠিক নয়। এই অ্যালগরিহমটি সময়কে ব্যবহার করে সিপিলেক্সটি মিথ্যা সংখ্যার উপরের সীমাতে নির্ভর করে, যা ক্যান্টর দ্বারা উত্পাদিত স্ট্রিংয়ের উপর ভিত্তি করে ((3/2) ^ (লগ (এন) / লগ (3)) হয় এবং স্থান জটিলতা এটি হয়ে যায়, তবে সময়ের জটিলতা n দ্বারা এই গুণিত হয়। আমার দ্বিতীয় উত্তর পরীক্ষা করে দেখুন। (the

— ণাত্মক নয়

@ রালু: এটি আপনার অনুমানের অধীনে রয়েছে যে ক্যান্টোর দ্বারা উত্পাদিত স্ট্রিংগুলি সবচেয়ে খারাপ পরিস্থিতি, যা ভুল। রেকর্ডের জন্য, জোড়ার সংখ্যা অবশ্যই ও (এন ^ 2); তবে আমি অনুমান করি যে আমি সত্যিই বোঝাচ্ছিলাম যে এটি বিগ-ওমেগা (এন ^ 2) ছিল, যা এই ফলাফলগুলি দিয়ে ভুল (বিশেষত NrootN লিঙ্কটি দেখুন), বিগ-ওমেগা (n ^ (2 / 1.52) এর জোড়গুলির মধ্যে একটি নিম্ন সীমাটি প্রস্তাব করছে )) প্রমাণ দ্বারা বা বড়-ওমেগা (n ^ (4/3)) দ্বারা অনুমান দ্বারা।

— p00ya

Answer 8

সাধারণ সমস্যার ধরণের জন্য (যেমন আপনি কেবল " শূন্য বা তার চেয়ে বেশি)" 0 "এর মধ্যে তিনটি" 1 "অনুসন্ধান করেন ) এটি বেশ সহজ: আপনি কেবল" 1 "এ ক্রমটি বিভক্ত করতে পারেন এবং দুটি সংলগ্ন অনুচ্ছেদ অনুসন্ধান করতে পারেন একই দৈর্ঘ্য (দ্বিতীয়টি অবশ্যই শেষেরটি নয়, অবশ্যই)। স্পষ্টতই, এটি ও (এন) সময়ে করা যেতে পারে ।

আরও জটিল সংস্করণের জন্য (যেমন আপনি একটি সূচক i এবং একটি ফাঁক g > 0 এর মতো অনুসন্ধান করেছেন s[i]==s[i+g]==s[i+2*g]=="1") এর জন্য আমি নিশ্চিত নই, যদি সেখানে কোনও O (n লগ এন) সমাধান থাকে তবে সম্ভবত O (n²) ট্রিপল্ট রয়েছে এই সম্পত্তি (সকলের একটি স্ট্রিং মনে করুন, প্রায় তিন / তিনটি এরকম ট্রিপল্ট রয়েছে)। অবশ্যই, আপনি এর মধ্যে একটির সন্ধান করছেন, তবে আমার বর্তমানে কোনও ধারণা নেই, এটি কীভাবে সন্ধান করবেন ...

Comments

হ্যাঁ, আমরা সমস্যার শক্ত সংস্করণটি নিয়ে আলোচনা করছি। তবুও, এন * লগ (এন) সমাধান সম্ভব হতে পারে।

— অলেক্সিয়

আসলে এন 3 বেছে নিন যা ও (এন ^ 3) সম্ভাব্য ট্রিপল, আমি যখন আপনি আনুমানিক এন ^

— 2/2

@gmatt: n চয়ন 2 যথেষ্ট; যদি আমরা দুটি 1s স্থির করি তবে তৃতীয়টির অবস্থান নির্ধারিত হয় এবং স্থিতিশীল সময়টি position পজিশনে 1 আছে কি না তা দেখার জন্য constant

— শ্রীভাতসারআর

@ শ্রীভাতসার: হ্যাঁ ঠিকই আমি মনে করি, আমি অনিয়ন্ত্রিত মামলার কথা ভাবছিলাম।

— ldog

@ গ্যাম্যাট: আসলে, আমরা 0 <= i <(n-3) এবং 0 <g <(এনআই -1) / 2 এর সাথে উপরের সংজ্ঞাগুলির সাথে উপরে সংজ্ঞায়িত টুপলস (i, g) খুঁজছি, সুতরাং এর অনুমান n ^

— 2/2

Answer 9

একটি মজাদার প্রশ্ন, তবে একবার আপনি বুঝতে পারবেন যে দুটি '1 এর মধ্যে আসল প্যাটার্নটি কোনও ব্যাপার নয়, অ্যালগরিদমটি হয়ে যায়:

• একটি '1' জন্য চেহারা স্ক্যান
• পরের অবস্থান থেকে অন্য '1' স্ক্যান করে শুরু করুন (অ্যারে বিয়োগের শেষে বর্তমান প্রথম '1' থেকে দূরত্ব বা অন্যথায় 3 য় '1' সীমা ছাড়িয়ে যাবে)
• যদি প্রথম '1' তৃতীয় '1' এর সাথে দ্বিতীয় '1' এর অবস্থানের স্থানে থাকে তবে আমাদের সমানভাবে ফাঁকা স্থান রয়েছে।

কোডে, জেস্টেস্ট ফ্যাশন, (নোট করুন এই কোডটি সবচেয়ে কার্যকর হিসাবে লেখা হয়নি এবং আমি কী ঘটে তা দেখার জন্য কিছু প্রিন্টলন যুক্ত করেছি))

import java.util.Random;

import junit.framework.TestCase;

public class AlgorithmTest extends TestCase {

 /**
  * Constructor for GetNumberTest.
  *
  * @param name The test's name.
  */
 public AlgorithmTest(String name) {
  super(name);
 }

 /**
  * @see TestCase#setUp()
  */
 protected void setUp() throws Exception {
  super.setUp();
 }

 /**
  * @see TestCase#tearDown()
  */
 protected void tearDown() throws Exception {
  super.tearDown();
 }

 /**
  * Tests the algorithm.
  */
 public void testEvenlySpacedOnes() {

  assertFalse(isEvenlySpaced(1));
  assertFalse(isEvenlySpaced(0x058003));
  assertTrue(isEvenlySpaced(0x07001));
  assertTrue(isEvenlySpaced(0x01007));
  assertTrue(isEvenlySpaced(0x101010));

  // some fun tests
  Random random = new Random();

  isEvenlySpaced(random.nextLong());
  isEvenlySpaced(random.nextLong());
  isEvenlySpaced(random.nextLong());
 }

 /**
  * @param testBits
  */
 private boolean isEvenlySpaced(long testBits) {
  String testString = Long.toBinaryString(testBits);
  char[] ones = testString.toCharArray();
  final char ONE = '1';

  for (int n = 0; n < ones.length - 1; n++) {

   if (ONE == ones[n]) {
    for (int m = n + 1; m < ones.length - m + n; m++) {

     if (ONE == ones[m] && ONE == ones[m + m - n]) {
      System.out.println(" IS evenly spaced: " + testBits + '=' + testString);
      System.out.println("               at: " + n + ", " + m + ", " + (m + m - n));
      return true;
     }
    }
   }
  }

  System.out.println("NOT evenly spaced: " + testBits + '=' + testString);
  return false;
 }
}

Comments

যদি আমি ভুল না হয়ে থাকি তবে এটি ও (n²) কারণ বাইরের লুপটি n বার চালায় এবং অভ্যন্তরীণ লুপটি n / 2 বার গড়ে চলে।

— স্ট্রিপলিং ওয়ারিয়র

বাহ্যিক লুপটি n বার চালায় এবং অভ্যন্তরীণ লুপটি গড়ে n / 4 চালায় তবে কেবল '1' অনুসরণ করে অবস্থান থেকে শুরু হয়। একটি n ^ 2 আচরণের কাছে যেতে '1 এর সংখ্যা অবশ্যই বেশি হওয়া উচিত যার ফলস্বরূপ প্রকৃত ফলাফলের ফলস্বরূপ প্রক্রিয়া বন্ধ করা হবে। সুতরাং n ^ 2 আচরণ কখনই ঘটবে না। কীভাবে ডেটির পরিচিত বৈশিষ্ট্যের উপর ভিত্তি করে একটি ও নির্ধারণ করবেন এই মুহুর্তে আমাকে এড়িয়ে চলে।

— আরএসপি

দুর্ভাগ্যজনকভাবে এটি গড় বাস্তব জীবনের রানটাইম সম্পর্কে নয় বরং তাত্ত্বিক বিগ হে রানটাইম। এবং আপনার দৃষ্টিভঙ্গি হ'ল (n²) (আমার মতই কারণ আপনার দৃষ্টিভঙ্গি আমার মতো))

— ডক্লাউন

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

— আরএসপি

আপনি যদি অভ্যন্তরীণ লুপের মধ্যে পাওয়া প্রথম 1টির সাথে বাইরের লুপে সূচকটি আপডেট করেন অর্থাত্, (যদি [এম [এম] == এক) {n = মি}? এটি কি বড় ওকে সহায়তা করে?

— স্টিমার 25

Answer 10

আমি একটি বিভাজন এবং বিজয়ী পদ্ধতির কথা ভেবেছিলাম যা কার্যকর হতে পারে।

প্রথমত, preprocessing আপনি অর্ধেক আপনার ইনপুট আকার (কম সমস্ত নম্বর সন্নিবেশ করতে প্রয়োজন এন / 3) একটি তালিকায়।

একটি স্ট্রিং দেওয়া হয়েছে: 0000010101000100 (এই বিশেষ উদাহরণটি বৈধ কিনা তা নোট করুন)

1 থেকে (16/2) থেকে সমস্ত প্রাইম (এবং 1) একটি তালিকায় sertোকান: {1, 2, 3, 4, 5, 6, 7}

তারপরে এটি অর্ধেক ভাগ করুন:

100000101 01000100

আপনি আকারের স্ট্রিং 1 না হওয়া পর্যন্ত এটি চালিয়ে যান; সমস্ত আকার-ওয়ান স্ট্রিংগুলির মধ্যে একটি 1 এর সাথে, স্ট্রিংটির সূচকে সম্ভাবনার তালিকায় যুক্ত করুন; অন্যথায়, ব্যর্থতার জন্য -1 ফিরুন।

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

সুতরাং উপরের উদাহরণটি দিয়ে চালিয়ে যাচ্ছি:

1000 0101 0100 0100

10 00 01 01 01 00 01 00

1 0 0 0 0 1 0 1 0 1 0 0 0 1 0 0

প্রথম সম্মিলন পদক্ষেপে, এখন আমাদের দুটি সেট আট আছে। প্রথমটিতে, আমাদের কাছে একটি সেট হওয়ার সম্ভাবনা রয়েছে তবে আমরা শিখেছি যে অন্য শূন্যটি সেখানে থাকার কারণে 1 দ্বারা ব্যবধান করা অসম্ভব। সুতরাং আমরা 0 অনুসারে (সূচকের জন্য) এবং by 2,3,4,5,7 return এই সত্যের জন্য যে 1 দ্বারা ব্যবধান করা অসম্ভব বলে ফিরে আসি। দ্বিতীয়টিতে, আমাদের কাছে কিছুই নেই এবং তাই ফিরুন -1। তৃতীয়টিতে আমাদের একটি ম্যাচ আছে যেখানে সূচি 5 এ কোনও ফাঁক ছাড়েনি, সুতরাং 5, {1,2,3,4,5,7 return ফিরিয়ে দিন} চতুর্থ জুটিতে আমরা 7, {1,2,3,4,5,7} ফিরে আসি} পঞ্চম, 9 ফিরে, {1,2,3,4,5,7}। ষষ্ঠিতে, রিটার্ন -1। সপ্তমীতে, 13 এ ফিরে আসুন, {1,2,3,4,5,7}} অষ্টমীতে, ফিরুন -1।

চারটি চারটি সেটটিতে আবার সংমিশ্রণ করা:

1000: রিটার্ন (0, {4,5,6,7}) 0101: রিটার্ন (5, {2,3,4,5,6,7}), (7, {1,2,3,4,5,6) , 7}) 0100: ফিরে (9, {3,4,5,6,7}) 0100 : ফিরে (13, {3,4,5,6,7})

আটটি সেট মিশ্রন:

10000101: রিটার্ন (0, {5,7}), (5, {2,3,4,5,6,7}), (7, {1,2,3,4,5,6,7}) 01000100: রিটার্ন (9, {4,7}), (13, {3,4,5,6,7})

ষোল একটি সেট মিশ্রণ:

10000101 01000100

আমরা যেভাবে অগ্রগতি করেছি, আমরা এখন পর্যন্ত সমস্ত সম্ভাবনা যাচাই করে চলছি। এই পদক্ষেপ অবধি আমরা স্ট্রিংয়ের শেষ ছাড়িয়ে গেছে এমন স্টাফ রেখেছি, তবে এখন আমরা সমস্ত সম্ভাবনা পরীক্ষা করতে পারি।

মূলত, আমরা প্রথম 1 টি 5 এবং 7 এর ফাঁক দিয়ে চেক করি এবং দেখতে পাই যে সেগুলি 1 এর মধ্যে নেই। (নোট করুন যে প্রতিটি চেকটি কনট্যান্ট, লিনিয়ার সময় নয়) তারপরে আমরা দ্বিতীয় (সূচক 5) 2, 3, 4, 5, 6, এবং 7 এর ফাঁক দিয়ে চেক করি - বা আমরা চাইব, তবে আমরা 2 এ থামতে পারি যে আসলে মেলে।

রাম রাম! এটি বরং দীর্ঘ দীর্ঘ অ্যালগরিদম।

আমি সর্বশেষ পদক্ষেপের কারণে এটি ও (এন লগ এন) হয় কিনা 100% জানি না , তবে যতদূর আমি বলতে পারি সেখানে সমস্ত কিছু অবশ্যই O (n লগ এন) রয়েছে । আমি পরে এটিতে ফিরে আসব এবং শেষ পদক্ষেপটি পরিমার্জন করার চেষ্টা করব।

সম্পাদনা: ওয়েলবোগের মন্তব্য প্রতিফলিত করতে আমার উত্তর পরিবর্তন করেছে। ত্রুটির জন্য দুঃখিত। আমি পরে আরও কিছু সিউডোকোড লিখব, যখন আমি আবার কী লিখেছি তা বোঝার জন্য যখন আমি আরও কিছুটা সময় পাই। ;-)

Comments

আমি আপনার অ্যালগরিদম অনুসরণ করি না, তবে অ্যালগরিদম চেষ্টা করার জন্য +1 যা আসলে ও (এন লগ এন) হওয়ার চেষ্টা করে

— ldog

ধন্যবাদ। আমি বেশি সময় পেলে এটি আরও ভাল করে ব্যাখ্যা করার চেষ্টা করব (সম্ভবত কিছু সিউডোকোড বা কিছু লিখুন)।

— প্লাটিনাম আজুর

আপনি কেবল প্রাইমগুলির ফাঁক সম্ভাবনাগুলি কেন দেখছেন? আপনি কীভাবে কোনও স্ট্রিংয়ের সাথে মিল রাখার প্রস্তাব করবেন 100010001? আমি যদি আপনার পদ্ধতির সঠিকভাবে বুঝতে পারি তবে এটি এটির সাথে মিলবে না কারণ সঠিক উত্তরটি (0,{4})গণনা করা সম্ভব নয়। আপনার তালিকায় আপনার নন-প্রাইমগুলির প্রয়োজন রয়েছে, এটি এমন প্যাথলজিকাল স্ট্রিংগুলির সাথে সহজেই আসে যা আপনাকে O (n লগ (এন)) এর চেয়ে উচ্চে পরীক্ষা করতে হবে এমন সম্ভাবনার তালিকাগুলি বাড়িয়ে দেয়।

— ওয়েলবোগ 21

কসম খায় , আমি মূলত বহুগুণ করতে যাচ্ছিলাম, তবে আমি আমার উত্তরটি মাঝপথে বদলে দিয়েছি এবং সব কিছু বদলাতে পেলাম না। দুঃখিত। শীঘ্রই ঠিক হয়ে যাবে

— প্ল্যাটিনাম আজুর

আমি মনে করি না এটি ও (এন লগ এন)। প্রথম একত্রিত পদক্ষেপে, আপনি (এন / 2) সেটগুলি চিকিত্সা করেন, যার প্রতিটিই সম্ভবত ও (এন) এর সম্ভাব্য ব্যবধানগুলির একটি সেট ফেরত দেয়। দুর্ভাগ্যক্রমে, এটি একা এটি ও (এন ^ 2) করে।

— মার্টিনস্টেটনার

Answer 11

আমি এখানে আমার মোটামুটি অনুমান দেব, এবং যারা জটিলতার গণনার সাথে আরও ভাল তারা আমাকে কীভাবে আমার স্বীকৃতি হিসাবে অ্যালগরিদম ভাড়ার ক্ষেত্রে সহায়তা করতে সহায়তা করবে

1. প্রদত্ত বাইনারি স্ট্রিং 0000010101000100 (উদাহরণস্বরূপ)
2. শস্যের শিরোনাম এবং পুচ্ছ -> 00000 101010001 00
3. আমরা পূর্ববর্তী গণনা থেকে 101010001 পাই
4. মাঝখানের বিটটি 'এক' কিনা তা সঠিক হলে সত্য তিনটি সমানভাবে ব্যবধানযুক্ত 'একই' পাওয়া যায় (কেবলমাত্র বিটের সংখ্যাটি বিজোড় সংখ্যাযুক্ত হলে)
5. তুলনামূলকভাবে, যদি টুকরো টুকরো টুকরো টুকরো বিট সংখ্যাটিও গণনা করা হয় তবে মাথা এবং লেজ 'এক' সমানভাবে ব্যবধানযুক্ত 'এক' এর অংশ হতে পারে না,
6. আমরা উদাহরণস্বরূপ 1010100001 ব্যবহার করি (এমনকি সংখ্যাযুক্ত শস্য হয়ে উঠতে অতিরিক্ত 'শূন্য' দিয়ে), এক্ষেত্রে আমাদের আবার শস্য নেওয়া দরকার, তারপরে -> 10101 00001
7. আমরা পূর্ববর্তী গণনা থেকে 10101 পেয়েছি, এবং মাঝারি বিটটি পরীক্ষা করেছি এবং আমরা আবার সমানভাবে ব্যবধানযুক্ত বিটটি পেয়েছি

এর জন্য জটিলতা কীভাবে গণনা করা যায় তা আমার কোনও ধারণা নেই, কেউ কি সহায়তা করতে পারে?

সম্পাদনা: আমার ধারণাটি চিত্রিত করার জন্য কিছু কোড যুক্ত করুন

edit2: আমার কোডটি সংকলনের চেষ্টা করেছিল এবং কিছু বড় ত্রুটিগুলি পাওয়া গেছে fixed

char *binaryStr = "0000010101000100";

int main() {
   int head, tail, pos;
   head = 0;
   tail = strlen(binaryStr)-1;
   if( (pos = find3even(head, tail)) >=0 )
      printf("found it at position %d\n", pos);
   return 0;
}

int find3even(int head, int tail) {
   int pos = 0;
   if(head >= tail) return -1;
   while(binaryStr[head] == '0') 
      if(head<tail) head++;
   while(binaryStr[tail] == '0') 
      if(head<tail) tail--;
   if(head >= tail) return -1;
   if( (tail-head)%2 == 0 && //true if odd numbered
       (binaryStr[head + (tail-head)/2] == '1') ) { 
         return head;
   }else {
      if( (pos = find3even(head, tail-1)) >=0 )
         return pos;
      if( (pos = find3even(head+1, tail)) >=0 )
         return pos;
   }
   return -1;
}

Comments

@ রিসার্সিভ আমি মনে করি এটি যখন ফাইন্ড3 ইভেন (মাথা + 1, লেজ) কল পৌঁছেছে তখন এটি কাজ করবে, যা পরে এটি = 11 হেড = 4 এ পরিণত হবে, আপনি কি আমার জন্য আবার পরীক্ষা করতে পারবেন?

— andycjw

@ রিসার্সিভ দয়া করে আমার পূর্বে তৈরি সিউডো কোডটি আরও ভালভাবে ব্যাখ্যা করার জন্য আমি যে কোডটি যুক্ত করেছি তা পরীক্ষা করে দেখুন, যা খুব কঠোর এবং সংক্ষিপ্ত নয়

— andycjw

এটি নিষ্ক্রিয় - এন বিটের জন্য আমরা আনুমানিক লগইন পুনরাবৃত্তিগুলি এন * সি বিটগুলি পরীক্ষা করে দেখি যেখানে সি একটি ধ্রুবক।

— রন ওয়ারহলিক

হ্যাঁ, এটি 111001 এবং 100111 এ সবচেয়ে সহজ কেস হিসাবে ব্যর্থ বলে মনে হচ্ছে। সমানভাবে ব্যবধানযুক্ত 1 এর মাঝের বিটকে কেন্দ্র করতে হবে না।

— ডিন জে

এটি সঠিকভাবে এই কেসগুলি পরিচালনা করে, 111001 এর বিট সংখ্যা রয়েছে তাই এটি তাত্ক্ষণিকভাবে 111 এবং 001 এ বিভক্ত হয় Since 111 বিটগুলির একটি বিজোড় সংখ্যা রয়েছে এবং মাঝারি বিটটি এটি সফলভাবে ফিরে আসে।

— রন ওয়ারহোলিক

Answer 12

আমি এরকম কিছু নিয়ে এসেছি:

def IsSymetric(number):
    number = number.strip('0')

    if len(number) < 3:
        return False
    if len(number) % 2 == 0:
        return IsSymetric(number[1:]) or IsSymetric(number[0:len(number)-2])
    else:
        if number[len(number)//2] == '1':
            return True
        return IsSymetric(number[:(len(number)//2)]) or IsSymetric(number[len(number)//2+1:])
    return False

এটি andycjw দ্বারা অনুপ্রাণিত।

1. শূন্যগুলি কেটে ফেলুন।
2. তারপরেও দুটি স্ট্রিংিং 0 - (লেন -2) (শেষ বর্ণটি এড়িয়ে চলুন) এবং 1 - (লেন -1) (প্রথম চরটি এড়িয়ে যান) পরীক্ষা করুন
3. যদি না হয় তবে মাঝের চরটি আমাদের সাফল্যের চেয়ে এক হয়। অন্যটি মিডল উপাদান ছাড়াই মিডলটিতে স্ট্রিংটি ভাগ করুন এবং উভয় অংশ পরীক্ষা করুন।

জটিলতার ক্ষেত্রে এটি ও (nlogn) হতে পারে যেমন প্রতিটি পুনরাবৃত্তি হিসাবে আমরা দুটি দ্বারা ভাগ করছি।

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

Comments

দেখে মনে হচ্ছে আপনি এন উপাদানগুলির একটি সমস্যাটিকে এন -1 উপাদানগুলির সাথে 2 টি সমস্যায় রূপান্তর করছেন। অর্ধেক ভাগ করার অর্থ এটি N / 2 উপাদানগুলির সাথে 2 টি সমস্যায় রূপান্তরিত হবে।

— আরএইচসিগার 21

এমনকি দৈর্ঘ্যের ক্ষেত্রে এটিই। সুতরাং লেনটি যদি 8 হয় তবে অ্যালগোরিদম দৈর্ঘ্যের স্ট্রিং তৈরি করে: 7, 7, 3, 3, 3, 3। পুনরাবৃত্তি গাছের দৈর্ঘ্য 3 এবং এটি এলজি (8) এর সমান।

— বেকু

Answer 13

ঠিক আছে, আমি সমস্যাটিতে আরও একটি ছুরিকাঘাত করব। আমি মনে করি যে আমি ও (এন লগ (এন)) অ্যালগরিদমকে প্রমাণ করতে পারি যা ইতিমধ্যে 1 এর মধ্যে দূরত্ব সঞ্চয় করতে ভারসাম্য বাইনারি গাছ ব্যবহার করে আলোচিতদের মতো। এই পদ্ধতির সমাধানটিকে 1 এর মধ্যে দূরত্বের তালিকায় সমস্যা হ্রাস সম্পর্কে জাস্টিসের পর্যবেক্ষণ দ্বারা অনুপ্রাণিত করা হয়েছিল।

আমরা কি 1 এর অবস্থানের আশেপাশে সুষম বাইনারি গাছ তৈরি করতে ইনপুট স্ট্রিংটি স্ক্যান করতে পারি যে প্রতিটি নোড 1 এর অবস্থান সংরক্ষণ করে এবং প্রতিটি প্রান্ত প্রতিটি শিশু নোডের জন্য সংলগ্ন 1 এর দূরত্ব সহ লেবেলযুক্ত। উদাহরণ স্বরূপ:

10010001 gives the following tree

      3
     / \
  2 /   \ 3
   /     \
  0       7

এটি ও (এন লগ (এন)) এ করা যেতে পারে, যেহেতু আকারের এন এর স্ট্রিংয়ের জন্য প্রতিটি সন্নিবেশ সবচেয়ে খারাপ অবস্থায় ও (লগ (এন)) নেয়।

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

আমি কিছু মিস করেছি?

Comments

"যেহেতু সাবট্রিতে পাথের সংখ্যা লগ (n) এর সমানুপাতিক হবে" কেন এন? সাধারণত এটি একটি আশাব্যঞ্জক পন্থা।

— sdcvvc

@sdcwc: এটি লগ (আন) এর আনুপাতিক এবং n নয় কারণ ভারসাম্যযুক্ত গাছে প্রতিটি সাবট্রির অর্ধেকটি নোড থাকে এবং সাবট্রির মূলের পাথের সংখ্যা সাবট্রির নোডের সংখ্যার সমান হয় (বাদে বাদে) রুট)।

— জেরেমি বাউরক

Answer 14

এটি মজাদার সমস্যাটিকে পছন্দ করেছে বলে আমি এটি করার চেষ্টা করেছি।

আমি ধারণা করছি যে 111000001 প্রথম 3 টি খুঁজে পাবে এবং সফল হবে। মূলত 1 টি অনুসরণ করে শূন্যের সংখ্যাটি গুরুত্বপূর্ণ বিষয়, যেহেতু 0111000 আপনার সংজ্ঞা অনুসারে 111000 এর সমান। একবার আপনি দুটি এর দুটি কেস পেয়ে গেলে পরের 1 টি পাওয়া ট্রেলজিটি সম্পূর্ণ করে।

এটি পাইথনে রয়েছে:

def find_three(bstring):
    print bstring
    dict = {}
    lastone = -1
    zerocount = 0
    for i in range(len(bstring)):
        if bstring[i] == '1':
            print i, ': 1'
            if lastone != -1:
                if(zerocount in dict):
                    dict[zerocount].append(lastone)
                    if len(dict[zerocount]) == 2:
                        dict[zerocount].append(i)
                        return True, dict
                else:
                    dict[zerocount] = [lastone]
            lastone = i
            zerocount = 0
        else:
            zerocount = zerocount + 1
    #this is really just book keeping, as we have failed at this point
    if lastone != -1:
        if(zerocount in dict):
            dict[zerocount].append(lastone)
        else:
            dict[zerocount] = [lastone]
    return False, dict

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

Comments

@ রিসার্সিভ, এগুলি সমানভাবে ব্যবধানযুক্ত নয়।

— জেমস ম্যাকমাহন

সমান দুরত্বের অর্থ কী? সূচক 0, 3 এবং 6 দেখুন All সমস্তগুলি এবং দুটি পৃথক করে।

— পুনরাবৃত্তির

ওহ, আমি যেমন বুঝতে পেরেছি, শূন্যগুলি কেবল ব্যবধানে অন্তর্ভুক্ত ছিল।

— জেমস ম্যাকমাহন

প্রশ্নটিতে "1001011" উল্লেখ করা হয়েছে, যার উপর এটি কাজ করে না। একটি পূর্ববর্তী (এখন মুছে ফেলা) উত্তর ছিল, প্রশ্ন জিজ্ঞাসার সাথে সাথে পোস্ট করা হয়েছিল, যা এই হিসাবে একই (অন্যান্য) সমস্যার সমাধান করেছে। :-)

— শ্রীবতসআর

আমি আজ কাজের দিকে এটি তাকিয়ে ছিলাম এবং রব তার সম্পাদনাটির অর্থ কী তা আমি বুঝতে পারি নি। আমি স্বচ্ছতার জন্য প্রশ্নটি সম্পাদনা করেছি। আমার জানা উচিত ছিল যখন আমি এটির সাথে একটি সহজ সময় কাটিয়েছি তখন আমি কিছু মিস করছি।

— জেমস ম্যাকমাহন

Answer 15

আমি অনুমান করি যে এই কারণটি এনলগ (এন) হ'ল নিম্নলিখিত কারণে:

• ট্রিপলেটের শুরু যেটি 1 এটি খুঁজতে, আপনাকে (এন -২) অক্ষর পরীক্ষা করতে হবে। যদি আপনি এটি অবধি খুঁজে না পেয়ে থাকেন তবে আপনি (অক্ষর এন -1 এবং এন একটি ট্রিপলেট শুরু করতে পারবেন না) (ও (এন))
• দ্বিতীয় 1 টি ট্রিপলেটের অংশ (প্রথমটি দিয়ে শুরু করা) এটির জন্য আপনাকে এম / 2 (মি = এনএক্স) পরীক্ষা করতে হবে, যেখানে x প্রথম 1 এর অফসেট) characters এটি কারণ, যদি প্রথম প্রথম থেকে শেষের অর্ধেকের মধ্যে আপনি যদি দ্বিতীয় 1টি না পেয়ে থাকেন তবে আপনি পাবেন না ... যেহেতু তৃতীয় 1 অবশ্যই দ্বিতীয় থেকে ঠিক একই দূরত্বের হতে হবে।(হে (লগ (ঢ)))
• এটি সর্বশেষ 1 খুঁজে বের করতে ও (1) আপনি সূচকটি জানেন বলে এটি প্রথম এবং দ্বিতীয়টি খুঁজে পাওয়ার সময় অবশ্যই হওয়া উচিত।

সুতরাং, আপনার এন, লগ (এন), এবং 1 ... ও (nlogn) আছে

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

---

টিসিএল তে বাস্তবায়ন

proc get-triplet {input} {
    for {set first 0} {$first < [string length $input]-2} {incr first} {
        if {[string index $input $first] != 1} {
            continue
        }
        set start [expr {$first + 1}]
        set end [expr {1+ $first + (([string length $input] - $first) /2)}]
        for {set second $start} {$second < $end} {incr second} {
            if {[string index $input $second] != 1} {
                continue
            }
            set last [expr {($second - $first) + $second}]
            if {[string index $input $last] == 1} {
                return [list $first $second $last]
            }
        }
    }
    return {}
}

get-triplet 10101      ;# 0 2 4
get-triplet 10111      ;# 0 2 4
get-triplet 11100000   ;# 0 1 2
get-triplet 0100100100 ;# 1 4 7

Answer 16

আমি মনে করি আমি সমস্যা সমাধানের একটি উপায় খুঁজে পেয়েছি, তবে আমি কোনও আনুষ্ঠানিক প্রমাণ তৈরি করতে পারি না। আমি যে সমাধানটি করেছি তা জাভাতে লেখা হয়েছে এবং এটি কতগুলি তালিকা / অ্যারে ব্যবহার করে তা গণনা করার জন্য এটি একটি 'এন' ব্যবহার করে uses সুতরাং এনটি স্ট্রিংলেংথ * লগ (স্ট্রিংলংথ) এর চেয়ে কম বা সমান হওয়া উচিত। আমি 0 থেকে 2 ^ 22 সংখ্যার জন্য চেষ্টা করেছিলাম, এবং এটি কার্যকর হয়।

এটি ইনপুট স্ট্রিংটি দিয়ে পুনরাবৃত্তি করে এবং সমস্ত সূচকগুলির তালিকা তৈরি করে যা একটি ধারণ করে। এটি কেবল ও (এন)।

তারপরে সূচকের তালিকা থেকে এটি প্রথম ইন্ডেক্স এবং দ্বিতীয়টি সূচকটি প্রথমটির চেয়ে বড় ex এই দুটি সূচকে অবশ্যই একটি অবশ্যই রাখা উচিত কারণ তারা সূচকের তালিকায় রয়েছে। সেখান থেকে তৃতীয়আইডেক্স গণনা করা যেতে পারে। যদি ইনপুটস্ট্রিং [তৃতীয় সূচক] 1 হয় তবে এটি বন্ধ হয়ে যায়।

public static int testString(String input){
//n is the number of array/list accesses in the algorithm
int n=0;

//Put the indices of all the ones into a list, O(n)
ArrayList<Integer> ones = new ArrayList<Integer>();
for(int i=0;i<input.length();i++){
    if(input.charAt(i)=='1'){
        ones.add(i);
    }
}

//If less than three ones in list, just stop
if(ones.size()<3){
    return n;
}

int firstIndex, secondIndex, thirdIndex;
for(int x=0;x<ones.size()-2;x++){
    n++;
    firstIndex = ones.get(x);

    for(int y=x+1; y<ones.size()-1; y++){
        n++;
        secondIndex = ones.get(y);
        thirdIndex = secondIndex*2 - firstIndex;

        if(thirdIndex >= input.length()){
            break;
        }

        n++;
        if(input.charAt(thirdIndex) == '1'){
            //This case is satisfied if it has found three evenly spaced ones
            //System.out.println("This one => " + input);
            return n;
        }
    }
}

return n;

}

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

Comments

আপনার কাছে এখনও ও (এন) এর দুটি লুপ রয়েছে, যা এটিকে ও (n ^ 2) করে তোলে

— আরএইচসিগার

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

— রবার্ট পার্কার

আমি মনে করি এই সমস্যার কৌশলটি হ'ল আপনার অ্যালগরিদম ও (এন ^ 2) হওয়া সত্ত্বেও, আপনি যে স্ট্রিংয়ের সবচেয়ে খারাপ সম্ভাব্য পরিস্থিতি পেতে পারেন তার ফলাফল কেবল ও (এনলগন) পুনরাবৃত্তিতে ঘটতে পারে অন্যথায় আপনি আপনার অ্যালগোরিদম ব্যবহার করে একটি সমাধান পেয়েছেন।

— z -

এটি 2 ^ 22 পর্যন্ত পরীক্ষা করা সত্যিই এটির জটিলতার পরীক্ষা করে না। 2 ^ 22 টিতে কেবল 22 টি বিট থাকে যার অর্থ আপনার এন 22 হয় N এমন কয়েকটি মানের জন্য চেষ্টা করুন যেখানে এন কয়েক মিলিয়ন।

— পিটার পুনরুদ্ধার করুন

Yx এর উত্তরে প্রদত্ত সর্বাধিক "খারাপ" স্ট্রিংগুলির সাহায্যে এই অ্যালগরিদমটি ব্যবহার করে দেখুন এবং এটি আপনি একটি O(n^2)অ্যালগোরিদম খুঁজে পাবেন ।

— ওয়েলবোগ

Answer 17

সমস্যার একটি অন্তঃস্থল বিষয়গুলি এবং স্থানান্তর সম্পর্কে চিন্তা করা।

স্থানান্তরিত করার সাথে, আপনি নিজের এবং অন্য শূণ্যের স্ট্রিংকে নিজের পরিবর্তিত সংস্করণের সাথে তুলনা করুন। তারপরে আপনি মিলে যাবেন। এই উদাহরণটিকে দুটি দ্বারা স্থানান্তরিত করুন:

1010101010
  1010101010
------------
001010101000

ফলস্বরূপ 1 এর (বিটওয়াস এ্যান্ডেড), অবশ্যই সেই 1 টির প্রতিনিধিত্ব করবে যা দুটি দ্বারা সমানভাবে ব্যবধানে রয়েছে। একই উদাহরণ তিনটি দ্বারা স্থানান্তরিত:

1010101010
   1010101010
-------------
0000000000000

এক্ষেত্রে এমন কোনও 1 নেই যা সমানভাবে তিনটি পৃথকভাবে আলাদা হয়।

তাহলে এটি আপনাকে কী বলে? ভাল যে আপনি কেবল শিফট পরীক্ষা করতে হবে যা প্রাথমিক সংখ্যা। উদাহরণস্বরূপ বলুন আপনার দুটি দুটি আছে যা ছয়টি পৃথক। আপনাকে কেবল 'দুটি' শিফট এবং 'তিন' শিফ্ট পরীক্ষা করতে হবে (যেহেতু এই বিভাজন ছয়টি)। উদাহরণ স্বরূপ:

10000010 
  10000010 (Shift by two)
    10000010
      10000010 (We have a match)

10000010
   10000010 (Shift by three)
      10000010 (We have a match)

সুতরাং আপনার কেবলমাত্র যে শিফ্টগুলি চেক করা দরকার তা হ'ল 2,3,5,7,11,13 ইত্যাদি of

প্রায় সমাধান?

আমি মনে করি আমি একটি সমাধানের কাছাকাছি। মূলত:

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

আমি মনে করি যে উত্তরের বৃহত্তম সূত্রটি হ'ল দ্রুততম বাছাই করা অ্যালগরিদমগুলি হ'ল হে (এন * লগ (এন))।

ভুল

সহকর্মী দ্বারা চিহ্নিত হিসাবে পদক্ষেপ 1 ভুল। আমাদের যদি ২২, ২২ ও ১০২ পজিশনে থাকে তবে 10 টির একটি মডিউল গ্রহণ করলে সেগুলি একই রকম অবশিষ্ট থাকে এবং তবুও তারা সমানভাবে আলাদা হয় না! দুঃখিত।

Comments

এটি একটি আকর্ষণীয় পদ্ধতির, আপনি যদি একটি সম্পূর্ণ সমাধান নিয়ে আসে তবে আমাদের জানান।

— জেমস ম্যাকমাহন

একটি সংখ্যা কে ও (এন) বার দ্বারা শিফট করুন এবং তারপরে ও (এন) শিফটে প্রতি চেকগুলি একটি ও (এন ^ 2) অ্যালগরিদম অর্জন করে, এমনকি আপনি যদি একটি সংখ্যার দ্বারা স্থানান্তরিত হন। আপনার অ্যালগরিদম একাধিক সংখ্যার দ্বারা স্থানান্তরিত করতে হবে।

— ldog

Answer 18

এখানে কিছু চিন্তাভাবনা রয়েছে যা আমার সর্বোত্তম প্রচেষ্টা সত্ত্বেও, নিজেকে ধনুকের মধ্যে আবৃত করবে বলে মনে হবে না। তবুও, তারা কারও বিশ্লেষণের জন্য দরকারী সূচনা পয়েন্ট হতে পারে।

প্রস্তাবিত সমাধানটি নিম্নরূপে বিবেচনা করুন, যা এই উত্তরটির পূর্ববর্তী সংস্করণে নিজেকে অন্তর্ভুক্ত করে একাধিক লোক পরামর্শ দিয়েছেন approach :)

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

নিম্নলিখিতগুলির মতো ইনপুট স্ট্রিংয়ের স্ট্রিংগুলি বিবেচনা করুন, যার কোনও সমাধান হবে না:

101
101001
1010010001
101001000100001
101001000100001000001

সাধারণভাবে, এটি জে 0 এর ফর্মের কে স্ট্রিংগুলির সংক্ষিপ্তকরণ এবং তারপরে শূন্য থেকে কে -1 পর্যন্ত জের জন্য 1 রয়েছে।

k=2  101
k=3  101001
k=4  1010010001
k=5  101001000100001
k=6  101001000100001000001

নোট করুন যে সাবস্ট্রিংগুলির দৈর্ঘ্য 1, 2, 3 ইত্যাদি। সুতরাং, সমস্যা আকার n এর 1 = k এর দৈর্ঘ্যের সাব-স্ট্রিংগুলি রয়েছে যেমন এন = কে (কে + 1) / 2।

k=2  n= 3  101
k=3  n= 6  101001
k=4  n=10  1010010001
k=5  n=15  101001000100001
k=6  n=21  101001000100001000001

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

k=2  n= 3  p= 1  101
k=3  n= 6  p= 3  101001
k=4  n=10  p= 6  1010010001
k=5  n=15  p=10  101001000100001
k=6  n=21  p=15  101001000100001000001

N এবং p এর মধ্যে সম্পর্ক হল যে এন = পি + কে।

স্ট্রিংয়ের মধ্য দিয়ে যাওয়ার প্রক্রিয়াটি O (n) সময় নেয়। প্রতিবার যখন 1 এর মুখোমুখি হয়, সর্বাধিক (কে -1) তুলনা করা হয়। যেহেতু এন = কে (কে + 1) / 2, এন> কে ** 2, সুতরাং স্কয়ার্ট (এন)> কে। এটি আমাদের ও (এন স্ক্রিট (এন)) বা ও (এন ** 3/2) দেয়। তবে দ্রষ্টব্য যে এটি সত্যই শক্ত বাঁধা নাও হতে পারে, কারণ তুলনার সংখ্যাটি 1 থেকে সর্বোচ্চ কেতে যায়, এটি পুরো সময় কে হয় না। তবে আমি গণিতে কীভাবে এটি হিসাব করব তা নিশ্চিত নই।

এটি এখনও ও (এন লগ (এন)) নয়। এছাড়াও, আমি প্রমাণ করতে পারি না যে ইনপুটগুলি সবচেয়ে খারাপ ক্ষেত্রে, যদিও আমি সন্দেহ করি সেগুলি। আমি মনে করি সামনের দিকে 1 এর একটি প্যাকেজজাত প্যাকিং এর শেষে একটি স্পার্সার প্যাকিং ফলাফল results

যেহেতু কেউ এখনও এটি দরকারী হিসাবে খুঁজে পেতে পারেন, পার্লে সেই সমাধানের জন্য আমার কোড এখানে:

#!/usr/bin/perl

# read input as first argument
my $s = $ARGV[0];

# validate the input
$s =~ /^[01]+$/ or die "invalid input string\n";

# strip leading and trailing 0's
$s =~ s/^0+//;
$s =~ s/0+$//;

# prime the position list with the first '1' at position 0
my @p = (0);

# start at position 1, which is the second character
my $i = 1;

print "the string is $s\n\n";

while ($i < length($s)) {
   if (substr($s, $i, 1) eq '1') {
      print "found '1' at position $i\n";
      my @t = ();
      # assuming this is the middle '1', go through the positions
      # of all the prior '1's and check whether there's another '1'
      # in the correct position after this '1' to make a solution
      while (scalar @p) {
         # $p is the position of the prior '1'
         my $p = shift @p;
         # $j is the corresponding position for the following '1'
         my $j = 2 * $i - $p;
         # if $j is off the end of the string then we don't need to
         # check $p anymore
         next if ($j >= length($s));
         print "checking positions $p, $i, $j\n";
         if (substr($s, $j, 1) eq '1') {
            print "\nsolution found at positions $p, $i, $j\n";
            exit 0;
         }
         # if $j isn't off the end of the string, keep $p for next time
         push @t, $p;
      }
      @p = @t;
      # add this '1' to the list of '1' positions
      push @p, $i;
   }
   $i++;
}

print "\nno solution found\n";

Comments

আপনার "অ-সমাধান" ক্রমটি ভুল; প্রতিটি 1 এর সূচকটি 1, 3, 6, 10, 15 ... ইত্যাদি ত্রিভুজাকার সংখ্যার ক্রম এবং এতে 6, 36, এবং 66 সংখ্যা রয়েছে যা একটি গাণিতিক অগ্রগতি গঠন করে।

— জেসন এস

Answer 19

1 এস স্ক্যান করার সময়, একটি তালিকায় তাদের অবস্থানগুলি যুক্ত করুন। দ্বিতীয় এবং ধারাবাহিক 1 এস যুক্ত করার সময় এটিকে তালিকার প্রতিটি অবস্থানের সাথে তুলনা করুন। ব্যবধান বর্তমানের এক (কেন্দ্র) সমান - পূর্ববর্তী এক (বাম)। ডান পাশের বিটটি বর্তমান এক + ব্যবধান। যদি এটি 1, শেষ।

এগুলির তালিকা তাদের মধ্যবর্তী স্থানের সাথে বিপরীতভাবে বৃদ্ধি পায়। সরলভাবে বলা হয়েছে, যদি আপনি 1s এর মধ্যে প্রচুর 0 টি পেয়েছেন (সবচেয়ে খারাপ হিসাবে), তবে আপনার পরিচিত 1s এর তালিকা বেশ ধীরে ধীরে বাড়বে।

using System;
using System.Collections.Generic;

namespace spacedOnes
{
    class Program
    {
        static int[] _bits = new int[8] {128, 64, 32, 16, 8, 4, 2, 1};

        static void Main(string[] args)
        {
            var bytes = new byte[4];
            var r = new Random();
            r.NextBytes(bytes);
            foreach (var b in bytes) {
                Console.Write(getByteString(b));
            }
            Console.WriteLine();
            var bitCount = bytes.Length * 8;
            var done = false;
            var onePositions = new List<int>();
            for (var i = 0; i < bitCount; i++)
            {
                if (isOne(bytes, i)) {
                    if (onePositions.Count > 0) {
                        foreach (var knownOne in onePositions) {
                            var spacing = i - knownOne;
                            var k = i + spacing;
                            if (k < bitCount && isOne(bytes, k)) {
                                Console.WriteLine("^".PadLeft(knownOne + 1) + "^".PadLeft(spacing) + "^".PadLeft(spacing));
                                done = true;
                                break;
                            }
                        }
                    }
                    if (done) {
                        break;
                    }
                    onePositions.Add(i);
                }
            }
            Console.ReadKey();
        }

        static String getByteString(byte b) {
            var s = new char[8];
            for (var i=0; i<s.Length; i++) {
                s[i] = ((b & _bits[i]) > 0 ? '1' : '0');
            }
            return new String(s);
        }

        static bool isOne(byte[] bytes, int i)
        {
            var byteIndex = i / 8;
            var bitIndex = i % 8;
            return (bytes[byteIndex] & _bits[bitIndex]) > 0;
        }
    }
}

Answer 20

আমি ভাবলাম সমস্যার 22 তম নিষ্পাপ সমাধান পোস্ট করার আগে আমি একটি মন্তব্য যুক্ত করব। নিষ্পাপ সমাধানের জন্য, আমাদের দেখানোর দরকার নেই যে স্ট্রিংয়ের মধ্যে 1 এর সংখ্যা সর্বাধিক ও (লগ (এন)), তবে এটি সর্বাধিক ও (স্কয়ার্ট (এন * লগ (এন)) এর মধ্যে রয়েছে।

সমাধানকারী:

def solve(Str):
    indexes=[]
    #O(n) setup
    for i in range(len(Str)):
        if Str[i]=='1':
            indexes.append(i)

    #O((number of 1's)^2) processing
    for i in range(len(indexes)):
        for j in range(i+1, len(indexes)):
                            indexDiff = indexes[j] - indexes[i]
            k=indexes[j] + indexDiff
            if k<len(Str) and Str[k]=='1':
                return True
    return False

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

লোভী স্ট্রিং বিল্ডার:

#assumes final char hasn't been added, and would be a 1 
def lastCharMakesSolvable(Str):
    endIndex=len(Str)
    j=endIndex-1
    while j-(endIndex-j) >= 0:
        k=j-(endIndex-j)
        if k >= 0 and Str[k]=='1' and Str[j]=='1':
            return True
        j=j-1
    return False



def expandString(StartString=''):
    if lastCharMakesSolvable(StartString):
        return StartString + '0'
    return StartString + '1'

n=1
BaseStr=""
lastCount=0
while n<1000000:
    BaseStr=expandString(BaseStr)
    count=BaseStr.count('1')
    if count != lastCount:
        print(len(BaseStr), count)
    lastCount=count
    n=n+1

(আমার প্রতিরক্ষা হিসাবে, আমি এখনও বোঝার 'অজগর শিখি' পর্যায়ে আছি)

এছাড়াও, স্ট্রিংগুলির লোভী বিল্ডিং থেকে সম্ভাব্যভাবে কার্যকর আউটপুট, 1 এর সংখ্যায় 2 এর শক্তিকে আঘাত করার পরে একটি সামঞ্জস্যপূর্ণ ঝাঁপ দাও ... যা আমি 2096-এ আঘাত করার সাক্ষী হয়ে অপেক্ষা করতে রাজি ছিল না।

strlength   # of 1's
    1    1
    2    2
    4    3
    5    4
   10    5
   14    8
   28    9
   41    16
   82    17
  122    32
  244    33
  365    64
  730    65
 1094    128
 2188    129
 3281    256
 6562    257
 9842    512
19684    513
29525    1024

Answer 21

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

1. একটি নির্দিষ্ট সংখ্যক স্পেস kএবং একটি স্ট্রিং দেওয়া S, একটি কে-স্পেসড-ট্রিপলিট অনুসন্ধান O(n)করে - আমরা কেবল 0<=i<=(n-2k)যদি প্রতিটির জন্য পরীক্ষা করি S[i]==S[i+k]==S[i+2k]। পরীক্ষা নেয় O(1)এবং আমরা এটা করতে n-kবার যেখানে kএকটি ধ্রুবক, তাই এটি লাগে O(n-k)=O(n)।

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

3. বলুন যে kআমার সন্ধান করতে হবে এমন সম্ভাব্য সংখ্যার উপর একটি উচ্চ আবদ্ধ থাকুন । এখন, জন্য প্রতিটি 1অবস্থিত S[i]আমরা জন্য চেক করতে হবে 1সালে S[i-1]এবং S[i+1], S[i-2]এবং S[i+2], ... S[i-k]এবং S[i+k]। এই সময় লাগে O((k^2-k)/2)=O(k^2)প্রত্যেকের জন্য 1এ Sকারণে - গাউস 'সিরিজ সমষ্টি ফর্মুলা । নোট করুন যে এটি বিভাগ 1 থেকে পৃথক হয়েছে - আমি kস্পেসের সংখ্যার জন্য একটি উচ্চতর আবদ্ধ হিসাবে রাখছি , ধ্রুবক স্থান হিসাবে নয়।

আমাদের প্রমান করা দরকার O(n*log(n))। যে, আমরা k*(number of 1's)আনুপাতিক এটি প্রদর্শন করা প্রয়োজন log(n)।

আমরা তা করতে পারেন, অ্যালগরিদম তুচ্ছ হয় - জন্য প্রতিটি 1মধ্যে Sযার সূচক i, সহজভাবে জন্য চেহারা 1'দূরে প্রতিটি পাশ থেকে গুলি k। দু'জন একই দূরত্বে পাওয়া গেলে, ফিরে আসুন iএবং k। আবার, জটিল অংশটি সন্ধান করা হবেk এবং সঠিকতা প্রমাণ করা হবে।

আমি এখানে আপনার মন্তব্যের সত্যই প্রশংসা করব - আমি এখনও পর্যন্ত আমার হোয়াইটবোর্ডে kএবং এর সংখ্যার মধ্যে 1সন্ধানের চেষ্টা করেছি, সাফল্য ছাড়াই।

Answer 22

ধৃষ্টতা:

ঠিক ভুল, লগ (এন) এর উপরের সীমাবদ্ধতার সংখ্যা সম্পর্কে কথা বলা

সম্পাদনা করুন:

এখন আমি দেখতে পেয়েছি যে ক্যান্টোর নম্বরগুলি ব্যবহার করে (সঠিক হলে), সেটে ঘনত্ব (2/3) ^ লগ_3 (এন) (কী বিচিত্র ফাংশন) এবং আমি সম্মত হই, লগ (এন) / এন ঘনত্ব শক্তিশালী।

যদি এটি উচ্চতর সীমা থাকে তবে কমপক্ষে ও (এন * (3/2) log (লগ (এন) / লগ (3)) সময়ের জটিলতা এবং ও ((3/2) in ( লগ (এন) / লগ (3)) স্থান জটিলতা। (অ্যালগরিহিটমের জন্য বিচারকের জবাবটি দেখুন)

এটি এখনও ও (এন ^ 2) এর চেয়ে অনেক বেশি ভাল

এই ফাংশন ((3/2) ^ (লগ (এন) / লগ (3))) সত্যই প্রথম দর্শনে n * লগ (এন) এর মতো দেখাচ্ছে।

আমি এই সূত্রটি কীভাবে পেলাম?

স্ট্রিং এ ক্যান্টরস নম্বর প্রয়োগ করা।
মনে করুন স্ট্রিংয়ের দৈর্ঘ্য 3 ^ p == n
ক্যান্টোর স্ট্রিংয়ের প্রজন্মের প্রতিটি ধাপে আপনি প্রচুর সংখ্যার 2/3 রাখুন। এই পি বার প্রয়োগ করুন।

এর অর্থ (এন * ((২/৩) ^ পি)) -> (((৩ ^ পি))) * ((২/৩) ^ পি)) বাকি এবং সরলকরণের পরে ২ ^ পি। এর অর্থ 3 ^ পি স্ট্রিং -> (3/2) ^ পি 2 টি পি ^ বিকল্প পি = লগ (এন) / লগ (3) এবং পান
((3/2) ^ (লগ (এন) / লগ (3)))

Comments

মিথ্যা: ক্যান্টর সেটের ঘনত্ব n ^ লগ_3 (2) রয়েছে।

— sdcvvc

Answer 23

ও (এন ^ 2) স্পেস সহ একটি সাধারণ ও (এন) সমাধান কীভাবে? (সমস্ত বিটওয়াইড অপারেটর ও (1) এ কাজ করে এমন অনুমানটি ব্যবহার করে))

অ্যালগরিদম মূলত চারটি ধাপে কাজ করে:

প্রথম পর্যায়: আপনার আসল সংখ্যার প্রতিটি বিটের জন্য এটিগুলি কতটা দূরে রয়েছে তা সন্ধান করুন তবে কেবল একটি দিক বিবেচনা করুন। (আমি সমস্ত বিটকে সর্বনিম্ন উল্লেখযোগ্য বিটের দিকে বিবেচনা করেছি considered)

দ্বিতীয় পর্যায়: ইনপুটটিতে বিটের ক্রমটি বিপরীত করুন;

পর্যায় 3: বিপরীত ইনপুটটিতে পদক্ষেপ 1 পুনরায় চালান।

মঞ্চ 4: পর্যায় 1 এবং পর্যায় 3 থেকে ফলাফলের তুলনা করুন যদি কোনও বিট উপরে এবং নীচে সমানভাবে ব্যবধানে থাকে তবে আমাদের অবশ্যই হিট করতে হবে।

মনে রাখবেন যে উপরের অ্যালগরিদমের কোনও পদক্ষেপ O (n) এর চেয়ে বেশি সময় নেয় না। ^: _ ^

একটি অতিরিক্ত সুবিধা হিসাবে, এই অ্যালগরিদম প্রতিটি সংখ্যা থেকে সমস্ত সমানভাবে ব্যবধানযুক্তগুলি খুঁজে পাবেন। সুতরাং উদাহরণস্বরূপ যদি আপনি "0x0005" এর ফলাফল পান তবে সেখানে 1 ও 3 ইউনিট দূরে সমানভাবে ব্যবধান রয়েছে

আমি নীচের কোডটি সত্যিই অপ্টিমাইজ করার চেষ্টা করিনি, তবে এটি সিগেলযোগ্য সি # কোড যা কাজ করে মনে হচ্ছে।

using System;

namespace ThreeNumbers
{
    class Program
    {
        const int uint32Length = 32;

        static void Main(string[] args)
        {
            Console.Write("Please enter your integer: ");
            uint input = UInt32.Parse(Console.ReadLine());

            uint[] distancesLower = Distances(input);
            uint[] distancesHigher = Distances(Reverse(input));

            PrintHits(input, distancesLower, distancesHigher);
        }

        /// <summary>
        /// Returns an array showing how far the ones away from each bit in the input.  Only 
        /// considers ones at lower signifcant bits.  Index 0 represents the least significant bit 
        /// in the input.  Index 1 represents the second least significant bit in the input and so 
        /// on.  If a one is 3 away from the bit in question, then the third least significant bit 
        /// of the value will be sit.
        /// 
        /// As programed this algorithm needs: O(n) time, and O(n*log(n)) space.  
        /// (Where n is the number of bits in the input.)
        /// </summary>
        public static uint[] Distances(uint input)
        {
            uint[] distanceToOnes = new uint[uint32Length];
            uint result = 0;

            //Sets how far each bit is from other ones. Going in the direction of LSB to MSB
            for (uint bitIndex = 1, arrayIndex = 0; bitIndex != 0; bitIndex <<= 1, ++arrayIndex)
            {
                distanceToOnes[arrayIndex] = result;
                result <<= 1;

                if ((input & bitIndex) != 0)
                {
                    result |= 1;
                }
            }

            return distanceToOnes;
        }

        /// <summary>
        /// Reverses the bits in the input.
        /// 
        /// As programmed this algorithm needs O(n) time and O(n) space.  
        /// (Where n is the number of bits in the input.)
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static uint Reverse(uint input)
        {
            uint reversedInput = 0;
            for (uint bitIndex = 1; bitIndex != 0; bitIndex <<= 1)
            {
                reversedInput <<= 1;
                reversedInput |= (uint)((input & bitIndex) != 0 ? 1 : 0);
            }

            return reversedInput;
        }

        /// <summary>
        /// Goes through each bit in the input, to check if there are any bits equally far away in 
        /// the distancesLower and distancesHigher
        /// </summary>
        public static void PrintHits(uint input, uint[] distancesLower, uint[] distancesHigher)
        {
            const int offset = uint32Length - 1;

            for (uint bitIndex = 1, arrayIndex = 0; bitIndex != 0; bitIndex <<= 1, ++arrayIndex)
            {
                //hits checks if any bits are equally spaced away from our current value
                bool isBitSet = (input & bitIndex) != 0;
                uint hits = distancesLower[arrayIndex] & distancesHigher[offset - arrayIndex];

                if (isBitSet && (hits != 0))
                {
                    Console.WriteLine(String.Format("The {0}-th LSB has hits 0x{1:x4} away", arrayIndex + 1, hits));
                }
            }
        }
    }
}

কেউ সম্ভবত মন্তব্য করবে যে পর্যাপ্ত পরিমাণে সংখ্যার জন্য, বিটওয়াইজ অপারেশনগুলি ও (1) এ করা যাবে না। আপনি ঠিক থাকবেন। তবে, আমি অনুমান করেছিলাম যে প্রতিটি সমাধান যা সংযোজন, বিয়োগ, গুণ বা বিভাগ ব্যবহার করে (যা স্থানান্তরিত করে করা যায় না) তাতেও সমস্যা হবে would

Answer 24

নীচে একটি সমাধান। এখানে এবং সেখানে কিছুটা ছোট ভুল হতে পারে তবে ধারণাটি দুর্দান্ত sound

সম্পাদনা করুন: এটি এন * লগ নয় (এন)

সুডোকোড:

foreach character in the string
  if the character equals 1 {         
     if length cache > 0 { //we can skip the first one
        foreach location in the cache { //last in first out kind of order
           if ((currentlocation + (currentlocation - location)) < length string)
              if (string[(currentlocation + (currentlocation - location))] equals 1)
                 return found evenly spaced string
           else
              break;
        }
     }
     remember the location of this character in a some sort of cache.
  }

return didn't find evenly spaced string

সি # কোড:

public static Boolean FindThreeEvenlySpacedOnes(String str) {
    List<int> cache = new List<int>();

    for (var x = 0; x < str.Length; x++) {
        if (str[x] == '1') {
            if (cache.Count > 0) {
                for (var i = cache.Count - 1; i > 0; i--) {
                    if ((x + (x - cache[i])) >= str.Length)
                        break;

                    if (str[(x + (x - cache[i]))] == '1')
                        return true;                            
                }
            }
            cache.Add(x);                    
        }
    }

    return false;
}

কিভাবে এটা কাজ করে:

iteration 1:
x
|
101101001
// the location of this 1 is stored in the cache

iteration 2:
 x
 | 
101101001

iteration 3:
a x b 
| | | 
101101001
//we retrieve location a out of the cache and then based on a 
//we calculate b and check if te string contains a 1 on location b

//and of course we store x in the cache because it's a 1

iteration 4:
  axb  
  |||  
101101001

a  x  b  
|  |  |  
101101001


iteration 5:
    x  
    |  
101101001

iteration 6:
   a x b 
   | | | 
101101001

  a  x  b 
  |  |  | 
101101001
//return found evenly spaced string

Comments

আপনার অ্যালগরিদম কাজ করে, তবে আপনাকে প্রমাণ করতে হবে যে এটি হে (এন ^ 2) এর চেয়ে কম। তুচ্ছ বিশ্লেষণ আপনাকে ও (N ^ 2) এ দেয়। প্রতি 1 এর জন্য, আপনি এর আগে যে 1 টি রেখেছিলেন সেগুলি অতিক্রম করে যান। জটিলতা ফাংশনটি 1 + 2 + 3 + করা ... + (কে / 2-1) = ও (কে ^ 2) [যেখানে কে 1 এর সংখ্যা]।

— আনা

আমি যাচাই করেছি এবং প্রকৃতপক্ষে কোনও সমাধান ছাড়াই সবচেয়ে খারাপ পরিস্থিতি ও এর চেয়ে বড় (হে n লগ (এন))

— নাইক এইচ।

Answer 25

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

একটি গাছ তৈরি করুন যেখানে প্রতিটি নোডে তিনটি বাচ্চা থাকে এবং প্রতিটি নোডে তার পাতায় মোট 1 টি সংখ্যা থাকে। 1 এর উপরেও একটি লিঙ্কযুক্ত তালিকা তৈরি করুন। প্রতিটি নোডের আওতাধীন সীমার তুলনামূলক একটি অনুমোদিত ব্যয় নির্ধারণ করুন। যতক্ষণ না প্রতিটি নোডে সময় কাটানো হয় বাজেটের মধ্যে থাকে ততক্ষণ আমাদের একটি ও (এন lg এন) অ্যালগরিদম থাকবে।

-

মূল থেকে শুরু করুন। যদি এর নিচে মোট 1 এর সংখ্যার বর্গক্ষেত্র এটির অনুমোদিত ব্যয়ের তুলনায় কম হয় তবে নির্দোষ আলগোরিদিম প্রয়োগ করুন। অন্যথায় এর বাচ্চাদের উপর পুনরাবৃত্তি করুন।

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

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

-

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

অ্যালগরিদমের রান সময়টি মোটেই সুস্পষ্ট নয়। এটি ক্রমের অ-তুচ্ছ বৈশিষ্ট্যগুলির উপর নির্ভর করে। যদি 1 টি সত্যই অপ্রয়োজনীয় হয় তবে নির্দোষ অ্যালগরিদম বাজেটের অধীনে কাজ করবে। যদি 1 টি ঘন হয় তবে এখনই একটি ম্যাচ খুঁজে পাওয়া উচিত। তবে যদি ঘনত্বটি 'ঠিক ঠিক' থাকে (যেমন: near n ^ 0.63 এর কাছাকাছি, যা আপনি বেস 3 তে কোনও '2' সংখ্যা ছাড়াই পজিশনে সমস্ত বিট সেট করে অর্জন করতে পারেন), আমি জানি না এটি কার্যকর হবে কিনা। আপনাকে প্রমাণ করতে হবে যে বিভাজন প্রভাব যথেষ্ট শক্তিশালী।

Answer 26

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

যাইহোক এখানে প্রোগ্রাম, নীচে। এটি একটি মন্টি-কার্লো স্টাইল প্রোগ্রাম যা স্থির এন এর জন্য এনটিআরআইএলএস প্রচুর পরিমাণে ট্রায়াল চালায় এবং এলোমেলোভাবে নির্দিষ্ট করা যেতে পারে এমন সীমাগুলির মধ্যে সীমাবদ্ধতাযুক্ত ঘনত্বের সাথে বার্নোল্লি প্রক্রিয়াগুলি ব্যবহার করে কে-মানগুলির বিস্তৃত বিটসেট তৈরি করে এবং চলমান সময়টি রেকর্ড করে সমানভাবে ব্যবধানযুক্ত একটি ট্রিপল খুঁজে পেতে বা ব্যর্থ হওয়ার, সিপিইউ সময় নয় এমন পদক্ষেপগুলিতে সময় পরিমাপ করা। আমি এন = ,৪, 256, 1024, 4096, 16384 * (এখনও চলছে) এর জন্য এটি চালিয়েছি, কোন কে-মানগুলি দীর্ঘতম সময় নেয় তা দেখতে 500000 ট্রায়াল সহ প্রথম পরীক্ষা চালানো হয়, তারপরে সংক্ষিপ্ততরগুলির সাথে 5000000 ট্রায়াল সহ আরও একটি পরীক্ষা - এই মানগুলি কেমন দেখতে ঘনত্ব ফোকাস। দীর্ঘতম চলমান সময়গুলি খুব বিরল ঘনত্বের সাথে ঘটে (উদাহরণস্বরূপ এন = 4096 চলমান সময় শৃঙ্গগুলি কে = 16-64 সীমার মধ্যে থাকে, গড় রানটাইমটির জন্য একটি হালকা শিখর 4212 পদক্ষেপে @ k = 31, সর্বোচ্চ রানটাইম 5101 পদক্ষেপে পৌঁছেছে @ কে = 58)। দেখে মনে হচ্ছে এটি সবচেয়ে খারাপ অবস্থার হে (কে ^ 2) পদক্ষেপের চেয়ে ও (এন) পদক্ষেপের চেয়ে বড় হয়ে উঠার জন্য চির বড় আকারের মান গ্রহণ করবে যেখানে আপনি 1 এর অবস্থান সূচকগুলি সন্ধান করতে বিটস্ট্রিং স্ক্যান করেন।

package com.example.math;

import java.io.PrintStream;
import java.util.BitSet;
import java.util.Random;

public class EvenlySpacedOnesTest {
    static public class StatisticalSummary
    {
        private int n=0;
        private double min=Double.POSITIVE_INFINITY;
        private double max=Double.NEGATIVE_INFINITY;
        private double mean=0;
        private double S=0;

        public StatisticalSummary() {}
        public void add(double x) {
            min = Math.min(min, x);
            max = Math.max(max, x);
            ++n;
            double newMean = mean + (x-mean)/n;
            S += (x-newMean)*(x-mean);
            // this algorithm for mean,std dev based on Knuth TAOCP vol 2
            mean = newMean;
        }
        public double getMax() { return (n>0)?max:Double.NaN; }
        public double getMin() { return (n>0)?min:Double.NaN; }
        public int getCount() { return n; }
        public double getMean() { return (n>0)?mean:Double.NaN; }
        public double getStdDev() { return (n>0)?Math.sqrt(S/n):Double.NaN; } 
        // some may quibble and use n-1 for sample std dev vs population std dev    
        public static void printOut(PrintStream ps, StatisticalSummary[] statistics) {
            for (int i = 0; i < statistics.length; ++i)
            {
                StatisticalSummary summary = statistics[i];
                ps.printf("%d\t%d\t%.0f\t%.0f\t%.5f\t%.5f\n",
                        i,
                        summary.getCount(),
                        summary.getMin(),
                        summary.getMax(),
                        summary.getMean(),
                        summary.getStdDev());
            }
        }
    }

    public interface RandomBernoulliProcess // see http://en.wikipedia.org/wiki/Bernoulli_process
    {
        public void setProbability(double d);
        public boolean getNextBoolean();
    }

    static public class Bernoulli implements RandomBernoulliProcess
    {
        final private Random r = new Random();
        private double p = 0.5;
        public boolean getNextBoolean() { return r.nextDouble() < p; }
        public void setProbability(double d) { p = d; }
    }   
    static public class TestResult {
        final public int k;
        final public int nsteps;
        public TestResult(int k, int nsteps) { this.k=k; this.nsteps=nsteps; } 
    }

    ////////////
    final private int n;
    final private int ntrials;
    final private double pmin;
    final private double pmax;
    final private Random random = new Random();
    final private Bernoulli bernoulli = new Bernoulli();
    final private BitSet bits;
    public EvenlySpacedOnesTest(int n, int ntrials, double pmin, double pmax) {
        this.n=n; this.ntrials=ntrials; this.pmin=pmin; this.pmax=pmax;
        this.bits = new BitSet(n);
    }

    /*
     * generate random bit string
     */
    private int generateBits()
    {
        int k = 0; // # of 1's
        for (int i = 0; i < n; ++i)
        {
            boolean b = bernoulli.getNextBoolean();
            this.bits.set(i, b);
            if (b) ++k;
        }
        return k;
    }

    private int findEvenlySpacedOnes(int k, int[] pos) 
    {
        int[] bitPosition = new int[k];
        for (int i = 0, j = 0; i < n; ++i)
        {
            if (this.bits.get(i))
            {
                bitPosition[j++] = i;
            }
        }
        int nsteps = n; // first, it takes N operations to find the bit positions.
        boolean found = false;
        if (k >= 3) // don't bother doing anything if there are less than 3 ones. :(
        {       
            int lastBitSetPosition = bitPosition[k-1];
            for (int j1 = 0; !found && j1 < k; ++j1)
            {
                pos[0] = bitPosition[j1];
                for (int j2 = j1+1; !found && j2 < k; ++j2)
                {
                    pos[1] = bitPosition[j2];

                    ++nsteps;
                    pos[2] = 2*pos[1]-pos[0];
                    // calculate 3rd bit index that might be set;
                    // the other two indices point to bits that are set
                    if (pos[2] > lastBitSetPosition)
                        break;
                    // loop inner loop until we go out of bounds

                    found = this.bits.get(pos[2]);
                    // we're done if we find a third 1!
                }
            }
        }
        if (!found)
            pos[0]=-1;
        return nsteps;
    }

    /*
     * run an algorithm that finds evenly spaced ones and returns # of steps.
     */
    public TestResult run()
    {
        bernoulli.setProbability(pmin + (pmax-pmin)*random.nextDouble());
        // probability of bernoulli process is randomly distributed between pmin and pmax

        // generate bit string.
        int k = generateBits();
        int[] pos = new int[3];
        int nsteps = findEvenlySpacedOnes(k, pos);
        return new TestResult(k, nsteps); 
    }

    public static void main(String[] args)
    {
        int n;
        int ntrials;
        double pmin = 0, pmax = 1;
        try {
            n = Integer.parseInt(args[0]);
            ntrials = Integer.parseInt(args[1]);
            if (args.length >= 3)
                pmin = Double.parseDouble(args[2]);
            if (args.length >= 4)
                pmax = Double.parseDouble(args[3]);
        }
        catch (Exception e)
        {
            System.out.println("usage: EvenlySpacedOnesTest N NTRIALS [pmin [pmax]]");
            System.exit(0);
            return; // make the compiler happy
        }

        final StatisticalSummary[] statistics;
        statistics=new StatisticalSummary[n+1];
        for (int i = 0; i <= n; ++i)
        {
            statistics[i] = new StatisticalSummary();
        }

        EvenlySpacedOnesTest test = new EvenlySpacedOnesTest(n, ntrials, pmin, pmax);
        int printInterval=100000;
        int nextPrint = printInterval;
        for (int i = 0; i < ntrials; ++i)
        {
            TestResult result = test.run();
            statistics[result.k].add(result.nsteps);
            if (i == nextPrint)
            {
                System.err.println(i);
                nextPrint += printInterval;
            }
        }
        StatisticalSummary.printOut(System.out, statistics);
    }
}

Answer 27

# <algorithm>
def contains_evenly_spaced?(input)
  return false if input.size < 3
  one_indices = []
  input.each_with_index do |digit, index|
    next if digit == 0
    one_indices << index
  end
  return false if one_indices.size < 3
  previous_indexes = []
  one_indices.each do |index|
    if !previous_indexes.empty?
      previous_indexes.each do |previous_index|
        multiple = index - previous_index
        success_index = index + multiple
        return true if input[success_index] == 1
      end
    end
    previous_indexes << index
  end
  return false
end
# </algorithm>

def parse_input(input)
  input.chars.map { |c| c.to_i }
end

আমি কয়েক মিলিয়ন সংখ্যার সবচেয়ে খারাপ পরিস্থিতি নিয়ে সমস্যায় পড়ছি। /dev/urandomমূলত ফিজ করা আপনাকে ও (এন) দেয় তবে আমি জানি সবচেয়ে খারাপ পরিস্থিতি এর চেয়েও খারাপ is আমি কত খারাপ জানি না। ছোট হিসাবে n, এটি কাছাকাছি ইনপুটগুলি সন্ধান করা তুচ্ছ 3*n*log(n), তবে এই বিশেষ সমস্যার জন্য বৃদ্ধির কিছু অন্যান্য ক্রম থেকে তাদের পার্থক্য করা আশ্চর্যজনকভাবে শক্ত hard

সবচেয়ে খারাপ কেস ইনপুট নিয়ে কাজ করা যে কেউ এক লক্ষ হাজারের চেয়ে বেশি দৈর্ঘ্যের স্ট্রিং তৈরি করতে পারে?

Comments

যেমনটি আমি আমার উত্তরে উল্লেখ করেছি যে কোনও সংখ্যার অঙ্কের খারাপ (যদিও সবচেয়ে খারাপ ক্ষেত্রে নয়) স্ট্রিং উত্পন্ন করা সহজ: ঠিক সেই পজিশনে 1 সেগুলি রাখুন যেখানে তাদের ত্রৈমাসিক উপস্থাপনায় কোনও "1" এস থাকে না (যেমন এখানে অবস্থান 2, 6, 8, 18, 20, 24, 26, 54, 56, 60 ...: গবেষণা সূত্র দেখুন। 3 ^ 13 ≈ 1 মিলিয়ন এর জন্য এটিতে 2 ^ 13 ≈ 8000 1s রয়েছে। এই জাতীয় স্ট্রিংগুলিতে চলমান সময়টি ≈ n ^ (1.26) হবে - যা এ জাতীয় ছোট এন এর জন্য ও (এন লগ এন) থেকে পৃথক করা এখনও শক্ত। চেষ্টা করে দেখুন।

— শ্রীভবসআর

Answer 28

রবিন-কার্প অ্যালগরিদমের একটি অভিযোজন আপনার পক্ষে সম্ভব হতে পারে। এর জটিলতা 0 (এন) তাই এটি আপনাকে সহায়তা করতে পারে।

একবার দেখুন http://en.wikedia.org/wiki/Rines- কার্প_ স্ট্রিং_সার্চ_ালগোরিদিম

Comments

রবিন-কার্প সঠিক সাবস্ট্রিংগুলি সন্ধান করতে স্ট্রিং হ্যাশিং ব্যবহার করে, সুতরাং এটি সমস্যার সাথে সহায়তা করতে পারে না।

— রবার্ট পার্কার

Answer 29

এটি কি কোনও সমাধান হতে পারে? আমি 'এটি' ও '(এনলগন) কিনা নিশ্চিত নই তবে আমার মতে এটি ও (এনও) এর চেয়ে ভাল better কারণ ট্রিপলকে খুঁজে না পাওয়ার একমাত্র উপায় হ'ল মূল সংখ্যা বিতরণ।

উন্নতির জন্য জায়গা রয়েছে, দ্বিতীয়টি পাওয়া গেছে প্রথমটি পরবর্তী 1 টি হতে পারে Also এছাড়াও কোনও ত্রুটি পরীক্ষা করার চেষ্টা করা হয়নি।

#include <iostream>

#include <string>

int findIt(std::string toCheck) {
    for (int i=0; i<toCheck.length(); i++) {
        if (toCheck[i]=='1') {
            std::cout << i << ": " << toCheck[i];
            for (int j = i+1; j<toCheck.length(); j++) {
                if (toCheck[j]=='1' && toCheck[(i+2*(j-i))] == '1') {
                    std::cout << ", " << j << ":" << toCheck[j] << ", " << (i+2*(j-i)) << ":" << toCheck[(i+2*(j-i))] << "    found" << std::endl;
                    return 0;
                }
            }
        }
    }
    return -1;
}

int main (int agrc, char* args[]) {
    std::string toCheck("1001011");
    findIt(toCheck);
    std::cin.get();
    return 0;
}

Comments

প্রযুক্তিগতভাবে এটি ও (এন ^ 2)। প্রতিবার এটি চালিত হওয়ার সাথে সাথে অভ্যন্তরীণ লুপটি অর্ধেক n এর উপরে পুনরাবৃত্তি করবে। সুতরাং এটি ও (এন * (এন / 2)) হিসাবে লেখা যেতে পারে এবং এটি ও (এন ^ 2) এ সরলীকৃত করা যেতে পারে

— রবার্ট পার্কার

হুম, দেখে মনে হচ্ছে তুমি ঠিক আছ এটি কোনও সাধারণ সমস্যা নয়, কেবলমাত্র 1 টি O (n) কে নেবে, ও (লগন) জটিলতার সাথে আরও অনুসন্ধান / তুলনা করার জন্য খুব বেশি জায়গা নেই find

— ডেকলাউন

Answer 30

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

#include <iostream>
using namespace std;

bool HasEvenBits (string &sequence, int &num_compares)
{
  bool
    has_even_bits = false;

  num_compares = 0;

  for (unsigned i = 1 ; i <= (sequence.length () - 1) / 2 ; ++i)
  {
    for (unsigned j = 0 ; j < sequence.length () - 2 * i ; ++j)
    {
      ++num_compares;
      if (sequence [j] == '1' && sequence [j + i] == '1' && sequence [j + i * 2] == '1')
      {
        has_even_bits = true;
        // we could 'break' here, but I want to know the worst case scenario so keep going to the end
      }
    }
  }

  return has_even_bits;
}

int main ()
{
  int
    count;

  string
    input = "111";

  for (int i = 3 ; i < 32 ; ++i)
  {
    HasEvenBits (input, count);
    cout << i << ", " << count << endl;
    input += "0";
  }
}

এই প্রোগ্রামটি প্রতিটি স্ট্রিংয়ের দৈর্ঘ্যের জন্য 32 টি অক্ষর পর্যন্ত পরীক্ষার সংখ্যাকে আউটপুট করে। ফলাফল এখানে:

 n  Tests  n log (n)
=====================
 3     1     1.43
 4     2     2.41
 5     4     3.49
 6     6     4.67
 7     9     5.92
 8    12     7.22
 9    16     8.59
10    20    10.00
11    25    11.46
12    30    12.95
13    36    14.48
14    42    16.05
15    49    17.64
16    56    19.27
17    64    20.92
18    72    22.59
19    81    24.30
20    90    26.02
21   100    27.77
22   110    29.53
23   121    31.32
24   132    33.13
25   144    34.95
26   156    36.79
27   169    38.65
28   182    40.52
29   196    42.41
30   210    44.31
31   225    46.23

আমি 'এন লগ এন' মানগুলিও যুক্ত করেছি। দুটি ফলাফলের মধ্যে পারস্পরিক সম্পর্ক দেখতে আপনার পছন্দসই গ্রাফিং সরঞ্জামটি ব্যবহার করে এটিকে প্লট করুন। এই বিশ্লেষণটি কি এন এর সমস্ত মানকে প্রসারিত করে? আমি জানি না।

Comments

এটি একটি নিখুঁত সম্পর্ক নয়, আমি সম্মত। তবে, বক্ররেখা n log 2 এর চেয়ে n লগ এন এর নিকটবর্তী।

— স্কিজেড

এক মিলিয়ন বা তারও বেশি মাধ্যমে ইনপুট আকার পাম্প করার চেষ্টা করুন। ছোট ইনপুটগুলিতে বক্ররেখাকে প্রায়শই অ্যালগরিদমের কার্ভগুলির সাথে সমান মনে হয় যা ইনপুট আকারের পাম্প করা হলে স্পষ্টতই ভাল হয়।

— নিক লারসেন 18

বাহ্যিক দ্বারা আবদ্ধ অভ্যন্তরের সাথে লুপের জন্য একটি ডাবল ত্রিভুজাকার আকার তৈরি করে, যা এখনও জটিলতায় ও (এন ^ 2) হয়। সমস্ত (i, j) এর কথা চিন্তা করুন যে আমি [0, n] এবং জে [0, n-2 * i] এ, আপনার একটি ত্রিভুজ রয়েছে এবং ত্রিভুজের ক্ষেত্রের একটি চতুর্ভুজ প্রবণতা রয়েছে।

— ম্যাথিউ এম।

নির্ভুল হতে, টেস্টগুলি = (এন ^ 2-2n) / 4 এমনকি এন এর জন্য; স্পষ্টত চতুষ্কোণ

— দাদু