Java学习---程序设计_面试题[2]
百度2017春招笔试真题编程题集合之买帽子
// 2017-10-09
// 题目描述
// 度度熊想去商场买一顶帽子，商场里有N顶帽子，有些帽子的价格可能相同。度度熊想买一顶价格第三便宜的帽子，问第三便宜的帽子价格是多少？
// 输入描述:
// 首先输入一个正整数N（N <= 50），接下来输入N个数表示每顶帽子的价格（价格均是正整数，且小于等于1000）
// 输出描述:
// 如果存在第三便宜的帽子，请输出这个价格是多少，否则输出-1
// 输入例子:
// 10
// 10 10 10 10 20 20 30 30 40 40
// 输出例子:
// -------------------------------------------------
package com.huawei.test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner; /**
输入描述:
首先输入一个正整数N（N <= 50），接下来输入N个数表示每顶帽子的价格（价格均是正整数，且小于等于1000）
输出描述:
如果存在第三便宜的帽子，请输出这个价格是多少，否则输出-1
输入例子:
10
10 10 10 10 20 20 30 30 40 40
输出例子:
30
*/
public class Test {
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
while(scan.hasNext()){
//输入一个正整数
int n = scan.nextInt();
//开辟空间
int[] prices = new int[n];
//读取价格
for(int i = 0; i < prices.length; i++){
prices[i] = scan.nextInt();
}
//价格排序
Arrays.sort(prices);
ArrayList<Integer> list = new ArrayList<>();
//去重复
for(int i = 0;i < n; i++){
if(!list.contains(prices[i])){
list.add(prices[i]);
}
}
if(list.size()<3){
System.out.println(-1);
}else{
System.out.println(list.get(2));
} }
}
}
寻找三角形
/**
* 题目描述
*
* 三维空间中有N个点，每个点可能是三种颜色的其中之一，三种颜色分别是红绿蓝，分别用'R', 'G', 'B'表示。
* 现在要找出三个点，并组成一个三角形，使得这个三角形的面积最大。
* 但是三角形必须满足：三个点的颜色要么全部相同，要么全部不同。
* 输入描述: 首先输入一个正整数N三维坐标系内的点的个数.(N <= 50) 接下来N行
* 每一行输入 c x y z，c为'R', 'G', 'B'的其中一个。
* x，y，z是该点的坐标。(坐标均是0到999之间的整数)
* 输出描述: 输出一个数表示最大的三角形面积，保留5位小数。
* 输入例子:
* 5
* R 0 0 0
* R 0 4 0
* R 0 0 3
* G 92 14 7
* G 12 16 8
* 输出例子: 6.00000
*/
package com.ftl.test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 输入一个正整数Ｎ
System.out.println("Please input the Num:");
int n = sc.nextInt();
// N行 N 个数组
String[] nums = new String[n];
// 初始化
double temp = 0.0;
double area = Double.MAX_VALUE;
// 输入N行，用数组保存
for (int i = 0; i < n; i++) {
nums[i] = sc.nextLine();
}
// 获取颜色
char[] colors = new char[n];
for (int i = 0; i < n; i++) {
colors[i] = nums[i].split(" ")[0].charAt(0);
}
// 获取X轴
int[] x = new int[n];
for (int i = 0; i < n; i++) {
x[i] = Integer.parseInt(nums[i].split(" ")[1]);
}
// 获取Y轴
int[] y = new int[n];
for (int i = 0; i < n; i++) {
x[i] = Integer.parseInt(nums[i].split(" ")[2]);
}
// 获取Z轴
int[] z = new int[n];
for (int i = 0; i < n; i++) {
x[i] = Integer.parseInt(nums[i].split(" ")[3]);
}
// 进行判断 三个点的颜色要么全部相同，要么全部不同
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
for (int k = j + 1; k < n; k++) {
if (colors[i] == colors[j] && colors[j] == colors[k]
|| colors[i] != colors[j] && colors[j] != colors[k]
&& colors[k] != colors[i]) {
if (colors[i] == colors[j] && colors[j] == colors[k]
|| colors[i] != colors[j]
&& colors[j] != colors[k]
&& colors[i] != colors[k]) {
double a = Math
.pow(Math.pow(Math.abs(x[i] - x[j]), 2)
+ Math.pow(Math.abs(y[i] - y[j]), 2)
+ Math.pow(Math.abs(z[i] - z[j]), 2),
0.5);
double b = Math
.pow(Math.pow(Math.abs(x[i] - x[k]), 2)
+ Math.pow(Math.abs(y[i] - y[k]), 2)
+ Math.pow(Math.abs(z[i] - z[k]), 2),
0.5);
double c = Math
.pow(Math.pow(Math.abs(x[k] - x[j]), 2)
+ Math.pow(Math.abs(y[k] - y[j]), 2)
+ Math.pow(Math.abs(z[k] - z[j]), 2),
0.5); double p = (a + b + c) / 2;
// 海伦公式求空间三角形面积
temp = Math.pow(p * (p - a) * (p - b) * (p - c),
0.5);
if (area < temp) {
area = temp;
}
}
}
}
}
}
System.out.printf("%.2f",area);
}
}
输出不同的元素的个数
package com.ftl;
/**
* 输入字符串长度len1，字符串s1，字符串长度len2，字符串s2。
* 从后向前比较，以最短字符串为标准，输出不同的元素的个数。
* 例如: 输入：s1="1,3,5" len1=3 s2="2,4,1,7,5" len2=5
输出：2
函数原型 public int getDiffNum(int len1, String s1, int len2, String s2)
*
* @author ftl
*/ public class HWText {
public static void main(String[] args){
String s1="1,3,5";
int len1=3;
String s2="2,4,2,7,6";
int len2=5;
int diffNum= getDiffNum(s1,len1,s2,len2);
System.out.println("不同的数目："+diffNum);
} public static int getDiffNum(String s1,int len1, String s2, int len2){
int num = 0;
//字符串转换为字符数组
String[] str1 = s1.split(",");
String[] str2 = s2.split(",");
//以最端的字符串为标准(换言之，就是确定循环的次数)
int len = len1<len2?len1:len2;
for (int i = 0; i < len; i++) {
//判断是否相等
if(!str1[len1-1-i].equals(str2[len2-1-i])){
num++;
}
}
return num;
}
}
混合运算
package com.ftl; import java.util.ArrayList;
import java.util.List; /**
输入一个表达式，没有括号，数字小于0-9之间，输出计算结果，所有的中间结果化为整形。
例如: 输入：3+8×2/9-2
输出：2
* @author ftl
*/ public class HWText {
public static void main(String[] args){
String s="3+8×2/9-2 ";
int result=getMyRet(s);
System.out.println("最后结果："+result);
} public static int getMyRet(String s){
int len = s.length();
List<String> list = new ArrayList<>();
//字符串变成集合
for(int i = 0; i < len; i++){
list.add(s.charAt(i)+"");
}
System.out.println("list--->"+ list);//list--->[3, +, 8, ×, 2, /, 9, -, 2,
for(int i = 0; i<list.size(); i++){
if(list.get(i).equals("x")){
//计算乘法
int ji = Integer.parseInt(list.get(i-1))*Integer.parseInt(list.get(i+1));
//将积放在集合中，整个位置都后移一位，8现在是i的位置
list.add(i-1,ji+"");
//删除原来的位置
list.remove(i); //删除8
list.remove(i); //删除*
list.remove(i); //删除2
System.out.println("list--x后->"+ list);//list--x后->[3, +, 16, /, 9, -, 2, ]
//回到积的位置，再次参与运算
i--;
}else if(list.get(i).equals("/")){
int shang = Integer.parseInt(list.get(i-1))/Integer.parseInt(list.get(i+1));
list.add(i-1,shang+"");
list.remove(i); //删除16
list.remove(i); //删除/
list.remove(i); //删除9
System.out.println("list--/后->"+ list);//list--/后->[3, +, 1, -, 2, ]
i--; //回到商的位置
}
}
//新的list，只有+-,注意用新的变量k，否则会编译报错
for(int k=0;k<list.size();k++){//这个时候是新的size
if(list.get(k).equals("+")){
int he=Integer.parseInt(list.get(k-1))+Integer.parseInt(list.get(k+1));
list.add(k-1,he+"");
list.remove(k);
list.remove(k);
list.remove(k);
System.out.println("list--+后->"+ list); //list--+后->[4, -, 2, ]
k--;
}
if(list.get(k).equals("-")){
int cha=Integer.parseInt(list.get(k-1))-Integer.parseInt(list.get(k+1));
list.add(k-1,cha+"");
list.remove(k);
list.remove(k);
list.remove(k);
System.out.println("list-- -后->"+ list); //list-- -后->[2, ]
k--;
}
}
return Integer.parseInt(list.get(0));
}
}
二叉树算法描述
二叉树的遍历是指按照某条搜索路径访问树中的每个节点，使得每个节点的均只被访问一次。由二叉树的递归定义，遍历一棵二叉树便要决定对根节点、左子树和右子树的访问顺序。
常见的遍历次序有先序遍历、中序遍历和后序遍历。其中序指的是根节点在何时被访问。
先序遍历(PreOrder)：若二叉树非空，则先访问根节点，再访问左子树，最后访问右子树。
中序遍历(InOrder)：若二叉树非空，则先访问左子树，再访问根节点，最后访问右子树。
后序遍历(PostOder)：若二叉树非空，则先访问左子树，再访问右子树，最后访问根节点。
统计字符串中某个字符出现的次数
package com.ftl;
public class HelloFtl {
public static void main(String[] args) {
// TODO 自动生成的方法存根
System.out.println("----------------------------------------");
String str = "want you know one thing";
int count = 0;
int count1 = 0;
char[] c = str.toCharArray();
for ( int i = 0; i < c.length; i++)
{
if (c[i] == 'o')
{
count++;
}
if (c[i] == 'n')
{
count1++;
}
}
System.out.println("O出现的次数为：" + count);
System.out.println("n出现的次数为：" + count1);
System.out.println("----------------------------------------");
int c1 = 0;
while ( str.indexOf("n") != -1) //indexOf存在则返回所处位置，否则返回-1
{
c1++;
//改变字符串数量
str = str.substring(str.indexOf("n") + 1);
System.out.println("Str "
+ "为：" + str);
}
System.out.println("n出现的次数为：" + c1);
}
}
输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数
package com.ftl; import java.util.HashMap;
import java.util.Map;
/**
*题目：输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。
*1.程序分析：利用循环,使用Map存储数据.其实完全可以使用4个变量来解决,这边舍近求远复习下Map啦
*
* @author 小a玖拾柒
* Date: 2018年8月18日
*
*/
public class Test2018 {
public static void main(String[] args) {
String str = "abcd 1234 ef *";
check(str);
check2(str);
check3(str);
}
// 方案一： 设定变量，根据数组ch[i]实现
private static void check(String str) {
int shuzi = 0;
int zifu = 0;
int kongge = 0;
int qita = 0;
char[] ch = str.toCharArray();
for(int i = 0; i < ch.length; i++){
if(String.valueOf(ch[i]).matches("\\d+")){
shuzi++;
}else if(String.valueOf(ch[i]).matches("\\w+")){
zifu++;
}else if(String.valueOf(ch[i]).matches("\\s+")){
kongge++;
}else{
qita++;
}
}
System.out.println("【方案一】" + "数字：" + shuzi + "、字符：" + zifu + "、空格：" + kongge + "、其他：" + qita);
}
// 方案二： 设定变量，根据charAt(i)实现
private static void check2(String str) {
int shuzi = 0;
int zifu = 0;
int kongge = 0;
int qita = 0;
for(int i = 0; i < str.length(); i++){
if(String.valueOf(str.charAt(i)).matches("\\d+")){
shuzi++;
}else if(String.valueOf(str.charAt(i)).matches("\\w+")){
zifu++;
}else if(String.valueOf(str.charAt(i)).matches("\\s+")){
kongge++;
}else{
qita++;
}
}
System.out.println("【方案二】" +"数字：" + shuzi + "、字符：" + zifu + "、空格：" + kongge + "、其他：" + qita);
}
// 方案三： 设定变量，根据map实现
private static void check3(String str) {
Map<String,Integer> map = new HashMap<>();
map.put("数字",0);
map.put("字符",0);
map.put("空格",0);
map.put("其他",0);
for(int i = 0; i < str.length(); i++){
if(String.valueOf(str.charAt(i)).matches("\\d+")){
map.put("数字", map.get("数字")+1);
}else if(String.valueOf(str.charAt(i)).matches("\\w+")){
map.put("字符", map.get("字符")+1);
}else if(String.valueOf(str.charAt(i)).matches("\\s+")){
map.put("空格", map.get("空格")+1);
}else{
map.put("其他", map.get("其他")+1);
}
}
System.out.println("【方案三】" +map);
}
}
简单的登录验证系统
package com.ftl; import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader; class Check
{
private int age = 11; // 内部类
public boolean validate(String name, String password)
{
if (name.equals("ftl") &&
password.equals("1012"))
{
return true;
}
else
{
return false;
} }
} class Operate
{
private String info[]; public Operate(String info[])
{
this.info = info;
}
public String login()
{
Check check = new Check();
String name = this.info[0];
String password = this.info[1];
String str = null;
if (check.validate(name, password))
{
str = "Welcome " + name.toUpperCase() +" comingg ";
}
else
{
str = "No Welcome " + name.toUpperCase() +" comingg ";
}
return str;
}
} public class HelloFtl
{
public static void main(String args[])
{
String[] arg = new String[2];
BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Input the name and password[换行表示结束]: ") ;
for(int i = 0; i < arg.length; i++ ){
try
{
arg[i] = buf.readLine() ;
} catch (IOException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}
boolean flag = new Check().validate(arg[0], arg[1]);
System.out.println("-------------------------------------------");
if(flag){
Operate oper = new Operate(arg);
System.out.println(oper.login());
System.out.println("黄沙百战穿金甲，不破楼兰终不还");
} }
}
加减乘除计算
package com.ftl; import java.util.ArrayList;
import java.util.List; /**
输入一个表达式，没有括号，数字小于0-9之间，输出计算结果，所有的中间结果化为整形。
例如: 输入：3+8×2/9-2
输出：2
* @author ftl
*/ public class HWText {
public static void main(String[] args){
String s="3+8×2/9-2 ";
int result=getMyRet(s);
System.out.println("最后结果："+result);
} public static int getMyRet(String s){
int len = s.length();
List<String> list = new ArrayList<>();
//字符串变成集合
for(int i = 0; i < len; i++){
list.add(s.charAt(i)+"");
}
System.out.println("list--->"+ list);//list--->[3, +, 8, ×, 2, /, 9, -, 2,
for(int i = 0; i<list.size(); i++){
if(list.get(i).equals("x")){
//计算乘法
int ji = Integer.parseInt(list.get(i-1))*Integer.parseInt(list.get(i+1));
//将积放在集合中，整个位置都后移一位，8现在是i的位置
list.add(i-1,ji+"");
//删除原来的位置
list.remove(i); //删除8
list.remove(i); //删除*
list.remove(i); //删除2
System.out.println("list--x后->"+ list);//list--x后->[3, +, 16, /, 9, -, 2, ]
//回到积的位置，再次参与运算
i--;
}else if(list.get(i).equals("/")){
int shang = Integer.parseInt(list.get(i-1))/Integer.parseInt(list.get(i+1));
list.add(i-1,shang+"");
list.remove(i); //删除16
list.remove(i); //删除/
list.remove(i); //删除9
System.out.println("list--/后->"+ list);//list--/后->[3, +, 1, -, 2, ]
i--; //回到商的位置
}
}
//新的list，只有+-
for(int k=0;k<list.size();k++){//这个时候是新的size
if(list.get(k).equals("+")){
int he=Integer.parseInt(list.get(k-1))+Integer.parseInt(list.get(k+1));
list.add(k-1,he+"");
list.remove(k);
list.remove(k);
list.remove(k);
System.out.println("list--+后->"+ list); //list--+后->[4, -, 2, ]
k--;
}
if(list.get(k).equals("-")){
int cha=Integer.parseInt(list.get(k-1))-Integer.parseInt(list.get(k+1));
list.add(k-1,cha+"");
list.remove(k);
list.remove(k);
list.remove(k);
System.out.println("list-- -后->"+ list); //list-- -后->[2, ]
k--;
}
}
return Integer.parseInt(list.get(0));
}
}
生成随记不重复ID
import java.util.Random; /**
* 各种id生成策略
* <p>Title: IDUtils</p>
* <p>Description: </p>
* @version 1.0
*/
public class IDUtils { /**
* 图片名生成
*/
public static String genImageName() {
//取当前时间的长整形值包含毫秒
long millis = System.currentTimeMillis();
//long millis = System.nanoTime();
//加上三位随机数
Random random = new Random();
int end3 = random.nextInt(999);
//如果不足三位前面补0
String str = millis + String.format("%03d", end3); return str;
} /**
* 商品id生成
*/
public static long genItemId() {
//取当前时间的长整形值包含毫秒
long millis = System.currentTimeMillis();
//long millis = System.nanoTime();
//加上两位随机数
Random random = new Random();
int end2 = random.nextInt(99);
//如果不足两位前面补0
String str = millis + String.format("%02d", end2);
long id = new Long(str);
return id;
} public static void main(String[] args) {
for(int i=0;i< 100;i++)
System.out.println(genItemId());
}
}
就餐问题抽查情况
/**
问题描述： 某公司由于人多，午餐分为多批次就餐，严格要求每批次就餐时间。并定期抽查就餐情况。请编写程序实现就餐抽查情况。
• 要求实现函数： void check_lunch(int num, int time,int input[], int output[])
【输入】 int num，就餐总人数 int time，就餐分批数 char input[]，就餐情况
【输出】 char output[]， 违规就餐情况
【返回】 无 注：对就餐分3批的情况，12人就餐，正确的就餐情况应如下分布[1,2,3,1,2,3,1,2,3,1,2,3]，不符合该分布的即是违规，输出时对相应位置0。
• 示例
1） 输入：num = 12，time = 3，input =[1,2,3,3,1,3,1,1,1,1,2,3] 输出：output = [1,2,3,0,0,3,1,0,0,1,2,3]
2） 输入：num = 11，time = 4，input =[1,2,3,4,2,3,3,4,1,2,3] 输出：output = [1,2,3,4,0,0,3,4,1,2,3]
• 算法思路：
比较简单，对数组中的元素进行取余运算判断与输入的关系
•算法代码：
* @author ftl
*/ public class FTL2018 {
public static void main(String[] args){
int[] num = {1,2,3,3,1,3,1,1,1,1,2,3};
int[] output = sort(num, num.length);
}
public static int[] sort(int[] num, int len){
int count = 0;
int output[] = new int[len];
System.out.println("输入数据：" + Arrays.toString(num));
for (int i = 1; i <= len; i++) {
// 位置上的数字准确
if(i % 3 == num[i-1]){
output[i-1] = num[i-1];
}else if(i % 3 == 0 && num[i-1] == 3) {
output[i-1] = num[i-1];
}else{
output[i-1] = 0;
}
if(output[i-1] == 0){
count++;
}
}
System.out.println("输出数据：" + Arrays.toString(output));
System.out.println("共有" + count + "个人违规"); return output; }
}
输入联想【正则匹配】
package com.ftl; import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern; /**
问题描述： 输入联想功能是非常实用的一个功能，请编程实现类似功能。
• 要求实现函数： void auto_complete(char *str, char *tmp,char *output)
【输入】 char *str，候选字符串 char *tmp，输入字符串
【输出】 int *output，联想匹配的字符串
【返回】 无 注：候选字符串以空格隔开，输入字符串仅从字符串开始处匹配。将匹配的子字符串输出，同样以空格隔开。如无匹配成功的子字符串，则输出空字符串。
• 示例
1） 输入：str = chengdu chongqing，tmp = c 输出：output = chengdu Chongqing
2） 输入：str = chengdu chongqing，tmp = che 输出：end = Chengdu
3） 输入：str = beijing nanjing，tmp = jing 输出：end =
•算法思路：字符串匹配，充分利用容器string的优势，给出两种代码：一种利用string，一种利用字符串数组。 •算法代码：
* @author ftl
*/ public class FTL2018 {
public static void main(String[] args){
String str = "chengdu,chongqing,changan";
String tmp = "che";
auto_complete(str, tmp);
auto_complete1(str, tmp);
}
//方案一： 利用正则进行查找
public static void auto_complete(String str, String tmp){
List<String> list = new ArrayList<>();
String[] s = str.split(",");
for(int i = 0; i < s.length; i++){
String regex = tmp + "[a-zA-Z]";
Matcher p = Pattern.compile(regex).matcher(s[i]);
if(p.find()){
list.add(s[i]);
}
}
System.out.println("匹配成功["+ list.size() +"]\n" + list);
}
//方案二： 利用String类的startWith()方法
public static void auto_complete1(String str, String tmp){
List<String> list = new ArrayList<>();
String[] s = str.split(",");
for(int i = 0; i < s.length; i++){
if(s[i].startsWith(tmp)){
list.add(s[i]);
}
}
System.out.println("匹配成功["+ list.size() +"]\n" + list);
}
}
正则学习
package com.ftl; import java.util.regex.Matcher;
import java.util.regex.Pattern; public class Test2018 {
public static void main(String[] args) {
//需要进行爬虫的字符串
String s = "shshska13966668888hdjd13966668888iaj";
//写正则
String regex = "s\\w";
//把正则表达式编译成一个正则对象
Pattern p = Pattern.compile(regex);
//获取匹配器
Matcher m = p.matcher(s);
while(m.find()){
System.out.println(m.group());
}
}
}
有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中
package com.ftl; import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Vector; /**
* 题目：有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。
* @author 小a玖拾柒
* Date: 2018年8月18日
*/ public class Test2018 { public static void main(String[] args) {
int[] ch = new int[]{1,2,3,5,6,7,9,12,16}; //已经排好序的数组
int num = 15;
// 方案一： 排序判断,有小问题，针对此案例，问题不大
addNumber(ch, num ); // 方案二： 利用Collections工具类
List<Integer> list = new Vector<>();
for(int i = 0; i < ch.length; i++){
list.add(ch[i]);
}
list.add(num);
Collections.sort(list);
System.out.println("【方案二】:" + list); // 方案三： 利用System类
String str = "1,2,3,5,6,7,9,12,16";
String[] arr = str.split(",");
String[] abc = new String[arr.length + 1];
int flag = 0;
for(int i = 0; i < arr.length; i++){
if(Integer.valueOf(arr[i]) > num){
flag = i;
break;
}
}
System.arraycopy(arr, 0, abc, 0, flag);
abc[flag] = String.valueOf(num);
System.arraycopy(arr, flag, abc, flag+1, 1);
System.out.println("【方案三】:" + Arrays.toString(abc));
} public static int[] addNumber(int[] ch, int num){ int[] arr = new int[ch.length + 1];
int tmp = 0;
for(int i = 0; i < ch.length; i++){
// 如果小，则不动
if(ch[i] < num){
arr[i] = ch[i];
}else{
arr[i] = num;
tmp = i;
break;
}
}
for(int i = tmp ; i < ch.length; i++){
arr[i+1] = ch[i];
}
System.out.println("【方案一】:" + Arrays.toString(arr));
return arr;
}
}
有200个小朋友拉成一个圆圈，从其中某一个小朋友开始依次编号1－200，从1号小朋友开始循环1－3报数，数到3的小朋友就退出。编写一个Java应用程序，计算出最后一个小朋友的号码是多少。
package com.ftl; import java.util.ArrayList;
import java.util.List;
import java.util.Scanner; /**
* 有200个小朋友拉成一个圆圈，从其中一个小朋友开始依次编号1－200，
* 从1号小朋友开始循环1－3报数，数到3的小朋友就退出。
* 编写一个Java应用程序，计算出最后一个小朋友的号码是多少。
*
* 1 2 3 1 2 3 1 2 3
* @author 小a玖拾柒
* Date: 2018年8月18日
*/ public class Test2018 { public static void main(String[] args) {
System.out.println("输入有多少个小朋友:");
Scanner s = new Scanner(System.in);
int n = s.nextInt(); List<Integer> l = new ArrayList<Integer>();
for(int i=1; i<=n; i++){
l.add(i);
}
System.out.println(play(l, 0, 3));
} /**
* @param l 剩下小朋友List
* @param n 第n个开始报数
* @param m 数到m的人退出
* @return 最后一个小朋友的号码
*/
public static int play(List<Integer> list, int n, int m){
int num = list.size();
// 仅剩余一个学生, 返回最后一个学生的信息
if(num <= 1 ){
return list.get(0);
}else{
n = n + m - 1;
while(n >= num)
n = n - num;
list.remove(n);
return play(list, n, m);
}
}
}
取一个整数a从右端开始的4～7位
package com.ftl; import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Scanner; /**
取一个整数a从右端开始的4～7位。
* @author 小a玖拾柒
* Date: 2018年8月18日
*/ public class Test2018 { public static void main(String[] args) {
int a = 123456789;
// 方案一： 利用数组进行数组反转输出
String str = String.valueOf(a);
char[] arr = new char[str.length()];
for(int i = 0; i < arr.length; i++){
arr[arr.length-i-1] = str.charAt(i);
}
System.out.println("【方案一】：");
for(int i = 3; i < 7; i++){
System.out.print(arr[i] + "\t");
} // 方案二： 利用list进行数组反转输出
List<Character> list = new ArrayList<>();
for(int i = 0; i < arr.length; i++){
list.add(str.charAt(i));
}
Collections.reverse(list);
System.out.println("\n【方案二】：");
for(int i = 3; i < 7; i++){
System.out.print(list.get(i) + "\t");
}
// 方法三：
System.out.println("\n【方案三】：");
getNum(a, 4, 7);
}
public static void getNum(int a, int m, int n){
int[] ans = new int[n-m+1];
for(int i=1,j=0; j<ans.length && a>0;i++){
if(i>=m && i<=n){
ans[j] = a%10;
j++;
}
a = a / 10;
} for(int i=ans.length-1; i>=0; i--){
System.out.print(ans[i]+"\t");
}
System.out.println();
}
}
Java学习---程序设计_面试题[2]的更多相关文章
- Java学习---程序设计_基础题[1]
180813 补全没有的答案! 0. 数组排序大全[冒泡/选择/快速/插入] package com.ftl; import java.io.BufferedReader; import java.i ...
- #Java学习之路——面试题
(一)[基础知识梳理——JAVAse部分]Java中的变量和常量 在程序中存在大量的数据来代表程序的状态,其中有些数据在程序的运行过程中值会发生改变,有些数据在程序运行过程中值不能发生改 ...
- Java学习笔记_ 数据库隔离级别和事务传播行为
转自: https://blog.csdn.net/qq_38545713/article/details/79779265 一:数据库的事物隔离级别与传播行为总结: 很多人 ...
- Java学习笔记_网络+多线程
支持同时收发的客户端和服务器端 客户端 import javax.swing.*; import java.awt.*; import java.io.*; import java.net.*; im ...
- Java学习笔记_网络(2)
单向的客户端发送服务器端接收并显示,没有使用多线程 import javax.swing.*; import java.awt.*; import java.io.*; import java.net ...
- java学习笔记_网络
客户端 import java.io.*; import java.net.*; public class DailyAdviceClient { public void go() { try { S ...
- java学习笔记_序列化
如果父类没有实现Serializable接口,子类实现了Serializable接口,那么子类是可以序列化的. 但是如果想要反序列化,那么就需要父类支持默认构造函数. 因为在反序列化的过程中不会调用子 ...
- java学习笔记_接口
接口:interface(关键字) public interface USB {} 1. 接口中都是抽象方法,方法前面的可见度(public.private)和抽象关键字(abstract)可以不写. ...
- java学习笔记_多态
多态:父类的变量可以引用子类的对象 引用: Student s1 = stu; s1.setScore(200); 1.一个对象可以有多个引用,可以有多个变量操作同一个对象 2.当一个对象没有任何 ...
随机推荐
- disable Nouveau kernel driver
nano /etc/modprobe.d/blacklist-nouveau.conf with the following contents: blacklist nouveau options n ...
- springboot整合mybatis分页插件PageHelper
1 pom文件引入依赖 (注意:pagehelper版本不能太高,楼主之前用的5.0以上的版本,然后分页没有效果,浪费了两个小时才发现这个原因) <!-- mybatis的分页插件 --> ...
- java当中的定时器
对于开发游戏项目的同胞来说,Timer 这个东西肯定不会陌生,今天对以前自己经常使用的定时进行了一番小小的总结!没有写具体实现的原理,只是列举出了其中的四种比较常见的使用方法,相对而言,所以只要按照其 ...
- R语言统计字符串的字符数ncahr函数
函数计算字符数量,包括在一个字符串的空格的个数. 语法 nchar()函数的基本语法是: nchar(x) 以下是所使用的参数的说明: x - 向量输入. 示例 result <- nchar( ...
- nodejs学习笔记四（模块化、在npm上发布自己的模块）
模块化: 1.系统模块: http.querystring.url 2.自定义模块 3.包管理器 [系统模块] Assert 断言:肯定确定会出现的情 ...
- MySQL字符串函数：字符串截取
MySQL 字符串截取函数:left(), right(), substring(), substring_index().还有 mid(), substr().其中,mid(), substr() ...
- [转]HTTP Error 502.5 - Process Failure asp.net core error in IIS
本文转自:http://www.cnblogs.com/autohome7390/p/6840652.html 在windows server 2012 上安装完dotnet-win-x64.1.1. ...
- 十、curator recipes之信号量InterProcessSemaphoreV2
简介 跟Java并信号量没有什么不同,curator实现的信号量也是基于令牌桶算法,当一个线程要执行的时候就去桶里面获取令牌,如果有足够的令牌那么我就执行如果没有那么我就阻塞,当线程执行完毕也要将令牌 ...
- Hbase配置指南
注意点 Hbase 需要zookeeper. Hbase 需要在各个节点的机器上配置. 集群中的启动顺序是Hadoop.zookeeper 和Hbase 搭建步骤 解压安装文件并配置环境变量. exp ...
- spring-cloud-sleuth简单使用
快速开始 一.导入依赖 <!--链路追踪 start--> <dependency> <groupId>org.springframework.cloud</ ...