作品集

主页

主页左侧预警分析

主页

主页

用户

附近人

消息

我的

编程题1

package com.liangzy.coding.nn;

import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * 随机 N
 *
 * <ol>
 *     题目理解
 *     <li>生成总数为 100</li>
 *     <li>随机的生成比例</li>
 *     <li>随机的0-100阿拉伯数字</li>
 *     <li>随机的&gt;&lt;字符</li>
 *     <li>按照比例输出正确/错误的表达式</li>
 *     <li>整体格式为字符串</li>
 * </ol>
 *
 * @author :Liangzy (Potato)
 * @date: 2021-11-03 21:21
 */
public class RandomN {

    /**
     * 主要执行的方法
     * <ol>
     *     执行逻辑
     *     <li>先,生成一个对的比例</li>
     *     <li>然后计算对应比例所对应的值</li>
     *     <li>然后开始随机生成0-100之间的数</li>
     *     <li>注意：这里不考虑生成的表达式参数相等的情况</li>
     * </ol>
     *
     * @param bound 表达式的数量
     * @return 返回一个表达式集合
     */
    public List<String> mainMethod(int bound) {
        // 容器
        ArrayList<String> containers = new ArrayList<>();
        // 统一随机对象
        Random random = new Random();
        // 生成对错比例
        double right = proportion();
        System.out.println("对的表达式比例->" + right);
        // 计算对错所对应的数量
        double rightNum = bound * right;
        for (int i = 0; i < bound; i++) {
            // 在0-100之间生成两组数字
            int toTheLeft = random.nextInt(100);
            int toTheRight = random.nextInt(100);
            if (toTheLeft == toTheRight) {
                containers.add(toTheLeft + "=" + toTheRight);
                continue;
            }
            if (i < rightNum) {
                containers.add(
                        toTheLeft > toTheRight ?
                                toTheLeft + ">" + toTheRight :
                                toTheLeft + "<" + toTheRight
                );
            } else {
                containers.add(
                        toTheLeft > toTheRight ?
                                toTheLeft + "<" + toTheRight :
                                toTheLeft + ">" + toTheRight
                );
            }
        }

        return containers;
    }

    /**
     * 随机生成比例
     *
     * @return 输出为对的比例, 相减则为错误比例
     */
    private double proportion() {
        double a = Math.random();
        DecimalFormat df = new DecimalFormat("0.00");
        return Double.parseDouble(df.format(a));
    }

    /**
     * 测试
     */
    public static void main(String[] args) {
        RandomN randomN = new RandomN();
        List<String> strings = randomN.mainMethod(100);
        // 循环输出
        strings.forEach(System.out::println);
    }

    /**
     * 随机生成&gt;&lt;字符
     */
    @Deprecated
    private char randomOperatorSymbol() {
        return randomStr(new char[]{'<', '>'});
    }

    @Deprecated
    private char randomStr(char[] strs) {
        int random_index = (int) (Math.random() * strs.length);
        return strs[random_index];
    }
}

编程题2

package com.liangzy.coding.nn;

/**
 * 数组重复计算
 *
 * <ol>
 *     此类的考虑点
 *     <li>利用泛型来提高类的可用性</li>
 *     <li>只满足基本业务，并不考虑并发的情况</li>
 *     <li>利用数组来实现去重的话，其根本是每次插入之前查询一次，但是数组查询性能并不是很高，数据量很大会有性能瓶颈</li>
 * </ol>
 * <ol>
 *     扩展优化点
 *     <li>其实这里更好的方法是模仿 HashSet 底层调用 HashMap去实现的去重</li>
 *     <li>当然我们还需要实现一些其他的引用类型,比如自建的对象的去重，那么这个就又需要
 *     有一套自己的数据比对处理逻辑,通过反射去拿到这个对象的真实类型，并且反射去取值，每个值每个进行比对</li>
 * </ol>
 *
 * @author :Liangzy (Potato)
 * @date: 2021-11-03 21:51
 */
public class ArraySet<T> {

    // size 用作每次元素的添加实际数据量
    private int size;

    // 用作底层真实存储的数组数据,但是不考虑并发的问题,如果是考虑并发,那就需要加锁/读写锁来解决
    T[] elementArray;

    public ArraySet(int defaultCapacity) {
        if (defaultCapacity > 0) {
            this.elementArray = (T[]) new Object[defaultCapacity];
        }
    }

    /**
     * 核心方法
     * <ol>
     *     <li>添加之前先查询是否存在于数组当中</li>
     *     <li>如果存在的话则直接返回false,如果不存在则添加,之后返回 true,代表添加成功</li>
     *     <li>在本例中这个返回参数并没有实际的作用</li>
     * </ol>
     *
     * @param object 插入的对象
     * @return 返回是否操作成功
     */
    public boolean add(T object) {
        // 去数组当中去查询
        for (int i = 0; size > 0 && i < size; i++) {
            if (elementArray[i].equals(object)) {
                return false;
            }
        }

        // 触发扩容
        if (size == elementArray.length) {
            grow();
        }
        // 增加到数组中
        elementArray[size] = object;
        this.size++;

        // 不考虑其他情况，如果程序执行到这里代表执行成功,并不做强一致的校验
        return true;
    }

    /**
     * 数组扩容
     * <ol>
     *     <li>这里不考虑任何空间上的优化，直接扩容 2 倍</li>
     * </ol>
     */
    private void grow() {
        // 新扩容的 array
        T[] obj = (T[]) new Object[size << 1];
        System.arraycopy(elementArray, 0, obj, 0, elementArray.length);
        elementArray = obj;
    }

    /**
     * 循环输出
     */
    public void foreachPrint() {
        for (int i = 0; size > 0 && i < size; i++) {
            System.out.println(elementArray[i]);
        }
    }

    /**
     * 测试
     * 给定一个数组,去重其中的元素
     */
    public static void main(String[] args) {
        // 注意看，这里有两个 G，所以符合题意这是一个重复的字符串数组
//        String[] str = new String[]{"A", "B", "C", "D", "E", "F", "G", "G"};
        Integer[] integer = new Integer[]{1, 2, 3, 4, 5, 6, 7, 7};
        // 接下来调用我们写的 ArraySet
        ArraySet<Integer> arraySet = new ArraySet<>(4);
        System.out.println("开始插入");
        for (int i = 0; i < integer.length; i++) {
            arraySet.add(integer[i]);
        }
        System.out.println("插入成功");
        // 最后输出
        arraySet.foreachPrint();
    }
}