रूबी में एक स्ट्रिंग या पूर्णांक को बाइनरी में कैसे बदलें?

Question

आप बाइनरी स्ट्रिंग्स में 0..9 और गणित ऑपरेटर + - * / पूर्णांक कैसे बनाते हैं। उदाहरण के लिए:

 0 = 0000,
 1 = 0001, 
 ...
 9 = 1001

एक पुस्तकालय का उपयोग किए बिना रूबी 1.8.6 के साथ ऐसा करने का एक तरीका है?

Comments

जब आप कहते हैं कि आप गणित ऑपरेटरों को बाइनरी स्ट्रिंग्स में बदलना चाहते हैं, तो वास्तव में आपका क्या मतलब है? बाइनरी में लिखे गए ASCII प्रतिनिधित्व का उपयोग करें?

— बटा

मुझे लगता है कि आप लोकप्रिय आनुवंशिक एल्गोरिथम बात करना चाहते थे? :-)

— nemesisfixx

Answer 1

आपके पास Integer#to_s(base)और String#to_i(base)आप के लिए उपलब्ध।

Integer#to_s(base) एक दशमलव संख्या को निर्दिष्ट आधार में संख्या का प्रतिनिधित्व करने वाले स्ट्रिंग में परिवर्तित करता है:

9.to_s(2) #=> "1001"

जबकि रिवर्स के साथ प्राप्त किया जाता है String#to_i(base):

"1001".to_i(2) #=> 9

Comments

@TomRavenscroft इसके अलावा, आप बिट्स की एक निश्चित संख्या का उपयोग ("%08b" % int)या ("%08b" % string)वापस करने के लिए कर सकते हैं ।

— क्षय

शानदार माइक, शानदार रूबी!

— ताम्र शालाश

-9.to_s(2) => "-1001"क्या कोई इसे समझा सकता है?

— user1201917

अपने जैसे @ क्षय के कोड से भ्रमित लोगों के लिए, वह ' स्प्रिंटफ

— टेलर लिस

@ user1201917 इसमें क्या गलत है? 9है 1001बाइनरी में।

— preferred_anon

Answer 2

मैंने एक ऐसा ही सवाल पूछा । @Sawa के उत्तर के आधार पर , बाइनरी प्रारूप में एक स्ट्रिंग में पूर्णांक का प्रतिनिधित्व करने का सबसे रसीला तरीका स्ट्रिंग स्ट्रिंग का उपयोग करना है:

"%b" % 245
=> "11110101"

आप यह भी चुन सकते हैं कि स्ट्रिंग का प्रतिनिधित्व कितने समय तक होना चाहिए, जो निश्चित चौड़ाई बाइनरी संख्याओं की तुलना करने के लिए उपयोगी हो सकता है:

1.upto(10).each { |n| puts "%04b" % n }
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010

Comments

मैंने पूर्णांक को बाइनरी स्ट्रिंग में बदलने के लिए कुछ स्थानीय परीक्षण किया था, लेकिन परिणाम दिखाता है कि जैसे कोड की 245.to_s(2)तुलना में तेजी से होगा"%b" % 245

— ग्रीन सु

इसके अलावा, यह नकारात्मक मूल्यों के साथ ठीक से काम नहीं करता है।

— एलेक्स

Answer 3

बटा के लुकअप टेबल आइडिया को उठाते हुए, आप लुकअप टेबल को ब्लॉक बना सकते हैं। मान तब उत्पन्न होते हैं जब उन्हें पहले एक्सेस किया जाता है और बाद में संग्रहीत किया जाता है:

>> lookup_table = Hash.new { |h, i| h[i] = i.to_s(2) }
=> {}
>> lookup_table[1]
=> "1"
>> lookup_table[2]
=> "10"
>> lookup_table[20]
=> "10100"
>> lookup_table[200]
=> "11001000"
>> lookup_table
=> {1=>"1", 200=>"11001000", 2=>"10", 20=>"10100"}

Answer 4

आप स्वाभाविक रूप से उपयोग करेंगे Integer#to_s(2), String#to_i(2)या "%b"एक वास्तविक कार्यक्रम में, लेकिन, अगर आप रुचि रखते हैं कि अनुवाद कैसे काम करता है, तो यह विधि बुनियादी ऑपरेटरों का उपयोग करके किसी पूर्णांक के द्विआधारी प्रतिनिधित्व की गणना करती है:

def int_to_binary(x)
  p = 0
  two_p = 0
  output = ""

  while two_p * 2 <= x do
    two_p = 2 ** p
    output << ((two_p & x == two_p) ? "1" : "0")
    p += 1
  end

  #Reverse output to match the endianness of %b
  output.reverse
end

यह काम करता है की जाँच करने के लिए:

1.upto(1000) do |n|
  built_in, custom = ("%b" % n), int_to_binary(n)
  if built_in != custom
    puts "I expected #{built_in} but got #{custom}!"
    exit 1
  end
  puts custom
end

Answer 5

यदि आप केवल एकल अंक 0-9 के साथ काम कर रहे हैं, तो लुकअप तालिका बनाने की संभावना अधिक तेज़ है, इसलिए आपको हर बार रूपांतरण फ़ंक्शन को कॉल करने की आवश्यकता नहीं है।

lookup_table = Hash.new
(0..9).each {|x|
    lookup_table[x] = x.to_s(2)
    lookup_table[x.to_s] = x.to_s(2)
}
lookup_table[5]
=> "101"
lookup_table["8"]
=> "1000"

किसी संख्या के पूर्णांक या स्ट्रिंग प्रतिनिधित्व का उपयोग करके इस हैश तालिका में अनुक्रमित करने से एक स्ट्रिंग के रूप में द्विआधारी प्रतिनिधित्व प्राप्त होगा।

आप लंबे समय (अग्रणी शून्य रखने के लिए) अंक की एक निश्चित संख्या होने के लिए द्विआधारी तार की आवश्यकता होती है, तो बदल x.to_s(2)करने के लिए sprintf "%04b", x(जहां 4उपयोग करने के लिए अंक की न्यूनतम संख्या है)।

Comments

@ bta- मैं इन सभी पात्रों को बाइनरी में एन्कोडिंग कर रहा हूं ताकि मैं उन्हें जेनेटिक एल्गोरिथम में उपयोग कर सकूं। मैं वास्तव में सांकेतिक शब्दों में बदलना / डिकोड के लिए एक लुकअप टेबल का विचार पसंद करता हूं क्योंकि सेट

— ०.९

Answer 6

यदि आप रूबी वर्ग / विधि की तलाश कर रहे हैं तो मैंने इसका उपयोग किया है, और मैंने परीक्षण भी शामिल किए हैं:

class Binary
  def self.binary_to_decimal(binary)
    binary_array = binary.to_s.chars.map(&:to_i)
    total = 0

    binary_array.each_with_index do |n, i|
      total += 2 ** (binary_array.length-i-1) * n
    end
    total
   end
end

class BinaryTest < Test::Unit::TestCase
  def test_1
   test1 = Binary.binary_to_decimal(0001)
   assert_equal 1, test1
  end

 def test_8
    test8 = Binary.binary_to_decimal(1000)
    assert_equal 8, test8
 end

 def test_15
    test15 = Binary.binary_to_decimal(1111)
    assert_equal 15, test15
 end

 def test_12341
    test12341 = Binary.binary_to_decimal(11000000110101)
    assert_equal 12341, test12341
 end
end