经常有些面试官很变态，一般都是老阴逼级别的，喜欢问一些变态的问题。但是，反过来思考一下，这些题目也确实具备一些动手的能力，变相能够考查面试者的coding能力。
面试一：怎么样用数组实现不产过固定大小的队列和栈？
队列实现：
package code2.数组实现栈和队列_02;
public class Queue_02 {
class MyQueue {
private int pollIndex;
private int pushIndex;
private int size;
private int[] arr;
private int limit;
MyQueue(int limit) {
pollIndex = 0;
pushIndex = 0;
arr = new int[limit];
size = 0;
this.limit = limit;
}
private int nexIndex(int index) {
return index == limit-1 ? 0 : ++index;
}
public void push(int data) {
if (size == limit) {
System.out.println("队列满了，无法添加元素：" + data);
return;
}
arr[pushIndex] = data;
pushIndex = nexIndex(pushIndex);
size++;
}
public int poll () {
if (size == 0) {
System.out.println("队列为空，无法取出元素");
return -1;
}
int temp = arr[pollIndex];
pollIndex = nexIndex(pollIndex);
size--;
return temp;
}
}
public static void main(String[] args) {
Queue_02 test = new Queue_02();
MyQueue queue = test.new MyQueue(5);
for(int i = 0; i < 6; i++) {
queue.push(i);
}
System.out.println("取出对应元素" + queue.poll());
System.out.println("取出对应元素" + queue.poll());
System.out.println("取出对应元素" + queue.poll());
queue.push(11);
queue.push(12);
queue.push(13);
queue.push(14);
//遍历队列
System.out.println("=========遍历============");
for(int i =0; i < 5; i++) {
System.out.println("取出对应元素" + queue.poll());
}
}
}
栈实现：
package code2.数组实现栈和队列_02;
public class Stack_01 {
class MyStack {
private int[] arr = null;
private int index;
private int size;
public MyStack(int limit) {
arr = new int[limit];
size = limit;
index = 0;
}
public void pushElement (int data)
{
if (size == index) {
System.out.println("准备插入数据：" + data + " ,由于栈已满，无法插入成功");
return;
}
arr[index] = data;
index++;
}
public int pollElement()
{
if (index == 0) {
System.out.println("栈为空, 无法获取数据");
return -1;
}
index--;
int temp = arr[index];
return temp;
}
}
public static void main(String[] args) {
Stack_01 test = new Stack_01();
MyStack stack =test.new MyStack(5);
for (int i = 0; i < 8; i++) {
stack.pushElement(i);
}
for (int i = 0; i < 8; i++) {
System.out.println(stack.pollElement());
}
}
}
面试题二：
实现一个特殊的栈，在基本功能的基础上，再实现返回栈中最小元素的功能
1）pop、push、getMin操作的时间复杂度都是 O(1)。
2）设计的栈类型可以使用现成的栈结构
解题思路就是用2个数组，一个数组存储栈的元素，另一个数组这是存储栈中的最小值，下图是我手绘的流程：
package code2.数组实现栈和队列_02;
/**
* 实现一个特殊的栈，在基本功能的基础上，再实现返回栈中最小元素的功能
* 1）pop、push、getMin操作的时间复杂度都是 O(1)。
* 2）设计的栈类型可以使用现成的栈结构。
*/
public class Stack_03 {
class MyStack {
private int[] arr = null;
private int[] minArr = null;
private int index;
private int limit;
public MyStack(int limit) {
arr = new int[limit];
minArr = new int[limit];
this.limit = limit;
index = 0;
}
public void pushElement (int data)
{
if (index == limit) {
System.out.println("准备插入数据：" + data + " ,由于栈已满，无法插入成功");
return;
}
arr[index] = data;
setMin(data);
index++;
}
public int pollElement()
{
if (index == 0) {
System.out.println("栈为空, 无法获取数据");
return -1;
}
index--;
int temp = arr[index];
arr[index] = 0;
minArr[index] = 0;
return temp;
}
public void setMin(int data) {
if (index != 0) {
int temp = index;
int value = minArr[--temp];
if (data < value) {
minArr[index] = data;
}
else {
minArr[index] = value;
}
}
else {
minArr[0] = data;
}
}
public int getMin() {
int temp = index;
return minArr[--temp];
}
}
public static void main(String[] args) {
Stack_03 test = new Stack_03();
MyStack stack =test.new MyStack(5);
for (int i = 8; i > 6; i--) {
stack.pushElement(i);
}
stack.pushElement(11);
stack.pushElement(2);
stack.pushElement(13);
System.out.println("获取最小值：" + stack.getMin());
stack.pushElement(14);
System.out.println("删除：" + stack.pollElement());
System.out.println("获取最小值：" + stack.getMin());
System.out.println("删除：" + stack.pollElement());
System.out.println("获取最小值：" + stack.getMin());
System.out.println("删除：" + stack.pollElement());
System.out.println("获取最小值：" + stack.getMin());
stack.pushElement(6);
System.out.println("获取最小值：" + stack.getMin());
System.out.println("删除：" + stack.pollElement());
System.out.println("获取最小值：" + stack.getMin());
System.out.println("删除：" + stack.pollElement());
System.out.println("获取最小值：" + stack.getMin());
//8, 7,11,2,13
}
}
面试题三：用栈结构实现队列
package code2.数组实现栈和队列_02;
import java.util.Stack;
//栈实现队列
public class StackImpmentQueue {
private Stack stackPush;
private Stack stackPop;
public StackImpmentQueue()
{
stackPush = new Stack<Integer>();
stackPop = new Stack<Integer>();
}
public void push (int data)
{
if (!stackPop.isEmpty()) {
throw new RuntimeException("stackPop中还有数据待取出，无法添加新元素");
}
stackPush.push(data);
}
public int pop () {
while (!stackPush.isEmpty()) {
stackPop.push(stackPush.pop());
}
if (stackPop.isEmpty()) {
throw new RuntimeException("Queue is empty!");
}
return (int) stackPop.pop();
}
public static void main(String[] args)
{
StackImpmentQueue t = new StackImpmentQueue();
for (int i = 0; i < 5; i++) {
t.push(i);
}
for (int i = 0; i < 5; i++) {
System.out.println("get :" + t.pop());
}
for (int i = 11; i < 15; i++) {
t.push(i);
}
for (int i = 0; i < 5; i++) {
System.out.println("get :" + t.pop());
}
}
}
面试题四：用队列实现栈：
package code2.数组实现栈和队列_02;
import java.util.LinkedList;
import java.util.Queue;
//队列实现栈
public class QueueImplementStack {
private Queue queuePush;
private Queue queueBak;
public QueueImplementStack() {
queueBak = new LinkedList();
queuePush = new LinkedList();
}
public void push(int value) {
queuePush.add(value);
}
public int pop() {
if (queuePush.isEmpty()) {
throw new RuntimeException("队列为空，无法获取有效数据");
}
while(queuePush.size() > 1) {
queueBak.add(queuePush.poll());
}
Object val = queuePush.poll();
Queue temp = queueBak;
queueBak = queuePush;
queuePush = temp;
return (int)val;
}
public boolean isEmpty () {
return queuePush.isEmpty();
}
public static void main(String[] args) {
QueueImplementStack stack = new QueueImplementStack();
stack.push(1);
stack.push(2);
stack.push(3);
stack.push(4);
System.out.println("获取栈元素" + stack.pop());
stack.push(5);
System.out.println("获取栈元素" + stack.pop());
while (!stack.isEmpty()) {
System.out.println("获取栈元素" + stack.pop());
}
}
}
我有一个用户工厂。我希望默认情况下确认用户。但是鉴于unconfirmed特征，我不希望它们被确认。虽然我有一个基于实现细节而不是抽象的工作实现，但我想知道如何正确地做到这一点。factory:userdoafter(:create)do|user,evaluator|#unwantedimplementationdetailshereunlessFactoryGirl.factories[:user].defined_traits.map(&:name).include?(:unconfirmed)user.confirm!endendtrait:unconfirmeddoenden
我有一个涉及多台机器、消息队列和事务的问题。因此，例如用户点击网页，点击将消息发送到另一台机器，该机器将付款添加到用户的帐户。每秒可能有数千次点击。事务的所有方面都应该是容错的。我以前从未遇到过这样的事情，但一些阅读表明这是一个众所周知的问题。所以我的问题。我假设安全的方法是使用两阶段提交，但协议(protocol)是阻塞的，所以我不会获得所需的性能，我是否正确？我通常写Ruby，但似乎Redis之类的数据库和Rescue、RabbitMQ等消息队列系统对我的帮助不大——即使我实现某种两阶段提交，如果Redis崩溃，数据也会丢失，因为它本质上只是内存。所有这些让我开始关注erlang和
目录一.加解密算法数字签名对称加密DES(DataEncryptionStandard)3DES(TripleDES)AES(AdvancedEncryptionStandard)RSA加密法DSA(DigitalSignatureAlgorithm)ECC(EllipticCurvesCryptography)非对称加密签名与加密过程非对称加密的应用对称加密与非对称加密的结合二.数字证书图解一.加解密算法加密简单而言就是通过一种算法将明文信息转换成密文信息，信息的的接收方能够通过密钥对密文信息进行解密获得明文信息的过程。根据加解密的密钥是否相同，算法可以分为对称加密、非对称加密、对称加密和非
华为OD机试题本篇题目：明明的随机数题目输入描述输出描述：示例1输入输出说明代码编写思路最近更新的博客华为od2023|什么是华为od，od薪资待遇，od机试题清单华为OD机试真题大全，用Python解华为机试题|机试宝典【华为OD机试】全流程解析+经验分享,题型分享,防作弊指南华为o
C#实现简易绘图工具一.引言实验目的:通过制作窗体应用程序(C#画图软件),熟悉基本的窗体设计过程以及控件设计,事件处理等,熟悉使用C#的winform窗体进行绘图的基本步骤,对于面向对象编程有更加深刻的体会.Tutorial任务设计一个具有基本功能的画图软件**·包括简单的新建文件,保存,重新绘图等功能**·实现一些基本图形的绘制,包括铅笔和基本形状等,学习橡皮工具的创建**·设计一个合理舒适的UI界面**注明:你可能需要先了解一些关于winform窗体应用程序绘图的基本知识,以及关于GDI+类和结构的知识二.实验环境Windows系统下的visualstudio2017C#窗体应用程序三.
MIMO技术的优缺点优点通过下面三个增益来总体概括：阵列增益。阵列增益是指由于接收机通过对接收信号的相干合并而活得的平均SNR的提高。在发射机不知道信道信息的情况下，MIMO系统可以获得的阵列增益与接收天线数成正比复用增益。在采用空间复用方案的MIMO系统中，可以获得复用增益，即信道容量成倍增加。信道容量的增加与min(Nt,Nr)成正比分集增益。在采用空间分集方案的MIMO系统中，可以获得分集增益，即可靠性性能的改善。分集增益用独立衰落支路数来描述，即分集指数。在使用了空时编码的MIMO系统中，由于接收天线或发射天线之间的间距较远，可认为它们各自的大尺度衰落是相互独立的，因此分布式MIMO
遍历文件夹我们通常是使用递归进行操作，这种方式比较简单，也比较容易理解。本文为大家介绍另一种不使用递归的方式，由于没有使用递归，只用到了循环和集合，所以效率更高一些！一、使用递归遍历文件夹整体思路1、使用File封装初始目录，2、打印这个目录3、获取这个目录下所有的子文件和子目录的数组。4、遍历这个数组，取出每个File对象4-1、如果File是否是一个文件，打印4-2、否则就是一个目录，递归调用代码实现publicclassSearchFile{publicstaticvoidmain(String[]args){//初始目录Filedir=newFile("d:/Dev");Datebeg
目录第1题连续问题分析：解法：第2题分组问题分析：解法：第3题间隔连续问题分析：解法：第4题打折日期交叉问题分析：解法：第5题同时在线问题分析：解法：第1题连续问题如下数据为蚂蚁森林中用户领取的减少碳排放量iddtlowcarbon10012021-12-1212310022021-12-124510012021-12-134310012021-12-134510012021-12-132310022021-12-144510012021-12-1423010022021-12-154510012021-12-1523.......找出连续3天及以上减少碳排放量在100以上的用户分析：遇到这类
通常，数组被实现为内存块，集合被实现为HashMap，有序集合被实现为跳跃列表。在Ruby中也是如此吗？我正在尝试从性能和内存占用方面评估Ruby中不同容器的使用情况 最佳答案 数组是Ruby核心库的一部分。每个Ruby实现都有自己的数组实现。Ruby语言规范只规定了Ruby数组的行为，并没有规定任何特定的实现策略。它甚至没有指定任何会强制或至少建议特定实现策略的性能约束。然而，大多数Rubyist对数组的性能特征有一些期望，这会迫使不符合它们的实现变得默默无闻，因为实际上没有人会使用它:插入、前置或追加以及删除元素的最坏情况步骤复
在ruby中，你可以这样做:classThingpublicdeff1puts"f1"endprivatedeff2puts"f2"endpublicdeff3puts"f3"endprivatedeff4puts"f4"endend现在f1和f3是公共(public)的，f2和f4是私有(private)的。内部发生了什么，允许您调用一个类方法，然后更改方法定义？我怎样才能实现相同的功能(表面上是创建我自己的java之类的注释)例如...classThingfundeff1puts"hey"endnotfundeff2puts"hey"endendfun和notfun将更改以下函数定