create a palindrome from a number by reversing digits and adding

palindrome.go

package main

import (
  "strconv";
  "reflect"
)

func intToSlice(num int) ([]int) {
  str := strconv.Itoa(num)
  var nums []int
  for _, c := range str {
    digit, _ := strconv.Atoi(string(c))
    nums = append(nums, digit)
  }
  return nums
}

func sliceToInt(nums []int) (int) {
  var str string
  for i := range nums {
      str += strconv.Itoa(nums[i])
  }
  num, _ := strconv.Atoi(str)
  return num
}

func reverseSlice(s []int) ([]int) {
  for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
        s[i], s[j] = s[j], s[i]
  }
  return s
}

func isPalindrome(num int) (bool) {
  if reflect.DeepEqual(intToSlice(num), 
          reverseSlice(intToSlice(num))) {
    return true
  } else {
    return false
  }
}

func reverseDigits(num int) (int) {
  return sliceToInt(reverseSlice(intToSlice(num)))
}

func createPalindrome(num int) (int) {
  if isPalindrome(num) == true {
    return num
  } else {
    for isPalindrome(num) == false {
      num = num + reverseDigits(num)
    }
    return num
  }
}

palindrome.py

def int_to_list(integer):
  num_string = str(integer)
  res = [int(x) for x in num_string]
  return res

def list_to_int(ls):
  res = ''.join(str(c) for c in ls)
  return int(res)

def is_palindrome(integer):
  if int_to_list(integer) == int_to_list(integer)[::-1]:
    return True
  else:
    return False

def reverse_digits(integer):
  return list_to_int(int_to_list(integer)[::-1])

def create_palindrome(integer):
  if is_palindrome(integer) == True:
    return integer
  else:
    while is_palindrome(integer) == False:
      integer = integer + reverse_digits(integer)
      if is_palindrome(integer) == True:
        return integer

palindrome.rs

use std::char;

fn int_to_vector(num: u32) -> Vec<u32> {
    let s: String = num.to_string();
    let mut nums: Vec<u32> = Vec::new();
    for c in s.chars() {
        let digit: u32 = c.to_digit(10).unwrap();
        nums.push(digit);
    }
    return nums;
}

fn vector_to_int(nums: Vec<u32>) -> u32 {
    let mut s: String = String::new();
    for n in nums.iter() {
        s.push(char::from_digit(n.to_owned(), 10).unwrap());
    }
    let num: u32 = s.parse().unwrap();
    return num;
}

fn reverse_vec(v: Vec<u32>) -> Vec<u32> {
    let mut res: Vec<u32> = Vec::new();
    for i in v.iter().rev() {
        res.push(i.to_owned());
    }
    return res;
}

fn is_palindrome(num: u32) -> bool {
    if int_to_vector(num) == reverse_vec(int_to_vector(num)) {
        return true;
    } else {
        return false;
    }
}

fn reverse_digits(num: u32) -> u32 {
    let res: u32 = vector_to_int(reverse_vec(int_to_vector(num)));
    return res;
}

fn create_palindrome(num: u32) -> u32 {
    let mut n = num;
    if is_palindrome(n) {
        return n;
    } else {
        while is_palindrome(n) == false {
            n = n + reverse_digits(n);
        }
        return n;
    }
}

palindrome.scm

(define (integer->list int)
  (map (lambda (c) (- (char->integer c) 48))
         (string->list (number->string int))))

(define (list->integer ls)
  (string->number (list->string 
      (map (lambda (n) (integer->char (+ n 48))) ls))))

(define (is-palindrome? int)
  (equal? (integer->list int)
          (reverse (integer->list int))))

(define (reverse-digits int)
  (list->integer (reverse (integer->list int))))

(define (create-palindrome num)
  (let loop ([int num])
    (cond ([is-palindrome? int] int)
          (else (loop (+ int (reverse-digits int)))))))