Integer Right Triangles

// Authored by: Tim Varley 💘
// Assisted-by: Grok Code Fast via Crush 💘 <crush@charm.land>

#include <iostream>
#include <vector>
#include <string>

int integer_right_triangles() {
    int max_count = 0;
    int best_p = 0;
    for(int p=12; p<=1000; p++) {
        int count = 0;
        for(int a=1; a<p; a++) {
            for(int b=a; b<p-a; b++) {
                int c = p - a - b;
                if(a*a + b*b == c*c) count++;
            }
        }
        if(count > max_count) {
            max_count = count;
            best_p = p;
        }
    }
    return best_p;
}

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

package org.tvarley.euler.solutions;

import org.tvarley.euler.Solution;

public class Solution039 implements Solution {
  public String solve() {
    int max = 0;
    int maxP = 0;
    for (int p = 1; p <= 1000; p++) {
      int count = 0;
      for (int a = 1; a < p; a++) {
        for (int b = a; b < p - a; b++) {
          int c = p - a - b;
          if (a * a + b * b == c * c) count++;
        }
      }
      if (count > max) {
        max = count;
        maxP = p;
      }
    }
    return Integer.toString(maxP);
  }
}

module.exports = {
  answer: () => {
    let maxCount = 0, maxP = 0;
    for (let p = 1; p <= 1000; p++) {
      let count = 0;
      for (let a = 1; a < p; a++) {
        for (let b = a; b < p - a; b++) {
          const c = p - a - b;
          if (c < b) continue;
          if (a * a + b * b === c * c) count++;
        }
      }
      if (count > maxCount) {
        maxCount = count;
        maxP = p;
      }
    }
    return maxP;
  }
};

def solve():
    """
    Integer Right Triangles
    If p is the perimeter of a right angle triangle with integral length sides, {a, b, c}, there are exactly three solutions for p = 120.

    {20,48,52}, {24,45,51}, {30,40,50}

    For which value of p ≤ 1000, is the number of solutions maximised?
    https://projecteuler.net/problem=39
    """
    max_solutions = 0
    max_p = 0
    for p in range(1, 1001):
        solutions = 0
        for a in range(1, p // 2):
            for b in range(a, (p - a) // 2):
                c = p - a - b
                if a**2 + b**2 == c**2:
                    solutions += 1
        if solutions > max_solutions:
            max_solutions = solutions
            max_p = p
    return max_p

package main

import "fmt"

func main() {
  maxCount := 0
  maxP := 0
  for p := 1; p <= 1000; p++ {
    count := 0
    for a := 1; a < p; a++ {
      for b := a; b < p-a; b++ {
        c := p - a - b
        if a*a + b*b == c*c {
          count++
        }
      }
    }
    if count > maxCount {
      maxCount = count
      maxP = p
    }
  }
  fmt.Println(maxP)
}

// Answer: 840

pub fn integer_right_triangles() -> u64 {
    let mut max_count = 0;
    let mut max_p = 0;
    for p in 1..=1000 {
        let mut count = 0;
        for a in 1..p / 2 {
            for b in a..(p - a) / 2 {
                let c = p - a - b;
                if a * a + b * b == c * c {
                    count += 1;
                }
            }
        }
        if count > max_count {
            max_count = count;
            max_p = p;
        }
    }
    max_p
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn euler_039() {
        assert_eq!(integer_right_triangles(), 840);
    }
}