标题：数位和数学家高斯很小的时候就天分过人。一次老师指定的算数题目是：1+2+...+100。
高斯立即做出答案：5050!这次你的任务是类似的。但并非是把一个个的数字加起来，而是对该数字的每一个数位作累加。
这样从1加到100的“和”是：901从10加到15是：21，也就是：1+0+1+1+1+2+1+3+1+4+1+5，这个口算都可以出结果的。
按这样的“加法”，从1加到1000是多少呢？ 请通过浏览器提交该结果。
当然，我们并不期望你能像高斯一样，发现数字背后深奥的秘密，只要请计算机帮忙，一切都easy!
注意：你需要提交的是一个整数，不要填写任何多余的内容（比如：说明性文字）
答案: 13501
package The_Eight;
public class One {
public static void main(String[] args) {
//数位和
int sum = 0;
for (int i = 1; i <= 1000; i++) {
int a = i;
while (a>0){
sum += a%10;
a/=10;
}
}
System.out.println(sum);
}
}
标题：数字划分
w星球的长老交给小明一个任务：
1,2,3...16 这16个数字分为两组。
要求：
这两组数字的和相同，
并且，两组数字的平方和也相同，
并且，两组数字的立方和也相同。请你利用计算机的强大搜索能力解决这个问题。
并提交1所在的那个分组的所有数字。这些数字要从小到大排列，两个数字间用一个空格分开。
即类似：1 4 5 8 ... 这样的答案。注意，只提交这一组数字，不要填写任何多余的内容。
----------------------------------------
笨笨有话说：
只要一个组的成员确定了，另一个组的成员也就确定了。枚举一个组的成员就可以了。
凭直觉，两个组的成员数目不会差太多吧。
歪歪有话说：
既然求 1 所在的那个组，那只要枚举剩余的成员就可以了。
貌似都是8个成员的可能性很大啊。
答案：1 4 6 7 10 11 13 16
package The_Eight;
import java.util.ArrayList;
public class Two {
public static int []arr;
public static int h;
public static void main(String[] args) {
//数字化分
h = 0;
arr = new int[8];
for (int i = 1; i <= 16; i++) {
h += i;
}
arr[0] = 1;
h /= 2;
//求一所在组 所以1是一定在的 那么从第二位开始
getNum(1,2,0);
}
//index :取了几个了 n:当前数可取范围
public static void getNum(int index,int n,int sum){
//因为1是默认的 没有在这里循环 所以-1
if (sum==h-1){
boolean sign = true;
//这一组数字中不能有相同的
int p = 0;
int l = 0;
for (int i = 0; i < arr.length; i++) {
int len = 0;
for (int j = 0; j < arr.length; j++) {
if (arr[i]==arr[j]){
len++;
}
}
if (len>1){
sign = false;
break;
}
p += arr[i] * arr[i];
l += arr[i] * arr[i] * arr[i];
}
if (sign){
// for (int i = 0; i < arr.length; i++) {
// System.out.print(arr[i]+" ");
// }
// System.out.println();
//他与另一组数的立方和平方都相同
int p1 = 0;
int l1 = 0;
for (int i = 1; i <= 16; i++) {
boolean sign1 = true;
for (int j = 0; j < arr.length; j++) {
if (i==arr[j]){
sign1 = false;
break;
}
}
if (sign1){
// System.out.print(i+" ");
p1 += i*i;
l1 += i*i*i;
}
}
// System.out.println();
// System.out.println(p+" "+p1+"|"+l+" "+l1);
if (p==p1&&l==l1){
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}
return;
}
if (index>=8){
return;
}
for (int i = n; i <= 16; i++) {
arr[index] = i;
sum += i;
getNum(index+1,i+1,sum);
sum -= i;
}
}
}
标题：树形显示对于分类结构可以用树形来形象地表示。比如：文件系统就是典型的例子。
树中的结点具有父子关系。我们在显示的时候，把子项向右缩进（用空格，不是tab），并添加必要的连接线，以使其层次关系更醒目。
下面的代码就是为了这个目的的，请仔细阅读源码，并填写划线部分缺少的代码。
import java.util.*;class MyTree
{
private Map<String, List<String>> map_ch = new HashMap<String, List<String>>();
private Map<String,String> map_pa = new HashMap<String,String>();
public void add(String parent, String child)
{
map_pa.put(child, parent);
List<String> lst = map_ch.get(parent);
if(lst==null){
lst = new ArrayList<String>();
map_ch.put(parent, lst);
}
lst.add(child);
}
public String get_parent(String me){
return map_pa.get(me);
}
public List<String> get_child(String me){
return map_ch.get(me);
}
private String space(int n)
{
String s = "";
for(int i=0; i<n; i++) s += ' ';
return s;
}
private boolean last_child(String x){
String pa = map_pa.get(x);
if(pa==null) return true;
List<String> lst = map_ch.get(pa);
return lst.get(lst.size()-1).equals(x);
}
public void show(String x){
String s = "+--" + x;
String pa = x;
while(true){
pa = map_pa.get(pa);
if(pa==null) break;
s = ___________________________________ ; // 填空
}
System.out.println(s);
}
public void dfs(String x){
show(x);
List<String> lst = map_ch.get(x);
if(lst==null) return;
for(String it: lst){
dfs(it);
}
}
}public class TreeView
{
public static void main(String[] args)
{
MyTree tree = new MyTree();
tree.add("root", "dog");
tree.add("root", "cat");
tree.add("root", "duck");
tree.add("dog", "AAdog");
tree.add("dog", "BBdog");
tree.add("dog", "CCdog");
tree.add("AAdog", "AAdog01");
tree.add("AAdog", "AAdog02");
tree.add("cat", "XXcat");
tree.add("cat", "YYcat");
tree.add("XXcat","XXcat-oo");
tree.add("XXcat","XXcat-qq");
tree.add("XXcat-qq", "XXcat-qq-hahah");
tree.add("duck", "TTduck");
tree.add("TTduck", "TTduck-001");
tree.add("TTduck", "TTduck-002");
tree.add("TTduck", "TTduck-003");
tree.add("YYcat","YYcat.hello");
tree.add("YYcat","YYcat.yes");
tree.add("YYcat","YYcat.me");
tree.dfs("root");
}
}对于题目中的测试数据，输出结果:
+--root
+--dog
| +--AAdog
| | +--AAdog01
| | +--AAdog02
| +--BBdog
| +--CCdog
+--cat
| +--XXcat
| | +--XXcat-oo
| | +--XXcat-qq
| | +--XXcat-qq-hahah
| +--YYcat
| +--YYcat.hello
| +--YYcat.yes
| +--YYcat.me
+--duck
+--TTduck
+--TTduck-001
+--TTduck-002
+--TTduck-003
如有平字体对齐问题，可以参见图【p1.png】注意，只填写划线部分缺少的代码，不要抄写已有的代码或符号。
package The_Eight;
import java.util.ArrayList;
public class Two {
public static int []arr;
public static int h;
public static void main(String[] args) {
//数字化分
h = 0;
arr = new int[8];
for (int i = 1; i <= 16; i++) {
h += i;
}
arr[0] = 1;
h /= 2;
//求一所在组 所以1是一定在的 那么从第二位开始
getNum(1,2,0);
}
//index :取了几个了 n:当前数可取范围
public static void getNum(int index,int n,int sum){
//因为1是默认的 没有在这里循环 所以-1
if (sum==h-1){
boolean sign = true;
//这一组数字中不能有相同的
int p = 0;
int l = 0;
for (int i = 0; i < arr.length; i++) {
int len = 0;
for (int j = 0; j < arr.length; j++) {
if (arr[i]==arr[j]){
len++;
}
}
if (len>1){
sign = false;
break;
}
p += arr[i] * arr[i];
l += arr[i] * arr[i] * arr[i];
}
if (sign){
// for (int i = 0; i < arr.length; i++) {
// System.out.print(arr[i]+" ");
// }
// System.out.println();
//他与另一组数的立方和平方都相同
int p1 = 0;
int l1 = 0;
for (int i = 1; i <= 16; i++) {
boolean sign1 = true;
for (int j = 0; j < arr.length; j++) {
if (i==arr[j]){
sign1 = false;
break;
}
}
if (sign1){
// System.out.print(i+" ");
p1 += i*i;
l1 += i*i*i;
}
}
// System.out.println();
// System.out.println(p+" "+p1+"|"+l+" "+l1);
if (p==p1&&l==l1){
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}
return;
}
if (index>=8){
return;
}
for (int i = n; i <= 16; i++) {
arr[index] = i;
sum += i;
getNum(index+1,i+1,sum);
sum -= i;
}
}
}
标题： 小数第n位我们知道，整数做除法时，有时得到有限小数，有时得到无限循环小数。
如果我们把有限小数的末尾加上无限多个0，它们就有了统一的形式。本题的任务是：在上面的约定下，求整数除法小数点后的第n位开始的3位数。
输入：
一行三个整数：a b n，用空格分开。a是被除数，b是除数，n是所求的小数后位置（0<a,b,n<1000000000）
输出：
一行3位数字，表示：a除以b，小数后第n位开始的3位数字。比如：
输入：
1 8 1程序应该输出：
125再比如：
输入：
1 8 3程序应该输出：
500再比如：
输入：
282866 999000 6程序应该输出：
914资源约定：
峰值内存消耗 < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。----------------------------------------
笨笨有话说：
这个除法小学就会算啊，模拟手算除法的过程就可以了吧。
只是数有点大啊....
管它呢，能算多远算多远....
歪歪有话说：
如果我能确定循环节从哪里开始到哪里结束，再大的数不过就是与它取模的余数等价啊
package The_Eight;
import java.util.Scanner;
public class Four {
public static void main(String[] args) {
//小数第n位
Scanner sr = new Scanner(System.in);
double a = sr.nextInt();
double b = sr.nextInt();
int c = sr.nextInt();
System.out.println(a/b);
String d = ""+a/b;
int index = d.indexOf(".");//小数点的位置
if (c<d.length()-index-1&&c+2<=d.length()-index-1){//如果小数点后的位数 大于要求的位数 那么正常给
System.out.println(d.substring(index+c,index+c+3));
}else if (c<=d.length()-index-1&&d.length()-index-1<c+2){//如果小数位有c个 但取不够三个
String f = d.substring(index+c,d.length());
int len = f.length();
for (int i = 0; i < 3-len; i++) {
f += "0";
}
System.out.println(f);
}else{
System.out.println("000");
}
}
}
标题：分考场n个人参加某项特殊考试。
为了公平，要求任何两个认识的人不能分在同一个考场。
求是少需要分几个考场才能满足条件。输入格式：
第一行，一个整数n(1<n<100)，表示参加考试的人数。
第二行，一个整数m，表示接下来有m行数据
以下m行每行的格式为：两个整数a，b，用空格分开 (1<=a,b<=n) 表示第a个人与第b个人认识。输出格式：
一行一个整数，表示最少分几个考场。例如：
输入：
5
8
1 2
1 3
1 4
2 3
2 4
2 5
3 4
4 5程序应该输出：
4再比如：
输入：
5
10
1 2
1 3
1 4
1 5
2 3
2 4
2 5
3 4
3 5
4 5则程序应该输出：
5资源约定：
峰值内存消耗 < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
package The_Eight;
import java.util.ArrayList;
import java.util.Scanner;
public class five {
public static ArrayList<ArrayList<Integer>> arr;
public static int []b;
public static boolean [][]x;
public static int students;
public static void main(String[] args) {
//分考场
//思路: 按顺序给考生分考场 每个考生分的时候都遍历所有考场 查看当前要分考场的学生 与已经在考场里的学生是否认识 如果不认识就加进去 如果所有考场都有认识的人 那么新增考场
Scanner sr = new Scanner(System.in);
students = sr.nextInt();//学生数
int a = sr.nextInt();//共有多少对 认识关系
b = new int[a*2];
for (int i = 0; i < b.length; i++) {
b[i] = sr.nextInt();
}
arr = new ArrayList<ArrayList<Integer>>();//考场
//最小也得有一个考场
arr.add(new ArrayList<Integer>());
//学生关系
x = new boolean[students+1][students+1];
for (int i = 0; i < b.length; i+=2) {
x[b[i]][b[i+1]] = true;
x[b[i+1]][b[i]] = true;
}
fk(1);
System.out.println(arr);
}
//分考场 student:当前要分考场的学生
public static void fk(int student){
//如果当前学生编号 已经超过学生总数(即分完了)
if (student>students){
//输出考场数量
System.out.println(arr.size());
return;
}
//遍历所有已有考场
//有没有加入任意考场
boolean jr = false;
for (int i = 0; i < arr.size(); i++) {
//查看当前要分考场的学生 与已经在考场里的学生是否认识
//是否可以放入当前考场
boolean fr = true;
//遍历当前考场的所有学生
for (int j = 0; j < arr.get(i).size(); j++) {
//如果当前学生 跟当前考场中的任意一个认识 就不能加入该考场
if (x[arr.get(i).get(j)][student]){
fr = false;
break;
}
}
if (fr){
//吧当前学生加入当前考场
arr.get(i).add(student);
jr = true;
break;
}
}
//加入成功加入 那么 分下一个学生 否则 增加一个考场 然后将当前学生加入新考场 然后再分下一个学生
if (jr){
fk(student+1);
}else{
//新增考场
arr.add(new ArrayList<Integer>());
//将当前学生加入新考场
arr.get(arr.size()-1).add(student);
//分下一个学生
fk(student+1);
}
}
}
标题：合根植物w星球的一个种植园，被分成 m * n 个小格子（东西方向m行，南北方向n列）。每个格子里种了一株合根植物。
这种植物有个特点，它的根可能会沿着南北或东西方向伸展，从而与另一个格子的植物合成为一体。如果我们告诉你哪些小格子间出现了连根现象，你能说出这个园中一共有多少株合根植物吗？
输入格式：
第一行，两个整数m，n，用空格分开，表示格子的行数、列数（1<m,n<1000）。
接下来一行，一个整数k，表示下面还有k行数据(0<k<100000)
接下来k行，第行两个整数a，b，表示编号为a的小格子和编号为b的小格子合根了。格子的编号一行一行，从上到下，从左到右编号。
比如：5 * 4 的小格子，编号：
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
17 18 19 20样例输入：
5 4
16
2 3
1 5
5 9
4 8
7 8
9 10
10 11
11 12
10 14
12 16
14 18
17 18
15 19
19 20
9 13
13 17
样例输出：
5其合根情况参考图[p1.png]
资源约定：
峰值内存消耗 < 256M
CPU消耗 < 2000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
package The_Eight;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Scanner;
public class Six {
public static ArrayList<HashSet<Integer>> arr;//合根完成后的植物
public static boolean [][]map;
public static int sum;
public static void main(String[] args) {
//合跟植物
Scanner sr = new Scanner(System.in);
int x = sr.nextInt();//园子的行数
int y = sr.nextInt();//园子的列数
sum = x*y;
int k = sr.nextInt();//合根动作的数量
map = new boolean[x*y+1][x*y+1];
//状态图 方便查看一株植物都与那些植物进行锅合根
for (int i = 0; i < k; i++) {
int a = sr.nextInt();
int b = sr.nextInt();
map[a][b] = true;
map[b][a] = true;
}
arr = new ArrayList<HashSet<Integer>>();
hg(1);
}
//index: 当前要进行合根的植物
public static void hg(int index){
//遍历所有以合根的植物 集合 看当前植物 是不是已经跟哪一个植物合并过了
// 如果是那么将 所有与当前植物连接的植物都加入该合根植物 否则就新建一个合跟植物并将 所有与当前植物连接的植物都加入该合根植物
//如果当前植物编号 大于 植物总数（所有植物合根完成）
if (index>sum){
System.out.println(arr.size());
System.out.println(arr);
return;
}
//是否加入了其中的一个合根植物
boolean jr = false;
//遍历所有“已合根植物”
for (int i = 0; i < arr.size(); i++) {
//能否加入当前合根植物
boolean fr = false;
//当前合跟植物 中 是否有当前植物
if(arr.get(i).contains(index)){
fr = true;
}else{
//如果没有当前植物 那么 查看所有与当前植物合根的植物中 有没有存在于当前合根植物中的 如果有 就正常加入
for (int j = 0; j < map[index].length; j++) {
if(map[index][j]&&arr.get(i).contains(j)){
fr = true;
break;
}
}
}
//如果可以加入 那么将所有与当前植物连接的植物都加入该合根植物
if (fr){
jr = true;
for (int j = 1; j < map[index].length; j++) {
if (map[index][j]){
arr.get(i).add(j);
}
}
break;
}
}
//如果已经当前植物已经加入完成了 那么加下一个植物 如果没有加入 所有合跟植物都没有与当前植物合根过 那么新增加一个合跟植物 并将当前植物加入 然后继续加下一个植物
if (jr){
hg(index+1);
}else{
//新增一个合根植物
arr.add(new HashSet<Integer>());
//将当前植物 和 所有与当前植物连接的植物都加入该合根植物
arr.get(arr.size()-1).add(index);
for (int j = 1; j < map[index].length; j++) {
if (map[index][j]){
arr.get(arr.size()-1).add(j);
}
}
hg(index+1);
}
}
}
901
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
