Java grammar && Java Codewar Solutions

Java 多个线程同步运行

class Counter{
int count;
public synchronized void increment(){ //两个线程不能同步执行该方法 加 synchronized
    count++;
	}
}
class RunSyncThread{
public void run() throws Exception{
    Counter c = new Counter();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0;i<1000;i++){
                    c.increment();
                }
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0;i<1000;i++){
                    c.increment();
                }
            }
        });
    t1.run();
    t2.run();
    t1.join();
    t2.join();
    System.out.println(c.count);
	}
}

public class kata {
    public static void main(String[] args) throws Exception {
        RunSyncThread run_sync_thread = new RunSyncThread();
        run_sync_thread.run();
    }
}

Java Streams

import java.util.List;
import java.util.Set;
import java.util.Objects;
import java.util.stream.Collectors;

import static Streams._Stream.Gender.*;

public class _Stream {
    public static void main(String[] args) {
        List<_Stream.Person> people = List.of(
                new _Stream.Person("Alen", MALE),
                new _Stream.Person("Andrey", MALE),
                new _Stream.Person("Alex", FEMALE),
                new _Stream.Person("Amili", FEMALE),
                new _Stream.Person("Mali", PREFER_NOT_TO_SAY)
        );
//      [MALE, FEMALE]
       Set<Gender> genders =  people.stream()
                .map(person -> person.gender)
                .collect(Collectors.toSet());
       System.out.println(genders);

//    [Anana, Alex, Andrey, Alen, Amili]
        Set<String> names =  people.stream()
                .map(person -> person.name)
                .collect(Collectors.toSet());
        System.out.println(names);

//  filter some people in List
        List<Person> the_people_of_DONT_WANT_TO_SAY = people.stream().filter(ITEM ->ITEM.gender.equals(PREFER_NOT_TO_SAY)).collect(Collectors.toList());
        System.out.println("the_people_of_DONT_WANT_TO_SAY: "+the_people_of_DONT_WANT_TO_SAY);
        System.out.println("the_people_of_DONT_WANT_TO_SAY COUNT : "+people.stream().filter(ITEM ->ITEM.gender.equals(PREFER_NOT_TO_SAY)).count()); //count 满足条件的元素

//  Determine the presence or absence
//        .anyMatch(ITEM->ITEM.gender.equals(PREFER_NOT_TO_SAY)); //存在一个 就返回true
//        .allMatch(ITEM->ITEM.gender.equals(PREFER_NOT_TO_SAY)); //所有都满足 就返回true else 返回false
//        .noneMatch(ITEM->ITEM.gender.equals(PREFER_NOT_TO_SAY)); //与allMatch相反,判断条件里的元素,所有的都不是,返回true
        Boolean presence_SOME_PEOPLE_DONT_WANT_TO_SAY = people.stream().anyMatch(ITEM->ITEM.gender.equals(PREFER_NOT_TO_SAY)); //存在一个 就返回true
        System.out.println("presence_SOME_PEOPLE_DONT_WANT_TO_SAY: "+presence_SOME_PEOPLE_DONT_WANT_TO_SAY);
    }
    record Person(String name, Gender gender) {

        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", gender=" + gender +
                    '}';
        }

        @Override
        public int hashCode() {
            return Objects.hash(name, gender);
        }

    }
    enum Gender{
        MALE,FEMALE,PREFER_NOT_TO_SAY,
    }
}

Java StringBuffer

public class _StringBuffer {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.append(15);  //add int
        sb.append("string");
        sb.append(true);
        sb.append(15);
        sb.append(15);
        sb.append(15);
        sb.append(15);
        sb.append(15);

        sb.insert(0, "first "); //0 index insert value

        sb.reverse(); //反转所有字符

        sb.delete(0, 5); //delete index 0..=4

        sb.replace(5, 8, "are"); //replace index 5..=7

        System.out.println("Print StingBuffer : "+sb);  //convert to string
        System.out.println(sb.charAt(0)); //get 0 index item
        System.out.println(sb.length()); //length
        System.out.println(sb.indexOf("string"));  //get string index
    }
}

Java Math

public class _Math {
    public static void main(String[] args) {
        // print the absolute value
        System.out.println(Math.abs(-7.89));

        // create long variable
        long c = 12345678l;
        long d = 987654321l;

        // addExact() with long arguments
        System.out.println(Math.addExact(c, d));  // 999999999

        // compute square root of 25
        System.out.println(Math.sqrt(25));

        // create a double variable
        double value2 = 27.0; //三次根号
        System.out.println(Math.cbrt(value2));  // 3.0

        // computes 5 raised to the power 3
        System.out.println(Math.pow(5, 3));

        // Math.min() with float arguments
        float num5 = 4.5f;
        float num6 = 9.67f;
        System.out.println(Math.min(num5, num6));  // 4.5

        // Math.min() with double arguments
        double num7 = 23.44d;
        double num8 = 32.11d;
        System.out.println(Math.min(num7, num8));  // 23.44

        // compute max of 88 and 98
        System.out.println(Math.max(88, 98));

        // Math.ceil() method (1.0 大 返回2.0)
        // value greater than 5 after decimal
        double a = 1.878;
        System.out.println(Math.ceil(a));  // 2.0

        // value equals to 5 after decimal
        double b = 1.5;
        System.out.println(Math.ceil(b));  // 2.0

        // value less than 5 after decimal
        double c1 = 1.34;
        System.out.println(Math.ceil(c1));  // 2.0

        //Math.floor() 向下取整
        double a1 = 3.8;
        System.out.println(Math.floor(a1)); //3

        //Math.round() 向上取整
        double a2 = 3.8;
        System.out.println(Math.round(a2)); //4

        //Ganerate Random number between 10 and 20
        int upperBound = 20;
        int lowerBound = 10;
        // upperBound 20 will also be included
        int range = (upperBound - lowerBound) + 1;
        System.out.println("Random Numbers between 10 and 20:");
        for (int i = 0; i < 10; i ++) {
            // generate random number
            // (int) convert double value to int
            // Math.round() generate value between 0.0 and 1.0
            int random = (int)(Math.random() * range) + lowerBound;
            System.out.print(random + ", ");
        }
        // Math.rint()
        // value greater than 5 after decimal
        System.out.println(Math.rint(1.878));  // 2.0

        // value less than 5 after decimal
        System.out.println(Math.rint(1.34));   // 1.0

        // value equal to 5 after decimal
        System.out.println(Math.rint(1.5));    // 2.0

        // value equal to 5 after decimal
        System.out.println(Math.rint(2.5));    // 2.0

    }
}

Java Read File

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;


public class _Read_File {

    public static void ReadFile_Use_BufferedReader() throws IOException {
        // We need to provide file path as the parameter:
        // double back quote is to avoid compiler interpret words
        // like \test as \t (ie as escape sequence)
        File file = new File("/home/alen/code/java_code/learn/src/File/test.txt");

        BufferedReader br = new BufferedReader(new FileReader(file));

        String st;
        while ((st = br.readLine()) != null) {
            System.out.println(st);
        }
    }

    public static void ReadFile_Use_FileReader() throws IOException {
        // pass the path to the file as a parameter
        FileReader fr =
                new FileReader("/home/alen/code/java_code/learn/src/File/test.txt");

        int i;
        while ((i=fr.read()) != -1)
            System.out.print((char) i);
    }

    public static void ReadFile_Use_Scanner() throws IOException {
        // pass the path to the file as a parameter
        {
            File file =
                    new File("/home/alen/code/java_code/learn/src/File/test.txt");
            Scanner sc = new Scanner(file);

            while (sc.hasNextLine())
                System.out.println(sc.nextLine());
        }

        {
            //without loop
            File file = new File("/home/alen/code/java_code/learn/src/File/test.txt");
            Scanner sc = new Scanner(file);

            // we just need to use \\Z as delimiter
            sc.useDelimiter("\\Z");

            System.out.println(sc.next());
        }
    }


    public static List<String> readFileInList(String fileName)
    {

        List<String> lines = Collections.emptyList();
        try
        {
            lines =
                    Files.readAllLines(Paths.get(fileName), StandardCharsets.UTF_8);
        }

        catch (IOException e)
        {

            // do something
            e.printStackTrace();
        }
        return lines;
    }
    public static void ReadFileIntoList(){
        List l = readFileInList("/home/alen/code/java_code/learn/src/File/test.txt");

        Iterator<String> itr = l.iterator();
        while (itr.hasNext())
            System.out.println(itr.next());
    }

    public static String readFileAsString(String fileName)throws Exception
    {
        String data;
        data = new String(Files.readAllBytes(Paths.get(fileName)));
        return data;
    }

        public static void main(String[] args) throws Exception {
            System.out.println("ReadFile_Use_BufferedReader:");
            ReadFile_Use_BufferedReader();

            System.out.println("ReadFile_Use_FileReader:");
            ReadFile_Use_FileReader();

            System.out.println("ReadFile_Use_Scanner:");
            ReadFile_Use_Scanner();

            System.out.println("ReadFileIntoList:");
            ReadFileIntoList();


            System.out.println("readFileAsString:");
            String data = readFileAsString("/home/alen/code/java_code/learn/src/File/test.js");
            System.out.println(data);

    }

}

Java Write File

import java.io.*;

public class _Write_File {
    public static void Write_File_Use_BufferedWriter(){
        try {
            BufferedWriter out = new BufferedWriter(new FileWriter("/home/alen/code/java_code/learn/src/File/wrote_file.txt"));
            out.write("a String");
            out.close();
            System.out.println("File created successfully");
        }
        catch (IOException e) {
        }
    }
    public static void main(String[] args) {
        Write_File_Use_BufferedWriter();
    }
}

Java Run Command

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class _Run_py {
    public static void run_py(){
        try {
            Process p = Runtime.getRuntime().exec("python /home/alen/code/java_code/learn/src/exec/test.py");
            BufferedReader in = new BufferedReader(
                    new InputStreamReader(p.getInputStream()));
            String line = null;
            while ((line = in.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void run_ls(){
        try {
            Process p = Runtime.getRuntime().exec("ls -lha");
            BufferedReader in = new BufferedReader(
                    new InputStreamReader(p.getInputStream()));
            String line = null;
            while ((line = in.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) throws IOException {
        run_py();
        run_ls();
    }
}

Java CallBack

import java.util.function.Consumer;
public class _CallBack {
    public static void main(String[] args) {
        hello("Alen",null,value->System.out.println("use Consumer: last_name not defined for :"+value));
        hello1("Alen",null,()->System.out.println(" use Runnable: last_name not defined"));
    }
//   用Consumer 跟javascript 的callback 一样 使用 callback
    static void hello(String fist_name, String lat_name, Consumer<String> callback){
        System.out.println(fist_name);
        if (lat_name !=null){
            System.out.println(lat_name);
        }else {
            callback.accept(fist_name);
        }
    }
//   用Runnable 跟javascript 的callback 一样 使用 callback
    static void hello1(String fist_name, String lat_name, Runnable callback){
        System.out.println(fist_name);
        if (lat_name !=null){
            System.out.println(lat_name);
        }else {
            callback.run();
        }
    }
}

Java Consumer

package FunctionalInterface;

import java.util.function.BiConsumer;//take two argument return void
import java.util.function.Consumer;//take one argument return void

public class _Consumer {
    public static void main(String[] args) {

        System.out.println("//          normal function");
        greetingCustomer(new Customer("Alen", "15354843621"));

        System.out.println("//          Customer Function");
        greetingCustomer_ByConsumer.accept(new Customer("Andry", "19909284728"));

        System.out.println("//          BiCustomer Function");
        greetingCustomer_ByBiConsumer.accept((new Customer("Andry", "19909284728")),false);
    }
//    use Consumer
    static Consumer<Customer> greetingCustomer_ByConsumer = consumer->
        System.out.println("Hello "+consumer.CustomerName+"  Thanks for registering phone number  "+consumer.CustomerPhoneNumber);



// use void function
    static void greetingCustomer(Customer customer){
        System.out.println("Hello "+customer.CustomerName+"  Thanks for registering phone number  "+customer.CustomerPhoneNumber);
    }


// BiConsumer
    static BiConsumer<Customer,Boolean> greetingCustomer_ByBiConsumer = (customer,showPhoneNumber) ->
        System.out.println("Hello "+customer.CustomerName+"  Thanks for registering phone number  "+ (showPhoneNumber ? customer.CustomerPhoneNumber:"***************"));


    static class Customer{
        private final String CustomerName;
        private final String CustomerPhoneNumber;

        public Customer(String customerName, String customerPhoneNumber) {
            CustomerName = customerName;
            CustomerPhoneNumber = customerPhoneNumber;
        }
    }
}

Java Function

package FunctionalInterface;

import java.util.function.BiFunction; //take two argument return one
import java.util.function.Function; //take one argument return one

public class _Function {
    public static void main(String[] args) {
        System.out.println("***function***");
        int inc = increment(0);
        System.out.println(inc);

        System.out.println("***Function***");
        int inc1 = incrementFunction.apply(0);
        System.out.println(inc1);

        //合并两个Function
        Function<Integer,Integer> mergeFunction = incrementFunction.andThen(multipleBy10);

        int mergeResult = mergeFunction.apply(0);
        System.out.println(mergeResult);
        System.out.println(incrementFunction.andThen(multipleBy10).apply(0));

        //BIFunction
        System.out.println("***BiFunction***");
        BiFunction<Integer,Integer,Integer> multipleBiFunction = (num,numToMultipleBy)  //2个输入参数 1个输出参数
                ->(num +1)*numToMultipleBy;
        System.out.println(multipleBiFunction.apply(4,100));
    }
//    function
    static int increment(int num){
        num++;
        return num;
    }
//    Function
    static Function<Integer,Integer> incrementFunction = num -> num+1;

    static Function<Integer,Integer> multipleBy10 = num -> num*10;
}

Java Predicate

package FunctionalInterface;

import java.util.function.BiPredicate; //take Two argument return Boolean
import java.util.function.Predicate;//take one argument return Boolean

public class _Predicate {
    public static void main(String[] args) {
        System.out.println(isPhoneNumberValid("15354843621"));
        System.out.println(isPhoneNumberValid("153548436201"));

        System.out.println(isPhoneNumberValid_ByUse_Predicate.test("15354843621"));

//        合并组合使用Predicate  and 同时满足为true
        System.out.println("//       Predicate");
        Boolean result = isPhoneNumberValid_ByUse_Predicate.and(containsNumber).test("15354843621");
        System.out.println(result);

//          合并组合使用Predicate 和 BiPredicate   && 同时满足为true
        System.out.println("//    BiPredicate");
        Boolean result1 = (isPhoneNumberValid_ByUse_Predicate.test("15354843621") &&containsNumber_Use_BiPredicate.test("15354843621",'9') );
        System.out.println(result1);
    }

    static  boolean isPhoneNumberValid(String phoneNumber){
        return phoneNumber.startsWith("1") && phoneNumber.length() ==11;
    }

    static Predicate<String> isPhoneNumberValid_ByUse_Predicate = phoneNumber->
                    phoneNumber.startsWith("1") && phoneNumber.length() ==11;

    static Predicate<String> containsNumber = phoneNumber ->
            phoneNumber.contains("3");

    static BiPredicate<String,Character> containsNumber_Use_BiPredicate = (phoneNumber,num) ->
            phoneNumber.contains(num.toString());

}

Java Supplier

package FunctionalInterface;

import java.util.List;
import java.util.function.Supplier;//do not take any argument

public class _Supplier {
    public static void main(String[] args) {
        System.out.println("normal function");
        System.out.println(getConnectionUrl());

        System.out.println("use Supplier ");
        System.out.println(getConnectionUrl_Use_Supplier.get());
    }
    static String getConnectionUrl(){
        return "jdbc://localhost5432/user";
    }
    static Supplier<List<String>> getConnectionUrl_Use_Supplier = ()->
            List.of("jdbc://localhost5432/user",
                    "jdbc://localhost5432/user",
                    "jdbc://localhost5432/user"
            );
}

Kata1 (用ASCII码加密 数据)

/*
*Encrypt this!
 *Examples:
Kata.encryptThis("Hello") => "72olle"
Kata.encryptThis("good") => "103doo"
Kata.encryptThis("hello world") => "104olle 119drlo"
 */
import java.util.*;
import java.util.stream.Collectors;
import java.util.function.*;

class Kata1 {
    public static String encryptThis(String text) {
        UnaryOperator<String> encrtyper = s -> {
            switch (s.length()) {
                case 0:
                    return s;
                case 1:
                    return String.valueOf((int) s.charAt(0));
                case 2:
                    return (int) s.charAt(0) + s.substring(s.length()-1);
                default:
                    return (int) s.charAt(0) + s.substring(s.length()-1) + s.substring(2, s.length()-1) + s.substring(1, 2);
            }
        };
        return Arrays.stream(text.split(" "))
                .map(s -> encrtyper.apply(s))
                .collect(Collectors.joining(" "));
    }
}

Kata2 (转化为二进制 ,数1的个数)

/***
 * Bit Counting (转化为二进制 ,数1的个数)
 * Example: The binary representation of 1234 is 10011010010, so the function should return 5 in this case
 */
import java.util.*;
import java.util.stream.Collectors;
import java.util.function.*;
class BitCounting1 {
    public static int countBits(int n){
        // Show me the code!
        String binary = String.valueOf(Integer.toBinaryString(n));
        int count = 0;
        for(String s : binary.split("")){
            if(s.equals("1")){
                count++;
            }
        }
        return count;
    }
}
class BitCounting2 {
    public static int countBits(int n){
        return Integer.bitCount(n);
    }
}

Kata3 (返回,最小和最大数)

/***
 * The highest profit wins!(返回,最小和最大数)
 * Examples
 * MinMax.minMax(new int[]{1,2,3,4,5}) == {1,5}
 * MinMax.minMax(new int[]{2334454,5}) == {5, 2334454}
 * MinMax.minMax(new int[]{1}) == {1, 1}
 */
import java.util.*;
import java.util.stream.Collectors;
import java.util.function.*;
class MinMax {
    public static int[] minMax(int[] arr) {
        // Your awesome code here
        int min = Arrays.stream(arr)
                .min()
                .getAsInt();
        int max = Arrays.stream(arr)
                .max()
                .getAsInt();
        return new int[]{min, max};
    }
}

Kata4 (排序array)

/***
 * Array Sort (数组小到大排序) int
 */
import java.util.*;
import java.util.stream.Collectors;
import java.util.function.*;
class Sort1{
    public static int[] ArraySort(int[] arr){
        Arrays.sort(arr);
        return arr;
    }
//System.out.println(Arrays.toString(Sort.ArraySort(new int[]{51,26,6,14,2}))); //[2, 6, 14, 26, 51]
}

/***
 * Array Sort (数组小到大排序) String
 */
class Sort2{
    public static String[] ArraySort(String[] arr){
        Arrays.sort(arr);
        return arr;
    }
//        System.out.println(Arrays.toString(Sort2.ArraySort(new String[]{"d","a","c"}))); //[a, c, d]
}

Kata5 (卡号部分模糊显示)

/**
 *Credit Card Mask  (卡号模糊显示)
 * Examples
 * Maskify.Maskify("4556364607935616"); // should return "############5616"
 * Maskify.Maskify("64607935616");      // should return "#######5616"
 * Maskify.Maskify("1");                // should return "1"
 * Maskify.Maskify("");                 // should return ""
 * // "What was the name of your first pet?"
 * Maskify.Maskify("Skippy");                                   // should return "##ippy"
 * Maskify.Maskify("Nananananananananananananananana Batman!"); // should return "####################################man!"
 */
import java.util.*;
import java.util.stream.Collectors;
import java.util.function.*;
class Maskify {
    public static String maskify(String str) {
        List<String> list = new ArrayList<String>();
        for (String s : str.split("")){
            list.add(s);
        }
        if(list.size()>4){
            for (int i = 0; i < list.size()-4; i++) {
                list.set(i,"*");
            }
        }
//        System.out.println(list.stream().collect(Collectors.joining(" ")));
        return list.stream().collect(Collectors.joining(""));
    }
}

Kata6 (统计元素出现次数,输出奇数次数的元素)

import java.util.*;
import java.util.stream.Collectors;
import java.util.function.*;
class FindOdd {
    public static int findIt(int[] a) {
        HashMap<String, Integer> hashMap = new HashMap<>();
        for (Integer s : a){
            if(!hashMap.containsKey(s.toString())) {
                hashMap.put(s.toString(), 0);
            }
        }
        for (Integer s : a){
            if(hashMap.containsKey(s.toString())) {
                Integer value = hashMap.get(s.toString());
                value = value+1;
                hashMap.put(s.toString(),value);
            }
        }
//        System.out.println(hashMap);  //{1=2, 2=2, 3=2, 4=2, 5=3, 20=2}
//        System.out.println(hashMap.values());
        Integer oddIndex =0;
        for(Integer s : hashMap.values()) {
            oddIndex++;
            if(s%2!=0){
//                System.out.println(s);
                break;
            }
        }
//        System.out.println(hashMap.keySet()); //return key set
//        System.out.println(hashMap.keySet().toArray()[oddIndex-1]);
//        System.out.println(oddIndex);
//        System.out.println(FindOdd.findIt(new int[]{2,2,3,4,55,55,55})); // 输出出现次数 {55=3, 2=2, 3=1, 4=1}
        Integer oddNumber = Integer.parseInt((String) hashMap.keySet().toArray()[oddIndex-1]);
        return oddNumber;
    }
}

//solution 2
class FindOdd1 {
    public static int findIt(int[] A) {
        final TreeSet<Integer> set = new TreeSet<>();
        for (int x : A) {
            if (set.contains(x)) {
                set.remove(x);  //because return odd frequency so remove even frequency
            } else {
                set.add(x);
            }
        }
//        System.out.println(set); //[5]
        return set.first();
    }
}

Kata7 (输出子字符串)

/***
 *Which are in?
 *Given two arrays of strings a1 and a2 return a sorted array r in lexicographical order of the strings of a1 which are substrings of strings of a2.
 *
 * Example 1:
 * a1 = ["arp", "live", "strong"]
 *
 * a2 = ["lively", "alive", "harp", "sharp", "armstrong"]
 *
 * returns ["arp", "live", "strong"]
 */
import java.util.*;
import java.util.stream.Collectors;
import java.util.function.*;
class WhichAreIn {
    public static String[] inArray(String[] array1, String[] array2) {
        return Arrays.stream(array1)
                .filter(str -> Arrays.stream(array2).anyMatch(s -> s.contains(str)))
                .distinct()
                .sorted()
                .toArray(String[]::new);
    }
}

Kata8 (判断出现o,x次数是否相同)

/***
 *Exes and Ohs (if O和X的出现次数相同=>true)
 * Examples input/output:
 *
 * XO("ooxx") => true
 * XO("xooxx") => false
 * XO("ooxXm") => true
 * XO("zpzpzpp") => true // when no 'x' and 'o' is present should return true
 * XO("zzoo") => false
 */
class XO {
    public static boolean getXO (String str) {
        str = str.toLowerCase(Locale.ROOT); //转化为小写
        HashMap<String, Integer> hashMap = new HashMap<>();
        for (String s : str.split("")){
            if(!hashMap.containsKey(s.toString())) {
                hashMap.put(s, 0);
            }
        }
        for (String s : str.split("")){
            if(hashMap.containsKey(s.toString())) {
                Integer value = hashMap.get(s.toString());
                value = value+1;
                hashMap.put(s,value);
            }
        }
        String str1 = String.valueOf(hashMap.get("o"));
        String str2 = String.valueOf(hashMap.get("x"));
//        System.out.println(str1);
//        System.out.println(str2);

            if (hashMap.get("o")== null && hashMap.get("x")==null) {
                return true;
            }
            else if(hashMap.get("o")!= null && hashMap.get("x")!=null && hashMap.get("o").equals(hashMap.get("x"))) {
                return true;
            }
            else {
                return false;
            }


    }
}

Kata9 (Count the smiley faces(用正则表达式))

/**
 *Count the smiley faces!
 * Rules for a smiling face:
 * Each smiley face must contain a valid pair of eyes. Eyes can be marked as : or ;
 * A smiley face can have a nose but it does not have to. Valid characters for a nose are - or ~
 * Every smiling face must have a smiling mouth that should be marked with either ) or D
 * Example
 * countSmileys([':)', ';(', ';}', ':-D']);       // should return 2;
 * countSmileys([';D', ':-(', ':-)', ';~)']);     // should return 3;
 * countSmileys([';]', ':[', ';*', ':$', ';-D']); // should return 1;
 * Valid smiley face examples: :) :D ;-D :~)
 * Invalid smiley faces: ;( :> :} :]
 */
import java.util.*;
import java.util.stream.Collectors;
import java.util.function.*;
import java.util.TreeSet;
import java.util.stream.Stream;
class SmileFaces {
    public static int countSmileys(List<String> arr) {
        return (int)arr.stream().filter( x -> x.matches("[:;][-~]?[)D]")).count();
    }
}

Kata10 (Merge Two list use stream)

/***
 * Merge Two list use stream
 */
import java.util.*;
import java.util.stream.Collectors;
import java.util.function.*;
import java.util.TreeSet;
import java.util.stream.Stream;
class Merge{
    public static List run(List<String> List1, List<String> List2){
        // convert both lists into stream
        Stream<String> list1 = List1.stream();
        Stream<String> list2 = List2.stream();

        // merge two streams
        Stream<String> merged = Stream.concat(list1, list2);

        // convert the merged stream into list
        List<String> numbers = merged.collect(Collectors.toList());

        System.out.println("Merged List: " + numbers);
        return numbers;
    }
}

Kata11 (Stack Application 栈的实现)

/**
 *  包含min函数的栈
 */
import java.util.*;
import java.util.stream.Collectors;
import java.util.function.*;
import java.util.TreeSet;
import java.util.stream.Stream;
import java.util.Stack;
class StackApplication {
    private Stack<Integer> dataStack = new Stack<>(); // 数据栈
    private Stack<Integer> minStack = new Stack<>(); // 维护min函数的栈

    public void push(int node) {
        dataStack.push(node);

        if (minStack.isEmpty() || minStack.peek() > dataStack.peek()) {
            minStack.push(dataStack.peek()); // 当前minStack的栈顶元素大于数据栈的栈顶元素
        } else {
            minStack.push(minStack.peek()); // 当前minStack的栈顶元素小于数据栈的栈顶元素
        }
    }
    public void pop() {
        if (!dataStack.isEmpty()) {
            dataStack.pop();
        }
        if (!minStack.isEmpty()) {
            minStack.pop();
        }
    }
    public int top() {
        // 取出数据栈的栈顶元素
        return dataStack.peek();
    }
    public int min() {
        // 取出维护min函数的栈的栈顶元素
        return minStack.peek();
    }
}

public class kata {
    public static void main(String[] args) throws Exception {
        StackApplication st = new StackApplication();
        st.push(15);
        st.push(11);
        st.push(12);
        st.push(110);
        st.push(100);
        st.push(1515);
        st.pop(); //delete 1515
        System.out.println(st.top()); //100
        System.out.println(st.min());  //11
    }
}

Kata12 (findKth Solution ,查找第K元素)

/**
 *findKth Solution
 */
class findKthSolution {
    public static int findKth(int[] a, int n, int K) {
        Arrays.sort(a);
        return(a[n-K]);
    }
}

Kata15 (Largest Element Of Array 数组中最大的数)

public class LargestElementOfArray {
    public static void main(String[] args){
        // Initialize array
        int[] arr = new int[] { 25, 11, 7, 75, 56 };
        // Initialize max with first element of array.
        int max = arr[0];
        // Loop through the array
        for (int i = 0; i < arr.length; i++) {
            // Compare elements of array with max
            if (arr[i] > max)
                max = arr[i];
        }
        System.out.println(max);

    }
}

Kata16 (找出字符串中最长的回文子串长度)

/**
 * 找出字符串中最长的回文子串长度
 */
public class longestPalindromeSequence {

    public static int longestPalindrome(String s) {
        int len = s.length();
        int [][] dp = new int[len][len];
        for(int i = len - 1; i>=0; i--){
            dp[i][i] = 1;
            for(int j = i+1; j < len; j++){
                if(s.charAt(i) == s.charAt(j))
                    dp[i][j] = dp[i+1][j-1] + 2;
                else
                    dp[i][j] = Math.max(dp[i+1][j], dp[i][j-1]);
            }
        }
        return dp[0][len-1];
    }

    public static void main(String[] args) {
        System.out.println(longestPalindromeSequence.longestPalindrome("bbbabaaabcdabcd")); //9

    }
}

Kata17 (判断是否有重复部分)

import java.util.HashSet;

public class _isDuplicate {
    public static void main(String[] args) {
        int[] arr = {1,9,2,3,5,4};
        System.out.println(containsDuplicate(arr));
    }
    public static boolean containsDuplicate(int[] nums) {
        HashSet<Integer> set = new HashSet<>();
        for (int i = 0; i < nums.length; i++) {
            if (set.contains(nums[i])) {
                return true;
            }
            set.add(nums[i]);
        }
        return false;
    }
}

Kata18 (数组元素出现频度统计)

public class arrayFrequency {
    public static void main(String[] args) {
        // Initialize array
        int[] chars = new int[] { 1, 2, 8, 3, 2, 2, 2, 5, 1 };
        // Array fr will store frequencies of element
        int[] fr = new int[chars.length];
        for (int i = 0; i < chars.length; i++) {
            int count = 1;
            for (int j = i + 1; j < chars.length; j++) {
                if (chars[j] == chars[i]) {
                    count++;
                    fr[j] = -1;

                }
            }
            if (fr[i] != -1) {
                fr[i] = count;
            }
        }
        for (int i = 0; i < fr.length; i++) {
            if (fr[i] != -1)
                System.out.println("    " + chars[i] + "    |    " + fr[i]);
        }
       
    }
}

/**
*输出
*   1    |    2
    2    |    4
    8    |    1
    3    |    1
    5    |    1
*/

Kata19 (java 生成随机数)

import java.util.Random;
import java.util.function.Consumer;
/**
 * 生成随机数
 */
public class random {
	public static void main(String[] args) {
		Consumer<Integer> print = name-> {System.out.println(name);};
		Random random = new Random();
		int int_random = random.nextInt(); //输出int 范围内的 random number
		print.accept(int_random);

		int int_random1 = random.nextInt(6); //输出范围0-6
		System.out.println(int_random1);
		
		double double_random = random.nextDouble(); //输出double 范围 0-1 之间的 double number
		System.out.println(double_random);
		
		float float_random = random.nextFloat(); //输出float 范围 0-1 之间的 float number
		System.out.println(float_random);
		
		boolean boolean_random = random.nextBoolean(); //输出boolean 范围
		System.out.println(boolean_random);
	}
}

Kata20 (Java Reverse Array 数组反转)

import java.util.Arrays;
public class ReverseArray {
    public static void main(String[] args) {
        int[] array = new int[] { 1, 2, 3, 4, 5, 6, 7 };
        int[] reverse_array = new int[array.length];
        System.out.println("orignal arr:"+ Arrays.toString(array));
        for (int i = 0; i < array.length; i++) {
//            System.out.println(array[array.length - 1 - i]);
            reverse_array[i] = array[array.length - 1 - i];
        }
//        orignal arr:[1, 2, 3, 4, 5, 6, 7]
//        reversed arr:[7, 6, 5, 4, 3, 2, 1]
        System.out.println("reversed arr:" + Arrays.toString(reverse_array));
    }   
}

Kata 21 (PasrInt String use Java 转化为Int)

public class StrToInt {
    public static int StrToInt(String str) {
        if (str.length() == 0)
            return 0;
        char[] chars = str.toCharArray();
        // 判断是否存在符号位
        int flag = 0;
        if (chars[0] == '+')
            flag = 1;
        else if (chars[0] == '-')
            flag = 2;
        int start = flag > 0 ? 1 : 0;
        int res = 0;// 保存结果
        for (int i = start; i < chars.length; i++) {
            if (Character.isDigit(chars[i])) {// 调用Character.isDigit(char)方法判断是否是数字,是返回True,否则False
                int temp = chars[i] - '0';
//                System.out.println(temp);
                res = res * 10 + temp;
//                System.out.println(res);
            } else {
                return 0;
            }
        }
        return flag != 2 ? res : -res;

    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String s = "-1231231225";
        System.out.println("使用库函数转换:" + Integer.valueOf(s));
        int res = StrToInt(s);
        System.out.println("使用自己写的方法转换:" + res);
//        使用库函数转换:-1231231225
//        使用自己写的方法转换:-1231231225
    }
}

Kata 22 (查找返回Index,binarySearch )

/***
 * 小到大排序的数组返回index (binarySearch)
 * in:{1,5,9,15,20,23},15
 * out:target index 3
 * can't find target return -1
 * 时间复杂度 log(n)
 */

class binarySearch{
    public static int search(int[] values,int target){
        int left = 0;
        int right = values.length-1;
        int result = -1;
        while(left <=right){
            Integer mid = (left + right)/2;
            if(values[mid]==target){
                result = mid;
                break;
            }
            else if(values[mid] <target){
                left=mid+1;
            }else {
                right=mid-1;
            }
        }
        return result;

    }
}

Kata 23 ( List 交换相邻的元素 返回交换的List)

/**
 * List 交换相邻的元素 返回交换的List
 *out:[2, 1, 4, 3, 6,5]
 *in:[1, 2, 3, 4, 5,6]
 */
class reverse_neighbours
{
    public static List<Integer> reverse_(List<Integer> array) {
        List<Integer> list3 = new ArrayList<Integer>();
        for (int i = 0; i < array.size(); i++) {
            list3.add(0);
        }
        if(array.size()%2==0){
            for(int i=0;i<list3.size();i++){
                if(i%2==0)list3.set(i,array.get(i+1));
                if(i%2==0)list3.set(i+1,array.get(i));
            }
        }else {
            for(int i=0;i<list3.size()-1;i++){
                if(i%2==0)list3.set(i,array.get(i+1));
                if(i%2==0)list3.set(i+1,array.get(i));
            }
            list3.set(list3.size()-1,array.get(list3.size()-1));
        }
        System.out.println(list3);
        return list3;
    }
}
//System.out.println(reverse_neighbours.reverse_(Arrays.asList(new Integer[]{1, 2, 3, 4, 5})));

Kata 24 (slice List)

/**
 *         input:(["python", "pip", "ok","java","rust","cpp","kotlin"],3,5);
 *         output:[java, rust, cpp]
 */
class slice_list{
    public static <T> List<String> slice(List<T> asList,Integer start, Integer end) {
        List<String> list1 = new ArrayList();
        for(Integer s=start; s<=end; s++) {
            list1.add((String) asList.get(s));
        }
        return list1;
    }
}
//System.out.println(slice_list.slice(Arrays.asList(new String[]{"python", "pip", "ok","java","rust","cpp","kotlin"}),3,5));

Kata 25 (高精度计算,BigDecimal)

/**
 *java浮点数运算精度损失,用BigDecimal 解决
 */
class sumBigDecimal{
    public static double sum(double value1,double value2){
        java.math.BigDecimal big_val1 = new java.math.BigDecimal(Double.toString(value1));
        java.math.BigDecimal big_val2 = new java.math.BigDecimal(Double.toString(value2));
        double result = big_val1.add(big_val2).doubleValue();
        return result;
    }
}
//System.out.println(sumBigDecimal.sum(1.21,3.51)); //4.72

Kata 26 (求一个数的平方根)

/**
 * 求一个数的平方根
 */
class sqrt{
    public static double sqrt(int x){
        if(x==0 ||x==1)return x;
        double r = x;
        while(r*r>x){
            r = (r+x/r)/2;
        }
        return r;
    }
}