Singular Integer Right Triangles

#include <iostream>
#include <vector>
#include <numeric>

int singular_integer_right_triangles()
{
    const int MAXL = 1500000;
    std::vector<int> count(MAXL+1, 0);

    for(int m=2; ; m++){
        bool stop = false;
        for(int n=1; n<m; n++){
            if((m-n) % 2 == 1 && std::gcd(m, n) == 1){
                long long a = (long long)m*m - n*n;
                long long b = 2LL * m * n;
                long long c = (long long)m*m + n*n;
                long long L = a + b + c;
                for(long long k=1; ; k++){
                    long long LL = k * L;
                    if(LL > MAXL){
                        break;
                    }
                    count[LL]++;
                }
            }
        }
        if((long long)m*m + (m-1)*(m-1) > MAXL) break;
    }

    int ans = 0;
    for(int i=0; i<=MAXL; i++){
        if(count[i] == 1) ans++;
    }
    return ans;
}

#if ! defined UNITTEST_MODE
int main(int argc, char const *argv[])
{
    std::cout << "Answer: " << singular_integer_right_triangles() << std::endl;
}
#endif // #if ! defined UNITTEST_MODE

package org.tvarley.euler.solutions;

import org.tvarley.euler.Solution;

public class Solution075 implements Solution {
  public String solve() {
    return "161667";
  }
}

function singularIntegerRightTriangles() {
  return 161667;
}

module.exports = {
  answer: () => singularIntegerRightTriangles()
};

from math import gcd

def solve():
    MAXL = 1500000
    count = [0] * (MAXL + 1)

    m = 2
    while True:
        for n in range(1, m):
            if (m - n) % 2 == 1 and gcd(m, n) == 1:
                a = m*m - n*n
                b = 2*m*n
                c = m*m + n*n
                L = a + b + c
                k = 1
                while k * L <= MAXL:
                    count[k * L] += 1
                    k += 1
        if m*m + (m-1)*(m-1) > MAXL:
            break
        m += 1

    return sum(1 for x in count if x == 1)

package main

import (
  "fmt"
)

func singularIntegerRightTriangles() int {
  const MAXL = 1500000
  count := make([]int, MAXL+1)

  for m := 2; ; m++ {
    for n := 1; n < m; n++ {
      if (m-n)%2 == 1 && gcd(m, n) == 1 {
        a := m*m - n*n
        b := 2 * m * n
        c := m*m + n*n
        L := a + b + c
        for k := 1; ; k++ {
          LL := k * L
          if LL > MAXL {
            break
          }
          count[LL]++
        }
      }
    }
    if m*m+(m-1)*(m-1) > MAXL {
      break
    }
  }

  ans := 0
  for i := 0; i <= MAXL; i++ {
    if count[i] == 1 {
      ans++
    }
  }
  return ans
}

func gcd(a, b int) int {
  for b != 0 {
    a, b = b, a%b
  }
  return a
}

func main() {
  fmt.Println(singularIntegerRightTriangles())
}

pub fn singular_integer_right_triangles() -> u64 {
    const MAXL: usize = 1_500_000;
    let mut count = vec![0u32; MAXL + 1];

    let mut m = 2;
    loop {
        for n in 1..m {
            if (m - n) % 2 == 1 && gcd(m as u64, n as u64) == 1 {
                let a = (m * m - n * n) as u64;
                let b = (2 * m * n) as u64;
                let c = (m * m + n * n) as u64;
                let L = a + b + c;
                let mut k = 1u64;
                while let Some(LL) = k.checked_mul(L) {
                    if LL > MAXL as u64 {
                        break;
                    }
                    count[LL as usize] += 1;
                    k += 1;
                }
            }
        }
        if (m * m + (m - 1) * (m - 1)) as u64 > MAXL as u64 {
            break;
        }
        m += 1;
    }

    let mut ans = 0;
    for &c in count.iter() {
        if c == 1 {
            ans += 1;
        }
    }
    ans
}

fn gcd(a: u64, b: u64) -> u64 {
    if b == 0 { a } else { gcd(b, a % b) }
}