package everyworkdayprogramming._2015_1_04;
public class Java_1_4 {
/**
*
*
* 打印出所有的水仙花数，所谓水仙花数是指一个三位数，其各位数字立方和等于该数本身。
*
*
*/
public static void main(String[] args) {
int bit = 0, ten = 0, hun = 0;
for (int n = 100; n < 1000; n++) {
if (n < 1000) {
bit = n % 10; // 个位数，例如123除以10的余数是3
ten = n % 100 / 10; /*
* 十位数，例如123除以100的余数是23，再除以10就是2
* 也可以这样获得十位数，例如
* 123/10=12，然后12%10=2，这样也是获得了十位数
*/
hun = n / 100; // 百位数，例如123/100就是1
if (bit * bit * bit + ten * ten * ten + hun * hun * hun == n) {
System.out.println(n);
}
}
}
}
}
package everyworkdayprogramming._2015_1_05;
public class Java_1_5 {
/**
*
*
* 编写一个应用程序，对程序中给定的四个double型数据求其最大值和最小值。
*
*
*/
public static void main(String[] args) {
double[] numbers = { -3.1, 4.5, -6.6, 9.2 };
double max = numbers[0];
double min = numbers[0];
for (int i = 1; i < numbers.length; i++) {
if (max < numbers[i]) {
max = numbers[i];
}
if (min > numbers[i]) {
min = numbers[i];
}
}
System.out.println("max_________>" + max + "min______________>" + min);
}
}
package everyworkdayprogramming._2015_1_06;
public class Java_1_6 {
/**
*
* 一个数如果恰好等于它的因子之和，这个数就称为“完数”。例如6的因子为1、2、3，
* 而6=1+2+3。因此6是“完数”。编写一个小应用程序求1000之内的所有完数
*
*/
public static void main(String[] args) {
for (int i = 1; i <= 1000; i++) {
// 求和的循环过程中，有一个初始值为0的和值。 自我认为程序中的求和更应该是累加的过程
int a = 0;
// 一个能整除某个数的数必然小于等于这个数的一半（除了该数本身）
for (int j = 1; j <= i / 2; j++) {
if (i % j == 0) {
a += j;
}
}
if (a == i) {
System.out.println(i);
}
}
}
}
package everyworkdayprogramming._2015_1_07;
import java.math.BigDecimal;
public class Java_1_7 {
/**
* 要求1000！（1000*999*998...*2*1）的值。
*
* 这个值比较大，所以需要用到BigDecimal
*/
public static void main(String[] args) {
BigDecimal baseNum = new BigDecimal(1);
for (int i = 1; i <= 1000; i++) {
BigDecimal b = new BigDecimal(i);
baseNum = baseNum.multiply(b);
}
System.out.println("1000的阶乘是------------------------>" + baseNum);
}
}
package everyworkdayprogramming._2015_1_08;
public class Java_1_8 {
/**
*
*
* 设计一个能随机产生100个大写英文字母的方法，在该方法中统计产生了多少个元音字母，并输出这个数字。
*
*/
public static void main(String[] args) {
char[] ch = new char[100];
int count = 0;
System.out.println("一百个随机产生的大写字母为:");
System.out.println("----------------------------------------------------------------------------------------------------------------");
for (int i = 0; i < 100; i++) {
int a = (int) (Math.random() * 26);
ch[i] = (char) (a + 65);
System.out.print(ch[i] + "\t ");
if ((i + 1) % 10 == 0) {
System.out.println();
}
}
System.out.println("----------------------------------------------------------------------------------------------------------------");
// 统计原音个数
for (int i = 0; i < 100; i++) {
if (ch[i] == 'A' || ch[i] == 'E' || ch[i] == 'I' || ch[i] == 'O'
|| ch[i] == 'U') {
count++;
}
}
System.out.println("原音字母的个数为:" + count);
}
}
package everyworkdayprogramming._2015_1_09;
import java.util.Scanner;
public class Java_1_9 {
private static Scanner scanner;
/**
*
* 有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第3个月后每个月 又生一对兔子，假如兔子不死，问每个月的兔子总数为多少？
*
*/
public static void main(String[] args) {
scanner = new Scanner(System.in);
System.out.println("请输入月数");
int m = scanner.nextInt();
System.out.println("第一个月的兔对数为1");
System.out.println("第二个月的兔对数为1");
int f1 = 1, f2 = 1, f;
for (int i = 3; i <= m; i++) {
f = f2; //中间变量的记录作用
f2 = f2 + f1;
f1 = f;
System.out.println("第" + i + "个月的兔子对数: " + f2);
}
}
}
package everyworkdayprogramming._2015_1_10;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Java_1_10 {
/**
*
*
* 输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数
*
*/
public static void main(String[] args) throws IOException {
BufferedReader buf;
String str;
int a = 0, b = 0, c = 0, d = 0;
buf = new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入一串字符:");
str = buf.readLine();
char ch[] = str.toCharArray();
for (int i = 0; i < ch.length; i++) {
if ((ch[i] >= 'a' && ch[i] <= 'z')
|| (ch[i] >= 'A' && ch[i] <= 'Z'))
a++;
else if (ch[i] >= '0' && ch[i] <= '9')
b++;
else if (ch[i] == ' ')
c++;
else
d++;
}
System.out.println("英文字母有：" + a + "个");
System.out.println("数字有：" + b + "个");
System.out.println("空格有：" + c + "个");
System.out.println("其它字符有：" + d + "个");
}
}
package everyworkdayprogramming._2015_1_12;
public class Java_1_12 {
/**
*
*
* 猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一 个 第二天早上又将剩
* 下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下 的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。
*
*/
public static void main(String[] args) {
int sum = 1;
for (int i = 0; i < 9; i++) {
sum = (sum + 1) * 2;
}
System.out.println(sum);
}
}
package everyworkdayprogramming._2015_1_13;
public class Java_1_13 {
/**
* @Title: main
* @Description: 利用递归方法求5!
* @param @param args 设定文件
* @return void 返回类型
* @throws
* @author mpc
*/
public static void main(String[] args) {
System.out.println(getFactorial(5));
}
public static int getFactorial(int num) {
if (num == 1) {
return 1;
} else {
return getFactorial(num - 1) * num;
}
}
}
package everyworkdayprogramming._2015_1_14;
import java.util.Scanner;
public class Java_1_14 {
/**
*
* @Title: main
* @Description: 求一个3*3矩阵对角线元素之和.
* @param @param args 设定文件
* @return void 返回类型
* @throws
* @author mpc
*/
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入9个整数:");
int[][] number = new int[3][3];
int s1 = 0, s2 = 0;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
number[i][j] = scanner.nextInt();
}
}
System.out.println("输入的矩阵为:");
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
System.out.print(number[i][j] + "\t");
}
System.out.println();
System.out.println();
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i == j)
s1 += number[i][j];
if (i + j == 2)
s2 += number[i][j];
}
}
System.out.println("主对角线的和为：" + s1);
System.out.println("反对角线的和为：" + s2);
}
}
package everyworkdayprogramming._2015_1_15;
import java.util.Scanner;
/**
* @ClassName: Java_1_15
* @Description: 输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。
* @author mpc
* @date 2015年1月15日 上午8:58:10
*
*/
public class Java_1_15 {
public static void main(String[] args) {
int x = 10;
int max = 0, min = 0;
int maxb = 0, minb = 0, temp = 0;
System.out.println("请输入数组的大小:");
Scanner scanner = new Scanner(System.in);
x = scanner.nextInt();
int num[] = new int[x];
System.out.println("输入数组中的数值");
for (int i = 0; i < num.length; i++) {
num[i] = scanner.nextInt();
}
max = min = num[0];
System.out
.println("-------------------------------------------------------");
for (int i = 0; i < num.length; i++) {
if (max < num[i]) {
maxb = i;
}
if (min > num[i]) {
minb = i;
}
}
temp = num[0];
num[0] = num[maxb];
num[maxb] = temp;
temp = num[num.length - 1];
num[num.length - 1] = num[minb];
num[minb] = temp;
System.out.println(maxb + " " + minb);
for (int n : num) {
System.out.print(n);
}
}
}
package everyworkdayprogramming._2015_1_16;
public class Java_1_16 {
/**
*
* 定义复数的类Complex并测试其功能: 1. 复数由实部、虚部两个部分组成，在类的定义中应包含保存这两部分信息的内容。
* 2. 在类中定义构造函数，使用户能够在构造对象的同时为对象赋初值。
* 3. 在类中定义复数的加法、减法、乘法三个二元操作符来完成复数间的加、减、乘的功能。
* 4. 通过重载tosthing，使得Complex类的对象能够显示其自身信息。
* 5. 通过显示定义一个成员函数完成对象的赋值操作，使用户能够对Complex类的 对象进行赋值。
* 6. 编写一段主程序（main函数），使用户能够通过这段主程序输入复数并进行复数 的计算。
*
*/
public static void main(String[] args) {
Complex complex1;
Complex complex2;
complex1 = initialComplex(12, 3);
complex2 = initialComplex(16, 3);
System.out.println(complex1.toString());
System.out.println(complex2.toString());
Complex sum = Complex.additive(complex1, complex2);
System.out.println(sum.toString());
Complex sub = Complex.subtraction(complex1, complex2);
System.out.println(sub.toString());
Complex multi = Complex.multiplication(complex1, complex2);
System.out.println(multi.toString());
}
public static Complex initialComplex(float a, float b) {
return new Complex(a, b);
}
}
class Complex {
private float a;
private float b;
public float getA() {
return a;
}
public void setA(float a) {
this.a = a;
}
public float getB() {
return b;
}
public void setB(float b) {
this.b = b;
}
public Complex(float a, float b) {
super();
this.a = a;
this.b = b;
}
public Complex() {
}
public static Complex additive(Complex... c) {
if (c.length == 2) {
return new Complex(c[0].a + c[1].a, c[0].b + c[1].b);
} else {
return null;
}
}
public static Complex subtraction(Complex... c) {
if (c.length == 2) {
return new Complex(c[0].a - c[1].a, c[0].b - c[1].b);
} else {
return null;
}
}
public static Complex multiplication(Complex... c) {
if (c.length == 2) {
return new Complex(c[0].a * c[1].a + c[0].b * c[1].b, c[0].a
* c[1].b - c[0].b * c[1].a);
} else {
return null;
}
}
@Override
public String toString() {
if (a == 0 && b != 0) {
return b + "i";
} else if (a != 0 && b == 0) {
return a + "";
} else if (a == 0 && b == 0) {
return "0";
} else if (b < 0) {
return a + "+" + "(" + b + ")i";
} else {
return a + "+" + b + "i";
}
}
}package everyworkdayprogramming._2015_1_17;
public class Java_1_17 {
/**
*
*
* 求100之内的素数
*
*
* */
public static void main(String[] args) {
boolean flag = false;
System.out.print("100以内的素数有：2 3 ");
for (int i = 3; i <= 100; i += 2) {
//这块的开平方比较难理解,假设a*b=n;
//对n开根号,如果有a大于根号下n,必然有b小于根号下n,
//比如a=5,b=4,n=20,根号下n大概等于4点多,那你判断20是不是
//素数的时候对4取余都已经判断出来了,那还用对5取余判断吗
int n = (int) Math.sqrt(i);
for (int j = 2; j <= n; j++) {
if (i % j == 0) {
flag = false;
break;
} else
flag = true;
}
if (flag == true) {
System.out.print(i + " ");
}
}
}
}
package everyworkdayprogramming._2015_1_19;
import java.util.Scanner;
public class Java_1_19 {
/**
*
* 从键盘上输入10个整数，并将其放入一个一维数组中，然后将其前5个元素与后
* 5个元素对换，即：第1个元素与第10个元素互换，第2个元素与第9个元素互换
* …第5个元素与第6个元素互换。分别输出数组原来各元素的值和对换后各元素的值。
*
*
* */
public static void main(String[] args) {
int arr[] = new int[10];
int temp = 0;
Scanner scanner = new Scanner(System.in);
for (int i = 0; i < arr.length; i++) {
arr[i] = scanner.nextInt();
}
for (int i = 0; i < arr.length / 2; i++) {
temp = arr[i];
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = temp;
}
for (int a : arr) {
System.out.println(a);
}
}
}
package everyworkdayprogramming._2015_1_20;
import java.util.Scanner;
public class Java_1_20 {
/**
*
* 随便输入一段字符串，把出现次数最多的打印出来,如:aabbbbbbbbbcccdffff,就把b 打印出来,用java代码实现
*
* */
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请随意输入一串字符。。。");
String input = scanner.nextLine();
char[] ch = input.toCharArray();
int number[] = new int[ch.length];
for (int i = 0; i < number.length; i++) {
int count = 0;
for (int j = 0; j < number.length; j++) {
if (ch[i] == ch[j]) {
count++;
}
}
number[i] = count;
}
int max = number[0];
int k = 0;
for (int i = 0; i < number.length; i++) {
if (max < number[i]) {
max = number[i];
k = i;
}
}
System.out.println("出现次数最多的字符为：" + ch[k]);
}
}
package everyworkdayprogramming._2015_1_21;
public class Java_1_21 {
/**
*
* 给定N是一个正整数，求比N大的最小“不重复数”，这里的不重复是指没有两个相等的相邻位，如1102中的11是相等的两个相邻位故不是不重复数，
* 而12301是不重复数。
*
* */
public static void main(String[] args) {
System.out.println(getMinNotRep(112310 + 1));
}
public static int getMinNotRep(int number) {
int[] nums = new int[9];
int len = 0;
boolean flag = true;
int b = 0;
// 把要处理的数字的各个位保存到数组中去
while (number > 0) {
nums[len++] = number % 10;
number = number / 10;
}
for (int i = len - 1; i > 0; i--) {
// 如果遇到重复位，就把重复位中次高位加1
if (flag && nums[i] == nums[i - 1]) {
nums[i - 1]++;
flag = false;
} else if (flag == false) {
// 把重复位中次高位后的数字都变成 ...0101010101 的形式
nums[i - 1] = b;
b = (b == 0) ? 1 : 0;
}
}
for (int i = len - 1; i >= 0; i--) {
number = number * 10 + nums[i];
}
if (flag) {
return number;
} else {
return getMinNotRep(number);
}
}
}
package everyworkdayprogramming._2015_1_22;
public class Java_1_22 {
/**
*
*
* 设N是一个大整数，求长度为N的字符串的最长回文子串。
*
*
* */
public static void main(String[] args) {
System.out
.println(getMaxSubPalindromeString("2321323sdsadaaabbbbbaaafkljdsfjkdsjkfljdslkjflkjdslkfjlkds"));
}
public static String getMaxSubPalindromeString(String str) {
char[] ch = str.toCharArray();
boolean p[][] = new boolean[ch.length][ch.length];
// 初始化标记数组
for (int i = 0; i < p.length; i++) {
for (int j = 0; j < p[i].length; j++) {
p[i][j] = true;
}
}
for (int len = 2; len <= ch.length; len++) {
for (int i = 0; i < ch.length - len + 1; i++) {
int j = i + len - 1;
if (len == 2) {
p[i][j] = ch[i] == ch[j];
} else {
p[i][j] = (p[i + 1][j - 1] && (ch[i] == ch[j]));
}
}
}
int maxLength = 1;
int maxI = 0;
for (int i = 0; i < ch.length; i++) {
for (int j = 0; j < ch.length; j++) {
if (p[i][j] && maxLength < j - i + 1) {
maxLength = j - i + 1;
maxI = i;
}
}
}
return new String(ch, maxI, maxLength);
}
}
package everyworkdayprogramming._2015_1_23;
public class Java_1_23 {
/**
*
*
* 有1、2、3、4这几个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？
*
*
* */
public static void main(String[] args) {
int count = 0;
for (int i = 1; i < 5; i++) {
for (int j = 1; j < 5; j++) {
for (int k = 1; k < 5; k++) {
if (i != j && j != k && k != i) {
count++;
System.out.print(i * 100 + j * 10 + k+" ");
}
}
}
}
System.out.println("总数为-------->" + count);
}
}
package everyworkdayprogramming._2015_1_24;
public class Java_1_24 {
/**
*
*
* 爱因斯坦曾出过这样一道有趣的数学题：有一个长阶梯，每步上2阶，最后剩1
* 阶；若每步上3阶，最后剩2阶；若每步上5阶，最后剩4阶；若每步上6阶，最后剩5阶
* ；只有每步上7阶，最后一阶也不剩。请问该阶梯至少有多少阶。编写一个Java程序解决该问题。
*
*
* */
public static void main(String[] args) {
int n = 7;
while (true) {
if (n % 2 == 1 && n % 3 == 2 && n % 5 == 4 && n % 6 == 5
&& n % 7 == 0)
break;
n += 7;
}
System.out.println(n);
}
}
package everyworkdayprogramming._2015_1_26;
public class Java_1_26 {
/**
*
*
* 有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3 的人退出圈子，问最后留下的是原来第几号的那位。
*
*
* */
public static void main(String[] args) {
int n = 5;
boolean flag[] = new boolean[n];
for (int i = 0; i < flag.length; i++) {
flag[i] = true;
}
int left = n, count = 0, index = 0;
while (left > 1) {
if (flag[index] == true) {
count++;
if (count == 3) {
count = 0;
flag[index] = false;
left--;
}
}
index = (++index) % (n);
}
for (int i = 0; i < n; i++) {
if (flag[i] == true) {
System.out.println("留下来的有" + i);
}
}
}
}
package everyworkdayprogramming._2015_1_27;
public class Java_1_27 {
/**
*
*
* 哥德巴赫猜想是说任何一个大于2的偶数都能表示为两个素数之和。请编写一个
* Java程序，验证1～100内哥德巴赫猜想的正确性，也就是近似证明哥德巴赫猜想。
*
*
* */
public static void main(String[] args) {
boolean flag = false;
int number[] = new int[25];
number[0] = 2;
number[1] = 3;
int a = 2;
System.out.print("100以内的素数有:");
for (int i = 3; i <= 100; i += 2) {
for (int j = 2; j <= (int) Math.sqrt(i); j++) {
if (i % j == 0) {
flag = false;
break;
} else {
flag = true;
}
}
if (flag == true) {
number[a] = i;
a++;
}
}
for (int i = 0; i < number.length; i++) {
System.out.print(number[i] + " ");
}
System.out.println();
for (int i = 2; i <= 100; i += 2) {
for (int j = 0; j < number.length - 1; j++) {
for (int k = j + 1; k < number.length; k++) {
if (i == number[j] + number[k]) {
System.out.println(i + "=" + number[j] + "+"
+ number[k]);
}
}
}
}
}
}
package everyworkdayprogramming._2015_1_28;
import java.io.FileInputStream;
import java.lang.reflect.Method;
import java.util.Properties;
public class Java_1_28 {
/**
*
* 通过配置文件运行类中的方法
*
* */
public static void main(String[] args) throws Exception {
FileInputStream file = new FileInputStream("d:/show.txt");
Properties pro = new Properties();
pro.load(file);
file.close();
// 通过键值对获取对应的类名和方法名
String className = pro.getProperty("className");
String methodName = pro.getProperty("methodName");
// 通过反射获得字节码对象和方法对象
Class<?> demo = Class.forName(className);
Object o = demo.newInstance();
Method method = demo.getMethod(methodName, null);
method.invoke(o, null);
}
}
package everyworkdayprogramming._2015_1_29;
import java.util.Scanner;
public class Java_1_29 {
/**
*
* 随即输入QQ号:校验QQ号码：不能以0开头 是5-15位的数字
*
*
* ******使用正则表达式
* */
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String qq = scanner.nextLine();
String segex = "[^0][0-9]{4,14}";
boolean flag = qq.matches(segex);
if (flag) {
System.out.println(qq);
} else {
System.out.println("格式错误");
}
}
}
package everyworkdayprogramming._2015_1_30;
import java.util.TreeSet;
public class Java_1_30 {
/**
*
* 能将这些ip地址排序。按照地址段数值从小到大排序。
* "192.168.3.23 202.10.34.2 3.3.3.3 127.0.0.1 80.12.23.34" 思路
* ip地址都是字符串，所有字符串排序，用TreeSet。 如果用TreeSet 现在存在每个ip 地址，就会有问题。因为有部分ip没有满足三位。
* 这样比较是有问题的， 所有，我们采取补位的方式 1：先给每个 ip地址的每一个位在前面补2个0。 2：把超出3位的数据，截取成3位。
*
* */
public static void main(String[] args) {
String str = "192.168.3.23 202.10.34.2 3.3.3.3 127.0.0.1 80.12.23.34";
// 先补2个0
str = str.replaceAll("(\\d+)", "00$1");
System.out.println(str);
// 去掉超出3位的前面的0
str = str.replaceAll("0*(\\d{3})", "$1");
System.out.println(str);
String[] ips = str.split(" ");
TreeSet<String> ts = new TreeSet<String>();
for (String s : ips) {
ts.add(s);
}
for (String s : ts) {
s = s.replaceAll("0*(\\d+)", "$1");
System.out.println(s);
}
}
}
793
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
