ইতিবাচক পূর্ণসংখ্যায় শূন্য-বিটগুলি গণনা করার দ্রুত উপায়

Question

পাইথনের একটি পূর্ণসংখ্যার বিটের সংখ্যা গণনা করার জন্য আমার দ্রুত উপায় প্রয়োজন। আমার বর্তমান সমাধান

bin(n).count("1")

তবে আমি ভাবছি যে এটি করার কোনও দ্রুত উপায় আছে কিনা?

পিএস: (আমি সংখ্যার একক তালিকা হিসাবে একটি বড় 2 ডি বাইনারি অ্যারে উপস্থাপন করছি এবং বিটওয়াইস ক্রিয়াকলাপ করছি এবং এটি সময়কে কয়েক ঘন্টা থেকে কয়েক মিনিটে নামিয়ে আনবে। এবং এখন আমি এই অতিরিক্ত মিনিট থেকে মুক্তি পেতে চাই like

সম্পাদনা: 1. এটি অজগর 2.7 বা 2.6 এ থাকতে হবে

এবং স্বল্প সংখ্যার জন্য অনুকূল হওয়া এতোটা গুরুত্বপূর্ণ নয় যেহেতু এটি স্পষ্ট বাধা নয়, তবে আমার কাছে কয়েকটি জায়গায় 10 000 + বিট সহ সংখ্যা রয়েছে

উদাহরণস্বরূপ এটি 2000 বিট কেস:

12448057941136394342297748548545082997815840357634948550739612798732309975923280685245876950055614362283769710705811182976142803324242407017104841062064840113262840137625582646683068904149296501029754654149991842951570880471230098259905004533869130509989042199261339990315125973721454059973605358766253998615919997174542922163484086066438120268185904663422979603026066685824578356173882166747093246377302371176167843247359636030248569148734824287739046916641832890744168385253915508446422276378715722482359321205673933317512861336054835392844676749610712462818600179225635467147870208L

Comments

সম্পর্কিত: stackoverflow.com/questions/407587/...

— dusan

যদি আপনার "পূর্ণসংখ্যা" মানক অজগরটির চেয়ে দীর্ঘ হয় তবে আপনি কোন ধরণের প্রতিনিধিত্ব ব্যবহার করছেন int? এটি গণনা করার জন্য এর নিজস্ব পদ্ধতি নেই?

— মার্সিন

পাইথনে একটি পূর্ণসংখ্যার গণনা বিটের

— এন্ডোলিথ

যে থেকে প্রশ্ন আলাদা করতে stackoverflow.com/a/2654211/1959808 অনুগ্রহ করে "TITLE রিফ্রেশ বিবেচনা ... অ- সংখ্যা বেড়ে চলেছে (যদি এটি আলাদা হতে --- অন্তত তাই এটি দেখে মনে হচ্ছে এ দেয়ার উদ্দেশ্যে করা হচ্ছে) শূন্য বিট ... "বা অনুরূপ। অন্যথায় int.bit_lengthউত্তরটি হওয়া উচিত, এবং নীচে গৃহীত এক নয়।

— ইওনিস ফিলিপিসিস

Answer 1

নির্বিচারে দৈর্ঘ্যের পূর্ণসংখ্যার জন্য, bin(n).count("1")খাঁটি পাইথনের মধ্যে আমি সবচেয়ে দ্রুত খুঁজে পেতে পারি।

আমি পূর্ণসংখ্যাটি যথাক্রমে -৪-বিট এবং ৩২-বিট খণ্ডগুলিতে প্রক্রিয়াকরণের জন্য এসকার এবং অ্যাডামের সমাধানগুলি মানিয়ে নেওয়ার চেষ্টা করেছি। উভয়ই কমপক্ষে দশগুণ ধীর ছিল bin(n).count("1")(32-বিট সংস্করণ আবার প্রায় অর্ধেক সময় নিয়েছিল)।

অন্যদিকে, গিম্পি সময়টির popcount() প্রায় 1/20 তম সময় নিয়েছিল bin(n).count("1")। সুতরাং আপনি যদি জিএমপি ইনস্টল করতে পারেন তবে এটি ব্যবহার করুন।

মন্তব্যে একটি প্রশ্নের উত্তর দিতে, বাইটের জন্য আমি একটি সারণী ব্যবহার করতাম। আপনি রানটাইমে এটি তৈরি করতে পারেন:

counts = bytes(bin(x).count("1") for x in range(256))  # py2: use bytearray

বা কেবল এটি আক্ষরিক সংজ্ঞা:

counts = (b'\x00\x01\x01\x02\x01\x02\x02\x03\x01\x02\x02\x03\x02\x03\x03\x04'
          b'\x01\x02\x02\x03\x02\x03\x03\x04\x02\x03\x03\x04\x03\x04\x04\x05'
          b'\x01\x02\x02\x03\x02\x03\x03\x04\x02\x03\x03\x04\x03\x04\x04\x05'
          b'\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06'
          b'\x01\x02\x02\x03\x02\x03\x03\x04\x02\x03\x03\x04\x03\x04\x04\x05'
          b'\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06'
          b'\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06'
          b'\x03\x04\x04\x05\x04\x05\x05\x06\x04\x05\x05\x06\x05\x06\x06\x07'
          b'\x01\x02\x02\x03\x02\x03\x03\x04\x02\x03\x03\x04\x03\x04\x04\x05'
          b'\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06'
          b'\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06'
          b'\x03\x04\x04\x05\x04\x05\x05\x06\x04\x05\x05\x06\x05\x06\x06\x07'
          b'\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06'
          b'\x03\x04\x04\x05\x04\x05\x05\x06\x04\x05\x05\x06\x05\x06\x06\x07'
          b'\x03\x04\x04\x05\x04\x05\x05\x06\x04\x05\x05\x06\x05\x06\x06\x07'
          b'\x04\x05\x05\x06\x05\x06\x06\x07\x05\x06\x06\x07\x06\x07\x07\x08')

তারপরে এটিতে counts[x]1 বিটের সংখ্যা পাওয়া যাবে xযেখানে 0 ≤ x ≤ 255।

Comments

+1 টি! এর কথোপকথনটি সঠিক নয়, তবে এটি উল্লেখ করা উচিত: bin(n).count("0")'0 বি' উপসর্গের কারণে সঠিক নয়। bin(n)[2:].count('0')সেই গণনা করা দুষ্টুদের জন্য হওয়া দরকার ....

— নেকড়ে

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

— কান্ডেল করুন

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

— জারিত

: Numpy অ্যারে আমি ভালো কিছু দেখব চাই gist.github.com/aldro61/f604a3fa79b3dec5436a

— kindall

আমি ব্যবহার করেছি bin(n).count("1")। যাইহোক, পাইথন জমা দেওয়ার মাত্র 60% মারধর করে। @ লেটকোড

— উত্তর

Answer 2

আপনি নিম্নলিখিত অ্যালগরিদম মানিয়ে নিতে পারেন:

def CountBits(n):
  n = (n & 0x5555555555555555) + ((n & 0xAAAAAAAAAAAAAAAA) >> 1)
  n = (n & 0x3333333333333333) + ((n & 0xCCCCCCCCCCCCCCCC) >> 2)
  n = (n & 0x0F0F0F0F0F0F0F0F) + ((n & 0xF0F0F0F0F0F0F0F0) >> 4)
  n = (n & 0x00FF00FF00FF00FF) + ((n & 0xFF00FF00FF00FF00) >> 8)
  n = (n & 0x0000FFFF0000FFFF) + ((n & 0xFFFF0000FFFF0000) >> 16)
  n = (n & 0x00000000FFFFFFFF) + ((n & 0xFFFFFFFF00000000) >> 32) # This last & isn't strictly necessary.
  return n

এটি -৪-বিট ধনাত্মক সংখ্যার জন্য কাজ করে তবে এটি সহজেই প্রসারণযোগ্য এবং আর্গুমেন্টের লগারিদম (অর্থাত্ আর্গুমেন্টের বিট-আকারের সাথে রৈখিক) সহ অপারেশন সংখ্যা বৃদ্ধি করে।

এটি কীভাবে কাজ করে তা বোঝার জন্য আপনি পুরো -৪-বিট স্ট্রিংটিকে 1৪ 1-বিট বালতিতে বিভক্ত করেন। প্রতিটি বালতির মান বালতিতে সেট বিটের সংখ্যার সমান (কোনও বিট সেট না করা থাকলে 0 এবং এক বিট সেট করা থাকলে 1)। প্রথম রূপান্তরটির ফলাফল অ্যানালগাসিক অবস্থায় রয়েছে, তবে প্রতিটি 2-বিট দীর্ঘ 32 বালতি রয়েছে। এটি বালতিগুলি যথাযথভাবে স্থানান্তরিত করে এবং তাদের মানগুলি যুক্ত করে অর্জন করা হয় (একটি সংযোজন সমস্ত বালতিগুলির যত্ন নেয় কারণ কোনও বালতি জুড়েই বহন করতে পারে না - এন-বিট সংখ্যা এন এনকোড করার জন্য সর্বদা যথেষ্ট দীর্ঘ)) পরবর্তী রূপান্তরগুলি রাজ্যগুলিতে তাত্পর্যপূর্ণভাবে ক্রমবর্ধমান আকারের বালতিগুলির সংখ্যা হ্রাস করে যখন আমরা একটি -৪-বিট দীর্ঘ বালতি না পৌঁছায়। এটি মূল আর্গুমেন্টে সেট বিটের সংখ্যা দেয়।

Comments

10,000 বিট সংখ্যার সাথে এটি কীভাবে কাজ করবে তা আমার গুরুত্ব সহকারে কোনও ধারণা নেই তবে আমি সমাধানটি পছন্দ করি। আপনি কি আমাকে একটি ইঙ্গিত দিতে পারেন যদি এবং কীভাবে আমি এটি বড় সংখ্যায় আবেদন করতে পারি?

— zidarsk8

আপনি এখানে যে বিটগুলি ব্যবহার করছেন তার সংখ্যা আমি দেখতে পাইনি। আপনি কি সি এর মতো নিম্ন স্তরের ভাষায় আপনার ডেটা হ্যান্ডলিং কোডটি লেখার বিষয়টি বিবেচনা করেছেন? সম্ভবত আপনার অজগর কোডের এক্সটেনশন হিসাবে? পাইথনের বড় অঙ্কগুলির তুলনায় আপনি সি তে বড় অ্যারে ব্যবহার করে অবশ্যই কার্যকারিতা উন্নত করতে পারেন। এটি বলেছিল, আপনি CountBits()মাত্র 8 লাইন কোড যুক্ত করে 10 কে-বিট সংখ্যা হ্যান্ডেল করতে পুনরায় লিখতে পারেন । তবে বিশাল অবিচ্ছিন্নতার কারণে এটি অস্বাস্থ্যকর হয়ে উঠবে।

— অ্যাডাম জালকম্যান

ধ্রুবকের ক্রম উত্পন্ন করতে আপনি কোড লিখতে পারেন এবং প্রসেসিংয়ের জন্য একটি লুপ সেট আপ করতে পারেন।

— কার্ল নচেটল

এই উত্তরের দুর্দান্ত সুবিধা রয়েছে যে এটি বৃহত অ্যারেগুলির ক্ষেত্রে মামলাগুলির জন্য ভেক্টরাইজড হতে পারে numpy।

— জারিত

Answer 3

এখানে জনসংখ্যা গণনা অ্যালগরিদমের পাইথন বাস্তবায়ন, যা এই পোস্টে ব্যাখ্যা করা হয়েছে :

def numberOfSetBits(i):
    i = i - ((i >> 1) & 0x55555555)
    i = (i & 0x33333333) + ((i >> 2) & 0x33333333)
    return (((i + (i >> 4) & 0xF0F0F0F) * 0x1010101) & 0xffffffff) >> 24

এটা কাজ করবে 0 <= i < 0x100000000।

Comments

যে চালাক। হিপ থেকে উত্তর গুলি করার পরিবর্তে এটি সন্ধান করা সম্পূর্ণ উপযুক্ত!

— মিঃগোমেজ

আপনি কি এই মানদণ্ড করেছেন? পাইথন ২.7 ব্যবহার করে আমার মেশিনে, আমি এটি দেখতে পেয়েছিলাম যে এটি আসলে কিছুটা ধীরে bin(n).count("1")।

— ডেভিড ওয়েল্ডন

@ ডেভিডওয়েলডন না আমি না, আপনি দয়া করে আপনার মাপদণ্ড পোস্ট করতে পারেন?

— অস্কার লোপেজ

%timeit numberOfSetBits(23544235423): 1000000 loops, best of 3: 818 ns per loop; %timeit bitCountStr(23544235423): 1000000 loops, best of 3: 577 ns per loop।

— জারিত

যাইহোক, 841 in এস মধ্যে numberOfSetBitsআমার 864 × 64 প্রসেস করে numpy.ndarray। সঙ্গে bitCountStrআমি স্পষ্টভাবে লুপ আছে, এবং এটি 40.7 মাইক্রোসফট, বা আর প্রায় 50 বার লাগে।

— জারিত

Answer 4

এই পোস্ট অনুসারে , এটি হ্যামিং ওজনকে দ্রুততম প্রয়োগ হিসাবে মনে হচ্ছে (যদি আপনি প্রায় 64৪ কেবি স্মৃতি ব্যবহার না করেন)।

#http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetTable
POPCOUNT_TABLE16 = [0] * 2**16
for index in range(len(POPCOUNT_TABLE16)):
    POPCOUNT_TABLE16[index] = (index & 1) + POPCOUNT_TABLE16[index >> 1]

def popcount32_table16(v):
    return (POPCOUNT_TABLE16[ v        & 0xffff] +
            POPCOUNT_TABLE16[(v >> 16) & 0xffff])

পাইথন উপর 2.x আপনি প্রতিস্থাপন করা উচিত rangeসঙ্গে xrange।

সম্পাদন করা

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

gmpy এটি একটি সি-কোডেড পাইথন এক্সটেনশন মডিউল যা GMP গ্রন্থাগারটি মোড় করে।

>>> import gmpy
>>> gmpy.popcount(2**1024-1)
1024

Comments

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

— zidarsk8

তবে জিএমপি হ'ল খুব বড় সংখ্যার জন্য, আপনি উল্লেখ করেছেন এমন মাপের ও তার চেয়েও বেশি সংখ্যার জন্য।

— জেমস ইয়ংম্যান

মেমোরি ব্যবহার যদি আপনি ব্যবহার ভালো হবে array.arrayজন্য POPCOUNT_TABLE16, তারপর যেমন পাইথন একটি পরিবর্তনশীল আকারের তালিকা হিসাবে পূর্ণসংখ্যার একটি অ্যারের হিসাবে সংরক্ষিত করা হবে পরিবর্তে intঅবজেক্ট।

— gsnedders

Answer 5

আমি এই পদ্ধতিটি সত্যিই পছন্দ করি। পাইথনের অসীম পূর্ণসংখ্যা রয়েছে বলে এটি এর সহজ এবং বেশ দ্রুত কিন্তু বিট দৈর্ঘ্যেও সীমাবদ্ধ নয়।

এটি দেখতে দেখতে আরও চালাকি, কারণ এটি শূন্যগুলি স্ক্যান করতে সময় নষ্ট করা এড়ায়। উদাহরণস্বরূপ, 1111 এর মতো 10000000000000000000000100100000001 এ সেট বিটগুলি গণনা করতে একই সময় লাগবে।

def get_bit_count(value):
   n = 0
   while value:
      n += 1
      value &= value-1
   return n

Comments

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

— zidarsk8

"গড়পড়তা এটি বেশ ধীর" আপনি কী বোঝাতে চেয়েছেন তা আমি নিশ্চিত নই। কি তুলনায় বেশ ধীর? আপনি উদ্ধৃত করছেন না এমন কিছু অজগর কোডের সাথে তুলনা করার অর্থ কী? এটি গড় সংখ্যার জন্য বিট বিট গণনা হিসাবে দ্বিগুণ দ্রুত। আসলে আমার ম্যাকবুকটিতে এটি প্রতি সেকেন্ডে 12.6 মিলিয়ন বিট গণনা করে যা আমি এগুলি গণনা করার চেয়ে অনেক দ্রুত faster আপনার যদি আর একটি জেনেরিক পাইথন অ্যালগরিদম থাকে যা কোনও দৈর্ঘ্যের পূর্ণসংখ্যার জন্য কাজ করে এবং এর থেকে দ্রুত আমি এটি সম্পর্কে শুনতে চাই।

— রোবটব্যাগস

আমি গ্রহণ করি না যে এটি উপরের ম্যানুয়েলের উত্তর চেয়ে আসলে ধীর।

— রোবটব্যাগস

মোটামুটি ধীরে ধীরে ধীরে ধীরে, 10000 সংখ্যার সাথে 10000 সংখ্যার জন্য বিটগুলি গণনা করতে 0.15s লাগে bin(n).count("1")তবে এটি আপনার ফাংশনের জন্য 3.8 সেকেন্ড নিয়েছে। যদি সংখ্যাগুলিতে খুব কম বিট সেট থাকে তবে এটি দ্রুত কাজ করবে, তবে আপনি যদি কোনও এলোমেলো সংখ্যা নেন তবে গড়ে উপরের ফাংশনটি ধীরে ধীরে ধীরে ধীরে ক্রম হবে।

— zidarsk8

ঠিক আছে আমি এটা গ্রহণ করব। আমি অনুমান করি যে আমি কেবলমাত্র একজন ডিক হয়ে যাচ্ছিলাম আপনি কিছুটা অসম্পূর্ণ কিন্তু আপনি পুরোপুরি ঠিক বলেছেন। আমি আমার মন্তব্যের আগে উপরের ম্যানুয়েল দ্বারা পদ্ধতিটি ব্যবহার করে পরীক্ষা করেছিলাম না। এটি দেখতে খুব আড়ম্বরপূর্ণ তবে এটি আসলে খুব দ্রুত। আমি এখন এর মতো একটি সংস্করণ ব্যবহার করছি তবে অভিধানে ১ values ​​টি মান রয়েছে এবং এটি তার উদ্ধৃত সংস্করণের চেয়ে আরও দ্রুত। তবে রেকর্ডটির জন্য আমি একটি অ্যাপ্লিকেশনটিতে খনিটি ব্যবহার করছি যা কেবলমাত্র কয়েকটি বিট স্থাপন করা হয়েছিল যা 1 এ সেট করা হয়েছিল তবে সম্পূর্ণ এলোমেলো বিটের জন্য হ্যাঁ এটি দৈর্ঘ্যের সাথে সামান্য বৈচিত্র্য হ্রাসের সাথে প্রায় 50:50 এর দিকে যাচ্ছে।

— রোবটব্যাগস

Answer 6

আপনি একটি পূর্ণসংখ্যার বাইনারি স্ট্রিং [1] পেতে আলগোরিদিমটি ব্যবহার করতে পারেন তবে স্ট্রিংকে গাaten় করে পরিবর্তনের সংখ্যা গণনা করে:

def count_ones(a):
    s = 0
    t = {'0':0, '1':1, '2':1, '3':2, '4':1, '5':2, '6':2, '7':3}
    for c in oct(a)[1:]:
        s += t[c]
    return s

[1] https://wiki.python.org/moin/BitManipulation

Comments

এটি দ্রুত কাজ করে। কমপক্ষে p3 এ একটি ত্রুটি রয়েছে, [1:] হওয়া উচিত [2:] কারণ অক্ট () স্ট্রিংয়ের আগে '0o' প্রদান করে। কোডটি অনেক দ্রুত চলে যদিও আপনি যদি অক্ট () এর পরিবর্তে হেক্স () ব্যবহার করেন এবং 16 টি এন্ট্রি অভিধান তৈরি করেন

— রোবটবাগস

Answer 7

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

ceil(n/32.)32 বিট ইনটসের অ্যারে হিসাবে এন বিটস সংরক্ষণ করুন । তারপরে আপনি কীটপতঙ্গ ব্যবহার করে একইরকম ন্যাপি অ্যারের সাথে একইভাবে কাজ করতে পারেন, অন্য একটি অ্যারেটিকে সূচী করতে ব্যবহার করে।

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

setup = """
import numpy as np
#Using Paolo Moretti's answer http://stackoverflow.com/a/9829855/2963903
POPCOUNT_TABLE16 = np.zeros(2**16, dtype=int) #has to be an array

for index in range(len(POPCOUNT_TABLE16)):
    POPCOUNT_TABLE16[index] = (index & 1) + POPCOUNT_TABLE16[index >> 1]

def popcount32_table16(v):
    return (POPCOUNT_TABLE16[ v        & 0xffff] +
            POPCOUNT_TABLE16[(v >> 16) & 0xffff])

def count1s(v):
    return popcount32_table16(v).sum()

v1 = np.arange(1000)*1234567                       #numpy array
v2 = sum(int(x)<<(32*i) for i, x in enumerate(v1)) #single int
"""
from timeit import timeit

timeit("count1s(v1)", setup=setup)        #49.55184188873349
timeit("bin(v2).count('1')", setup=setup) #225.1857464598633

যদিও আমি অবাক হয়েছি কেউ আপনাকে সি মডিউল লেখার পরামর্শ দেয়নি।

Answer 8

#Python prg to count set bits
#Function to count set bits
def bin(n):
    count=0
    while(n>=1):
        if(n%2==0):
            n=n//2
        else:
            count+=1
            n=n//2
    print("Count of set bits:",count)
#Fetch the input from user
num=int(input("Enter number: "))
#Output
bin(num)

Answer 9

দেখা যাচ্ছে যে আপনার প্রারম্ভিক উপস্থাপনাটি ইনটগুলির তালিকার একটি তালিকা যা 1 বা 0 হয় কেবল সেগুলি উপস্থাপনায় তাদের গণনা করুন।

---

একটি পূর্ণসংখ্যার বিটের সংখ্যা অজগরটিতে স্থির থাকে।

তবে আপনি যদি সেট বিটের সংখ্যা গণনা করতে চান তবে দ্রুততম উপায়টি নিম্নলিখিত সিউডোকোড অনুসারে একটি তালিকা তৈরি করা: [numberofsetbits(n) for n in range(MAXINT)]

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

Comments

পুনঃটুইট করুন

— মার্সিন

আমি যখন আপনার উত্তরটি পড়ি তখন এটিতে আপনার প্রথম বাক্যটি থাকে: "পূর্ণসংখ্যার বিটের সংখ্যা অজগরটিতে স্থির থাকে।"

— স্টিভেন রাম্বালস্কি

আমার কাছে ইতিমধ্যে এটি গণনা করা সম্ভব যে সমস্ত গুণাগুলির জন্য একটি সামান্য গণনা সারণী রয়েছে, তবে সংখ্যার একটি বৃহত তালিকা রয়েছে এবং একটি [i] এবং একটি [জে] দিয়ে সেগুলি পরিচালনা করা, আপনার দ্রবণটিকে অকেজো করে তোলে যতক্ষণ না আমার 10++ থাকে জিবি র‌্যাম & ^ | এর জন্য অ্যারে 10000 সংখ্যার ট্রিপলগুলির জন্য 3 * 10000 ^ 3 লুকিং টেবিলের আকার হবে। যেহেতু আমি জানি না আমার কী প্রয়োজন, তাই যখন তাদের দরকার হয় তখন কয়েক হাজার গণনা করা আরও বুদ্ধিমান হয়

— zidarsk8

@ zidarsk8 বা, আপনি কোনও ধরণের ডাটাবেস বা ক্রমাগত কী-মান স্টোর ব্যবহার করতে পারেন।

— মার্সিন

@ zidarsk8 10 + জিবি র‌্যাম শোকের মতো বড় নয়। আপনি যদি দ্রুত সংখ্যার গণনা সম্পাদন করতে চান তবে মাঝারি-বড় লৌহটি ব্যবহার করা অযৌক্তিক নয়।

— মার্সিন