Lychrel numbers

#include <iostream>
#include <string>
#include <algorithm>

static std::string add_strings(const std::string& a, const std::string& b) {
    std::string result;
    int carry = 0;
    int i = a.size() - 1;
    int j = b.size() - 1;
    while (i >= 0 || j >= 0 || carry) {
        int sum = carry;
        if (i >= 0) sum += a[i--] - '0';
        if (j >= 0) sum += b[j--] - '0';
        carry = sum / 10;
        result.push_back(sum % 10 + '0');
    }
    std::reverse(result.begin(), result.end());
    return result;
}

static bool is_palindrome_lychrel(const std::string& s) {
    std::string rev = s;
    std::reverse(rev.begin(), rev.end());
    return s == rev;
}

bool is_lychrel(long long n) {
    std::string n_str = std::to_string(n);
    for (int iter = 0; iter < 50; ++iter) {
        std::string rev = n_str;
        std::reverse(rev.begin(), rev.end());
        std::string sum_str = add_strings(n_str, rev);
        if (is_palindrome_lychrel(sum_str)) return false;
        n_str = sum_str;
    }
    return true;
}

int lychrel_numbers() {
    int count = 0;
    for (long long i = 1; i < 10000; ++i) {
        if (is_lychrel(i)) ++count;
    }
    return count;
}

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

package main

import (
  "fmt"
  "math/big"
)

func reverse(s string) string {
  runes := []rune(s)
  for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
    runes[i], runes[j] = runes[j], runes[i]
  }
  return string(runes)
}

func isPalindrome(s string) bool {
  return s == reverse(s)
}

func isLychrel(n int) bool {
  num := big.NewInt(int64(n))
  for i := 0; i < 50; i++ {
    revStr := reverse(num.String())
    rev := new(big.Int)
    rev.SetString(revStr, 10)
    num.Add(num, rev)
    if isPalindrome(num.String()) {
      return false
    }
  }
  return true
}

func main() {
  count := 0
  for i := 1; i < 10000; i++ {
    if isLychrel(i) {
      count++
    }
  }
  fmt.Println(count)
}

package org.tvarley.euler.solutions;

import org.tvarley.euler.Solution;
import java.math.BigInteger;

public class Solution055 implements Solution {
  public String solve() {
    int count = 0;
    for (int n = 1; n < 10000; n++) {
      if (isLychrel(n)) {
        count++;
      }
    }
    return Integer.toString(count);
  }

  private boolean isLychrel(int n) {
    BigInteger num = BigInteger.valueOf(n);
    for (int i = 0; i < 50; i++) {
      BigInteger rev = new BigInteger(reverse(num.toString()));
      num = num.add(rev);
      if (isPalindrome(num.toString())) {
        return false;
      }
    }
    return true;
  }

  private String reverse(String s) {
    return new StringBuilder(s).reverse().toString();
  }

  private boolean isPalindrome(String s) {
    return s.equals(reverse(s));
  }
}

const isPalindrome = (str) => {
  return str === str.split('').reverse().join('');
};

const reverseAdd = (n) => {
  const str = n.toString();
  const rev = str.split('').reverse().join('');
  return BigInt(n) + BigInt(rev);
};

const isLychrel = (n, maxIter = 50) => {
  let current = BigInt(n);
  for (let i = 0; i < maxIter; i++) {
    current = reverseAdd(current);
    if (isPalindrome(current.toString())) return false;
  }
  return true;
};

module.exports = {
  answer: () => {
    let count = 0;
    for (let i = 1; i < 10000; i++) {
      if (isLychrel(i)) count++;
    }
    return count;
  }
};

def is_palindrome(n):
    s = str(n)
    return s == s[::-1]

def reverse_add(n):
    return n + int(str(n)[::-1])

def solve():
    count = 0
    for i in range(1, 10000):
        num = i
        for _ in range(50):
            num = reverse_add(num)
            if is_palindrome(num):
                break
        else:
            count += 1
    return count

use num_bigint::BigUint;

pub fn lychrel_numbers() -> u32 {
    let mut count = 0;
    for n in 1..10000 {
        if is_lychrel(n) {
            count += 1;
        }
    }
    count
}

fn is_lychrel(n: u64) -> bool {
    let mut num = BigUint::from(n);
    for _ in 0..50 {
        let rev = reverse_big(&num);
        num += &rev;
        if is_palindrome(&num) {
            return false;
        }
    }
    true
}

fn reverse_big(n: &BigUint) -> BigUint {
    let s = n.to_string();
    let rev_s: String = s.chars().rev().collect();
    BigUint::parse_bytes(rev_s.as_bytes(), 10).unwrap()
}

fn is_palindrome(n: &BigUint) -> bool {
    let s = n.to_string();
    s == s.chars().rev().collect::<String>()
}

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

    #[test]
    fn euler_055() {
        assert_eq!(lychrel_numbers(), 249);
    }
}