Convert a 32 bit binary IPv4 address to its quad-dotted notation

Question

Challenge

Write a program or function that converts a 32 bit binary number to its quad-dotted decimal notation (often used for representing IPv4)

Quad-dotted decimal

A quad-dotted decimal is formed like so:

1. Split the binary representation into its 4 individual bytes
2. Convert each byte into denary
3. place "." between each number

Example:

input:  10001011111100010111110001111110
step 1: 10001011 11110001 01111100 01111110
step 2:    139      241      124      126
step 3: 139.241.124.126

I/O examples

input --> output

10001011111100010111110001111110 --> 139.241.124.126
00000000000000000000000000000000 --> 0.0.0.0
01111111000000000000000000000001 --> 127.0.0.1
11000000101010000000000111111111 --> 192.168.1.255

Rules

• Input will always be a 32 bit binary number or a binary list or string
• Standard I/O rules apply
• No standard loopholes
• This is code-golf, so the shortest answer in bytes wins

Answer 1

x86-16 machine code, IBM PC DOS, 54 47 45 bytes

Binary:

00000000: be82 00b3 04b1 08ac d0d8 d0d4 e2f9 8ac4  ................
00000010: 41d4 0a50 8ac4 84c0 75f6 580c 30b4 0ecd  A..P....u.X.0...
00000020: 10e2 f74b 7406 b02e cd10 ebd9 c3         ...Kt........

Build and test BIN2IP.COM using xxd -r from above.

Unassembled listing:

BE 0082     MOV  SI, 82H        ; command line input address
B3 04       MOV  BL, 4          ; loop 4 bytes 
        BYTE_LOOP:
B1 08       MOV  CL, 8          ; loop 8 bits 
        BIT_LOOP: 
AC          LODSB               ; load next bit char into AL 
D0 D8       RCR  AL, 1          ; put LSB of char into CF 
D0 D4       RCL  AH, 1          ; put CF into LSB of byte value, then shift left
E2 F9       LOOP BIT_LOOP       ; continue bit loop 
8A C4       MOV  AL, AH         ; put byte result into AL
        GET_DIGIT: 
D4 0A       AAM                 ; byte divide by 10, AH = AL / 10, AL = AL % 10 
50          PUSH AX             ; save remainder in AL on stack 
8A C4       MOV  AL, AH         ; put quotient back into AL 
41          INC  CX             ; increment decimal digit count 
D4 C0       TEST AL, AL         ; quotient = 0? 
75 F6       JNZ  GET_DIGIT      ; if not, continue looping 
        PRINT_DIGIT: 
58          POP  AX             ; restore digit in AL 
0C 30       OR   AL, '0'        ; ASCII convert              
B4 0E       MOV  AH, 0EH        ; BIOS write char function   
CD 10       INT  10H            ; write to console 
E2 F7       LOOP PRINT_DIGIT    ; loop until done 
4B          DEC  BX             ; is last byte? 
74 06       JZ   END_LOOP       ; if so, don't display a '.' 
B0 2E       MOV  AL, '.'        ; otherwise display '.'
CD 10       INT  10H            ; write to console 
        END_LOOP:
75 D7       JNZ  BYTE_LOOP      ; continue byte loop 
C3          RET                 ; exit to DOS 

Output:

A standalone PC DOS executable. Input is command line, output to console.

Notes:

The "interesting part" (converting binary string to bytes) is about 15 bytes, whereas the rest of code is writing the itoa() function to convert binary bytes into a decimal string representation for display.

• -2 bytes eliminating unnecessary PUSH/POP thx to @PeterCordes!

Answer 2

05AB1E, 6 bytes

4äC'.ý

Try it online or verify all test cases.

Explanation:

4ä       # Convert the (implicit) input-string into 4 equal-sized parts
  C      # Convert each part from binary to an integer
   '.ý  '# Join this list by "."
         # (after which the result is output implicitly)

Answer 3

C (gcc), 48 bytes

i;f(n){for(i=4;i--;)printf(".%hhu"+i/3,n>>i*8);}

Takes as input a 32-bit integer.

Thanks to ceilingcat and gastropner for getting this answer where it is now!

Try it online!

Answer 4

Jelly, 10 6 bytes

s8Ḅj“.

Try it online!

s            Slice input list
 8           into size 8 chunks
  Ḅ          Convert from binary list to integer
   j“.       Join with dots as the separator
             Implicit output

Answer 5

PHP, 26 bytes

<?=long2ip(bindec($argn));

Try it online!

OR taking input as a integer as an anonymous function :

PHP, 7 bytes

long2ip

Try it online!

Answer 6

PowerShell, 46 bytes

""+[IPAddress]"$([Convert]::ToInt64($args,2))"

Try it online!

First takes input $args binary string and [System.Convert]s it into Int64. Uses the .NET type call [System.Net.Ipaddress] to parse that Int64 into an IPAddress object, then coerces the .IPAddressToString() method by prepending ""+.

Answer 7

Python 2, 47 bytes

f=lambda n,k=-2:k*`n`or f(n>>8,k+1)+'.'+`n%256`

Try it online!

---

Python 3, 46 bytes

lambda n:('.%d'*4%(*n.to_bytes(4,"big"),))[1:]

Try it online!

Shaving a byte from David Foerster's to_bytes solution using string formatting.

Answer 8

MathGolf, 6 bytes

8/å'.u

Try it online.

Explanation:

8/       # Split the (implicit) input-string into parts of size 8
  å      # Convert each part from a binary-string to an integer
   '.u  '# Join by "."
         # (after which the entire stack joined together is output implicitly)

Answer 9

APL (Dyalog Unicode), 20 19 bytes^SBCS

-1 thanks to Kritixi Lithos.

Full program. Prompts for 32-bit integer, optionally as list of bits.

' '⎕R'.'⍕256|83⎕DR⎕

Try it online!

⎕ console prompt for numeric input

83⎕DR interpret the bits of that data as 8-bit integers (internal Data Representation type 3)

256| convert to unsigned integers (lit. 256-mod of that)

⍕ stringify (makes space-separated string)

' '⎕R'.' Replace spaces with dots

Answer 10

JavaScript (V8), 49 44 bytes

-5 bytes thanks to Arnauld

s=>s.match(/.{8}/g).map(x=>'0b'+x|0).join`.`

Try it online!

Answer 11

C#7+, 117 73 bytes

s=>string.Join('.',(new System.Net.IPAddress(s)+"").Split('.').Reverse())

Accepts the bit representation of an IP address to transform it into a four-number notation, converts it to a string array, reverses the elements to account for the endianness differences of machines, then joins them together again with a dot.

Try it online!

• Reduced to 73 bytes by utilizing the string hack and chaining (c/o @Expired Data)

---

Initial answer, 117 bytes

string I(long b){var x=new System.Net.IPAddress(b).ToString().Split('.');Array.Reverse(x);return string.Join(".",x);}

Use it like:

void Main()
{
    Console.WriteLine(I(0b_10001011111100010111110001111110));
}

public string I(long b)
{
    var x = new System.Net.IPAddress(b).ToString().Split('.');
    Array.Reverse(x);
    return string.Join(".", x);
}

Answer 12

Japt, 7 bytes

ò8 mÍq.

Try it here

Answer 13

k4, 18 17 bytes

saved a byte by expressing in composed form instead of as a lambda:

("."/:$2/:'4 0N#)

original explanation: output is string, quad-dot decimal not supported by k

{"."/:$2/:'4 0N#x}

{                } /lambda with implicit arg x
           4 0N#x  /cut x into 4 pieces
       2/:'        /convert each piece to decimal
      $            /stringify
 "."/:             /join with .

called on 2 binaries:

{"."/:$2/:'4 0N#x}'(10001011111100010111110001111110b;11000000101010000000000111111111b)
("139.241.124.126";"192.168.1.255")

Answer 14

Java 9, 97 94 92 81 bytes

s->{for(int i=0;i<32;)System.out.print((i>0?".":"")+Long.parseLong(s,i,i+=8,2));}

-2 bytes thanks to @AZTECCO.
-11 bytes thanks to @Holger by combining the Long.parseLong(s.substring(i,i+=8),2) into Long.parseLong(s,i,i+=8,2).

Try it online.

Explanation:

s->{                   // Method with String parameter and no return-type
  for(int i=0;i<32;)   //  Loop `i` in the range [0, 32):
    System.out.print(  //   Print:
      (i>0?            //    If `i` is larger than 0 (so it's not the first iteration):
        "."            //     Print a dot
       :               //    Else:
        "")            //     Print nothing instead
      +                //    Appended with:
       Long.parseLong(s,i,i+=8,2));}
                       //     A substring of the input `s` from index `i` to `i+8`,
                       //     (and increase `i` by 8 for the next loop iteration)
                       //     Converted from binary-String to integer

Answer 15

Excel. 96 bytes

=BIN2DEC(LEFT(A1,8))&"."&BIN2DEC(MID(A1,9,8))&"."&BIN2DEC(MID(A1,17,8))&"."&BIN2DEC(RIGHT(A1,8))

Answer 16

Python 3 (125 bytes)

def f(x):
    y=''
    for j in range(4):
        y+=str(int(x[j*8:j*8+8],2))
        if j<4:
            y+="."
    return y

Try it online

Answer 17

Red, 33 bytes

func[n][to 1.1.1 debase/base n 2]

Try it online!

Takes the input as strings.

Answer 18

Burlesque, 13 bytes

8co{b2}]m'.IC

Try it online!

8co    #Break into chunks 8 long
{b2}]m #Read each chunk as base-2 and turn to string
'.IC   #Intercalate "." between each and collapse

Answer 19

Stax, 8 bytes

Ç∩0&→Ö¡ 

Run and debug it at staxlang.xyz!

Unpacked (9 bytes) and explanation:

8/{|Bm'.*
8/           Split into length-8 chunks. 4M would work just as well.
  {|Bm       Convert each chunk to decimal
      '.*    Join with .

Answer 20

Python 2, ^{81 \$\cdots\$ 58} 55 bytes

lambda s:'.'.join(`int(s[i:i+8],2)`for i in(0,8,16,24))

Try it online!

Saved 3 bytes thanks to ElPedro!!!

Lambda function that takes a string of 32 "0"s and "1"s.

Answer 21

C (clang), 66 61 bytes

i;g(*m){for(i=32;i--;)*++m+=i%8?*m*2:!printf(".%d"+i/24,*m);}

Try it online!

Input as an array of integers (bits)

Adds current number shifted to the next. Every 8 bits it prints instead of adding.

Saved 5 thanks to @gastropner and @ceilingcat

Answer 22

CJam, 10 bytes

l~8/2fb'.*

Try it online!

Explanation

l~    e# Read a line and evaluate it. Pushes list to the stack
8/    e# Split into sublists of 8 elements each. Gives list of sublists
2fb   e# Map "base conversion" with extra parameter 2 over the list of sublists
'.*   e# Join sublists with character ".". Implicitly display

Answer 23

Python 3, 47 bytes

lambda n:".".join(map(str,n.to_bytes(4,"big")))

Try it online!

Answer 24

PowerShell, 45 44 bytes

$args|%{$r+=+$r+"$_"}
[ipaddress]::Parse($r)

Try it online!

---

PowerShell, 45 bytes

Pure PowerShell. It does not use external libs.

($args|%{($r=2*$r%256+"$_")[++$i%8]})-join'.'

Try it online!

Unrolled and commented:

$bytes = $args|%{           # $args is array on character 48 or 49 (bits)
    $r = 2 * $r             # one bit shift left
                            # the first operand is integer, so Powershell converts the second operand to an integer
    $r = $r % 256           # bitwise and 0xFF
    $digit = "$_"           # convert a char 48, 49 to string "0" or "1" respectively
    $r = $r + $digit        # add a digit
                            # the first operand is integer, so Powershell converts the second operand to an integer
    # now $r is a byte containing 8 bits to the left of the current one

    $index = ++$i % 8       # 1,2,3,4,5,6,7,0, 1,2,3,4,5,6,7,0, ...
    ($r)[$index]            # represent $r as an array; take an element of this array
                            # index 0 will give $r, other indexes will give $null
                            # Powershell outputs non $null values only
                            # Compare to `Wrtie-Output ($r)[$index]`
}
# now $bytes is array of not $null elements
Write-Output ($bytes -join '.')

Answer 25

Perl 5, 30 bytes

s/.{8}/oct("0b$&").'.'/ge;chop

Try it online!

Search-replaces with regexp that takes eight bits (0 or 1) at a time and converts them to their decimal representation with . placed after each, but chops off the last . char. Using a function named oct here seems counter-intuitive since the input string isn't octal. But when the given string starts with 0b the rest is read as the binary string it is.

Answer 26

Ruby, 37 34 bytes

->b{(-3..0).map{|w|255&b<<w*8}*?.}

Try it online!

Answer 27

Perl 6, 28 27 bytes

-1 byte thanks to Jo King

{chop S:g/.**8/{:2(~$/)}./}

Try it online!

Answer 28

J, 18 bytes

' .'rplc~&":_8#.\]

Try it online!

Old answer

-2 thanks to Kritixi Lithos

' .'rplc~&":2#.4 8$]

Try it online!

My first answer in a non-esolang! (kinda). The way this answer works is pretty simple. Let's look first at a non-tacit form of this expression:

(":#.(4 8 $ n))rplc' .'

Assuming that (for instance) n is:

n =: 1 0 0 0 1 0 1 1 1 1 1 1 0 0 0 1 0 1 1 1 1 1 0 0 0 1 1 1 1 1 1 0 

The expression 4 8 $ n is equal to:

1 0 0 0 1 0 1 1
1 1 1 1 0 0 0 1
0 1 1 1 1 1 0 0
0 1 1 1 1 1 1 0

Then, the #. verb is applied over the matrix, yielding the following result:

139 241 124 126

The resulting list is stringified using ":, and using rplc every space in the string representation of list is swapped to a dot, yielding the final form:

139.241.124.126

Answer 29

REXX, 91 bytes

PARSE ARG WITH 1 A 9 B 17 C 25 D
SAY X2D(B2X(A))'.'X2D(B2X(B))'.'X2D(B2X(C))'.'X2D(B2X(D))

Online REXX interpreter

Answer 30

Forth (gforth), 130 bytes.

Requires a Forth that starts in decimal mode, works with gforth.

: p . 8 emit ." ." ;
: d dup 255 and swap ;      
: r 8 rshift d ;
: q 32 2 base ! word number drop d r r r drop decimal p p p . ;

Try it online!

Usage: q 10001011111100010111110001111110 [enter]

Deobfuscated version (or how I would really do it)

\ Forth program to convert a binary IP address to dotted decimal notation.

decimal
: binary   2 base ! ;

\ Get the binary string and convert to a number.
: getbin   32 binary word number drop ;

\ Shift and mask the byte we are interested in. Put all 4 on the stack.
hex
: mask   rshift dup ff and ;
: quad4   dup ff and swap ;
: quad   8 mask swap ;
: 3more   quad quad quad ;

\ Print a quad, backspace over it's trailing space, print a dot.
: .quad   . 8 emit ." ." ;

\ Print all 4 quads in decimal.
: .4quads   decimal .quad .quad .quad . ;

\ Get binary number, chop it up into 4 quads, print in decimal.
: qdot   getbin quad4 3more drop .4quads ;