Java第一次作业-回文素数
查找素数（0~1000）的算法（Java代码）
查找素数（0~1000）的算法（Java代码）1、⼀般⽅法，设置标兵，进⾏查找class prime{//检查是否是素数public void isPrime(){int m=0;for(int i=1;i<=1000;i++){double count=0;for(int j =1;j<i;j++){if(i%j==0){count++;}}if(count==1||i==1){System.out.print(i + "");m++;}}System.out.println("素数有"+m+"个");}public static void main(String args[]){new prime().isPrime();}}2、筛选法(1)、建⽴⼀个boolean类型的数组，将下标为奇数的值设为false，为偶数的下标设置为true(2)、进⾏遍历值为false的下标，并将下标的倍数值设置为true(3)、输出值为false的下标public void isPrime1(){int m=0;boolean prime[] = new boolean[1001];for(int i=1;i<=1000;i++){if(i%2==0){prime[i] = false;}else{prime[i] = true;}}for(int i =3;i<=1000;i+=2){if(prime[i]){for(int j=i+i;j<=1000;j+=i){prime[j] = false;}}}for(int i =0;i<=1000;i++){if(prime[i]||i==2){m++;System.out.print(i+"");}}System.out.print("0~1000之间的素数有"+m+"个");}3、⾼斯猜想‘n以内的素数个数⼤约与n/ln(n)相当，或者说，当n很⼤时，两者数量级相同。
java实验报告回文数
else
{
System.out.printf("\t%d不是回文数", number);
}
}
else if (【代码6】) //判断number是4位数的条件
{
System.out.printf("\n%d是4位数",number);
If (【代码7】) //判断number是回文数的条件码
{
System.out.printf("\t%d是回文数", number);
32567位数32567不是回文数6实验总结及心得这次实验使我对java程序的编写有了更进一步的了解熟悉掌握了ifelseif多分支语句的运用
《Java程序设计》实验报告
实验二：回文数
专业班级：通信工程2008级1班
姓名：
学号：
时间：
实验二：回文数
1、实验目的：
让学生掌握if-else if多分支语ຫໍສະໝຸດ 。}else{
System.out.printf("\t%d不是回文数", number);
}
}
else if(d2!=0)
{
System.out.printf("\n%d是2位数", number);
if(d1==d2)
{
System.out.printf("\t%d是回文数", number);
}
if(number<=99999&&number>=1)
{
d5=number/10000;
d4=number%10000/1000;
d3=number%1000/100;
素数java代码
素数java代码素数是指只能被1和自己整除的正整数，像2、3、5、7、11等都是素数。
在计算机编程中，判断一个数是否为素数是一项基本的算法。
本文将从Java语言的角度入手，介绍如何编写素数判断的代码，包括两种方法：暴力枚举法和筛法。
一、暴力枚举法暴力枚举法是一种较为简单粗暴的方法，通过一个循环枚举所有可能的因子，判断是否能被整除。
其Java代码如下：public static boolean isPrime(int n) { if (n < 2) { //小于2的数均不是素数 return false; } for (int i = 2; i <= Math.sqrt(n); i++) { if (n % i == 0) { //能被整除，即不是素数 return false; } } return true; //不被整除，即是素数 }首先判断输入的数n是否小于2，如果n小于2，则直接返回false，因为小于2的数均不是素数。
然后从2开始循环到n的平方根，检查是否能被整除，如果能则返回false，否则继续循环，最后返回true表示是素数。
这种方法的时间复杂度为O(√n)，因为最多需要枚举n的平方根次数。
在较小的n值的情况下，这种方法较为有效，但当n较大时，效率低下。
二、筛法筛法是用于快速筛选素数的一种高效算法，它的原理是从小到大依次枚举素数，将其倍数标记为合数。
例如，当枚举到2时，将4、6、8、10等标记为合数；当枚举到3时，将6、9、12等标记为合数。
由于合数被标记多次，所以这种方法比暴力枚举法更快。
筛法主要有两种：埃氏筛法和欧拉筛法。
下面分别介绍它们的Java代码实现。
2.1 埃氏筛法埃氏筛法是一种简单直接的筛法，其Java代码如下：public static int[] getPrimes(int n) { if (n < 2) { //小于2的数没有素数 return new int[0]; } boolean[] isPrime = new boolean[n + 1]; //初始化所有数为素数 for (int i = 2; i <= n; i++) { isPrime[i] = true; } for (int i = 2; i <= Math.sqrt(n); i++) { if (isPrime[i]) { //当前数为素数 for (int j = i * i; j <= n; j += i) { //枚举它的倍数isPrime[j] = false; //标记为合数 } } } List<Integer> list = new ArrayList<>(); for (int i = 2; i <= n; i++) { if (isPrime[i]) { //将素数添加到列表中 list.add(i); } } int[] primes = new int[list.size()]; //将列表转成数组 for (int i = 0; i < primes.length; i++){ primes[i] = list.get(i); } return primes; }首先判断输入的n是否小于2，如果n小于2，则返回一个长度为0的素数数组。
java输出1~100之间的全部素数的5种方式总结
java输出1~100之间的全部素数的5种⽅式总结⽬录需求：输出1~100的所有素数分析java输出素数找出素数规范输出需求：输出1~100的所有素数分析1.素数：判断条件1：只能被1和本⾝整除的称为素数；判断条件2：在区间（1，x/2）中找不到能整除素数x的整数；判断条件3：在区间（1，sqrt(x)）中找不到能整除素数x的整数；2.⽅法：很多，但不外是循环嵌套外加条件语句；class PrintSuShu {public static void main(String[] args) {//⽅法⼀：根据素数的定义来遍历检查//外层循环遍历被除数i(因为1既不是素数也不是和数，所以直接从2开始遍历)for (int i = 2; i <= 100; i++) {//定义⼀个逻辑值，初值为trueboolean flag = true;//内层遍历除数jfor (int j = 2; j < i; j++) {//判断是否存在j能整除i，若存在，则更改flag的值并跳出循环if (0 == i % j) {flag = false;break;}}//根据flag的值判断是否输出iif (flag) {System.out.print(i + " ");}}System.out.println('\n' + "---------------------------");//⽅法⼆：根据判断条件2进⾏遍历检查，减少遍历次数//外层循环遍历被除数i(因为1既不是素数也不是和数，所以直接从2开始遍历)for (int i = 2; i <= 100; i++) {//定义⼀个逻辑值flag，初始值为trueboolean flag = true;//内层循环遍历除数j(注意：此处若不取边界，则当i=4时，j=2会因为⼩于i/2=2⽽直接跳出内循环)for (int j = 2; j <= (i / 2); j++) {//判断是否存在除数j能整除i，若存在，则修改flag的值并跳出循环if (0 == i % j) {flag = false;break;}}//根据flag的值判断是否输出iif (flag) {System.out.print(i + " ");}}System.out.println('\n' + "---------------------------");//⽅法三：根据判断条件3进⾏遍历检查，减少遍历次数//外层循环遍历被除数i(因为1既不是素数也不是和数，所以直接从2开始遍历)for (int i = 2; i <= 100; i++) {//定义⼀个逻辑值flag，初始值为trueboolean flag = true;//内层循环遍历除数j(注意：此处若不取边界，则当i=4时，j=2会因为⼩于sqrt(i)=2⽽直接跳出内循环)//再思考⼀下若i=25时呢？若不取边界还有那些不是素数的数会输出呢？for (int j = 2; j <= Math.sqrt(i); j++) {//判断是否存在除数j能整除i，若存在，则修改flag的值并跳出循环if (0 == i % j) {flag = false;break;}}//根据flag的值判断是否输出iif (flag) {System.out.print(i + " ");}}System.out.println('\n' + "---------------------------");/*⽅法四：在⽅法三的前提上优化，优化基础是除2外的所有偶数均不是素数，*(i+=2)只遍历奇数，减少外层遍历次数；同理，由于奇数是不能被偶数整除的，*(j+=2)只遍历奇数，减少内层遍历次数*/System.out.print("2 ");//外层循环遍历被除数i(因为1既不是素数也不是和数，所以直接从2开始遍历)for (int i = 3; i <= 100; i += 2) {//定义⼀个逻辑值flag，初始值为trueboolean flag = true;//内层循环遍历除数j(注意：此处若不取边界，则当i=4时，j=2会因为⼩于sqrt(i)=2⽽直接跳出内循环)//再思考⼀下若i=25时呢？若不取边界还有那些不是素数的数会输出呢？for (int j = 3; j <= Math.sqrt(i); j += 2) {//判断是否存在除数j能整除i，若存在，则修改flag的值并跳出循环if (0 == i % j) {flag = false;break;}}//根据flag的值判断是否输出iif (flag) {System.out.print(i + " ");}}System.out.println('\n' + "---------------------------");//联想⼀下，能被2整除（偶数）的直接剔除，同样的道理，能被3or5整除的剔除掉会不会让外层循环的次数更少呢？//此处才到100，若是1000呢？10000呢？//定义⼀个数组，由于剔除了偶数，故数组长度不会超过总个数的⼀半int[] arr = new int[500];int count = 0;for (int i = 6; i <= 1000; i++) {boolean flag = true;if (0 == i % 2 || 0 == i % 3 || 0 == i % 5) {flag = false;}if (flag) {arr[count] = i;count++;}}System.out.println("6~1000中剔除能被2or3or5整除的数后还剩" + count + "个");System.out.println("1~1000中所有素数为：");System.out.print("2" + "\t");System.out.print("3" + "\t");System.out.print("5" + "\t");count = 0;for (int i = 0; i < 500; i++) {boolean flag = true;if (0 == arr[i]) {break;}for (int j = 7; j <= Math.sqrt(arr[i]); j += 2) {if (0 == (arr[i]) % j) {flag = false;break;}}if (flag) {System.out.print((arr[i]) + "\t");count++;}}System.out.println("\n" + "---------------------");System.out.println("\n" + "其中6~1000中剔除能被2or3or5整除的数中还是素数的有" + count + "个");}}java输出素数java输出1,000,000之内的所有素数找出素数for(n=3;n<=1000000;) {for(i=2;i<n;i++) {if(n%i= =0) break;if(i= =n-1) {su[count]=n;count++;｝}n+=2;}加⼆是因为从3开始奇数有可能是素数，第⼀个循环遍历1000000个数，第⼆个循环看它是不是素数。
回文数(java编程)
else
System.out.println("你输入的不是回文数");
}
}
这两种方法都能实现对回文数的判断，第一种只能针对整数，第二种似乎能针对所有的字符。
StringBuffer source = new StringBuffer(inputValue);
source.reverse();
String reverseString = new String(source);
if(reverseString.equals(inputValue))
第一种方法的代码如下：
import javax.swing.JOptionPane;
public class Palindrome
{
public static void main(String [] args)
{
String inputValuelog("请输入一个整数");
}
第二种方法的代码如下：
import javax.swing.JOptionPane;
public class PalindromeUseString
{
public static void main(String [] args)
{
String inputValue = JOptionPane.showInputDialog("请输入一个整数");
inputValueLong = inputValueLong/10;
}
if(reverseLong == temp)
java笔试手写算法面试题大全含答案
java笔试⼿写算法⾯试题⼤全含答案1.统计⼀篇英⽂⽂章单词个数。
public class WordCounting {public static void main(String[] args) {try(FileReader fr = new FileReader("a.txt")) {int counter = 0;boolean state = false;int currentChar;while((currentChar= fr.read()) != -1) {if(currentChar== ' ' || currentChar == '\n'|| currentChar == '\t' || currentChar == '\r') {state = false;}else if(!state) {state = true;counter++;}}System.out.println(counter);}catch(Exception e) {e.printStackTrace();}}}补充：这个程序可能有很多种写法，这⾥选择的是Dennis M. Ritchie和Brian W. Kernighan⽼师在他们不朽的著作《The C Programming Language》中给出的代码，向两位⽼师致敬。
下⾯的代码也是如此。
2.输⼊年⽉⽇，计算该⽇期是这⼀年的第⼏天。
public class DayCounting {public static void main(String[] args) {int[][] data = {{31,28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},{31,29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}};Scanner sc = new Scanner(System.in);System.out.print("请输⼊年⽉⽇(1980 11 28): ");int year = sc.nextInt();int month = sc.nextInt();int date = sc.nextInt();int[] daysOfMonth = data[(year % 4 == 0 && year % 100 != 0 || year % 400 == 0)?1 : 0];int sum = 0;for(int i = 0; i < month -1; i++) {sum += daysOfMonth[i];}sum += date;System.out.println(sum);sc.close();}}3.回⽂素数：所谓回⽂数就是顺着读和倒着读⼀样的数(例如：11，121，1991…)，回⽂素数就是既是回⽂数⼜是素数(只能被1和⾃⾝整除的数)的数。
回文质数问题
回文质数因为151即是一个质数又是一个回文数(左右对称)，所以151 号是回文质数。
写一个程序来找出范围[a,b](5 <= a < b <= 100,000,000)间的所有回文质数; 运行时间限制1秒以内。
输入：1 行二个整数a 和b .样例5 500输出：输出一个回文质数的列表，一行一个。
5711101131151181参考程序uses dos;varh,m,s,ss:word;{存储时间}t0:real;i,a,b,c:longint;t,x1,x2,x3,x4:integer;function zs(i:longint):boolean;var x:longint;beginzs:=false; x:=2;while (x<=trunc(sqrt(i)))and(i mod x<>0) do x:=x+1;if x>trunc(sqrt(i)) then zs:=true;end;beginreadln(a,b);gettime(h,m,s,ss);{获取当前系统时间}t0:=h*3600+m*60+s+ss/100;for i:=a to 11 doif i<=b thencase i of5:writeln('5');7:writeln('7');11:writeln('11');end;for x1:=0 to 9 dofor x2:=0 to 9 dofor x3:=0 to 9 dofor x4:=0 to 9 dobeginc:=x1*1000001+x2*100010+x3*10100+x4*1000;if x1=0 then begin c:=c div 10;if x2=0 then c:=c div 10 ;end;if (c<=b) and (a<=c) thenif zs(c) then begin writeln(c);t:=t+1;end;end;gettime(h,m,s,ss);{获取当前系统时间}writeln(t,' ',(h*3600+m*60+s+ss/100-t0):5:2);readln;end.。
2017Java最新编程设计题(含答案)
1、回文数字判断。
题目描述：有这样一类数字，他们顺着看和倒着看是相同的数，例如：121,656,2332等，这样的数字就称为：回文数字。
编写一个函数，判断某数字是否是回文数字。
要求实现方法：public String isPalindrome(String strIn);【输入】strIn: 整数，以字符串表示；【返回】true: 是回文数字；false: 不是回文数字；【注意】只需要完成该函数功能算法，中间不需要有任何IO的输入输出[java] view plain copyprint?1. package com.iotex;2.3. import java.util.Scanner;4.5. /**6. * @author iotex7. * 2017-5-10下午03:46:568. *4、回文数字判断。
9. *题目描述：10. * 有这样一类数字，他们顺着看和倒着看是相同的数，例如：121,656,2332等，这样的数字就称为：11. * 回文数字。
编写一个函数，判断某数字是否是回文数字。
12. */13. public class IsPalindrome {14. public static void main(String[] args) {15. System.out.print("请输入一个回文数字：");16. Scanner console = new Scanner(System.in);17. String numStr = console.nextLine();18. if(isPalindrome(numStr)) {19. System.out.println(numStr+"是回文数字！");20. }else{21. System.out.println(numStr+"不是回文数字！");22. }23.24. }25.26. public static boolean isPalindrome(String str){27. boolean result = false;28. for(int i = 0 ;i<str.length()/2-1;i++) {29. if(str.charAt(i) == str.charAt(str.length()-1-i)) {30. result = true;31. }32. }33.34. return result;35. }36.37. }[java] view plain copyprint?1. package com.iotex;2.3. import java.util.Scanner;4.5. /**6. * @author iotex7. * 2017-5-10下午03:46:568. *4、回文数字判断。
Java实现求质数（素数）
Java实现求质数（素数）Java实现求质数（素数）题⽬要求：输出0-100以内的所有质数（素数）。
质数：只能被 1 和它本⾝整除的数。
1不是素数也不是合数。
代码实现：public class PrimeNumber {public static void main(String[] args) {Boolean flag = true;// long start = System.currentTimeMillis();for(int i = 2;i <= 100;i++){for(int j = 2;j <= Math.sqrt(i);j++){if(i % j == 0){ // i 被 j 整除，不是质数flag = false; // flag 置为falsebreak;}}if(flag == true){System.out.print(i + " ");}flag = true; //将 flag 重置为 true}// long end = System.currentTimeMillis();// System.out.println("所花费的时间为：" + (end - start));}}运⾏结果：2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97System.currentTimeMillis()该⽅法的作⽤是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1⽉1号0时0分0秒所差的毫秒数。
返回的是 long 型。
可以通过这个⽅法计算程序的运⾏时长。
程序扩展：可以通过修改 i 的值，来输出其他区间的所有质数。
例如：输出 200 - 300 以内的质数。
public class PrimeNumber {public static void main(String[] args) {Boolean flag = true;// long start = System.currentTimeMillis();for(int i = 200;i <= 300;i++){for(int j = 2;j <= Math.sqrt(i);j++){if(i % j == 0){ // i 被 j 整除，不是质数flag = false; // flag 置为falsebreak;}}if(flag == true){System.out.print(i + " ");}flag = true; //将 flag 重置为 true}// long end = System.currentTimeMillis();// System.out.println("所花费的时间为：" + (end - start));}}输出结果：211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293。
跟我学Java面向对象程序设计技术及应用——识别某个自然数是否为回文数的Java程序实现示例
例如，若 n=1234321，则称 n 为一回文数，因为它的 n1=1234321；但若 n=1234567，则 n 不是回文数，因为它的 n1=7654321，但 n1≠n。
杨教授工作室 精心创作的优秀程序员 职业提升必读系列资料
1.2.2 在创建的 Java 应用程序项目中添加示例程序类 1、右击所创建的 Java 应用程序项目名称 JavaDemo，在弹出的快捷菜单中选择 New 新建一个 Java 程序类
杨教授工作室，版权所有4 ，盗版必究， 4/23 页
杨教授工作室 精心创作的优秀程序员 职业提升必读系列资料
杨教授工作室，版权所有1 ，盗版必究， 1/23 页
杨教授工作室 精心创作的优秀程序员 职业提升必读系列资料
1.1.3 如何判断一个自然数是否为回文数 判断一个自然数是否为回文数，可以根据它的定义来设计相关的算法——设 N 是一任意
的自然数，只需要获得 N 的各位数字，然后再将这些数字反向排列组成一个新的数字，这样 所获得的自然数 N1 如果与 N 相等，则可以判断出 N 为一回文数。
2、在工程项目创建的对话框中输入项目名称 JavaDemo，并选择项目存放的目录路径
杨教授工作室，版权所有2 ，盗版必究， 2/23 页
杨教授工作室 精心创作的优秀程序员 职业提升必读系列资料
3、点击对话框中的完成（Finish）按钮，将创建出一个空的 Java 应用程序项目
杨教授工作室，版权所有3 ，盗版必究， 3/23 页
2、在类创建的对话框中输入包名称为 com.bluedream.demo，类名称为 JavaPalindromeNumber， 并选择需要在 JavaPalindromeNumber 类中创建出 main()方法
java第一次作业题目2021版
java第一次作业题目2021版1. 题目：从键盘上输入两个正整数m和n，求其最大公约数和最小公倍数，必须判断输入数的正确性（比如非正整数等必须提示）。
[选题人数：3] 2. 题目：给出一个月的总天数编写程序，提示用户输入月份和年份，然后显示这个月的天数。
例如，如果用户输入的月份是2而年份是2000，那么程序应显示“2000年2月有29天”。
如果用户输入的月份为3而年份为2021，那么程序就应该显示“2021年3月有31天”。
（提示：必须判断是否是闰年） [选题人数：3]3. 题目：计算一个三角形的周长编写程序，提示用户从键盘输入三角形的三条边，如果输入值合法就计算这个三角形的周长，否则，显示这些输入值不合法（如果任意两条边的和大于第三条边，那么输入值都是合法的）。
[选题人数：3] 4. 题目：奖金发放问题企业发放的奖金根据利润提成。
利润(I)低于或等于10万元时，奖金可提10%；利润高于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可可提成7.5%；20万到40万之间时，高于20万元的部分，可提成5%；40万到60万之间时高于40万元的部分，可提成3%；60万到100万之间时，高于60万元的部分，可提成1.5%，高于100万元时，超过100万元的部分按1%提成，从键盘输入当月利润I，求应发放奖金总数？[选题人数：3]5. 题目：打印金字塔形的数字编写一个嵌套的for循环，打印下面的输出。
1 2 1 1 2 4 2 1 1 2 4 8 4 2 1 1 2 4 8 168 4 2 11 2 4 8 16 32 16 8 4 2 11 2 4 8 16 32 64 32 16 8 4 2 11 2 4 8 16 32 64 128 64 32 16 8 4 2 1[选题人数：2] 6. 题目：十进制转换成二进制或十六进制编写程序，从键盘上输入一个十进制整数，然后显示对应的二进制值或十六进制值。
算法笔记_038：特殊回文数（Java）
算法笔记_038：特殊回⽂数（Java）⽬录1 问题描述问题描述 123321是⼀个⾮常特殊的数，它从左边读和从右边读是⼀样的。
输⼊⼀个正整数n，编程求所有这样的五位和六位⼗进制数，满⾜各位数字之和等于n 。
输⼊格式 输⼊⼀⾏，包含⼀个正整数n。
输出格式 按从⼩到⼤的顺序输出满⾜条件的整数，每个整数占⼀⾏。
样例输⼊52样例输出899998989989998899数据规模和约定 1<=n<=54。
2 解决⽅案2.1 80分解法初步看题，⾃⼰把题意给理解的太深奥了，对于输出的五位数和六位数，我以为00100也是符合要求的五位回⽂数，那么问题就来了，如何输出00100呢？其解法就只能使⽤字符串了，那么使⽤字符串后，问题⼜来了，如何对字符串进⾏从⼩到⼤排序呢？好吧，在这⾥⼜得把字符串转换成整数⽐较⼤⼩，计算排序位置，计算完后，再次输出字符串的顺序。
说到这⾥，我个⼈感觉⾃⼰写的代码虽然复杂，但是计算的结果绝对⽐标答结果全，但是在蓝桥杯练习系统中判分却只有80分，郁闷，不过这次得吸取理解题意的教训了。
具体代码如下：package com.liuzhen.systemExe;import java.util.HashSet;import java.util.Scanner;import java.util.Set;public class Main{public void getReverseN(int n){Set<String> set = new HashSet<String>();for(int i = 0;i < 10;i++){int x1 = i;for(int j = 0;j < 10;j++){int x2 = j;for(int k = 0;k < 10;k++){int x3 = k;if(2*(x1+x2)+x3 == n){char[] temp = new char[5];temp[0] = (char) (x1 + 48);temp[1] = (char) (x2 + 48);temp[2] = (char) (x3 + 48);temp[3] = (char) (x2 + 48);temp[4] = (char) (x1 + 48);String tempS1 = String.valueOf(temp);set.add(tempS1);temp[0] = (char) (x2 + 48);temp[1] = (char) (x1 + 48);temp[2] = (char) (x3 + 48);temp[3] = (char) (x1 + 48);temp[4] = (char) (x2 + 48);String tempS2 = String.valueOf(temp);set.add(tempS2);}if(2*(x1+x2+x3) == n){char[] temp = new char[6];temp[0] = (char) (x1 + 48);temp[1] = (char) (x2 + 48);temp[2] = (char) (x3 + 48);temp[3] = (char) (x3 + 48);temp[4] = (char) (x2 + 48);temp[5] = (char) (x1 + 48);String tempS1 = String.valueOf(temp); set.add(tempS1);temp[0] = (char) (x1 + 48);temp[1] = (char) (x3 + 48);temp[2] = (char) (x2 + 48);temp[3] = (char) (x2 + 48);temp[4] = (char) (x3 + 48);temp[5] = (char) (x1 + 48);String tempS2 = String.valueOf(temp); set.add(tempS2);temp[0] = (char) (x2 + 48);temp[1] = (char) (x1 + 48);temp[2] = (char) (x3 + 48);temp[3] = (char) (x3 + 48);temp[4] = (char) (x1 + 48);temp[5] = (char) (x2 + 48);String tempS3 = String.valueOf(temp); set.add(tempS3);temp[0] = (char) (x2 + 48);temp[1] = (char) (x3 + 48);temp[2] = (char) (x1 + 48);temp[3] = (char) (x1 + 48);temp[4] = (char) (x3 + 48);temp[5] = (char) (x2 + 48);String tempS4 = String.valueOf(temp); set.add(tempS4);temp[0] = (char) (x3 + 48);temp[1] = (char) (x2 + 48);temp[2] = (char) (x1 + 48);temp[3] = (char) (x1 + 48);temp[4] = (char) (x2 + 48);temp[5] = (char) (x3 + 48);String tempS5 = String.valueOf(temp); set.add(tempS5);temp[0] = (char) (x3 + 48);temp[1] = (char) (x1 + 48);temp[2] = (char) (x2 + 48);temp[3] = (char) (x2 + 48);temp[4] = (char) (x1 + 48);temp[5] = (char) (x3 + 48);String tempS6 = String.valueOf(temp); set.add(tempS6);}}}}int len = set.size();String[] result = new String[len];int i = 0;for(String tem : set)result[i++] = tem;int[] rI = getSort(result);for(i = 0;i < len;i++){int k = getMinI(rI);System.out.println(result[k]);rI[k] = len;}}public int[] getSort(String[] A){int len = A.length;int[] result = new int[len];int[] tempResult = new int[len];for(int i = 0;i < len;i++){tempResult[i] = Integer.parseInt(A[i]);}for(int i = 0;i < len;i++){int count = 0;for(int j = 0;j < len;j++){if(tempResult[i] > tempResult[j])count++;}result[i] = count;}return result;}public int getMinI(int[] A){int result = 0;for(int i = 0;i < A.length;i++){if(A[result] > A[i])result = i;}return result;}public static void main(String[] args){//long t1 = System.currentTimeMillis();Main test = new Main();Scanner in = new Scanner(System.in);System.out.println("请输⼊⼀个10进制整数：");int n = in.nextInt();test.getReverseN(n);//long t2 = System.currentTimeMillis();//System.out.println("耗时："+(t2-t1)+"毫秒");}}运⾏结果：请输⼊⼀个10进制整数：100100请输⼊⼀个10进制整数：2002000101000110010001010010100001请输⼊⼀个10进制整数：528999989899899988992.2 ⽹友标答解法具体代码如下：package com.liuzhen.array_2;import java.util.ArrayList;import java.util.Collections;import java.util.Scanner;public class Main {public static void main(String[] args) {Scanner input = new Scanner(System.in);System.out.println("请输⼊数字n:");int n=input.nextInt();ArrayList<Integer> rs= new ArrayList<Integer>();for(int i=1; i<10; i++)for(int j=0; j<10; j++)for(int k=0; k<10; k++){if(2*i+2*j+k==n)rs.add(i*10000 + j*1000 + k*100+ j*10 + i);if(2*i+2*j+2*k==n)rs.add(i*100000 + j*10000+ k*1000 + k*100+ j*10 + i); }Collections.sort(rs);for(int i=0; i< rs.size(); i++)System.out.println(rs.get(i));}}运⾏结果：请输⼊数字n:1请输⼊数字n:210001100001请输⼊数字n:52899998989989998899。
Java第一次作业-回文素数
《Java语言》课程作业(第一次)题目第8题学院计算机学院专业班别学号姓名陈聪2015年4月22日一、课程题目8、题目：回文素数回文素数是指一个数同时为素数和回文数。
例如：131是一个素数，同时也是一个回文数。
数字313和757也是如此。
编写程序，显示前100个回文素数，每行显示10个数并且准确对齐，如下所示：2 3 5 7 11 101 131 151 181 191313 353 373 383 727 757 787 797 919 929……. …. …. ………………. [选题人数：3]二、题目分析与设计1、题目的需求：编写程序，显示前100个回文素数，每行显示10个数并且准确对齐。
2、制定对应程序的功能：(1)将2以后的素数挑选出来，直到显示完前100个回文素数：利用for循环。
(2)判断挑选出来的素数是否为回文数：通过将原素数倒置再与原素数比较来判断。
(3)输出回文素数，同时判断是否要换行，通过确定位数来使回文素数准确对齐。
3、(1)程序功能层次图：(2)程序结构流程图：4、所使用的开发环境：Eclipse (1)判断一个数是否为素数:i=2;while(i<a) {if(a%i==0) continue outer;i++;}(2)将素数倒置:s=a;b=0;while(s!=0) {b=b*10+s%10;s=s/10;}(3)判断素数是否为回文数并输出：if(a==b) {n++;if(n%10==0) System.out.printf("%8d\n",a);else System.out.printf("%8d",a);}三、测试分析1、题目的需求：编写程序，显示前100个回文素数，每行显示10个数并且准确对齐。
因此本程序不需要构建测试数据。
2、运行程序的结果如下：所得到的前一百个回文素数与预计结果一致，格式正确，每行显示10个数并且准确对齐。
跟我学Java面向对象程序设计技术及应用——识别某个自然数是否为回文数的Java程序实现示例
杨教授工作室 精心创作的优秀程序员 职业提升必读系列资料
* 获得所输入的数字的个数（识别字符串的长度） */ int userInputNumberStringLength = userInputNumberString.length(); /* * 对用户所输入的数字分别从左到右和从右到左顺序获得对应数位上的数字，并识 别它们是否相等 */ for(int loopCounterIntOne=0,loopCounterIntTwo=userInputNumberStringLength-1;
2、在类创建的对话框中输入包名称为 com.bluedream.demo，类名称为 JavaPalindromeNumber， 并选择需要在 JavaPalindromeNumber 类中创建出 main()方法
杨教授工作室，版权所有5 ，盗版必究， 5/23 页
杨教授工作室 精心创作的优秀程序员 职业提升必读系列资料
oneJavaPalindromeNumber.testPalindromeNumber(someOneUserInputNumber); if(returnResult) {
System.out.println("你输入的"+someOneUserInputNumber+"是个回文数。"); }else {
是否为回文数，并打印出判断的结果。 （1）程序代码示例 package com.bluedream.demo; import java.util.Scanner; public class JavaPalindromeNumber {
public static void main(String args[]) { System.out.println("请输入一个正整数，系统将识别是否是回文数"); /* * 从键盘中获得用户所输入的数字（整数） */ int someOneUserInputNumber = new Scanner(System.in).nextInt(); /* * 将用户所输入的数字转换为字符串以获得各个数位上的数字 */
java素数判定条件
java素数判定条件
在Java中，素数的判定条件是该数只能被1和它本身整除，不能被其他的数整除。
因此，我们可以通过循环判断该数能否被2到该数的平方根之间的所有自然数整除来判断该数是否为素数。
具体实现可以采用以下代码：
public static boolean isPrime(int n) {
if (n <= 1) {
return false;
}
for (int i = 2; i <= Math.sqrt(n); i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
在该方法中，我们首先判断n是否小于等于1，因为小于等于1的数都不是素数。
然后我们通过循环判断该数能否被2到该数的平方根之间的所有自然数整除，如果能被整除则说明该数不是素数，返回false，否则说明该数是素数，返回true。
使用该方法可以方便地判断一个数是否为素数，在实际编程中也可以用其他算法来进行素数的判定。
11：回文素数
11：回⽂素数11:回⽂素数总时间限制:5000ms内存限制:65536kB描述⼀个数如果从左往右读和从右往左读数字是相同的，则称这个数是回⽂数，如121，1221，15651都是回⽂数。
给定位数n，找出所有既是回⽂数⼜是素数的n位⼗进制数。
（注：不考虑超过整型数范围的情况）。
输⼊位数n,其中1<=n<=9。
输出第⼀⾏输出满⾜条件的素数个数。
第⼆⾏按照从⼩到⼤的顺序输出所有满⾜条件的素数，两个数之间⽤⼀个空格区分。
样例输⼊1样例输出42 3 5 7分析：参见百度百科回⽂素数是⼀个既是素数⼜是回⽂数的整数。
回⽂素数与记数系统的进位制有关。
回⽂素数是指，对⼀个整数n（n≥11）从左向右和从右向左读其结果值相同且是素数，即称n为回⽂素数。
除了11，偶数位的数不存在回⽂质数。
4位，6位，8位……数不存在回⽂质数。
最初⼏个回⽂素数：11，101，131，151，181，191，313，353，373，383，727，757，787，797，919，929……两位回⽂素数1个，三位回⽂素数15个，五位回⽂素数93个，七位回⽂素数668个，九位回⽂素数5172个。
思路：对n为偶数的情况，直接特殊处理。
对n为奇数的情况，可以先特殊处理n==1的情况，然后对n==3、5、7、9的情况按如下⽅法处理：先想办法够造出⼀个n位的回⽂数temp然后判断temp是否是质数。
够造n位的回⽂数temp的⽅法：⽤所有的（n+1）/2位的数分别够造n位的回⽂数。
例如：可以⽤123够造⼀个5位的回⽂数12321.（注意：123可以够造出12321和32123两个回⽂数，但是我们只需要使⽤123够造12321，在接下来的循环过程中会使⽤321够造32123这个回⽂数。
）具体代码：1 #include<stdio.h>2 #include<stdlib.h>3 #include<math.h>4int isPrime(int n);//判断n是否质数5long long huiWen(int n);//例如：n等于123，返回12321这样⼀个回⽂数6long myPow(int x);//计算并返回10^x78int main()9 {10int n;11long begin,end,i;12long long a[8000]={0},count;13long long temp=0;1415 freopen("11.IN","r",stdin);16 freopen("11.out","w",stdout);1718 scanf("%d",&n);1920if(n==2) printf("1\n11\n");21else if(n%2==0) printf("0\n");22else if(n==1) printf("4\n2 3 5 7\n");23else24 {25 n=(n+1)/2;26 begin=myPow(n-1);27 end=myPow(n);28 count=0;29for(i=begin;i<end;i++)30 {31 temp=huiWen(i);32if(isPrime(temp)==1) { a[count]=temp; count++; }33 }34 printf("%d\n",count);35for(i=0;i<count;i++)36 {37 printf("%d ",a[i]);38 }39 }40return0;41 }42int isPrime(int n)43 {44int x,i;45 x=sqrt(n);46for(i=2;i<=x;i++)47 {48if(n%i==0) return0;49 }50return1;51 }52long long huiWen(int n)//例如：n等于123，返回12321这样⼀个回⽂数53 {54long long ans=n;55 n=n/10;56while(n>0)57 {58 ans=ans*10+n%10;59 n=n/10;60 }61return ans;62 }63long myPow(int x)//计算并返回10^x64 {65int i;66long ans=1;67for(i=0;i<x;i++) ans=ans*10;68return ans;69 }。
java作业34-37
34、回文是一种正读和反读都一样的数字或文本段。
例如，下面几个
５位数字都是回文：１２３２１，５５５５５，４５５５４和１
１６１１。
编写一个程序，读入一个５位数，然后判断该数是不
是一个回文。
35、实现下列整型方法:
a)方法celsius返回一个与华氏温度等价的摄氏温度,使用算式:
c = 5.0 / 9.0 * ( F - 32 );
b)方法fahrenheit返回一个摄氏温度等价的华氏温度,使用算
式: F = 9.0 / 5.0 * c + 32;
36、编写一个方法minimum3,返回3个浮点数中最小的一个。
使用
Math.min来实现minimum3，要求读取用户输入的3个值,并使用
minimum3确定最小的值，在控制台显示结果。
37、一个整数为完数(perfect number)的条件是,其因子(包括1但
不包括该整数本身)的和等于该数.例如6是一个完数,因为6 = 1
+ 2 + 3 .编写一个方法,判断形参number是否为一个完数。
挑
战计算机的工作能力,测试一下大于1000的数。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《Java语言》课程作业
(第一次)
题目第8题
学院计算机学院专业
班别
学号
姓名陈聪
2015年4月22日
一、课程题目
8、题目：回文素数
回文素数是指一个数同时为素数和回文数。
例如：131是一个素数，同时也是一个回文数。
数字313和757也是如此。
编写程序，显示前100个回文素数，每行显示10个数并且准确对齐，如下所示：
2 3 5 7 11 101 131 151 181 191
313 353 373 383 727 757 787 797 919 929
……. …. …. ………………. [选题人数：3]
二、题目分析与设计
1、题目的需求：编写程序，显示前100个回文素数，每行显示10个数并且准确对齐。
2、制定对应程序的功能：
(1)将2以后的素数挑选出来，直到显示完前100个回文素数：利用for循环。
(2)判断挑选出来的素数是否为回文数：通过将原素数倒置再与原素数比较来判断。
(3)输出回文素数，同时判断是否要换行，通过确定位数来使回文素数准确
对齐。
3、(1)程序功能层次图：
(2)程序结构流程图：
4、所使用的开发环境：Eclipse (1)判断一个数是否为素数:
i=2;
while(i<a) {
if(a%i==0) continue outer;
i++;
}
(2)将素数倒置:
s=a;b=0;
while(s!=0) {
b=b*10+s%10;
s=s/10;
}
(3)判断素数是否为回文数并输出：
if(a==b) {
n++;
if(n%10==0) System.out.printf("%8d\n",a);
else System.out.printf("%8d",a);
}
三、测试分析
1、题目的需求：编写程序，显示前100个回文素数，每行显示10个数并且准确对齐。
因此本程序不需要构建测试数据。
2、运行程序的结果如下：
所得到的前一百个回文素数与预计结果一致，格式正确，每行显示10个数并且准确对齐。
附录：源代码
package hui;
public class huiwen{
public static void main(String args[]){
int a,b,s;
int n=0,i;
outer:for(a=2;n<100;a++) { //从2开始寻找为回文数的素数i=2;
while(i<a) {
if(a%i==0) continue outer; //判断一个数是否为素数
i++;
}
s=a;b=0;
while(s!=0) {
b=b*10+s%10;
s=s/10;
} //将素数倒置赋给b
if(a==b) { //判断素数是否为回文数
n++;
if(n%10==0) System.out.printf("%8d\n",a); //判断是否换行
else System.out.printf("%8d",a);
}
}
}
}。