Lua: imprimer entier comme un binaire

Comment puis-je représenter entier en Binaire?

afin que je puisse imprimer 7 comme 111

Jetez un oeil ici (je suppose que non intégré fonction?)
il est hors de date un peu 🙂

OriginalL'auteur fl00r | 2012-01-31

  1. 8

    Vous écrire une fonction pour faire cela.

    num=7
function toBits(num)
    -- returns a table of bits, least significant first.
    local t={} -- will contain the bits
    while num>0 do
        rest=math.fmod(num,2)
        t[#t+1]=rest
        num=(num-rest)/2
    end
    return t
end
bits=toBits(num)
print(table.concat(bits))

    En Lua 5.2 vous avez déjà fonctions au niveau du bit qui peut vous aider ( bit 32 )

    Ici est le plus important-de la première version, avec une option d'0 de rembourrage pour un certain nombre de bits:

    function toBits(num,bits)
    -- returns a table of bits, most significant first.
    bits = bits or math.max(1, select(2, math.frexp(num)))
    local t = {} -- will contain the bits        
    for b = bits, 1, -1 do
        t[b] = math.fmod(num, 2)
        num = math.floor((num - t[b]) / 2)
    end
    return t
end
    vous avez inversé les bits de votre fonction, de sorte 20 sera de retour 00101, pas 10100
    vous n'avez pas si vous voulais big ou little endian. L'exemple n'a pas le donner non plus, puisque 111 est un palindrome ;). De toute façon, l'adaptation c'est facile: il suffit d'utiliser nBits=ceiling(select(2,math.frexp(num))) et l'utilisation d'une boucle for de départ à nBits va 1.
    de ma faute, désolé, néanmoins la réponse est juste et utile, merci!
    J'ai ajouté un plus significatif de la version de votre réponse. J'ai laissé l'appel à math.ceil() parce que, autant que je peux dire, frexp toujours renvoie un entier pour la deuxième valeur. Est-il un cas limite que j'ai manqué?
    Non, vraiment, comme par le manuel de mathématiques.frexp, la deuxième valeur de retour doit être toujours entier. Merci pour le modifier!

    OriginalL'auteur jpjacobs

  2. 2
    function bits(num)
    local t={}
    while num>0 do
        rest=num%2
        table.insert(t,1,rest)
        num=(num-rest)/2
    end return table.concat(t)
end

    Puisque personne ne veut utiliser le tableau.insérez alors qu'il est utile ici de

    En fait, à l'aide de la table.insérez augmente la complexité de l'algorithme de O(n) O(n^2). Faire ce que jpjacobs a dit dans son commentaire, d'abord déterminer la longueur de la nombre, puis remplir le tableau à l'arrière, est beaucoup plus efficace. Surtout pour les grands nombres. Les seuls changements qui consisterait à remplacer while num>0 do par for i=math.ceil(select(2,math.frexp(num))),1,-1 do et t[#t+1] par t[i].

    OriginalL'auteur einsteinK

  3. 2

    Ici est une fonction inspiré par le a accepté de répondre avec une syntaxe correcte, qui renvoie un tableau de bits dans wriiten de droite à gauche.

    num=255
bits=8
function toBits(num, bits)
    -- returns a table of bits
    local t={} -- will contain the bits
    for b=bits,1,-1 do
        rest=math.fmod(num,2)
        t[b]=rest
        num=(num-rest)/2
    end
    if num==0 then return t else return {'Not enough bits to represent this number'}end
end
bits=toBits(num, bits)
print(table.concat(bits))

>>11111111

    OriginalL'auteur Ben

  4. 2

    Il y a un moyen plus rapide de faire ce qui prend avantage de la chaîne.format, qui convertit les nombres de base 8. Il est trivial pour ensuite les convertir en base 8 en binaire.

    --create lookup table for octal to binary
oct2bin = {
    ['0'] = '000',
    ['1'] = '001',
    ['2'] = '010',
    ['3'] = '011',
    ['4'] = '100',
    ['5'] = '101',
    ['6'] = '110',
    ['7'] = '111'
}
function getOct2bin(a) return oct2bin[a] end
function convertBin(n)
    local s = string.format('%o', n)
    s = s:gsub('.', getOct2bin)
    return s
end

    Si vous voulez les garder tous la même taille, alors ne

    s = string.format('%.22o', n)

    Qui vous obtient 66 bits. C'est deux bits à la fin, depuis octal travaux en groupes de 3 bits et 64 n'est pas divisible par 3. Si vous souhaitez 33 bits, le modifier à 11.

    Si vous avez la BitOp de la bibliothèque, qui est disponible par défaut dans LuaJIT, alors vous pouvez faire ceci:

    function convertBin(n)
    local t = {}
    for i = 1, 32 do
        n = bit.rol(n, 1)
        table.insert(t, bit.band(n, 1))
    end
    return table.concat(t)
end

    Mais notez que cela ne fait que les 32 premiers bits! Si votre nombre est plus grand que 2^32, le résultat de l'habitude " être correct.

    OriginalL'auteur Houshalter

  5. 0
    function reverse(t)
  local nt = {} -- new table
  local size = #t + 1
  for k,v in ipairs(t) do
    nt[size - k] = v
  end
  return nt
end

function tobits(num)
    local t={}
    while num>0 do
        rest=num%2
        t[#t+1]=rest
        num=(num-rest)/2
    end
    t = reverse(t)
    return table.concat(t)
end
print(tobits(7))
# 111
print(tobits(33))
# 100001
print(tobits(20))
# 10100
    Une autre façon est string.reverse(table.concat(t))

    OriginalL'auteur fl00r