作品集
主页
主页左侧预警分析
主页
主页
用户
附近人
消息
我的
编程题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>随机的><字符</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);
}
/**
* 随机生成><字符
*/
@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();
}
}