Topic: ( Challenge ) StringToBinary

[MP]

Convert a string to a list of binary strings, each binary string representing the value of the character's ASCII code, padded to 8 bit width.

e.g. (StringToBinary "ABC") => ("01000001" "01000010" "01000011")

Easy stuff, use the language of your choice.

[MP]

Here's my LISP code:

Code: [Select]

(defun _ByteToBin ( byte / power result )

    ;;  convert an ascii code to a binary equivalent.
    ;;
    ;;  e.g. (_ByteToBin 42) returns "00101010"
   
    (repeat (setq power 8)
        (setq result
            (cons
                (if
                    (zerop
                        (logand byte
                            (expt 2
                                (setq power
                                    (1- power)
                                )
                            )
                        )
                    )       
                    0
                    1
                )
                result
            )
        )               
    )
   
    (apply 'strcat (mapcar 'itoa (reverse result)))

)

(defun _StrToBin ( str )

    (mapcar '_ByteToBin (vl-string->list str))

)
But holy <!> look at my Python equiv:

Code: [Select]

def strToBin(s):
    def foo(i): return (('0'*8)+bin(i)[2:])[-8:]
    return list(map(foo,map(ord,s)))
 

[gile]

Hi,

Code: [Select]

(defun StringToBinary (str)
  (mapcar
    '(lambda (x / n s)
       (setq n 0
     s (itoa (rem x 2))
       )
       (repeat 7
(setq n (1+ n))
(if (/= 0 (logand x (expt 2 n)))
   (setq s (strcat "1" s))
   (setq s (strcat "0" s))
)
       )
     )
    (vl-string->list str)
  )
)

[MP]

Well done Gile!

[T.Willey]

Here is my cheesy entry.

Code: [Select]

(defun StringToBinary ( str )
   
    (mapcar
        '(lambda ( x / cnt str tempX)
            (setq cnt 128)
            (setq str "")
            (while (not (zerop cnt))
                (setq tempX (rem x cnt))
                (setq str
                    (strcat
                        str
                        (if (equal tempX x)
                            "0"
                            "1"
                        )
                    )
                )
                (setq x tempX)
                (setq cnt (/ cnt 2))
            )
            str
        )
        (vl-string->list str)
    )
)


[MP]

Well done Tim.

[VovKa]

Code: [Select]

(defun vk_Dec2Bin (Dec)
  (if (< (setq Dec (fix Dec)) 2)
    (itoa Dec)
    (strcat (vk_Dec2Bin (/ Dec 2)) (itoa (rem Dec 2)))
  )
)

(mapcar 'vk_Dec2Bin (vl-string->list "ABC"))

not padded to a byte length

[ronjonp]

Nerds    .... and it's awesome

[MP]

Nice work VovKa but ... it doesn't satisfy the requirement to pad all binary strings to an 8 bit width.

i.e. "A" should be "01000001", not "1000001".

[VovKa]

thanks MP, i was too exited to read till the end

Code: [Select]

(defun vk_Dec2Bin (Dec Len)
  (if (< Len 2)
    (itoa (rem Dec 2))
    (strcat (vk_Dec2Bin (/ Dec 2) (1- Len)) (itoa (rem Dec 2)))
  )
)
(mapcar '(lambda (a) (vk_Dec2Bin a 8)) (vl-string->list "ABC"))


[MP]

Outstanding, well played.

[gile]

Very nice Vovka !

Dirty C#

Code: [Select]

static string[] StringToBinary(string str)
{
    Encoding ascii = Encoding.ASCII;
    Byte[] bytes = ascii.GetBytes(str);
    string[]result = new string[bytes.Length];
    for (int i = 0; i < bytes.Length; i++)
    {
        string bin = "";
        for (int expt = 7; expt >= 0; expt--)
        {
            bin += (bytes[i] & (int)Math.Pow(2, expt)) == 0 ? "0" : "1";
        }
        result[i] = bin;
    }
    return result;
}

[MP]

Nice Gile, including the use of the ternary operator.

[SomeCallMeDave]

I'm loving Ruby more every day

Code: [Select]

"ABC".each_byte {|x| puts x.to_s(2).rjust(8,"0")}

Returns

Code: [Select]

01000001
01000010
01000011


[MP]

That's pretty cool, tho you didn't pen it as a function.

Python equivalent:

list(map(lambda a: (('0'*8)+bin(ord(a))[2:])[-8:],"ABC"))

=> ['01000001', '01000010', '01000011']

:P

I'm sure someone like Tim could do it more elegantly | concisely.