text:
Convert a 32 bit binary IPv4 address to its quad-dotted notation
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:

Split the binary representation into its 4 individual bytes
Convert each byte into denary
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

Input will always be a 32 bit binary number but your examples are binary lists. Is that also an acceptable input form?

Is it allowed to use a string as input instead of a list of binary digits?

I have added a brief description of how the qaud-dotted notation is formed @LuisMendo.

@Adám this is actually how I meant for the challenge to be interpreted, but I guess I couldn't find the right word. I have added it as an acceptable input form, but left the 32 bit binary number as valid input also.

@GalenIvanov yes, I will edit the post to reflect this as well.

I'm not clear, can we take in an actual number as input, like 2130706433 to give 127.0.0.1?

Is a trailing space or newline allowed?

seeing as I wrote that originally, I will allow it @xnor

that is fine @ElPedro

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)

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!

dec cx / jz end_loop could be re-arranged using a loop instruction that either falls through to a ret or jumps forward to mov al/int 10h/jmp byte_loop, for a net saving of I think 1 byte, from replacing dec cx/jcc with loop.  Or maybe use DI for that loop counter instead of CX, avoiding push/pop?

BTW, several size-neutral changes that would make it more efficient (especially on modern CPUs): shr al,1 to shift the low bit into CF, not RCR.  You don't need an input dependency on FLAGS.  (Or hmm, possibly even scasb with AL='1' instead of loading, but that would invert).  adc ah,ah can be 1 uop, RCL isn't.  Also, test reg,reg/jcc is more efficient than or reg,reg, and the same size.  I think the inefficient or idiom comes from 8080 ORA A, which didn't have an opcode that only set flags.

The question allows input as a 32-bit binary integer so you could just write a function that takes that (in memory pointed to by DS:SI if you want), instead of converting from a base 2 string.  Also, instead of push/pop for digit-order, you could maybe store backwards into a buffer, creating a $-terminated string, and when you're done you have a pointer to the first byte.  How do I print an integer in Assembly Level Programming without printf from the c library? shows the algorithm (and using a Linux write system call on it).

or al,al takes the same number of clock cycles on 8086, but read my linked answer for why it's slower on modern x86.  (Can't macro-fuse with JCC, and introduces an extra operation in the dependency chain for that register for later readers).  For the shifts, shr al is the semantically simpler operation, and for performance has no flag inputs.  Also, rotate-through-carry is never a single uop on modern CPUs but ADC can be (on Intel Broadwell and later, and on all AMD), so generally prefer adc reg,reg over of rcl reg,1 unless you need its slightly different flag output.

re: replacing dec cx / jz with LOOP: https://godbolt.org/z/BBkteF is NASM source for my 9-byte sequence that is equivalent to your 10-byte sequence.  My idea did work out, using LOOP to jump forward or fall through to a ret.

I'm not sure the ideas are compatible; if you use CX for the outer loop, you can't take advantage of loop for the inner bit-loop without spending 2 bytes on push/pop.  Since using BX saved 2 bytes (because you could take advantage of BH being known zero) vs. my idea only saving one, I think using BX wins.

@PeterCordes yes, I just tried and that's what's happening.  I was doing two different LOOPs on the "inner" loop, and since I can count on CX being 0 at the end of the first, I used it as the counter for decimal digits and looped again.  Unfortunately DEC / JNZ is 1 byte more than LOOP so my gain there offsets the BX outer loop gain.  So, yes, BX would seem to win but it was a great idea and fun exercise to go through!

re: mov + set flags.  Not in less than 4 bytes, unless there's a clever way to zero AL first.  Then you could do or al, ah to set AL=AH|0 = AH, and set flags.  If AH could only have a couple possible values, mov al, '0' / or al, ah and then branch on PF might be possible to fold in the later OR.  ARM has mov-and-set-flags; x86 doesn't.

One of my favourite abuses of LOOP is inc cx / loop target = 3 byte version of test cx,cx / jnz target.  (In 16 and 32-bit mode).  (Invented for this answer.  I assume I'm not the first inventor of this trick but I don't look at a lot of legacy code optimized for code-size over performance.)

After div, FLAGS are "undefined".  I haven't checked what actually happens on any real CPUs or emulators.  Taking advantage of implementation-specific behaviour is generally allowed in code-golf answers, if you want to do so.  But then you need a divisor in a register or memory, costing at least 2 bytes for a mov r8,10

x86 doesn't have conditional ret, and https://nasm.us/doc/nasmdocb.html doesn't seem to have any undocumented opcodes for it.  ARM32 can predicate anything, including bx lr, but on x86 JCXZ, LOOP, LOOPE/LOOPNE, and JCC are the only conditional jumps, if you don't count stuff like TSX xbegin / xabort.  e.g. Does an aborted xbegin transaction restore the stack context that existed at the xbegin start?.  But that's hardly useful golfing.

@PeterCordes I experimented with writing in reverse to a string buffer, and was only able to get it down to 48 bytes. Here's the scratchpad (https://godbolt.org/z/6853--) if you have any thoughts or ideas.

That idea probably works better for a function that takes a pointer arg and returns a pointer to the start of the string, so you get to skip actually printing.  And can maybe justify not storing a terminator yourself, leaving it up to the caller to choose to 0-terminate, '$'-terminate, or just calculate a length from end-start and use it as explicit-length.

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!

Missing semicolon in for loop. 48 bytes

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

If you use ” (character) rather than “ (start list of characters) this would be a Link rather than a full program (although submission may want to ba a full-program anyway, since the Link result is not just a list of characters, so we may prefer the implicit printing)

Are you counting Ḅ as a single byte?

@chrylis-onstrike- Jelly uses a custom code page to encode its characters. So, in this instance, yes, it's one byte.

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!

No need for bindec, $argn will be an integer.

@kerkouch yes, that's true. I think that option was allowed after I posted the original answer. That simplifies this quite a bit. :)

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 ""+.

Unfortunately on systems that are LittleEndian (like TIO and most computers... I think?) this parses the binary backwards so the IP in your TIO link has the quads in reverse order.

@Malivil Dang, that's a side-effect of removing the "$( )" that I golfed. I'll put that back in. Thanks for the bug catch!

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.

APL (Dyalog Unicode), 20 19 bytesSBCS
-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

Using ⎕r on ⍕'ing the entire list saves a byte

@KritixiLithos How?

' '⎕r'.'⍕256|... https://tio.run/##pZCxCsIwEIb3PsVtnSq5xKZ9ABdX3yBoFKG2tUmFipugRVBcBBdfLi9SNVBbSwfBfFzg/sv93EWkkTcrRJQsKlMe08oF11xumTtwzflGfb4L2SsfTV7X@4EzjjWj5nA1pz0BRpkp77YO5vyAWE6lUiIrQCeQZnIjYw0i14mn1rmUWwnJHNRKRBEsY60qsCd1EIgFbTT0qbXWUpzah8BftHywZ45fQafZ67sXW9HT1@XjYz8dKFKKGPjodwqkkyMPgoANWUf2kHMeDkPyBA

@KritixiLithos Oh right, for some reason I thought it was nested and would give too many spaces.

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)

JavaScript (V8), 49 44 bytes
-5 bytes thanks to Arnauld
s=>s.match(/.{8}/g).map(x=>'0b'+x|0).join`.`

Try it online!

44 bytes

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);
}

by using lambdas, chaining and a hack for ToString() you can reduce it to 73 bytes

Thanks, @ExpiredData, totally forgot the string hack.

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

Since Java 9, you can use Long.parseLong(s,i,i+=8,2) which will not only improve it from a golfing point of view, even the performance will be better as it saves the substring operations.

@Holger Oh, I didn't knew that. Thanks! :)

Japt, 7 bytes
ò8 mÍq.

Try it here

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

Hi. Small problem in that this outputs an extra "." at the end. Easily fixed by changing j<4 to j<3. Also we normally count bytes and not characters and according to TIO this is 125 bytes.

Here are a few hints for 80 bytes Try it online!

Thank you @ElPedro for the knowledge.

My pleasure, however there are a couple more golfs that I didn't mention. I'll leave those for you to find. Since OP has said that trailing space is alowed then you can save at least 6 more. Have fun :)

BTW, even if you don't use the hints, you should really update the answer to correct the identified problem and please feel free to post my suggestions as an improved answer.

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")

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

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.

Red, 33 bytes
func[n][to 1.1.1 debase/base n 2]

Try it online!
Takes the input as strings.

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.

Ha, just came up wth the same thing! If you switch to Python 2 you can use backticks instead of str() to save 3 more Try it online!

@ElPedro Awesome, great minds think alike! Good idea switching to 2 for str()
to backticks save. :-)

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

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 .

Perl 6, 28 27 bytes
-1 byte thanks to Jo King
{chop S:g/.**8/{:2(~$/)}./}

Try it online!

Using chop is one byte shorter

Ruby, 37 34 bytes
->b{(-3..0).map{|w|255&b<<w*8}*?.}

Try it online!

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

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

63 bytes

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 '.')

Witchcraft! I can't even begin to understand how the second one works -- can you add an explanation?

Thanks, O' Valley of Plenty. I've added explanation.

Python 3, 47 bytes
lambda n:".".join(map(str,n.to_bytes(4,"big")))

Try it online!

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 ;

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

If REXX had a function that would go directly from binary to decimal I could chop 20 bytes off of this.

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

[:#. can become 2#., and you can also remove the cap in rplc~[:": with rplc~&":. Also 2#.4 8$] can become shorter with the adverb infix https://www.jsoftware.com/help/dictionary/d430.htm

I can't spot the the possibility of using adverb infix in the code

Julia, 58 52 bytes
x->join(parse.(Int,x[n:n+7] for n=1:8:25;base=2),:.)
Takes the input string and uses a comprehension to create an array of the 8 bits. Then parses each element (via 'broadcasting' with the . into an Int. Last step is to join with the period.
Reductions per comments below:

4 byte reduction by simplifying the comprehension indexing
1 byte reduction in changing the separator from a string to a symbol (which join converts into a string upon joining with the integers)

x->join(parse.(Int,(x[n:n+7] for n=1:8:25),base=2),".") for 55 bytes - from a suggested edit.

Using 52 bytes: x->join(parse.(Int,x[n:n+7] for n=1:8:25;base=2),:.)

Vyxal, 45 bitsv2, 5.625 bytes
8ẇvB\.j

Try it Online!
7 bytes -> 5.625 bytes.
Explained
8ẇvB\.j
8ẇ       # Split into chunks of length 8
  vB     # Convert each to binary. Pretty sure it should work without the v. Could be a bug
    \.j  # Join on "."s

Created with the help of Luminespire.

Batch, 56 bytes
@for /f "tokens=2" %%f in ('ping %1')do @echo %%f&exit/b

Takes input as the first command-line argument. Somewhat slow, but -n1 -w1 can be added to the ping command to speed it up a bit.

GolfScript, 20 bytes
8/{1/{~}%2base}%'.'*

Try it online!
Explanation
8/                   # Split into size 8 chunks
  {           }%     # For-each over the chunks
   1/                # Split into size-1 chunks
     {~}%            # Convert each from string to number
         2base       # Convert to base 10
                '.'* # Join with dots

[C (gcc clang)], 97 85 77 bytes
x;f(*s){x=strtoul(s,s,2);printf("%hhu.%hhu.%hhu.%hhu\n",x>>24,x>>16,x>>8,x);}

Try it online!
This version takes a string as input. 8 bytes shaved off thanks to JL2210!

You can remove the &255 by using %hhu.

I think the final newline is not required. To leave it out saves 2 bytes.

Alchemist, 97 bytes
_->3a+7b+i
i+n->i+m
i+0n->j+In_n
j+m->j+2n
j+0m+b->i
j+0m+0b->k+Out_n
k+n->k
k+0n+a->7b+i+Out_"."

Try it online!
a and b count down the bytes and bits remaining, respectively.  i, j, and k are phase/step atoms.  The current byte is stored in n, with temporary storage in m.

Pyth, 10 9 bytes
j\.iR2cz8

Try it online!
Chops input into pieces of length 8 (cz8), then maps int(x, 2) over the result (iR2). Then just joins those with a dot separator (j\.).
-1 by using a more specialized map (R) instead of the generic m.

SmileBASIC, 49 bytes
INPUT X
RGBREAD X OUT A,B,C,D?A;".";B;".";C;".";D

Takes a decimal integer as input
the RGB and RGBREAD functions were designed to convert between 32 bit ARGB color values and separate 8 bit channels

Python 3, 44 bytes
Another one using to_bytes trick, but this one also uses f-strings.
'.'.join(f"{b}"for b in n.to_bytes(4,"big"))

You don't appear to be doing any input or output. To be valid, you should either make this a function by prepending lambda n: to the front, or mark this as REPL and change n to int(input())

Haskell, 52 bytes
s n|(y,x)<-divMod n 256=concat[s y++"."|y>0]++show x

Try it online!
Takes input as number.  Repeatedly divMods by 256 until the div is zero.

Perl, 33 bytes
$_=join'.',unpack'C4',pack'B*',$_

Try it online!
Read in right-to-left order:

Encode input using pack
Extract four unsigned bytes with unpack
Intercalate . separators with join

Ruby -p, 34 bytes
Replaces each 8-character subsequence with its decimal conversion plus a dot, then removes the last dot.
gsub(/.{8}/){"#{$&.to_i 2}."}
chop

Try it online!

Lua, 82 bytes
print(io.read():gsub(("%d"):rep(8),function(n)return'.'..tonumber(n,2)end):sub(2))

Try it online!
Takes input from stdin and writes to stdout. Works on Lua 5.0+.
This works by using string.gsub's ability to replace matches using a helper function. The function used here replaces a string of eight binary digits with a . followed by the digits in decimal. The :sub(2) at the end removes the extraneous . at the beginning of the resulting string.
Un-golfed version + extra explanation:
print(                                       -- print
    string.sub(                              --  substring
        string.gsub(                         --   replace
            io.read(),                       --    in string
            "%d%d%d%d%d%d%d%d",              --    replace
            function(n)                      --    with
                return                       --     result of
                    '.' ..                   --      concatenate with
                    tonumber(                --      string to number
                        n,                   --       convert this
                        2                    --       with base
                    )
            end
        ),
        2                                    --   starting at character (1-index)
    )
)

Fortran (GFortran), 58 bytes
integer i(4)                 !Declare 4 int array
read('(4B8)'),i              !Read as 4 length 8 binary numbers
print('(3(i0,"."),i0)'),i    !Print as 3 auto-length ints followed by a '.' and then the last int
end

Try it online!

Thunno 2, 6 bytes
8ẇḂ'.j

Try it online!
4ẆḂ'.j

Try it online!
Explanation
         # Implicit input
 ẇ       # Split the input into
8        # chunks of length eight
 Ẇ       # Or, split the input into
4        # four equal-sized chunks
  Ḃ      # Then, convert each from binary
   '.j  '# And join the list by "."s
         # Implicit output


text:
Cartesian LCM of two arrays
Given two nonempty arrays of natural numbers \$a\$ and \$b\$, return the shortest nonempty array of pairs of natural numbers \$q\$ such that the sequence of first elements of \$q\$ consists of a whole number of repeated copies of \$a\$, and the sequence of second elements of \$q\$ consists of a whole number of repeated copies of \$b\$.
When \$a\$ and \$b\$ have the same length, this acts like a zip, but when the lengths of \$a\$ and \$b\$ are coprime, this acts like a Cartesian product.
You can use any reasonable input and output format for arrays (pointers, lists, space-separated strings, strings of char codes, etc.)
This is code-golf, so the shortest valid answer (measured in bytes) wins.
Test Cases
[1],          [2]       -> [(1, 2)]
[1, 2],       [3]       -> [(1, 3), (2, 3)]
[1, 2],       [3, 4]    -> [(1, 3), (2, 4)]
[1, 2, 3, 4], [5, 6]    -> [(1, 5), (2, 6), (3, 5), (4, 6)]
[5, 5, 5],    [5, 5, 5] -> [(5, 5), (5, 5), (5, 5)]
[5, 5],       [5, 5, 5] -> [(5, 5), (5, 5), (5, 5), (5, 5), (5, 5), (5, 5)]
[1, 2, 3, 4], [1, 2, 3, 4, 5, 6] ->
    [(1, 1), (2, 2), (3, 3), (4, 4),
     (1, 5), (2, 6), (3, 1), (4, 2),
     (1, 3), (2, 4), (3, 5), (4, 6)]

can we assume a separate variable is passed to function with the length of each array or do you want us to find the length of the input strings?

Yes, that's acceptable.

Related

Can we sort the input by array length?

@Shaggy No, I'd say you can't.

Question about data input output due to discussion below my answer... have I golfed too far?. I have set data input and output to rely on a single integer array, which has the first i members as the contents of a, the next j members are the contents of b and the remainder of the array is filled with zeroes so that when q is calculated it can be placed directly after the b items in the same array the first zero in the array indicates q end. This use of a single integer array for data input and output saves 2 bytes ;-) , but the question is.Is it a step too far or is it acceptable?

@tom That's fine.

Is two-row matrix output (interpreting each column as a pair, as in this answer) allowed?

@Bubbler That's allowed.

J, 14 13 bytes
,./@($&>~*./)

Try it online!
-1 byte thanks to Bubbler
This answer takes the two lists as its left arg, and the two list lengths as its right arg.

($&>~*./) is a dyadic hook which applies gcd between the two right arg lengths *./ and the reshapes the two left arg lists $ to that length after opening them &>.  At this point they'll be the same length so boxing is no longer needed.
[:,./ so now we can just zip them ,.

original answer taking the lists directly
J, 17 16 bytes
(*.&#$[),.*.&#$]

Try it online!

*.&# is the gcd *. after taking length # of both args

It turns out to be shorter to repeat this phrase than to remain DRY.

,. is zip and and $ is shape.  So we shape the left arg [ by the gcd of the list lengths, do the same to the right arg ], and zip them.

13 bytes ([: -> @).

Thanks Bubbler, don't know how I missed that :)

C (clang), 70 68 bytes
i;f(*a,*b,x,y){for(i=0;printf("(%d,%d)",a[i%x],b[i%y]),++i%x+i%y;);}

Try it online!
Takes input as pointer to a and b and the lengths, prints q to std out.
We use the modulo of an iterator by the data lengths e.g. i % x and i % y to access data, when both modules are equal to 0 , i is LCM and the function terminates.

Jelly, 7 bytes
ṁ€æl/}Z

A dyadic Link accepting a list of the two lists on the left and a list of their respective lengths on the right which yields a lists of lists.
(A monadic Link accepting only the left argument costs 8 bytes, ṁ€Ẉæl/$Z)
Try it online! Or see the test-suite.
How?
ṁ€æl/}Z - Link: list of lists [a, b], list [length(a), length(b)]
     }  - use the right argument as the left argument of:
    /   -   reduce by:
  æl    -     least common multiple (i.e. LCM(length(a), length(b))
 €      - for each list in the left argument (i.e. for x in [a,b]):
ṁ       -   mould like (i.e. repeat x cyclically until its length is the calculated LCM)
      Z - transpose

R, 69 60 54 51 bytes
function(a,b,x,y)cbind(rep(a,y/sum(!(1:x*y)%%x)),b)

Try it online!
Loosely based on my answer to this question. Takes a,b, and the lengths as x and y, respectively.
Returns a two-column matrix.
Thanks to Robin Ryder for saving 4 bytes, and then another 3.
Relies on the identity \$xy=GCD(x,y)\cdot LCM(x,y)\$; repeats a by \$y/GCD(x,y)\$ times to get it to the LCM length, and cbind automatically recycles b accordingly.

56 bytes

@RobinRyder ahhh, of course. Thanks!

51 bytes, assuming I didn't make a mistake with operator precedence...

@RobinRyder wow, that's clever! I'm not 100% sure, but this is using the identity that x*y = gcd(x,y) * lcm(x,y), and the sum(...) is computing the gcd?

Yes, that's right!

J, 8 bytes
*.&#$&>;

Try it online!
Takes two vectors as left/right args and gives a two-row matrix where each column represents a pair. If you insist a two-column matrix, prepend [:|: to the code, which is still shorter than previous J answer.
How it works
*.&#$&>;  NB. Tacit function; left=vector 1, right=vector 2
       ;  NB. Nested 2-item vector of two vectors
    $&>   NB. Disclose each and recycle to the length of...
*.&#      NB. LCM of the lengths
          NB. Two disclosed vectors automatically form a 2-row matrix

C (gcc), 85 76 bytes
n;z(a,i,j)int*a;{for(n=0;a[n*2+i+j]=a[n%i],a[n+++n+i+j]=a[n%j+i],n%i+n%j;);}

Try it online!
Thanks to ceilingcat for reduction 85->76 bytes.
The code above is golfed so that all the information is stored in a single integer array, which saves 2 bytes; the logic though is the same as previously with three arrays.
Try code with three arrays online this code has less bytes, but the arrays are global so that information is not directly passed in or out of function.
How
description of algorithm with ungolfed code or at least less golfed code.
setup (see online code)

a[],b[] input data - q[] output data
i,j length of a,b
n loop counter
do{                              }while(n%i+n%j);}
 // open loop that ends when counter mod i and j =0
   q[n*2]=a[n%i];
 // q[0,2,4...]=a[0,1,2...]
                 q[n+++n]=b[n%j];
 // q[1,3,5...]=b[0,1,2...]  and increase loop counter

In the golfing process all the data input and output was put into a single int array. The first i members are the contents of a, the next j members are the contents of b and the remainder of the array is filled with zeroes so that when q is calculated it can be placed directly after the b items in the same array the first zero in the array indicates q end. This use of a single integer array for data input and output saves 2 bytes. OP has indicated that this approach is acceptable for this challenge.

@AZTECCO - ok - sorry, had it as a function before, I have reinstated that - was trying to think of any way to reduce the number of bytes

@girobuz - ok see your point - note added about the compiler flag bytes

@AZTECCO - ok so I tried to reduce the byte count by using global variables, but if I understand correctly the point that you are making is that in the question we need to have input and output. So I reread the question and I can see your point. I will have a look at how to implement it so that there is input and output without adding too many bytes - thanks for the helpful feedback and thanks for the tio suggestion.

@AZTECCO edited to ensure data is passed to and from function rather than using global variables - thanks for pointing it out.

This function isn't reusable though, since n is never reset. I also don't think taking the two parameters as a joined array is valid either, though perhaps you can ask on Meta about that

@JoKing - thanks for comment about n=0 - ceilingcat fixed it :-) sp that point is ok.-- as far as the array goes I think it is up to the OP so will ask...

Perl 6, 39 36 25 bytes
-3 bytes thanks to Jo King
{zip $_>>[^[lcm]($_)X%*]}

Try it online!
Explanation
{                       }  # Anonymous block
     $_>>[             ]   # Index into both input arrays
          ^[lcm]($_)       # Range [0,lcm)
                    X%*    # modulo array size
 zip  # Zip

Perl 6, 35 bytes
{$^a <<,<<flat $^b xx($a lcm$b)/$b}

Try it online!

30 bytes

@nwellnhof Oh, I extrapolated that out to the exact same code as your answer, so I guess I'll leave mine as is

05AB1E, 7 bytes
€g.¿δ∍ø

Takes the input as a pair of lists of integers.
Try it online or verify all test cases.
Explanation:
€g       # Get the length of each inner list in the (implicit) input-pair of lists
  .¿     # Take the Least Common Multiple for the two values in this pair of lengths
    δ∍   # Extend both inner list in the (implicit) input-pair of lists to this length
      ø  # Then zip/transpose the (now equal-length) list of lists, swapping rows/columns
         # (after which the result is output implicitly)

Charcoal, 21 bytes
≔¹ηＷ⊙θ﹪ηＬκ≦⊕ηＩＥηＥθ§λκ

Try it online! Link is to verbose version of code. Takes input as an array of arrays and outputs as a double-spaced list of pairs. Explanation:
≔¹ηＷ⊙θ﹪ηＬκ≦⊕η

Count up from 1 until the LCM of the lengths of the arrays has been reached. (This O(n²) but even O(n) would cost 3 bytes.)
ＩＥηＥθ§λκ

Map over the implicit range and cyclically index both arrays.

Wolfram Language (Mathematica), 42 bytes
Thread@PadRight[#,{2,LCM@@(Length/@#)},#]&

Try it online!

35 bytes

Python 3.8 (pre-release), 78 76 bytes
-2 bytes thanks to Noodle9
lambda a,b:zip((x:=len(b))//(g:=math.gcd(y:=len(a),x))*a,y//g*b)
import math

Try it online!

JavaScript (ES6),  77 68 64  58 bytes
Saved 6 bytes thanks to @AZTECCO
Takes input as (a, b, a_length, b_length).
(a,b,n,N)=>(g=i=>[[a[i%n],b[i%N]],...++i%n+i%N?g(i):[]])``

Try it online!

APL (Dyalog Extended), 9 bytes
,¨/∧⍥≢⍴¨⍮

Try it online!
Takes two input strings as left and right arguments respectively. Being able to take lengths as separate arguments doesn't really help.
How it works
,¨/∧⍥≢⍴¨⍮  ⍝ left: string a, right: string b
        ⍮  ⍝ 2-item nested array of [a, b]
      ⍴¨   ⍝ Reshape (by cycling elements) each of [a, b] to the length of...
   ∧⍥≢     ⍝   LCM of lengths of a and b
,¨/        ⍝ Reduce by "pair up element-wise"

Brachylog, 15 bytes
{l×↙X}ᵛḃ₁g,?zbᵐ

Try it online!
Initially, I thought "it's funny, Brachylog has a cycling zip builtin but I don't think I'll need it", but my various attempts at j and z₂-based solutions have simply refused to terminate on test cases where the second list is longer than the first.
{    }ᵛ            For each element of the input,
 l                 the length
  ×                multiplied by
   ↙X              something
{    }ᵛ            comes out to the same value.
       ḃ₁          Convert that value to unary,
         g         wrap it in a list,
          ,?       append the elements of the input,
            z      cycling zip,
             bᵐ    and remove the first element from each element of the result.

Note that {×↙Xℕ₁}ᵛ calculates LCM, but the ℕ₁ constraint isn't necessary in this case because z fails if any element of its input is empty (since it can't be cycled).

Perl 5, 104 bytes
sub f{($A,$B,%s)=@_;map[$$A[$$_[0]],$$B[$$_[1]]],grep!$s{$$_[0],$$_[1]}++,map[$_%@$A,$_%@$B],0..@$A*@$B}

Try it online!
Slightly ungolfed:
sub f {
  ($A,$B,%s) = @_;                #input A and B, %s is the "seen" dictionary
  map [$$A[$$_[0]], $$B[$$_[1]]], #convert indexes to values from input A and B, return that.
  grep !$s{$$_[0],$$_[1]}++,      #filter out index pairs seen before
  map [$_%@$A,$_%@$B],            #make array of pairs where 1st elem is
                                  #...index of A and 2nd is index of B,
                                  #...but modulo their size respectively
  0..@$A*@$B                      #loop from 0 to size_of_A * size_of_B
}

Ruby, 52 bytes
->x,y{a=x.size;a/=g=a.gcd b=y.size;(x*b/=g).zip y*a}

Try it online!

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Inter-language 2-cycle quine
Challenge
Create 2 programs A and B

The output of program A is exactly program B

The output of program B is exactly program A

Neither program should depend on inputs to yield the correct output

A and B are not identical programs

A and B are of different programming languages

Neither program may be equivalent to itself in the other language.
For example, if the chosen languages are C and C++, the C++ program
must not be a valid and equivalent C program, else the
"inter-language" requirement is redundant

A solution should include:

The program source, as well as a Try it online (tio.run) link for both programs

Scoring
The score for a solution is:

The length of the shortest program +

The combined length of the names of both programming languages, as they appear on tio.run

The reason for this unusual scoring is because this constitutes the combined length of the minimum information necessary to communicate your solution.

This is my first post to Code Golf.
Any edits to this post to increase clarity or appropriate vocabulary are welcome.

Welcome to the site.  I would really recommend removing the name penalty.  "Common name" is not going to be clear for a lot of instances.  I don't really get the reason this was included in the first place and it just leads to trouble down the road when people try to golf the language name.

Also not an issue or even something that needs to be changed, but the penultimate and antepenultimate bullets are redundant, both are implied by the last bullet point.

So essentially, this is a multi-language quine that can't be a polyglot.

@PostRockGarfHunter I did suspect that the "Common name" qualifier may cause some problems, but for now I'd like to leave it as a (maybe naive) experiment in seeing how such an odd type of scoring will play out.

@Jono2906 no problem if either program can "speak" both languages, i.e. is a valid program in both languages, but if it gives the same output in both, that violates the last rule.  See Jo King's answer

@HymsForDisco but you say that A and B cannot be the same program. A polyglot is a program that does the same task in both languages.

@Jono2906 I see. I was unfamiliar with the common meaning of "polyglot" in programming.  I took it to mean any program that is simply valid in more than one language (not necessarily accomplishing the same task in each language).  Anyways, the original rules and wording still stand, any corrections will be made there.

If you want to leave it you really ought to clarify what you mean then.  A language can have multiple names, and some may be initialisms or nicknames. Can I say haskell is GHC even if it works in other haskell compilers? Can I say Prolog is SWI if it works in the SWI-Prolog interpreter?  If my python answer works in both Python 2 and Python 3 can I just say Python (does it need to work in Python 1 as well)? If I have C code that only works with a particular compiler is it still just C or do I have to use the longer compiler name?  There are a ton of edge cases that are not clear from the spec.

Hi! This seems similar to my posts, I love the creativity!

><> and Gol><>, 18 bytes + 3 + 6 = 27
'3d*:5-0@o~r{?H>o<

Try it online!
and
"3d*:5-0@o~r{?H>o<

Try it online!
Both output the same program, but with the first character flipped between ' and ". Neither program is equivalent to itself in the other language, since the behaviour of @ differs.

So the first is a Gol><> quine and the second is a ><> quine that both just happen to produce the same output in the other language? Seems that makes them equivalent to me, but what do I know?

Indeed this solution is quite a "near-miss", but both programs have different outputs in each language as outputted by "try it online".  I'm interested to see how the problem becomes (presumably) more complicated with non-golfing and more dissimilar languages

Sure, by running the first program in ><> and the second program in Gol><> they output each other, but that's not what I said.

Yes this is a valid. By "near-miss" I meant that it narrowly dodges each restriction i.e. 1. the programs are not identical, 2. the languages are not the same, and 3. neither program is equivalent in the other language

Ah I see now, both programs are equivalent to each other in the same language.

Jelly, 13 bytes + 8 = score 21
“Ṿ;⁾v`+/ŒṘ”v`

Try it online!
RAD
'“Ṿ;⁾v`+/ŒṘ”v`'

Try it online!
A Jelly quine that wraps itself in single quotes, such that the resultant RAD program simply prints the original Jelly program back out.
Thanks to @JoKing for golfing the language name for the second program!

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Largest monetary amount impossible to make with two types of coin
Suppose we have two different types of coin which are worth relatively prime positive integer amounts. In this case, it is possible to make change for all but finitely many quantities. Your job is to find the largest amount that cannot be made with these two types of coin.
Task
Input: A pair of relatively prime integers \$(a,b)\$ such that \$1<a<b\$.
Output: The largest integer that cannot be expressed as \$ax+by\$ where \$x\$ and \$y\$ are nonnegative integers.
Scoring:
This is code golf so shortest answer in bytes wins.
Example:
Input \$(3,11)\$
\$4\cdot 3- 1\cdot 11=1\$, so if \$n\geq 22\$ we can write \$n=q\cdot 3 + 2\cdot 11 +r\$ where \$q\$ is the quotient and \$r\in\{0,1,2\}\$ the remainder after dividing \$n-22\$ by \$3\$. The combination \$(q+4r)\cdot 3 + (2-r)\cdot 11 = n\$ is a nonnegative combination equal to \$n\$. Thus the answer is less than \$22\$. We can make \$21=7\cdot 3\$ and \$20=3\cdot 3 + 1\cdot 11\$ but it's impossible to make \$19\$ so the output should be \$19\$.
Test Cases:
[ 2,  3] => 1

[ 2,  7] => 5

[ 3,  7] => 11

[ 3, 11] => 19

[ 5,  8] => 27

[ 7, 12] => 65

[19, 23] => 395

[19, 27] => 467

[29, 39] => 1063

[ 1,  7] => error / undefined behavior (inputs not greater than one)

[ 6, 15] => error / undefined behavior (not relatively prime).

[ 3,  2] => error / undefined behavior (3 > 2)

[-3,  7] => error / undefined behavior (-3 < 0)

I remember seeing this challenge before, but I'm not coming up with it on searching.

@xnor I thought there was a good chance it would be a duplicate but I also failed to find it when I searched.

There is a problem for any number of coins. But I don't think it is a duplicate, because most answers here do not work for the case with more than 2 coins.

Are you the same Hood that has written poker software?

Here's a proof for the formula by one of the diamond mods of Math.SE.

@Jonah I am not. I am a mathematician (I study algebra, specifically homotopy theory) and hobbyist programmer.

shouldn't your "reasoning" contain 21= 73 instead of 21=83 which is obviously false

@eagle275 Oops fixed.

J, 7,6 3 bytes
-1 byte thanks to FrownyFrog !
-3 bytes thanks to Grimmy!
*-+

Try it online!
     -    subtract
      +   the sum of the arguments
    *     from their product

3 bytes with *-+

@Grimmy Great - this is much better! Thanks!

Seeing answers like this in J make me glad to lurk.

fails on the "not relative prime"-Example 6 f 15 which results in 69

and 69 is wrong as it is 64+153 ^^

@@eagle275 it is undefined behavior, as stated in the OP

well shouldn't J then show this - if you try the 05AB1E example - likewise 3 bytes , its working "correctly" by not  giving a result for the 6,15 pair

@eagle275 6,15

Husk, 4 bytes
←¤*←

Try it online!
Explanation
As proved in lots of places, the answer for inputs a and b is ab-a-b = (a-1)(b-1)-1. ¤ is the 'combine' combinator, so ¤*← is a function that applies ← (decrement) to each argument and 'combines' the results by multiplication. Then I decrement the result to get the final output.

Wolfram Language (Mathematica), 8 bytes
1##-+##&

Try it online!

Wolfram Language (Mathematica), 15 bytes
FrobeniusNumber

Try it online!

Because of course there's a builtin for that.

Is there a language that just has all the Mathematica builtins but as single characters?

@SamDeann How would that be possible, assuming that the number of builtins is more than the number of characters?

05AB1E, 3 bytes
<P<

Try it online!
<         # decrement both inputs
 P        # product
  <       # decrement

Perl 6, 43 13 bytes
(*-1)*(*-1)-1

Try it online!
Turns out there's a much shorter way to calculate the answer.
Perl 6, 43 bytes
->\a,\b{max ^(a*b)∖((a X*^b)X+(^a X*b)):}

Try it online!

Python 3, 18 bytes
lambda a,b:a*b-a-b

Try it online!

APL (Dyalog Unicode), 3 bytes
×-+

Try it online!
Dyadic train where a f b computes (a×b)-(a+b).
Jelly, 3 bytes
×_+

Try it online!
Dyadic link that takes two numbers a and b as left and right arguments. Works the same as the APL version, just with the symbol _ instead of - to represent subtraction.

C (clang), 31 22 bytes
f(a,b){return~-a*b-a;}

Try it online!
Saved 9 bytes thanks to ceilingcat!!!

Jelly, 3 bytes
P_S

Try it online!
A monadic link taking a pair of integers. Same method as most other answers (product minus sum).

Pyth, 5 bytes
-*FQs

Try it online!
Product minus sum.
t*FtM

Try it online!
a,b -> (a-1)*(b-1)-1

Pyth, 8 7 bytes
t*thQte

Try it online!
Uses the formula (a-1)(b-1) - 1. Takes input as a Python array of 2 integers.
-1 by using implicit appended Q

@FryAmTheEggman: isaacg already posted that as a separate solution, so I don't think it's worth editing this one, given how it's a rather different approach.

Ah, didn't see that, sorry!

C (gcc), 18 bytes
f(a,b){a=~-a*b-a;}

Noodle9's answer except using a= instead of return.
Try it online!

Java 8, 13 bytes
a->b->a*b-a-b

Try it online.
Explanation:
Similar as most other answers, it calculate the product minus the sum:
a->b->         // Method with two integer parameters and integer return-type
      a*b      //  Return the two parameters multiplied by each other,
         -a-b  //  after we've also subtracted both parameters from this product

Whitespace, 59 bytes
[S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   T   _Read_STDIN_as_integer][T   T   T   _Retrieve_input][S N
S _Duplicate_input][S N
S _Duplicate_input][T   N
T   T   _Read_STDIN_as_integer][T   T   T   _Retrieve_input][S N
S _Duplicate_input][S T S S T   S N
_Copy_0-based_2nd][T    S S N
_Multiply_top_two][S N
T   _Swap_top_two][T    S S T   _Subtract_top_two][S N
T   _Swap_top_two][T    S S T   _Subtract_top_two][T    N
S T _Print_as_integer_to_STDOUT]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.
Try it online (with raw spaces, tabs and new-lines only).
Explanation in pseudo-code:
Integer a = STDIN as integer
Integer b = STDIN as integer
Integer c = a * b
c = c - a - b
Print c as integer to STDOUT

Not much golfing involved, except for using the first input as heap-address for the second input, since it's guaranteed to be positive and we push it to stack right away.

Japt, 4 bytes
×-Ux

Try it here

Keg, 5 bytes
*¿¿+-

Simply a port of other answers. Uses latest github interpreter.

Excel, 12 bytes
=A1*B1-A1-B1

Same approach as other answers.

JavaScript (V8), 13 bytes
a=>b=>a*b-a-b

Try it online!
Same solution as other answers, I almost didn't post it but for once I found a question without a JS answer, so may as well. In fact this is the exact same as Kevin Cruijssen's answer, replacing Java's lambda -> with Javascript's =>. I've included a very basic testing framework in my TIO link so it does all the test cases. Most invalid inputs still execute.

Brainf*ck, 36 bytes
Cell layout: cells 1 and 2 are input, cell 3 is where the final answer is built, cell 4 is auxiliary
,->,-<[->[->+>+<<]>>[-<<+>>]<<<]>>-.

Or, with words:
,-               read a and decrement
>                move to cell 2
,-               read b and decrement
<                move back to a
 [-              while a isn't 0, decrement once and
  >              move to b (to add b to cells 3 and 4)
  [-             decrement b
   >+>+<<        add 1 to cells 3 and 4, go back to b
  ]
  >>             move to cell 4
  [-<<+>>]       copy cell 4 to cell 2 (i.e. put b again in cell 2
 <<<             move back to a
 ]
>>-.             go to cell 3, decrement and output

Try it online - this is not a link to tio.run. In this site I linked I was able to give input as \02\05 so that I could try smaller test cases, and I also get a "memory dump" to check the weird characters that were printed actually correspond to the answer.
Here, have a tio.run link as well.

AWK, 14 bytes
$0=$1*$2-$1-$2

Try it online!
Assumes input in the form of x y.

R, 11 7 bytes
a*b-a-b

Where a and b are the 2 numbers.
Thanks to Jo King for pointing out my error.

Is this actually taking input, or is a a predefined variable (which is not allowed)?

Ah good point @JoKing. I sometimes get confused with how to input the values on CG. Changed!

...I don't think this is any better is it? Now you're using two predefined variables? It should be prefixed with function(a,b) or something like that


text:
Compositional inverse of a power series
If \$f(x) = x + \sum_{i>1} a_ix^i\$ and \$g(x)=x+\sum_{i>1}b_ix^i\$ then there is a composite power series \$f(g(x))\$ also of this form. Given a power series \$f\$ the goal is to find a compositional inverse \$f^{-1}\$ so that \$f(f^{-1}(x))=x\$.
One approach to this is recursive: start with a guess \$g_1(x)=x\$ for the inverse. Suppose that \$f(g_{n-1}(x))=x+c_{n}x^n + O(x^{n+1})\$. Then set \$g_n(x)=g_{n-1}(x)-c_nx^n\$. Then \$f^{-1}=\lim_{n\to\infty}g_n\$. (The sequence \$g_n\$ is convergent in the power series norm so this limit is well defined.)
A second approach is to use the Lagrange inversion formula, which says that \$f^{-1}(x)=\sum b_ix^i\$ where
\$\displaystyle \qquad \qquad \qquad \qquad \qquad \qquad\,\,\,\,\,\,\, b_i=\frac{1}{n!}\frac{d^{n-1}}{dw^{n-1}}\left(\frac{w}{f(w)}\right)^n\$.
Task
Input: A list of integers \$[a_2, a_3,..., a_n]\$
Output: A list of integers \$[b_2,\ldots, b_n]\$ such that if
\$\displaystyle \qquad \qquad \qquad \qquad \qquad \qquad f(x)=x+\sum_{i=2}^n a_ix^i\$
and
\$\displaystyle \qquad \qquad \qquad \qquad \qquad \qquad g(x)=x+\sum_{i=2}^n b_ix^i\$
then
\$\displaystyle \qquad \qquad \qquad \qquad \qquad \,\,\,\,f(g(x))=x+O(x^{n+1})\$
You may alternatively accept input in whatever other format is most convenient. If you wish to accept an input list padded like \$[0, 1, a_2,\ldots,a_n]\$ or like \$[1,a_2,\ldots, a_n]\$ that is acceptable. If you wish to pad the output in either of these ways that is acceptable too.
Scoring
This is code golf so shortest answer in bytes wins.
Test cases
[0, 0, 0, 0, 0] => [0, 0, 0, 0, 0]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1] => [-1, 1, -1, 1, -1, 1, -1, 1, -1, 1]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] => [-1, 0, 2, -2, -5, 14, 5, -72, 68,
  278]
[2, 3, 4, 5, 6, 7, 8, 9, 10] => [-2, 5, -14, 42, -132, 429, -1430, 4862, -16796, 58797]
[1, 4, 9, 16, 25, 36] => [-1, -2, 6, 16, -67, -164]
[0, 0, 2, -4, 2, 3] => [0, 0, -2, 4, -2, 13]
[1, 2, -5, 1, 4, -5] => [-1, 0, 10, -47, 87, 333]
[2, 1, 0, 4, -3, -1] => [-2, 7, -30, 139, -669, 3285]


text:
Print out execution time of program
Challenge
Write a complete program that prints out the time it took to execute a certain part of itself. That part must include a process whose total number of operations (and therefore execution time) is dependent on a user-substituted numeric value - this can be denoted in any way in your code (uppercase N for example) and doesn't count as a byte.
Unlike many code golf challenges, this one is a valid use case - in environments that allow executing code from command line, you may want to have a short code snippet to roughly compare performance across different systems.
Rules

Execution time is denoted as a nonnegative integer or decimal value, followed by the corresponding time unit (let's accept ns, µs/us, ms, s, m and h). A space between the number and unit is optional, more spaces are also allowed (but not newline characters).
Output must include the execution time exactly once. There can be additional text around it, as long as no part of it could be matched with the execution time itself. This allows using standard functions for timing code execution that may use various formats for printing out the execution time.
Output goes to STDOUT. Anything in STDERR is disregarded.
You can import any standard libraries before the actual code, without any cost to the total number of bytes, but you are not allowed to change the library name in the import declaration.
Do not just use sleep to control the execution time, as that does not increase the number of operations (and also doesn't work as a performance benchmark). The execution time must also depend on the user-substituted value linearly, exponentially or polynomially (before you ask, a constant polynomial doesn't count).

Scoring
This is code golf, so the shortest answer in bytes wins.
Example
This is an unnecessarily long program written in Python:
import time

start_time = time.time()

for i in range(N):
    pass

end_time = time.time()

print("%fs" % (end_time - start_time))

Program description:

imports the standard time library (this adds no bytes to the code size)
stores the current time in seconds
loops N times, does nothing each iteration
stores the time after the loop
prints the time difference in the correct format

Some potential examples would be great for this challenge, as that would help show people what their solution should look like.

@Jono2906 I added an example program in Python.

Rather than have N as some user substituted value, why not just say that it is given as input?

So, how can you prevent someone submit a program say sleep(n); print(n);?

@JoKing Different languages handle inputs differently. I didn't want to go into the trouble of dealing with that.

@tsh As stated in the challenge, the user-substituted parameter should control the number of performed operations, and sleep doesn't become more operations when running for longer. Also sleep(n); print(n); is wrong simply because you're not measuring the time anywhere.

Regarding input... of course different languages handle input differently? They also handle timing stuff differently, so that doesn't really seem like a valid excuse for why n can't just be input?

@JoKing Although I agree in general, I can understand why OP overruled the default I/O rules as well. Having a hard-coded input that doesn't count towards the byte-count for all answers will make the comparison of the byte-counts easier across languages. I.e., in codegolf languages input is usually implicit and strings/integers are interchangeable, so for those languages it doesn't matter at all whether it's input or hard-coded. But for let's say Java, I'd have to read STDIN as String and convert that string to an integer, increasing the byte-count and distracting from the actual challenge.

Having said that, I agree it's better to use an actual input next time, since it's the default. Hard-coded inputs aren't allowed by default. So for next challenges I would indeed advice to follow @JoKing's suggestion and just having input. But for this challenge (considering the amount of answers) I would just leave it as hardcoded (non-counting) $n$ for now.

Zsh, 14(?) bytes
If N is substituted in place of $1 (as described in the prompt), then 14 bytes. If N is given as an argument, then 16 bytes.

time (: {0..$1})

Try it online!
Uses the builtin time (you can verify that this is a Zsh builtin: run type time). The time to expand the brace expansion increases with the input.
You might think to use time sleep $1, but sleep is an external program, not pure Zsh.

APL (Dyalog Unicode), 12 bytesSBCS
Full program. Returns elapsed time in seconds, followed an "s". Runtime on TIO is roughly linear with N, with a coefficient of about 6×10-10. Uses the dfns library, but per OP, import isn't counted.
's',⍨cmpx'⍳N'

Try it online!
'⍳N' expression generating the ɩntegers 1 through N
cmpx time the execution of that expression
's',⍨ append "s"

It seems to me that DeLay does not increase the number of performed operations.

@VojtěchStrnad OK, it now performs N sleep operations of 1 second each.

This now adheres to the challenge, however there is no need to use sleep. Isn't there a shorter way to perform N operations?

@VojtěchStrnad There certainly is a shorter way to perform N operations, but we also need to time these operations, and the sleep function has the benefit of coming with a built-in timing.

@VojtěchStrnad OK, now it actually does something (counting) and uses a library function to time it.

R, 29 28 bytes
cat(system.time(!1:9e6)[3],"s")

Try it online!
A full program printing the number of seconds elapsed complete with unit. The 9e6 is not counted per the rules and can be replaced with any other number. Thanks to @RobinRyder for saving a byte!
An alternative would be paste(system.time(!1:9e6),"s"), but this also prints our four other times (the correct one is in the middle).

Putting the program to sleep does not increase the number of operations. The idea behind this is to benchmark system performance, which this program does not.

@VojtěchStrnad I thought the key was the timing of execution, rather than what was done. Anyway, I’ve changed it to multiplying a sequence of integers by 2, which still scales with N and has the advantage of being shorter.

Excellent! I can't tell if this could be improved, but it looks really good.

To elaborate on what you wrote, yes, the key really is timing the execution. However there really is no point in timing a program whose running time you pretty much know already (when using sleep).

!1:9e6 would also work for -1 byte.

J, 16 14 19 bytes (20 - 1 for N)
echo's',~":6!:2'i.N'

Try it online!
-2 bytes thanks to Adam -- after looking at his answer I realized I didn't need to sum the integers, just generate them
+6 bytes thanks to Adam for pointing out I missed the unit
Generates the integers 0..N-1, times it, and prints it to stdout.  's',~ prepends the unit s for seconds.

you need to print a unit

05AB1E, 12 10 bytes
ƒžc})¥O's«

-2 bytes thanks to @ExpiredData.
Either add the \$n\$ as leading portion (i.e. 100ƒžc})¥O's«) or simply use \$n\$ as STDIN input.
Outputs the execution time in whole seconds (without space).
Try it online.
Explanation:
ƒ            # Loop in the range [0, n]:
 žd          #  Push the current time in seconds
   })        # After the loop: wrap all values on the stack into a list
     ¥       # Get the deltas (paired differences) of this list
      O      # And sum those (to get the difference between the first and last times)
       's«  '# And append a trailing "s" (without space)
             # (after which this is output implicitly to STDOUT)

how about this?

Also, can we save a byte by timing it in seconds instead? Try it online!

@ExpiredData Smart, thanks! :)

PowerShell, 38 bytes
param($n)$a={1..$n};Measure-Command $a

Try it online!

You can eliminate var $a Try it online! and use some golf trick Try it online!

Python 2.7 - 32 bytes
print timeit.timeit(number=N),'s'

We can take advantage of the different scoring rules here. timeit.timeit has been in the standard library since 2.6, so we get to ignore the import timeit and hence 14 bytes that would have cost.
timeit is designed to be able to take a statement for execution as a parameter, but has a default of pass. So the pass statement will be executed N times, and that is what will be timed.

Raku (18 or 25)
Depending on one's definition of a "standard" library for Raku...
use Timer; # uncounted import line
say timer {[+] ^N}

or
[+] ^N;say now -BEGIN now
$/=now;[+] ^N;say now -$/

[+] ^N sums all numbers from 0 to N, so the bigger it gets, the more ops it does.  The now - BEGIN now bit is a common idiom in Raku that virtually makes such libraries unnecessary (the phaserless alternative is as long or longer).

C (gcc), 59 bytes
main(c,a){a=clock();for(c=100;c--;);printf("%dus",clock()-a);}

Try it online!

Java 5/6, 99 98 78 bytes
import static java.lang.System.*;
enum A{A;{long s=nanoTime();for(int i=#;i-->0;);out.print(nanoTime()-s+"ns");}}

Loops the given \$n\$ amount of times without doing anything in the loop body.
Java 11, 128 122 121 101 bytes
import static java.lang.System.*;
interface M{static void main(String[]a){var s=nanoTime();"x".repeat(#);out.print(nanoTime()-s+"ns");}}

Creates a String of \$n\$ amount of "x" with the Java 11 String#repeat(int) builtin.
Try it online.
In both programs, replace the # for the actual number.
And both will output the execution time in nanoseconds (without space).
-20 bytes thanks to @Holger for remembering me to (ab)use the rule "You can import any standard libraries before the actual code, without any cost to the total number of bytes, but you are not allowed to change the library name in the import declaration." by using a static import for System.

Doesn’t “you can import any standard libraries before the actual code” of the challenge imply that you could use import static java.lang.System.*;? Then, you don’t need the System S=null; trick.

@Holger Ah, good call. Thanks!

SAS, 37 bytes
option stimer;data;do i=1to N;end;run;

This increments a loop counter i and outputs the final value N to a SAS dataset. This is not optimised out, so the run time is linearly dependent on N.

Wolfram Language (Mathematica), 40 29 28 26 bytes
First@Timing@Do[,N]~Print~s

Try it online!
Replace N with number of times to do the operation. Does null N times (doing nothing is an operation in this case, as you can observe by increasing N and time increases).

MathGolf, 10 9 (or 12?) bytes
{t}]│Σûms

With \$n\$ as STDIN input.
Try it online.
If this is not allowed, it would be 3 bytes longer instead:
"#"i{t}]│Σûms

Where the # is replaced with the integer \$n\$ (i.e. "100"i{t}]│Σûms).
Try it online.
Both answers output the execution time in milliseconds without space.
Explanation:
Uses a similar approach as my 05AB1E answer.
               #  Use the (implicit) input-integer
               # Or alternatively:
"#"            #  Push the integer-string
   i           #  And convert it from a string to an integer
    { }        # Loop that many times
     t         # Push the current timestamp in milliseconds
       ]       # After the loop, wrap all times in a list
        |      # Get the forward differences of this list
         Σ     # Sum those differences
          ûms  # Push the string "ms"
               # (after which the entire stack joined together is output implicitly)

NOTE: Simply using 100 instead of "100" would add three digits (1,0,0) to the stack instead, which is why I have to do the "100"i to make it universal for all possible \$n\$.
]│Σ could alternatively be ⌐-Þ for the same byte-count: Try it online.
       ⌐        # Rotate all values on the stack clockwise
        -       # Subtract the top two values on the stack
         Þ      # Discard everything from the stack, except for the top item

"#" doesn't count as bytes anyway: That part must include a process whose total number of operations (and therefore execution time) is dependent on a user-substituted numeric value - this can be denoted in any way in your code (uppercase N for example) and doesn't count as a byte.

PHP, 62 bytes
<?php $t=microtime(1);for(;$i<N;$i++);echo microtime(1)-$t.'s';

Try it online!
This is my first try in codeGolf, hope I get this right!
Some explanations:

microtime(true) gets timestamp in seconds as a float with the precision of microseconds
taking advatange that errors are discarded, so $i is not initialized
using automatic type conversions

Welcome to the site.  How is input taken for this program?

That part must include a process whose total number of operations (and therefore execution time) is dependent on a user-substituted numeric value - this can be denoted in any way in your code (uppercase N for example) and doesn't count as a byte. -- seems like input can be hardcoded.


text:
Smallest number such that concatenation is a square
Challenge
Write a program or function that takes a number \$n\$ and returns the smallest \$k\$ such that concatenation \$n'k\$ is a square. This sequence is described by A071176 on the OEIS.
I/O Examples
input --> output

1   -->    6 (4^2)
10  -->    0 (10^2)
35  -->  344 (188^2)
164 -->  836 (406^2)
284 --> 2596 (1686^2)

Rules

Input will always be a positive decimal integer
Output will be a positive decimal integer with no leading 0's or 0
Standard I/O rules apply
No standard loopholes
This is code-golf, so shortest code in bytes wins

I think your answer for 164 may be incorrect.   Why 405^2 = 164025, making the answer 025, no?

@Xcali I banged my head on the desk about that one too, but it's what oeis.org says is right. I believe the mathematical definition of concatenation doesn't allow for leading 0's...

OK, then.  It makes my code shorter to ignore the leading 0s anyway.

Despite not being able to find a 'mathematical' definition of concatenation, it does certainly seem as if leading 0's aren't allowed. I'll update the question to clarify this.

@640KB interesting that from that list 49 00, 64 00  and 81 00 are not allowed but 10 0 is. It seems 0 is allowed but a zero with additional leading zeros is not.

I think that would be because 0 is still a number, and so the 'no leading zeroes' rule still applies, even if the number is already 0 @LevelRiverSt

Ah yes of course, my bad @Noodle9

05AB1E, 7 bytes
∞<.Δ«Å²

Try it online or verify all test cases.
05AB1E (legacy), 8 bytes
[N«Å²#}N

Try it online or verify all test cases.
Alternative 8-byter which works in both 05AB1E versions (credit to @Grimmy):
[N«Å²iNq

Try it online (no test suite due to the program terminate q).
Explanation:
∞         # Push an infinite list in the range [1, ...]
 <        # Decrease each by 1 to make the range [0, ...]
  .Δ      # Find the first value which is truthy for:
    «     #  Concat the value to the (implicit) input-integer
     Å²   #  And check whether it is a square number
          # (after which this found first value is output implicitly as result)

[         # Start an infinite loop:
 N«       #  Concat the 0-based loop index to the (implicit) input-integer
   Å²     #  If it's a square number:
     #    #   Stop the infinite loop
}N        # After the infinite loop has stopped: push the last index
          # (after which this found index is output implicitly as result)

[         # Start an infinite loop:
 N«       #  Concat the 0-based loop index to the (implicit) input-integer
   Å²i    #  If it's a square number:
      N   #   Push the index again
       q  #   And terminate the program
          #   (after which this index is output implicitly as result)

The legacy version didn't had the ∞ builtin, and in the new version it isn't possible to push the last index N after a loop is terminated, which is why I decided to post both solutions.

Modern 6 with Δ«Å²Nα.

Actually my suggested 6 fails for 183673469387755102041 (yes this is the smallest counter-example I could find).

@Grimmy I was actually trying to find a counter example where n concatted with n in the first iteration would be square, but my test program timed out. That's unfortunate, but still very original approach!

@Grimmy: I'm not sure what your program does precisely, but it seems to me 13223140496 might be a smaller counterexample, as I expect an answer of 9685186064?

@A.Rex Indeed, any number that is a square when concatenated to itself will be a counter-example. Those are fairly rare.

J, 27 21 bytes
(]+0<1|2%:,&.":)^:_&0

Try it online!
-6 bytes thanks to FrownyFrog

( )^:_ invoke the verb in parens continuously until it's output stops changing
&0 set the right argument -- the one that will change each iteration -- to 0 (the left argument, the input, will remain fixed)

Now let's break down what's in the parens

]+ the right arg plus...
0< 0 or 1, depending on if 0 is less than...
1| the reminder when 1 divides...
2%: the square root of...
,&.": the left arg (original input) catted with , the right arg "under" &. stringification ":: ie, turn them both into strings, cat them, then convert back to an int

Perl 6, 23 bytes
{(0...($_~*)**.5%%1)-1}

Try it online!
Explanation
{                     }  # Anonymous codeblock
 (0...             )-1   # Find the first number
      ($_~*)             # That when appended to the input
            **.5         # Has a sqrt
                %%1      # That is whole

JavaScript (ES7), 33 bytes
Takes input as a string.
f=(n,k=0)=>(n+k)**.5%1?f(n,k+1):k

Try it online!

R, 45 bytes
n=scan();while((paste0(n,+F):1)^.5%%1)F=F+1;F

Try it online!
Throws a warning for each iteration noting that it only uses the first element of the vector as a loop condition. This will run out of space for large inputs since it constructs a vector of length \$n'k\$ at each iteration; this version will work for larger inputs and should be a bit faster, at a cost of 4 bytes.

This doesn't seem to be working on the first two test cases. n=1 is returning 44, n=10 is returning 89.

@ThomasMarkov if you're running them sequentially in a single session, the global variable F won't be reset properly.

Perl 5 -pal, 30 bytes
$_=0;$_++while"@F$_"**.5=~/\./

Try it online!

It's worth noting that since this relies on Perl's default print formatting of floating point numbers, the smallest input it fails with is 2026559 → 23218529 (even though Perl does use IEEE 754, thus would be able to handle all inputs less than 20256971 with a non-typographical "is integer?" test such as $x-int($x)). Not saying it needs changing, just noting the issue.

Nice answer! I didn't have **.5 in my brief attempt just now, which means you can get to 28 bytes using $\ : Try it online!

C, 123 115 bytes (thanks, Jo King!)
n,k,m=10,x,p;main(){scanf("%d",&n);for(;k<m||(m*=10);++k)for(p=0;x=n*m+k,p<=x;++p)if(p*p==x)return printf("%d",k);}

I noticed this version can fail on not-very-large inputs due to integer overflow. So I, did a separate version, with less overflow.
C, less overflow. 117 bytes
n,k,m=10,x,p;main(){scanf("%d",&n);for(;k<m||(m*=10);++k)for(p=0;x=n*m+k,p*p<=x;++p)if(p*p==x)return printf("%d",k);}

Pretty Printed:
n, k, m = 10, x, p;
main() {
    scanf("%d", &n);
    for (; k < m || (m *= 10); ++k)
        for (p = 0; x = n * m + k, p * p <= x; ++p)
            if (p * p == x)
                return printf("%d", k);
}

I think your byte count is 123, not 124. I assume it's a trailing newline thing; can you double check to see if it compiles correctly without it (if present)? It worked for me on TIO but I'm not sure if they insert trailing newlines for you there. Try it online!

@ValueInk ah yes. I had just checked the file size but it turns out my editor had inserted a trailing newline (which is not necessary in modern C). Thanks

@JoKing I tried implementing those tweaks without looking at your code but couldn't squeeze as much. I did get rid of the goto though. Thank you!

Basically, you can move the increment from the third part to the second part for both for loops. Oh, and you can also change the <= to just <

89 bytes

106 bytes

I like that your "less overflow" version is only 2 bytes longer; it's faster, too. Given that the 115 byte one fails at very small numbers: 218, 244, 245, 248, 254, 255, 279, 283, 284 (challenge-provided test case), 294, 296, 307, 308, 325, 333, 347, 354, 365, 366, and so on, I think maybe you should remove the 115 byte one and leave the 117 byte one as primary. (It of course still fails at 20737, but that's fine, as it must do so with a signed 32-bit int.)

C++ (clang), 194 \$\cdots\$ 128 129 bytes
#import<string>
#define z std::to_string
int f(int n){for(int j=-1;;)for(long i=0,m=stol(z(n)+z(++j));i++<m;)if(i*i==m)return j;}

Try it online!
Added a byte to fix overflow error kindly pointed out by Deadcode.

This fails (gives an incorrect answer) with many very small numbers: 218, 244, 245, 248, 254, 255, 279, 283, 284 (a test case provided by the challenge itself), 294, 296, 307, 308, 325, 333, 347, 354, 365, 366, and so on, due to integer overflow.

@Deadcode Fix that - thanks! :-)

Wow, very cool that clang has 64-bit long. I didn't know that! Some other dialects of C++ only have 32-bit long and require you to use long long to get 64 bits...

@Deadcode Yeah, clang gives very good mileage per byte! :))))

Python 2, 47 49 bytes
f=lambda p,i=0:int(`p`+`i`)**.5%1and f(p,i+1)or i

Try it online!

Brachylog, 8 bytes
;.c~^₂∧ℕ

Sadly enough it takes 3 bytes to check if a number is square and an extra ℕ is needed if the input is a square itself.
Explanation
;.c~^₂∧ℕ     # Find a value
;.c          #   that concatenate to the input
   ~^₂       #     gives a square number
      ∧ℕ     # and make sure that value is a number
             #   (otherwise we get the empty list for inputs that are square)

Try it online!

Python 3, 51 bytes
f=lambda n,i=0:int(f'{n}{i}')**.5%1and f(n,i+1)or i

Try it online!

This doesn't work for all of the test #s. 284 results in the recursion depth being exceeded.

I think it's standard to assume unlimited recursion depth in Python answers.

Ruby -pl, 43 bytes
i=1;i+=1until"#{i*i}"[/^#$_(?!0.|$)/]
$_=$'

Try it online!
Tests each square until it finds one that starts with the input and is followed by a number with no leading zero. I thought going in this direction rather than the more natural one would be shorter, but now I'm doubting that it is.

"...but now I'm doubting that it is." Well, after tons of searching I couldn't find anything shorter that works on TIO (which runs Ruby 2.5.5). I think $_=(?0..).find{|i|eval($_+i)**0.5%1==0} works on 2.6 for 39 bytes (remove |i| and replace i with @1 in 2.7 for 37 bytes) but I'm having trouble installing those versions on my machine.

Found a 42 byte solution that's TIO compatible using this technique. Try it online!

Pyth, 35 33 30 23 21 bytes
This is a program that uses only integer arithmetic. Since Python has arbitrary-precision integers, this is guaranteed to work for arbitrarily large numbers, whereas the square-root test used by most of the other answers fails with numbers greater than 252, having false positives with numbers very close to a perfect square.
Assumes that the input has no leading zeroes.
 f&J>K`*TTlzq+z`sJK)J

Try it online!
The leading space is needed to suppress printout of the value of T that resulted in loop termination, since f returns that value.
Ungolfed:
z = input()
for T in __import__('itertools').count(1):
    K = str(T*T);
    J = K[len(z):]
    if len(J)!=0 and z+str(int(J))==K:
        break
print(J)

Packed Pyth, 19 bytes
Hex dump: 41 99 34 A7  D2 F0 2A A9  53 67 AE 2A  FD 60 E7 2A  5A 99 40
Try it online!

Pyth, 18 16 15 11 10 bytes
Uses the floating point square root test, like most of the other answers. As such, the precision is eventually insufficient, and the smallest square it fails with is 4503599761588225 – with an input of 45035997, it returns 61588224 instead of 61588225 as it should. The smallest input it fails with is 20256971, returning 228498166 instead of 228498169 as it should. This is due to IEEE 754 floating point not being able to store precise integers greater than 252.
fsI@s+zT2Z

Try it online!
Ungolfed:
z = input()
Z = 0
for T in __import__('itertools').count(Z):
  tmp = int(z + str(T))**0.5
  if int(tmp) == tmp:
    print(T)
    break

Token by token explanation:
fsI@s+zT2Z
f            # (Implicitly print) First value of T for which the following is true:
         Z   # where T iterates over [Z, Z+1, Z+2, ...] with Z=0
     +zT     # the (string, since one of them is a string) concatenation of z and T
    s        # Converted from string to integer
   @    2    # To the 1/2 power
 sI          # is Invariant under floor conversion to integer

Packed Pyth, 9 bytes
Hex dump: CD CE 4C 0E 6A FD 54 65 68
Try it online!

Burlesque, 28 bytes
sajpsq~!_+2R@)S[jfeupjq[-jE!

Try it online!
Pretty sure this could be shorter, a lot of work is trying to drop N letters.
sa       #Find the length of the input to know how many characters to drop
j        #Put at bottom
ps       #Parse the string to {int}
q~!      #Boxed "starts with"
_+       #Concatenate to make {int !~} "starts with int"
2R@      # 2...inf
)S[      #Infinite list of squares
jfe      #Find an element that starts with int
up       #Turn int to string
jq[-jE!  #Drop (length of int) characters leaving the tail

Ah, accidentally removed the "up" while trying to shorten it.

Japt, 10 bytes
@s+X ¬v1}a

Try it

PHP, 53 47 44 bytes
for($k=-1;fmod(sqrt($argn.++$k),1););echo$k;

Try it online!

Nice +1. I have much to learn.

It's only a crumb, but can't you start $k at 0?

@GuillermoPhillips yeah, but if you start at 0 you have to do echo$k-1 at the end which is actually 1 byte more.  Similarly $k-- doesn't work since you can't  decrement NULL (though oddly you can increment it).  The value of $k has to be 0 the first time through, or else the 10 test case will fail... good thought though!

Why $argn? Just use $a and then you will save 3 bytes.

@Kerkouch How does $a work as input? Unless you're suggesting using a predefined variable, which is not allowed

You're right, I did forget that this script is meant to be run on the command line.

Japt, 10 bytes
_siU ¬%1}f

Saved a byte thanks to @AZTECCO
Try it

10 : https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LW0gLVI&code=X3NpVSCsJTF9Zg&input=WzEsMTAsMzUsMTY0LDI4NF0

K (ngn/k), 21 19 bytes
-2 bytes from @ovs's simplification
{(1!%.,/$x,)(1+)/0}

Try it online!

(cond)(code)/seed set up a while-reduce, seeded with 0, running the (code) clause until the (cond) clause returns a non-truthy value

(1+) code that increments its input
(1!%.,/$x,) the condition/check

.,/$x, append the current iteration value to the original input, convert each to a string, combine them, and eval the result (this converts the result to an integer)
1!% check if the remainder of the square root of the iteration value is non-zero

I think you can drop the ~~

Yep, nice simplification! (It works because the (cond) does a "truthiness" check versus requiring explicit 1's/0's)

JavaScript (Node.js), 38 Bytes
Try it Online!
f=(a,b=[0])=>(a+b)**.5%1?f(a,[++b]):+b

Jelly, 8 bytes
0ṭVÆ²ɗ1#

Try it online!
A monadic link taking as its argument an integer and returning an integer.
Explanation
0    ɗ1# | Starting with zero, find 1 integer where the following is true as a dyad, using the original argument as the right argument
 ṭ       | - Tag onto the end
  V      | - Evaluate after converting to string and concatenating
   Æ²    | - Check if perfect square

How do you learn this? I'm trying to learn jelly but I can't seem to figure it out. I tried breaking down your code but the symbol ɗ doen't even appear on the atoms page on github

Perl 5, 35 40 bytes
$k=0;L:$_="$n$k"**.5;!/\./ or$k++,goto L

Try it online!

Your $k=0 clause needs to be part of your code/byte count since it is absolutely necessary for getting the correct answer for the 10 input.

@Xcali Fair point; fixed. Thanks for catching it.

Neat technique there. It's worth noting that since this relies on Perl's default print formatting of floating point numbers, the smallest input it fails with is 2026559 → 23218529 (even though Perl does use IEEE 754, thus would be able to handle all inputs less than 20256971 with a non-typographical "is integer?" test such as $x-int($x)). Not saying it needs changing, just noting the issue.

@Deadcode Good catch, thanks!

cQuents, 13 bytes
#|1:#bA~N
?$$

Try it online!
Explanation
#|1         output nth element in sequence (remove to output indefinitely)
   :        mode: sequence, output nth element in sequence
    #       conditional: count N up, when true, add to sequence
     b      call second line, passing
      A~N                             input concatenated to N

?$$         second line - sequence of squares - return true if a square and false if not

Charcoal, 16 bytes
≔⁰ηＷ﹪₂Ｉ⁺θη¹≦⊕ηＩη

Try it online! Link is to verbose version of code. Explanation:
≔⁰η

Initialise the result to zero.
Ｗ﹪₂Ｉ⁺θη¹

Repeat until the concatenation is a square.
≦⊕η

Increment the result.
Ｉη

Output the result.
36 bytes for an efficient solution:
≔×χＮη

Try it online! Link is to verbose version of code. Explanation:
Multiply the input by 10.
≧⁺›₂η⌊₂ηη

Increment it unless it is already a square number.
Ｗ⌕ＩＸ⌈₂η²θ

Repeat until the square ceiling square root begins with the original input.
≧×χ

Multiply by 10.
η✂ＩＸ⌈₂η²Ｌθ

Output the suffix of the square ceiling square root.

GolfScript, 24 bytes
I don't feel right to have a Burlesque answer without a GolfScript answer.(Please don't mind if this is a little bit slow, although they seem to produce the right result.)
-1{).2$\+~.),{.*}%?)!}do

Try it online!
Explanation
-1                       # The counter for the current number (it is >= 0)
  {                      # Do at least 1 time until the number is a square number
   )                     #     Increment the counter

    .                    #     Copy the counter (to create an integer)
     2$                  #     Extract the 3rd-to-top to the top
       \                 #     Make sure that the casting to string works
        +                #     Join the numbers, as well as converting the
                         #     right operand to a string (input+count)
         ~               #     Evaluate the string to get a number

          .              #     Copy the number for the square number check
           ),            #     Generate range from 0 to the number
             {.*}%       #     Apply square for every number
                  ?      #     Find out where the number is inside the sequence
                         #     (yields -1 for nonexistent)

                   )     #     Increment, to make nonexistent false and others true
                    !    #     Negate, which means we shouldn't find the first non-square number.
                     }do # End do loop, use TOS as condition

                         # Output the counter at the end
```

AWK, 29 bytes
{while(($0x++)^.5%1);$0=x-1}1

Works with mawk, gawk and nawk on macOS and Ubuntu but not with TiO for some reason.

I also don't know why this happens, but I have faced this kind of error before. I managed to bypass it by assigning the result to $1 instead of $0, like this: {while(($0x++)^.5%1);$1=x-1}1. Try it online!

RProgN 2, 13 bytes
x={x\.nš1%¬}é

Explanation
x={x\.nš1%¬}é   #
x=              # Set 'x' to the input.
  {        }é   # Run the enclosed function with raising integers untill it returns truthy, and spit out that number
   x\.          # Place the input under the current number and concatenate them together
      nš        # Convert to a number and get the square root
        1%¬     # Is this a whole number?

Try it online!

Java, 75 63 61 bytes
Two bytes less thanks to Kevin Cruijssen.
And another two less in the second version again thanks to Kevin Cruijssen!
n->{int j=0;for(;Math.sqrt(new Long(n+j))%1>0;j++);return j;}

Try it online!
I also have another version with my first (and very different) approach, which is 107 92 93 91 bytes long:
n->{String a;for(long i=4;!(a=i*i+++"").matches(n+"([1-9].*|0)"););return a.split(n,2)[1];}

Try it online!
Both version have been tested against the first 10000 numbers.

You can remove the parenthesis surrounding Math.sqrt(new Long(n+j))%1 to save 2 bytes.

@KevinCruijssen True! In an initial version I needed them, but while refactoring I didn't realise I could remove them. Thanks!

Np. Btw, in your second version you can also save 2 bytes: 1 by changing long i=4;String a;while(...); to String a;for(long i=4;...;); to save on the semi-colon, and 1 by removing the + in your regex, since the .* already covers this. Nice answer, btw! And welcome to CGCC! :)

@KevinCruijssen Thanks again! I totally missed the long inside the for hack. And again the "+" was becuase of a previous version in which I didn't have the ".*|0" part, but whitout that part I didn't cover for the f(10) -> 0 case correctly and other solution with a 0 in them , but when I added it I didn't realise the "+" wasn't necessary any more. Really nice catch :).

PHP, 83 86 bytes
g:substr($k=$i*++$i,0,$l=strlen($n=$argn))==$n&&("$k")[$l]&&die(substr($k,$l));goto g;

Try it online!
-9 bytes thanks to @640KB and bugs fixed (+12). Only fails for case 10 currently.
Ungolfed
<?php

$number=$argv[1];
$len = strlen($number);
$i=0;
do {
    $k = $i*$i;
    if (substr($k,0,$len)==$number && substr($k,$len,1)!='0') {
        die(substr($k,$len));
    }
    $i++;
} while (true);

?>

Try it online!

Love the goto - will have to try to use that sometime!  Good news is that you don't have to include the opening <?php  in your byte count so this would only be 79 bytes. Bad news is that this answer fails for test cases 1, 164 and 284.

Thanks, g:goto g; is the same cost as for(;;){}, but I'm a rebel! I will have to tame those pesky leading zeros.

My first version was very similar to yours and I ran into the exact same problems, so I ended up scrapping it and doing it a different way. That's how it goes sometimes!

Haskell, 93 88 bytes
[j|i<-(show.(^2))<$>[0..],i/=n,n`isPrefixOf`i,j<-[drop(length n)i],j=="0"||j!!0/='0']!!0

Try it online!

Welcome to the site!  head can be shorter done as !!0.

Additionally your map could be <$> which would remove needing for the parentheses and save two bytes.

And just one more if you are in a list comprehension x<-[s] is a byte shorter than let x=s

@PostRockGarfHunter Thanks; updated! I wish I had a more elegant way to write the hideous j=="0"||j!!0/='0'.

How about j==show(read j)

Lua, 96 bytes
n=io.read()i=0 while i do for j=0,n..i do if (n..i)+0==j*j then print(i)return end end i=i+1 end

Try it online!

Vyxal, 6 bytes
≬?p∆²ṅ

Try it Online!
≬    ṅ # Find the first number where...
 ?p    # Prepending the input
   ∆²  # Produces a square?

Vyxal's square function uses sympy.ntheory.primetest.is_square, which works on arbitrary ints, so this won't fail on float precision.

brev, 71 bytes
(define((s k)n)(if(integer?(sqrt((as-string conc)n k)))k((s(+ k 1))n)))

Test:
(map (s 0) '(1 10 35 164 284))
=> (6 0 344 836 2596)


text:
Cutting Sequence for N dimensions
Inputs:
The program or function should take 2 vector-like (e.g. a list of numbers) O and V  of the same number of dimensions, and a number T (all floating-point numbers or similar)
Constraints:

T >= 0
All elements of Vector O will be in the range [0,1)

Output:
The program or function should output the N dimensional cutting sequence given an infinite ray whose origin is the first vector, and whose velocity is the second vector.  The sequence should include every cut the ray makes on the time interval (0, T], appearing in order of when they occur.  Details on the format and specification of the sequence are explained below
Cutting sequence
In a N dimensional Cartesian coordinate system, there exist axis-aligned unit coordinate facets, e.g. the integer points on a 1 dimensional number line, the unit grid lines on a 2D grid, planes like x = 1, z =- 10 or y = 0 in 3D space.  As this problem is generalized to N dimensions, from here forward we will no longer use lettered axes, but instead number the axes starting with 0.  Every facet can be defined by some equation like Axis j = k, where j and k are integers, and j is the characteristic axis of the facet.
As the ray extends through N dimensional space, it intersects these facets. This is called a cut.  Each of these cuts is described by 2 things.

The characteristic axis of the facet.
The direction of the cut, i.e. whether the ray extending positively or negatively with respect to the characteristic axis.

Hence each cut shall be outputted in the sequence as a string of a plus or minus sign corresponding to the direction of the cut, then the number (base 10) of the characteristic axis of the cut facet.
The sequence will be outputted as a continuous string of these cuts, e.g. +0+1+0+0+1-2+0
Examples

This image from the Wikipedia page for Cutting Sequence shows a 2D example. This is equivalent to O=[0,0] V=[1,0.618] T = 6.5, where the output is +0+1+0+0+1+0+1+0+0+1
For 1 dimension, all non-empty cutting sequences will look like +0+0+0... or -0-0-0...
More examples / test cases to be added
Special cases

If two or more cuts occur at exactly the same time (to the precision
of your numeric type), they must appear in the sequence in order of their axis from least to greatest
Your program should be accurate for extreme input values

e.g. for V=[1, -0.0009765625], the sequence will have a repeating pattern of +0 1024 times and then a -1.  This pattern should hold exactly for arbitrarily large values of T

Your program must always output a sequence, e.g.

If Vector V has a length 0, the program should not loop indefinitely, but output an empty sequence.
If the inputs are of 0 dimensions, the program should output an empty sequence

Your program should be accurate for extreme input values : what does this concretely mean? Your example with -0.0009765625 is likely to work in most languages as it is a power of $2$. But arbitrary floating point values will inexorably lead to floating point accuracy errors, unless the challenge is limited to languages that support arbitrary precision.

@Arnauld due to the fact that the problem is concerned with a regular grid of n-dimensional hypercubes, outputs will be theoretically identical for starting conditions that have the some offset with respect to the hypercube that contains them, hence the 2nd input constraint.  This also means that with any valid starting condition, you can always re-base your coordinates to equivalent small values that give you a comfortable amount of precision.  If you don't do that, your program is liable to become increasingly inaccurate as T gets larger

If I understand your comment correctly, the values we calculate will have a somewhat similar precision as the input precision (so 1e-10 / 0.0000000001 in case of -0.0009765625). But even if this indeed is true, I think @Arnauld is also asking whether the precision of this input can have a larger precision than the default of most languages (i.e. Java has a double/float precision of 16, so a value like 0.123456789123456789123456789 would actually be 0.12345678912345678). Java also has BigDecimal as arbitrary alternative, but most languages won't be able to exceed a precision of 16.

So can the precision of the input-values be arbitrary large as well?

Also, could you perhaps add some test cases / examples for larger dimensions (like $\geq4$)?

@KevinCruijssen your program can accept any input type you like, provided its a vector-like type of float-like numbers. The point about the inputs is that having an extreme large or small input (again, still within your chosen data-type), shouldn't affect the accuracy of your output.  It is accepted that most numeric types are not arbitrarily precise, and cannot be 100% accurate for every input case, but the program should be theoretically correct if it were run with arbitrary precision, and giving extreme inputs shouldn't make it less accurate

@HymnsForDisco Thanks, that clarifies it.

An example of an offending algorithm would be one that successively adds the ray velocity to its origin (assuming floating point). Obviously at some point as ray position becomes large, the lesser digits of the mantissa of the velocity will no longer have an effect in a floating point add of the two.  In this case, each axis will have a "stopping point", where eventually the relatively small value being added no longer results in the position float getting larger.

Related challenge, for n=2

Does this mean I win? XD

Python, 226 bytes
Assumes the lists O and V are defined, as well as the time T, either an int or a float.
Try it online
s=lambda x:int(x/abs(x));r=range;f=lambda O,V,T:"".join(map(lambda t:t[1],sorted(sum([[((i-o)/v,"%+d"%(s(v)*c))for i in r((v>0)-(v<0)*(o==0),int((o+T*v)//1)+(v>0),s(v))]for c,o,v in zip(r(len(O)),O,V)],[]),key=lambda t:t[0])))

The idea of the code is simple, first we loop over all coordinates, and for each coordinate we:

find where the first cut is, depending on the sign of v and the origin being 0 or not, the first cut might be at -1, 0 or 1;
find how far the ray goes in the time given with o + v*T (which then needs proper rounding to be an argument for the range function);
find the time t for which each successive cut occurs, by solving o + v*t = i iff t = (i - o)/v, for the successive integer values of i (this amounts to finding the time for which the ray crosses the hyperplane x_c = i);
sort everything by the time and drop the time, as it was just an auxiliary thing.

The code un-golfed:
# sign function, returns 1 for positive numbers and -1 for negative numbers
sgn = lambda x: int(x/abs(x))
l = []
# c is the coordinate we are in,
# o is the origin in this coordinate and v the velocity
for (c, o, v) in zip(range(len(O)), O, V):
    # find all the cuts for this coordinate
    sub_l = []
    # this is how far the ray goes, rounded to integers, in T seconds
    stop_at = int((o + T*v)//1) # if this is negative, //1 pushes the result away from 0
    if v > 0:
        stop_at += 1
    # this is where the first cut occurs (depends on o == 0 and the sign of v)
    if v > 0:
        start_at = 1
    elif o > 0:
        start_at = 0
    else:
        start_at = -1
    for i in range(start_at, stop_at, sgn(v)):
        # this is the time at which the ray cuts the x_c = i hyperplane
        t = (i - o)/v
        # append the time of the cut and the signed axis
        sub_l.append((t, "%+d"%(sgn(v)*c)))
    l.append(sub_l)
print(l)
# flatten list
l = sum(l, [])
# order list by the time at which the cut occurs
l.sort(key = lambda tup: tup[0])
# remove the times, keep the coordinates
l = map(lambda tup: tup[1], l)
# join and print
print("".join(l))

Then we just need to note a couple of things, like I can save some bytes if I redefine r = range or if I assign start_at = (v>0)-(v<0)*(o==0) and stop_at = int((o+T*v)//1)+(v>0).
I don't feel this is properly golfed, I just wrote a program that works and then crammed everything together. Please feel free to give me some feedback.
I used a flatten from https://stackoverflow.com/a/952946/2828287 and getting the sign of a number from https://stackoverflow.com/a/2763445/2828287

It will be interesting to see an explanation of this. One note though, I notice it fails to account for cuts in the negative direction (try a minus sign on one of the numbers in V)

@HymnsForDisco the code should work now with negative velocities. The TIO link includes your example but with V = [1, -0.618].

The standard on this site is that submissions should input either by function parameters or STDIN, and output by function return or STDOUT. They should either be programs or functions which perform the task - your code would be termed a snippet. See this meta post for more details.

@Stephen thank you for your comment. My edit should be acceptable now? I wrapped the "main code" around a lambda function. The TIO link has been updated.

@RGS yes, that's right