Maximum Path Sum II

#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>

static const char* test_data_fname_67 = "./src/euler_67_data.txt";

int maximum_path_sum_2(const char* fname)
{
  std::ifstream fin(fname);

  if( !fin.is_open()){
    std::cerr << "Failed to open input file: " << fname << std::endl;
    return -1;
  }

  std::vector<std::vector<int> > lines;

  for( std::string line ; std::getline(fin,line);){
    std::stringstream ss(line);
    std::string number;
    std::vector<int> inner;

    while (std::getline(ss,number,' ')) {
      inner.push_back(std::stoi(number));
    }
    lines.push_back(inner);
  }

  for( int i = lines.size()-1; i > 0 ; --i){
    for( int j = 0 ; j < i; j++){
      if( lines[i][j] > lines[i][j+1] ){
        lines[i-1][j] += lines[i][j];
      }else{
        lines[i-1][j] += lines[i][j+1];
      }
    }
  }

  return lines[0][0];
}

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

package org.tvarley.euler.solutions;

import org.tvarley.euler.Solution;
import java.io.*;
import java.util.*;

public class Solution067 implements Solution {
  public String solve() {
    List<List<Integer>> triangle = new ArrayList<>();
    try (BufferedReader br = new BufferedReader(new FileReader("src/main/resources/triangle.txt"))) {
      String line;
      while ((line = br.readLine()) != null) {
        List<Integer> row = new ArrayList<>();
        for (String s : line.trim().split("\\s+")) {
          row.add(Integer.parseInt(s));
        }
        triangle.add(row);
      }
    } catch (IOException e) {
      return "Error";
    }
    for (int i = triangle.size() - 2; i >= 0; i--) {
      for (int j = 0; j < triangle.get(i).size(); j++) {
        int maxBelow = Math.max(triangle.get(i+1).get(j), triangle.get(i+1).get(j+1));
        triangle.get(i).set(j, triangle.get(i).get(j) + maxBelow);
      }
    }
    return String.valueOf(triangle.get(0).get(0));
  }
}

function maximumPathSumII() {
  const fs = require('fs');
  const triangle = fs.readFileSync('src/euler_67_data.txt', 'utf8').trim().split('\n').map(line => line.trim().split(/\s+/).map(Number));
  for (let i = triangle.length - 2; i >= 0; i--) {
    for (let j = 0; j < triangle[i].length; j++) {
      triangle[i][j] += Math.max(triangle[i+1][j], triangle[i+1][j+1]);
    }
  }
  return triangle[0][0];
}

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

def solve():
    with open('data/euler_67_data.txt', 'r') as f:
        triangle = []
        for line in f:
            triangle.append([int(x) for x in line.split()])

    for i in range(len(triangle) - 2, -1, -1):
        for j in range(len(triangle[i])):
            triangle[i][j] += max(triangle[i+1][j], triangle[i+1][j+1])

    return triangle[0][0]

package main

import (
  "fmt"
  "os"
  "strconv"
  "strings"
)

func maximumPathSumII() int {
  content, _ := os.ReadFile("euler_67_data.txt")
  lines := strings.Split(string(content), "\n")
  triangle := make([][]int, 0)
  for _, line := range lines {
    if line == "" {
      continue
    }
    parts := strings.Fields(line)
    row := make([]int, len(parts))
    for i, p := range parts {
      row[i], _ = strconv.Atoi(p)
    }
    triangle = append(triangle, row)
  }
  for row := len(triangle) - 2; row >= 0; row-- {
    for col := 0; col < len(triangle[row]); col++ {
      triangle[row][col] += max(triangle[row+1][col], triangle[row+1][col+1])
    }
  }
  return triangle[0][0]
}

func max(a, b int) int {
  if a > b {
    return a
  }
  return b
}

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

use std::fs;

pub fn maximum_path_sum_ii() -> u64 {
    let content = fs::read_to_string("src/euler_67_data.txt").expect("Failed to read file");
    let mut triangle: Vec<Vec<u64>> = content
        .lines()
        .map(|line| {
            line.split_whitespace()
                .map(|s| s.parse().unwrap())
                .collect()
        })
        .collect();
    for row in (0..triangle.len() - 1).rev() {
        for col in 0..triangle[row].len() {
            triangle[row][col] += triangle[row + 1][col].max(triangle[row + 1][col + 1]);
        }
    }
    triangle[0][0]
}