Comment convertir une chaîne de caractères ou un entier en binaire en Ruby?

comment créer des entiers 0..9 et les opérateurs de mathématiques + - * / dans les chaînes binaires. Par exemple:

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

y a-t-il un moyen de le faire avec Ruby 1.8.6 sans utiliser de bibliothèque?

149
demandé sur Morgan 2010-02-26 08:35:36

6 réponses

vous avez Integer#to_s(base) et String#to_i(base) à votre disposition.

Integer#to_s(base) convertit un nombre décimal en chaîne représentant le nombre dans la base spécifiée:

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

alors que l'inverse est obtenu avec String#to_i(base) :

"1001".to_i(2) #=> 9
319
répondu Mike Woodhouse 2017-06-26 13:57:06

j'ai demandé à une question similaire . Basé sur la réponse de @sawa , la façon la plus succincte de représenter un entier dans une chaîne en format binaire est d'utiliser le formatteur de chaîne:

"%b" % 245
=> "11110101"

vous pouvez également choisir la longueur de la représentation de chaîne de caractères à être, ce qui pourrait être utile si vous voulez comparer des nombres binaires de largeur fixe:

1.upto(10).each { |n| puts "%04b" % n }
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
38
répondu Alex Popov 2017-05-23 12:18:21

en reprenant l'idée de la table de recherche de bta, vous pouvez créer la table de recherche avec un bloc. Les valeurs sont générées lorsqu'elles sont pour la première fois accessibles et stockées pour plus tard:

>> 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"}
20
répondu Michael Kohl 2010-02-27 19:06:52

vous utiliseriez naturellement Integer#to_s(2) , String#to_i(2) ou "%b" dans un vrai programme, mais, si vous êtes intéressé par la façon dont la traduction fonctionne, cette méthode calcule la représentation binaire d'un entier donné en utilisant des opérateurs de base:

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

Pour vérifier qu'il fonctionne:

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
11
répondu joews 2013-12-11 19:00:45

si vous travaillez seulement avec les chiffres simples 0-9, il est probablement plus rapide de construire une table de recherche de sorte que vous n'avez pas à appeler les fonctions de conversion à chaque fois.

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"

indexer dans cette table de hachage en utilisant soit le nombre entier soit la représentation de chaîne d'un nombre donnera sa représentation binaire comme une chaîne.

si vous avez besoin que les chaînes binaires soient longues d'un certain nombre de chiffres (gardez des zéros de tête), puis changez x.to_s(2) à sprintf "%04b", x (où 4 est le nombre minimum de chiffres).

4
répondu bta 2010-02-26 23:00:19

si vous cherchez une classe de rubis / méthode, j'ai utilisé ceci, et j'ai également inclus les tests:

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
2
répondu SharifH 2016-03-11 13:31:53