机试题-调整数组顺序使奇数位于偶数前面
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。
示例：
输入：nums = [1,2,3,4]
输出：[1,3,2,4]
注：[3,1,2,4] 也是正确的答案之一。
代码
/**
*
* <li>输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。</li>
* <li>输入：nums = [1,2,3,4]</li>
* <li>输出：[1,3,2,4]</li>
* <li>注：[3,1,2,4] 也是正确的答案之一。</li>
*/
public class Solution {
/**
* <li>输入数组nums，以下标0作为起始下标，进行一次类似于快排的做法，快排的标准就是奇数放在左边，偶数放右边</li>
*
* @param nums
* @return
*/
public static int[] exchange(int[] nums) {
int p = 0;
int len = nums.length;
for (int i = 0; i < len; i++) {
if ((nums[i] & 1) == 1) {
int tmp = nums[i];
nums[i] = nums[p];
nums[p++] = tmp;
}
}
return nums;
}
public static void main(String[] args) {
System.out.println("-----未调整的数组顺序----------");
int[] a = { 1, 2, 3, 4 };
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + " ");
}
System.out.println("");
System.out.println("-----调整数组顺序后----------");
int[] nums = exchange(a);
for (int i = 0; i < nums.length; i++) {
System.out.print(nums[i] + " ");
}
}
}
+++++++++++++++++++++++++++++++
机试题-最大交换-给定一个非负整数，你至多可以交换一次数字中的任意两位。返回你能得到的最大值。
示例 1 :
输入: 2736
输出: 7236
解释: 交换数字2和数字7。
示例 2 :
输入: 9973
输出: 9973
解释: 不需要交换。
注意:
给定数字的范围是 [0, 10^8]
package com.riskeys.service.impl;
/**
*
* <li>最大交换</li>
* <li>给定一个非负整数，你至多可以交换一次数字中的任意两位。返回你能得到的最大值</li>
* <li>示例 1 :</li>
* <li>输入: 2736</li>
* <li>输出: 7236</li>
* <li>解释: 交换数字2和数字7。</li>
* <li>示例 2 :</li>
* <li>输入: 9973</li>
* <li>输出: 9973</li>
* <li>解释: 不需要交换。</li>
*/
public class BigSwap {
public static int maximumSwap(int num) {
char[] A = Integer.toString(num).toCharArray();
System.out.println("----------生成last数组---------------");
int[] last = new int[10];
for (int i = 0; i < A.length; i++) {
// A[i] 为char类型，故需用A[i]-'0'转为数字类型
last[A[i] - '0'] = i; // 最后一次出现数字A[i]的下标i
}
System.out.println("----------比对交换------------------");
for (int i = 0; i < A.length; i++) {
for (int d = 9; d > A[i] - '0'; d--) {
if (last[d] > i) {
char tmp = A[i];
A[i] = A[last[d]];
A[last[d]] = tmp;
return Integer.valueOf(new String(A));
}
}
}
return num;
}
public static void main(String[] args) {
System.out.println("给定一个非负整数，你至多可以交换一次数字中的任意两位。返回你能得到的最大值");
System.out.println(maximumSwap(2736));
}
}
+++++++++++++++++++++++++++++++
机试题学习-删数
有一个数组a[N]顺序存放0~N-1，要求每隔两个数删掉一个数，到末尾时循环至开头继续进行，求最后一个被删掉的数的原始下标位置。以8个数(N=7)为例:｛0，1，2，3，4，5，6，7｝，0->1->2(删除)->3->4->5(删除)->6->7->0(删除),如此循环直到最后一个数被删除。
输入描述:
每组数据为一行一个整数n(小于等于1000)，为数组成员数,如果大于1000，则对a[999]进行计算。
输出描述:
一行输出最后一个被删掉的数的原始下标位置。
示例1
输入
8
输出
6
import java.util.*;
/**
* <li>题目中循环(从尾部循环到头部)肯定要取mod</li>
* <li>题目中要求每隔两个数删掉一个数，即找第三个数，i， i+1,i+2. i+2即是第三个数</li>
* <li>每组数据为一行一个整数n(小于等于1000)，为数组成员数,如果大于1000，则对a[999]进行计算。--> n大于1000时，n=999</li>
*/
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
int n = sc.nextInt();
if (n > 1000) {
n = 999;
}
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < n; i++) {
list.add(i);
}
int i = 0;
while (list.size() > 1) {
i = (i + 2) % list.size();// 取余
list.remove(i);// 删除i节点
}
System.out.println(list.get(0));
}
sc.close();
}
}
+++++++++++++++++++++++++++++++
机试题学习-扑克牌大小
扑克牌游戏大家应该都比较熟悉了，一副牌由54张组成，含3~A，2各4张，小王1张，大王1张。牌面从小到大用如下字符和字符串表示（其中，小写joker表示小王，大写JOKER表示大王）?
3 4 5 6 7 8 9 10 J Q K A 2 joker JOKER
输入两手牌，两手牌之间用“-”连接，每手牌的每张牌以空格分隔，“-”两边没有空格，如：4 4 4 4-joker JOKER
请比较两手牌大小，输出较大的牌，如果不存在比较关系则输出ERROR
基本规则：
（1）输入每手牌可能是个子，对子，顺子（连续5张），三个，炸弹（四个）和对王中的一种，不存在其他情况，由输入保证两手牌都是合法的，顺子已经从小到大排列；
（2）除了炸弹和对王可以和所有牌比较之外，其他类型的牌只能跟相同类型的存在比较关系（如，对子跟对子比较，三个跟三个比较），不考虑拆牌情况（如：将对子拆分成个子）
（3）大小规则跟大家平时了解的常见规则相同，个子，对子，三个比较牌面大小；顺子比较最小牌大小；炸弹大于前面所有的牌，炸弹之间比较牌面大小；对王是最大的牌；
（4）输入的两手牌不会出现相等的情况。
答案提示：
（1）除了炸弹和对王之外，其他必须同类型比较。
（2）输入已经保证合法性，不用检查输入是否是合法的牌。
（3）输入的顺子已经经过从小到大排序，因此不用再排序了.
输入描述:
输入两手牌，两手牌之间用“-”连接，每手牌的每张牌以空格分隔，“-”两边没有空格，如4 4 4 4-joker JOKER。
输出描述:
输出两手牌中较大的那手，不含连接符，扑克牌顺序不变，仍以空格隔开；如果不存在比较关系则输出ERROR。
输入例子1:
4 4 4 4-joker JOKER
输出例子1:
joker JOKER
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {// 多组录入
// 核心逻辑
printBigCard(sc.nextLine());
}
sc.close();
}
/**
* <p>
* 输出两手扑克牌中较大的那手
* </p>
* <li>1、除了炸弹和对王可以和所有牌比较之外，其他类型的牌只能跟相同的类型的存在比较关系</li>
* <li>2、个子、对子、三个和顺子比较牌面大小</li>
* <li>4、炸弹大于前面所有的牌，炸弹之间比较牌面大小</li>
* <li>5、对王是最大的牌</li>
* <li>6、如果不存在比较关系则输出ERROR</li>
* <li>7、一只手中是2张牌时可能就是对子或者王炸；是3张时就是有序的3张；4张时就是炸弹，5张时就是有序的张牌，不用考虑其他任何是否有杂牌或者无序的情况；</li>
* <li>8、另一只手中和前面一只手的类型不同(除了炸弹和王炸),则无法比较，直接报错ERROR</li>
* <li>9、每手牌类型 个子、对子、顺子（连续五张）、三个、炸弹（四个）和对王</li>
* @param str
* @return
*/
public static void printBigCard(String str) {
String[] total_str = str.split("-");
String[] left_str = total_str[0].split(" ");
String[] right_str = total_str[1].split(" ");
switch (left_str.length) {
case 1:// 如果左手是个子牌
if (right_str.length == 1) {// 右手是个子牌
if (getIndex(left_str[0]) > getIndex(right_str[0])) {// 比较牌面大小
System.out.println(total_str[0]);
} else {
System.out.println(total_str[1]);
}
} else if (right_str.length == 4 || total_str[1].equals("joker JOKER")) {// 右手是炸弹和王炸
System.out.println(total_str[1]);
} else {
System.out.println("ERROR");
}
break;
case 2:// 如果左手是对子
if (total_str[0].equals("joker JOKER")) {
System.out.println(total_str[0]);
} else {
if (right_str.length == 2) {
if (total_str[1].equals("joker JOKER")) {// 右手是王炸
System.out.println(total_str[1]);
} else {
if (getIndex(left_str[0]) > getIndex(right_str[0])) {// 比较牌面大小
System.out.println(total_str[0]);
} else {
System.out.println(total_str[1]);
}
}
} else if (right_str.length == 4) {// 右手是炸弹
System.out.println(total_str[1]);
} else {
System.out.println("ERROR");
}
}
break;
case 3:// 左手3张牌
if (right_str.length == 3) {// 右手3张牌
if (getIndex(left_str[0]) > getIndex(right_str[0])) {// 比较牌面大小
System.out.println(total_str[0]);
} else {
System.out.println(total_str[1]);
}
} else if (right_str.length == 4 || total_str[1].equals("joker JOKER")) {// 右手是炸弹或者王炸
System.out.println(total_str[1]);
} else {
System.out.println("ERROR");
}
break;
case 4:// 左手炸弹4张
if (right_str.length == 4) {// 右手4张牌
if (getIndex(left_str[0]) > getIndex(right_str[0])) {// 比较牌面大小
System.out.println(total_str[0]);
} else {
System.out.println(total_str[1]);
}
} else if (total_str[1].equals("joker JOKER")) {
System.out.println(total_str[1]);
} else {// 右手的牌既不是炸弹也不是王炸，则右手牌小于左手的牌
System.out.println(total_str[0]);
}
break;
case 5:// 左手顺子5张
if (right_str.length == 5) {// 右手3张牌
if (getIndex(left_str[0]) > getIndex(right_str[0])) {// 比较牌面大小
System.out.println(total_str[0]);
} else {
System.out.println(total_str[1]);
}
} else if (right_str.length == 4 || total_str[1].equals("joker JOKER")) {
System.out.println(total_str[1]);
} else {
System.out.println("ERROR");
}
break;
}
}
/**
* <p>
* 获取牌面对应的排序下标
* </p>
* <li>str是牌面的字符，将所有牌面字符转化到字符数组中，我们就可以排序</li>
*
* @param str
* @return
*/
public static int getIndex(String str) {
String[] tmpStr = { "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2", "joker", "JOKER" };
for (int i = 0; i < tmpStr.length; i++) {
if (tmpStr[i].equals(str)) {
return i;
}
}
return -1;
}
}
+++++++++++++++++++++++++++++++
机试题学习-简单错误记录
机试题学习-简单错误记录
[编程题] 简单错误记录
时间限制：1秒
空间限制：65536K
开发一个简单错误记录功能小模块，能够记录出错的代码所在的文件名称和行号。
处理:
1.记录最多8条错误记录，对相同的错误记录(即文件名称和行号完全匹配)只记录一条，错误计数增加；(文件所在的目录不同，文件名和行号相同也要合并)
2.超过16个字符的文件名称，只记录文件的最后有效16个字符；(如果文件名不同，而只是文件名的后16个字符和行号相同，也不要合并)
3.输入的文件可能带路径，记录文件名称不能带路径
输入描述:
一行或多行字符串。每行包括带路径文件名称，行号，以空格隔开。
文件路径为windows格式
如：E:\V1R2\product\fpgadrive.c 1325
输出描述:
将所有的记录统计并将结果输出，格式：文件名代码行数数目，一个空格隔开，如: fpgadrive.c 1325 1
结果根据数目从多到少排序，数目相同的情况下，按照输入第一次出现顺序排序。
如果超过8条记录，则只输出前8条记录.
如果文件名的长度超过16个字符，则只输出后16个字符
输入例子1:
E:\V1R2\product\fpgadrive.c 1325
输出例子1:
fpgadrive.c 1325 1
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
/**
*
* <li>List可使用contains()方法来查重并去重,但contains()的判断逻辑要用到equals和hashCode方法，所以要重写equals和hashCode方法</li>
* <li>List使用集合工具类Collections的方法sort进行排序，compareTo进行排序</li>
* <li>字符串截取处理函数substring(beginIndex,endIndex)</li>
* <li>list比set更适合处理该问题，list可查重contains，排序sort，获取下标indexOf</li>
* <li>在本地开发工具中不能调试这题目，因为题目中没有给定输入到底有多少行，sc.hasNext()一直在循坏，估计他们已经重写了hasNext()方法，可以自动停止循环</li>
*
* @author xinghua.liu
*
*/
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);// 从键盘获取用户输入的命令或数据
List<ErrorLog> list = new LinkedList<>();
String fileName = null;
// 1.输入多组测试数据
while (sc.hasNext()) {// 循环，可支持多组测试数据
fileName = sc.next();// next方式接收字符串,并截取文件名(文件路径是以一个反斜杠间隔，但是字符串中的反斜杠是两个)
ErrorLog fTemp = new ErrorLog(fileName.substring(fileName.lastIndexOf("\\") + 1, fileName.length()),
sc.nextInt());
if (list.contains(fTemp)) { // 判断list中是否已包含数据记录fTemp
int indexNUm = list.indexOf(fTemp);// 获取元素fTemp所在的下标
list.get(indexNUm).num++;// 题目要求:对相同的错误记录(即文件名称和行号完全匹配)只记录一条，错误计数增加
} else {
fTemp.num = 1;
list.add(fTemp);
}
}
sc.close(); // 关闭键盘输入
// 2.输入完毕后进行后续操作；排序和按题目要求输出
Collections.sort(list); // 排序
for (int i = 0; i < 8 && i < list.size(); i++) {// 如果超过8条记录，则只输出前8条记录
ErrorLog fTemp = list.get(i);// 获取对应list对应下标下的元素fTemp
// 如果文件名的长度超过16个字符，则只输出后16个字符
String nameTemp = fTemp.fileName.length() > 16
? fTemp.fileName.substring(fTemp.fileName.length() - 16, fTemp.fileName.length()) : fTemp.fileName;
System.out.println(nameTemp + " " + fTemp.row + " " + fTemp.num);// 按文件格式输出
}
System.out.println("执行完毕");
}
}
class ErrorLog implements Comparable<ErrorLog> {// 错误日志对象，实现Comparable接口
String fileName; // 文件名
int row; // 行号
int num;// 错误计数
public ErrorLog(String fileName, int row) {
this.fileName = fileName;
this.row = row;
}
@Override
public int hashCode() {
return 1;
}
// 比较
@Override
public boolean equals(Object obj) {
if (obj instanceof ErrorLog) {
ErrorLog o = (ErrorLog) obj;
return (this.row == o.row && this.fileName.equals(o.fileName)) ? true : false;
}
return false;
}
// 排序，按题目要求重写compareTo方法-结果根据数目从多到少排序，数目相同的情况下，按照输入第一次出现顺序排序
@Override
public int compareTo(ErrorLog o) {
if (this.num == o.num)
return 0;
return this.num > o.num ? -1 : 1;
}
}
+++++++++++++++++++++++++++++++
机试题-把字符串中的单词拼写翻转
把字符串中的单词拼写翻转，文中单词以英文空格分隔，整个句子单词顺序不变 This is a Java test
[output]:sihT a avaj tset
package test.interview;
/**
* 把字符串中的单词拼写翻转，文中单词以英文空格分隔，整个句子单词顺序不变 This is a Java test
* [output]:sihT a avaj tset
* **/
public class TestString {
public static void main(String[] args) {
String aa="This is a Java test";
StringBuffer dd=changeStr(aa);
System.out.println(dd);
}
public static StringBuffer changeStr(String aa){
String[] cc=aa.split(" ");
StringBuffer ee=new StringBuffer();
for (int i = 0; i < cc.length; i++) {
StringBuffer s=new StringBuffer(cc[i]);
if(i==(cc.length-1)){
ee.append(s.reverse());
}else{
ee.append(s.reverse()+" ");
}
}
return ee;
}
}
+++++++++++++++++++++++++++++++
6万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
