Division with returning quotient and remainder

I try to migrate from Python to Golang. I currently do research some math operations and wonder about how can I get both quotient and remainder value with result of a division. I'm going to share below an equivalent of Python code.

hours, remainder = divmod(5566, 3600)
minutes, seconds = divmod(remainder, 60)
print('%s:%s' % (minutes, seconds))
# 32:46

Above will be my aim. Thanks.

Integer division plus modulus accomplishes this.

func divmod(numerator, denominator int64) (quotient, remainder int64) {
    quotient = numerator / denominator // integer division, decimals are truncated
    remainder = numerator % denominator
    return
}

https://play.golang.org/p/rimqraYE2B

Edit: Definitions

Quotient, in the context of integer division, is the number of whole times the numerator goes into the denominator. In other words, it is identical to the decimal statement: FLOOR(n/d)

Modulo gives you the remainder of such a division. The modulus of a numerator and denominator will always be between 0 and d-1 (where d is the denominator)

if you want a one-liner,

quotient, remainder := numerator/denominator, numerator%denominator

If you have a 32 bit number, you can use one of these:

package main
import "math/bits"

func main() {
   { // example 1
      var n uint = 4294967295
      q, r := bits.Div(0, n, 2)
      println(q == n / 2, r == 1)
   }
   { // example 2
      var n uint32 = 4294967295
      q, r := bits.Div32(0, n, 2)
      println(q == n / 2, r == 1)
   }
}

If you have a 64 bit number, you can do it like this:

package main
import "math/bits"

func main() {
   var n uint64 = 18446744073709551615
   q, r := bits.Div64(0, n, 2)
   println(q == n / 2, r == 1)
}

If you have something larger than 64 bit, you can do it like this:

package main
import "math/bits"

func main() {
   q, r := bits.Div64(1, 0, 2)
   println(q == 9223372036854775808, r == 0)
}

• https://golang.org/pkg/math/bits#Div
• https://golang.org/pkg/math/bits#Div32
• https://golang.org/pkg/math/bits#Div64

I did this function maybe it's what you are looking for.

//QuotientAndRemainderF32 Computes the integer quotient and the remainder of the inputs. This function rounds floor(x/y) to the nearest integer towards -inf.
func QuotientAndRemainderF32(x, y float32) (Remainder, Quotient float32) {
	Quotient = float32(math.Floor(float64(x / y)))
	Remainder = x - y*Quotient
	return Remainder, Quotient
}

I think that this question is not clear: are you looking for something equivalent to the Python divmod or just a function that returns the quotient and the reminder?

These solutions are not equivalent to the Python divmod since they return the reminder instead of the modulus. So, they do not work the same way with negative numbers.

In Python divmod(-7, 4) returns -2, 1.
The answers here return -1, 3.

My suggestion is

func DivMod(n, d int64) (q, r int64) {
	q = n / d
	r = n % d

	// the numerator or the denominator is negarive (but not both)
	if r != 0 && n*d < 0 {
		q--
		r += d
	}
	return
}