This is also why 1.1 === 1.0.0.1

Saves 4 whole keystrokes if you quickly want to ping something to test connectivity.

In the 90s there was a campaign about the new worldwide 10-digit phone number format.

So if you own some 31.x block, you could have a phone number which matches your IP.

I wrote this a number of years ago to accomplish same:

    #!/bin/ksh                                                                                                                                                                                                     
                                                                                                                                                                                                                   
    Die() {                                                                                                                                                                                                        
        echo Bad IP                                                                                                                                                                                                
        exit 1                                                                                                                                                                                                     
    }                                                                                                                                                                                                              
                                                                                                                                                                                                                   
    [ $# = 1 ] || Die                                                                                                                                                                                              
                                                                                                                                                                                                                   
    [ ${1%%?*.?*.?*.?*} ] && Die                                                                                                                                                                                   
                                                                                                                                                                                                                   
    I=$1                                                                                                                                                                                                           
                                                                                                                                                                                                                   
    until [ ${#I} = 0 ]                                                                                                                                                                                            
    do                                                                                                                                                                                                             
        J=${I#[0-9.]}                                                                                                                                                                                              
        [ ${#I} = ${#J} ] && Die                                                                                                                                                                                   
        I=$J                                                                                                                                                                                                       
    done                                                                                                                                                                                                           
                                                                                                                                                                                                                   
    I=$1.                                                                                                                                                                                                          
                                                                                                                                                                                                                   
    typeset -ui N=0                                                                                                                                                                                                
                                                                                                                                                                                                                   
    while [ $I ]                                                                                                                                                                                                   
    do                                                                                                                                                                                                             
        J=${I%%.*}                                                                                                                                                                                                 
        I=${I#$J.}                                                                                                                                                                                                 
        [ $((J>>8)) = 0 ] || Die                                                                                                                                                                                   
        N=$(( (N<<8) + J ))                                                                                                                                                                                        
    done                                                                                                                                                                                                           
                                                                                                                                                                                                                   
    echo $N                                                                                                                                                                                                        
                                                                                                                                                                                                                   
    # End

Ah okay, I got it: it's the decimal representation of the IP address.

https://www.lookip.net/ip/172.217.23.110

Funny I wasn't aware of this despite 25 years of being an Internet user

Why do you need a different format for writing IP addresses to circumvent the PiHole? Shouldn't a regular IP address literal skip the DNS lookup, too?