Freestyle Sparring

export interface iType{
    id: number,
    name: string,
  }
  
  const datas: iType[] = [
    {
        id: 1,
        name: "Manny"
    },
    {
        id: 2,
        name: "Danny"
    },
    {
        id: 3,
        name: "Socciella"
    },
  ];
  export function findData ( data: iType[],selectedData: number): iType | undefined {
    return data.find(item => item.id === selectedData);
  }
  
  
  findData(datas,1);
  findData(datas,2);
  

export function takeANumber (text: string): number {
  // Don't Change This Variable
  let result: number = parseInt(text.slice(1));
  
  return result;
}

takeANumber("B0002")

takeANumber("B0000001")

takeANumber("B0000004")

fn sum(arr: &[i32]) -> i32 {
    arr.iter().sum()
}

use itertools::Itertools;

fn print(n: u64) -> u64 {
    n.to_string()
        .chars()
        .map(|c| c.to_digit(10).unwrap() as u64)
        .sorted()
        .rev()
        .fold(0, |acc, digit| acc * 10 + digit)
}

import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;

public class Kata {

	public static String arrivalTime(final String[] route, final String departureTime) {
		if (route.length == 0) return "The Train Driver has the day off";

		LocalTime timeResult = LocalTime.parse(departureTime, DateTimeFormatter.ofPattern("HH:mm"));
		String origin = "Skyport";
		int index = 0;
		while (index < route.length) {
			String destination = route[index];
			Map<String, double[]> destinationMap = tableTime.get(origin);
			if (destinationMap != null && destinationMap.containsKey(destination)) {
				double[] times = destinationMap.get(destination);
				timeResult = calculateTime(timeResult, times);
				origin = destination;
				index++;
			} else if (origin.equals(destination)) {
				timeResult = timeResult.plusHours(1);
				index++;
			} else {
				String transfer = "Skyport";
				double[] times = tableTime.get(origin).get(transfer);
				timeResult = calculateTime(timeResult, times);
				origin = transfer;
			}
		}
		return timeResult.format(DateTimeFormatter.ofPattern("HH:mm"));
	}

	private static Map<String, Map<String, double[]>> tableTime = new HashMap<String, Map<String, double[]>>() {
		{
			addRecord("Skyport", "Crystalium", 15, 2);
			addRecord("Skyport", "Oasis", 20, 3);
			addRecord("Oasis", "Crystalium", 15, 1.5);
			addRecord("Skyport", "Nexus", 15, 4);
		}

	private void addRecord(final String origin, final String destiny, final double minutesWait,
				final double hoursTravel) {
			putIfAbsent(origin, new HashMap<>());
			get(origin).put(destiny, new double[] { minutesWait, hoursTravel });

			putIfAbsent(destiny, new HashMap<>());
			get(destiny).put(origin, new double[] { minutesWait - 5, hoursTravel });
		}
	};

	private static LocalTime calculateTime(final LocalTime currentTime, final double[] times) {
		int minutes = (int) times[0];
		int remainingMinutes = (int) (times[1] * 60);

		return currentTime.plusMinutes(minutes).plusMinutes(remainingMinutes);
	}
}