Freestyle Sparring

#include <string>
#include <numeric>
#include <algorithm>
#include <string_view>

class StringComparer {
public:
    static inline auto verifySum(std::string_view w1, std::string_view w2) -> bool {
        return sumOfCharacters(w1) == sumOfCharacters(w2);
    }
  
    static inline auto sumOfCharacters(std::string_view word) -> int {
        return std::accumulate(std::begin(word), std::end(word), 0, [](int sum,  char ch) {
            return sum + ch;
        });
    }
};

def reverse_string(string): return string[::-1]

def you_are_cool(n="Taki"):
    if not isinstance(n, str):
        return "Wait, so your name ISN'T a string of text?! That's wild!"
    n = n.strip()
    if not n:
        return "There is no name, so I'm not complimenting you. LOL"
    if len(n) > 100:
        return "Man, you have an insanely long name! Do people call you by your full name or just a nickname?"
    if n.isdigit():
        return "Are you sure? That looks like a number. Unless you're secretly a robot with a numerical name!"
    return f"Hello {n}, you are very cool!"
    
# edge case go BRRR

pub trait Matrix {
    fn determinant(&self) -> i32;
    fn rows(&self) -> usize;
    fn cols(&self) -> usize;
    fn cofactor_matrix(&self, row: usize, col: usize) -> Self;
}

impl Matrix for Vec<Vec<i32>> {
   fn determinant(&self) -> i32 {
        if self.rows() == 2 && self.cols() == 2 {
            self[0][0] * self[1][1] - self[0][1] * self[1][0]
        } else {
            (0..self.cols()).map(|col| 
                (-1i32).pow(col as u32) * self[0][col] * self.cofactor_matrix(0, col).determinant()
            ).sum()
        }
    }
    
    fn rows(&self) -> usize {
        self.len()
    }
    
    fn cols(&self) -> usize {
        self[0].len()
    }
    
    fn cofactor_matrix(&self, row: usize, col: usize) -> Self {
        let mut cofactor = vec![vec![0;self.cols()-1];self.rows()-1];
        
        for (target_row, source_row) in (0..self.rows()).filter(|&n| n != row).enumerate() {
            for (target_col, source_col) in (0..self.cols()).filter(|&n| n != col).enumerate() {
                cofactor[target_row][target_col] = self[source_row][source_col];
            }
        }
        
        cofactor
    }
}

fn gradient(v: &[i32]) -> Vec<i32> {
    v.windows(2).map(|w| w[1] - w[0]).collect()
}

mod preloaded;
use preloaded::State;
use std::cmp::max;

fn dead_or_alive(human: (u32, u32), monster: (u32, u32), span: u32) -> State {
    if chebyshev_distance(human, monster) <= span {
        State::Dead
    } else {
        State::Alive
    }
}

fn chebyshev_distance(a: (u32, u32), b: (u32, u32)) -> u32 {
    max(a.0.abs_diff(b.0), a.1.abs_diff(b.1))
}

const ARRAY: [&str; 1] = ["codewars"];

fn isqrt(n: u64) -> u64 {
    (n as f64).sqrt() as u64
}

import java.util.Scanner;
class Fibonacci
{
    public static void main(String args[])
    {
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter the number of Iterations:");
        int n = sc.nextInt();
        int a = 0;
        int b = 1;
        System.out.println(a);
        System.out.println(b);
        for(int i = 1;i <=n; i++)
        {
            int c = a + b;
            System.out.println(c);
            a=b;
            b=c;
        }
    }
}

struct Person {
    name: String,
    age: u32,
}

impl Person {
    fn new(name: String, age: u32) -> Self {
        Self { name, age }
    }
    
    fn to_string(&self) -> String {
        format!("{} is {} years old", self.name, self.age)
    }
}

struct Developer {
    inner: Person,
    skills: Vec<String>
}

impl Developer {
    fn new(name: String, age: u32, skills: Vec<String>) -> Self {
        Self { inner: Person::new(name, age), skills }
    }
    
    fn to_string(&self) -> String {
        format!("{} and has {} skills", self.inner.to_string(), self.skills.join(" and "))
    }
}