有人说（手动@老组长）我上篇简书是混次数的，
我的回答是：“不”
因为——这篇才是。
其实前几天就在准备决赛了！
自信吗？还是自负？
emmm。哲学问题！
当然了，
就做了几道往年的决赛真（水）题，
跟真正的大佬差的很远！
这几天做的代码粘一下吧！
混篇简书。
//标题：方格填数
//在2行5列的格子中填入1到10的数字。
//要求：
//相邻的格子中的数，右边的大于左边的，下边的大于上边的。
//如【图1.png】所示的2种，就是合格的填法。
//请你计算一共有多少种可能的方案。
//请提交该整数，不要填写任何多余的内容（例如：说明性文字）。
public class 第六届C++A组第一题方格填数 {
public static int a[]= {1,2,3,4,5,6,7,8,9,10};
public static void f(int a[],int k)
{
if(k==10)
{
check(a);
return;
}
for(int i=k;i<10;i++)
{
int t=a[k];a[k]=a[i];a[i]=t;
f(a,k+1);
t=a[k];a[k]=a[i];a[i]=t;
}
}
public static void check(int a[])
{
if(a[0]<a[1]&&a[1]<a[2]&&a[2]<a[3]&&a[3]<a[4]&&
a[5]<a[6]&&a[6]<a[7]&&a[7]<a[8]&&a[8]<a[9]&&
a[0]<a[5]&&a[1]<a[6]&&a[2]<a[7]&&a[3]<a[8]&&a[4]<a[9])
{
ans++;
}
}
static int ans=0;
public static void main(String[] args) {
f(a,0);
System.out.println(ans);
}
}
//标题：积分之迷
//小明开了个网上商店，卖风铃。共有3个品牌：A，B，C。
//为了促销，每件商品都会返固定的积分。
//小明开业第一天收到了三笔订单：
//第一笔：3个A + 7个B + 1个C，共返积分：315
//第二笔：4个A + 10个B + 1个C，共返积分：420
//第三笔：A + B + C，共返积分....
//你能算出第三笔订单需要返积分多少吗？
//请提交该整数，不要填写任何多余的内容。
public class 第六届C++B组积分之谜 {
public static void main(String[] args) {
for(int a=0;a<100;a++)
{
for(int b=0;b<100;b++)
{
for(int c=0;c<100;c++)
{
if(3*a+7*b+c==315&&4*a+10*b+c==420)
{
System.out.println(a+b+c);
}
}
}
}
}
}
//标题：胡同门牌号
//小明家住在一条胡同里。胡同里的门牌号都是连续的正整数，由于历史原因，最小的号码并不是从1开始排的。
//有一天小明突然发现了有趣的事情：
//如果除去小明家不算，胡同里的其它门牌号加起来，刚好是100！
//并且，小明家的门牌号刚好等于胡同里其它住户的个数！
//请你根据这些信息，推算小明家的门牌号是多少？
//请提交该整数，不要填写任何多余的内容或说明性文字。
public class 第六届javaA组胡同门牌号 {
static void f(int x)
{
for(int i=1;i<x+1;i++)
{
int count=0;
for(int j=i;j<i+x+1;j++)
{
count+=j;
}
if(count==100+x)
{
System.out.println(x);
}
}
}
public static void main(String[] args) {
for(int x=1;x<50;x++)
{
f(x);
//8 or 10
}
}
}
//标题：分机号
//X老板脾气古怪，他们公司的电话分机号都是3位数，老板规定，所有号码必须是降序排列，且不能有重复的数位。比如：
//751,520,321 都满足要求，而，
//766,918,201 就不符合要求。
//现在请你计算一下，按照这样的规定，一共有多少个可用的3位分机号码？
//请直接提交该数字，不要填写任何多余的内容。
public class 六JavaB分机号 {
static int ans=0;
public static void main(String[] args) {
for(int i=2;i<10;i++)
{
for(int j=i-1;j>=1;j--)
{
for(int k=j-1;k>=0;k--)
{
System.out.println(i*100+j*10+k);
ans++;
}
}
}
System.out.println(ans);
}
}
//标题：机器人数目
//少年宫新近邮购了小机器人配件，共有3类，其中，
//A类含有：8个轮子，1个传感器
//B类含有: 6个轮子，3个传感器
//C类含有：4个轮子，4个传感器
//他们一共订购了100套机器人，收到了轮子600个，传感器280个。
//根据这些信息请你计算：B类型机器人订购了多少个？
//请直接提交该整数，不要填写任何多余内容。
public class 六JavaC机器人数目 {
public static void main(String[] args) {
for(int i=0;i<101;i++)
{
for(int j=0;j<101;j++)
{
for(int k=0;k<101;k++)
{
if((i*8+j*6+k*4)==600&&(i*1+j*3+k*4)==280&&i+j+k==100)
{
System.out.println(j);
}
}
}
}
}
}
//随意组合
//小明被绑架到X星球的巫师W那里。
//其时，W正在玩弄两组数据 (2 3 5 8) 和 (1 4 6 7)
//他命令小明从一组数据中分别取数与另一组中的数配对，共配成4对（组中的每个数必被用到）。
//小明的配法是：{(8,7),(5,6),(3,4),(2,1)}
//巫师凝视片刻，突然说这个配法太棒了！
//因为：
//每个配对中的数字组成两位数，求平方和，无论正倒，居然相等：
//87^2 + 56^2 + 34^2 + 21^2 = 12302
//78^2 + 65^2 + 43^2 + 12^2 = 12302
//小明想了想说：“这有什么奇怪呢，我们地球人都知道，随便配配也可以啊！”
//{(8,6),(5,4),(3,1),(2,7)}
//86^2 + 54^2 + 31^2 + 27^2 = 12002
//68^2 + 45^2 + 13^2 + 72^2 = 12002
//巫师顿时凌乱了。。。。。
//请你计算一下，包括上边给出的两种配法，巫师的两组数据一共有多少种配对方案具有该特征。
//配对方案计数时，不考虑配对的出现次序。
//就是说：
//{(8,7),(5,6),(3,4),(2,1)}
//与
//{(5,6),(8,7),(3,4),(2,1)}
//是同一种方案。
//注意：需要提交的是一个整数，不要填写任何多余内容（比如，解释说明文字等）
public class 七C语言A随意组合 {
public static int a[]= {2,3,5,8};
public static int b[]= {1,4,6,7};
public static int count=0;
public static void f(int b[],int k){
if(k==4){
check(b);
return;
}
for(int i=k;i<b.length;i++){
int t=b[k];b[k]=b[i];b[i]=t;
f(b,k+1);
t=b[k];b[k]=b[i];b[i]=t;
}
}
public static void check(int b[]){
int m=(a[0]*10+b[0])*(a[0]*10+b[0])+(a[1]*10+b[1])*(a[1]*10+b[1])+(a[2]*10+b[2])*(a[2]*10+b[2])+(a[3]*10+b[3])*(a[3]*10+b[3]);
int n=(b[0]*10+a[0])*(b[0]*10+a[0])+(b[1]*10+a[1])*(b[1]*10+a[1])+(b[2]*10+a[2])*(b[2]*10+a[2])+(b[3]*10+a[3])*(b[3]*10+a[3]);
if(m==n)
count++;
}
public static void main(String[] args) {
f(b,0);
System.out.println(count);
}
}
//一步之遥
//从昏迷中醒来，小明发现自己被关在X星球的废矿车里。
//矿车停在平直的废弃的轨道上。
//他的面前是两个按钮，分别写着“F”和“B”。
//小明突然记起来，这两个按钮可以控制矿车在轨道上前进和后退。
//按F，会前进97米。按B会后退127米。
//透过昏暗的灯光，小明看到自己前方1米远正好有个监控探头。
//他必须设法使得矿车正好停在摄像头的下方，才有机会争取同伴的援助。
//或许，通过多次操作F和B可以办到。
//矿车上的动力已经不太足，黄色的警示灯在默默闪烁...
//每次进行 F 或 B 操作都会消耗一定的能量。
//小明飞快地计算，至少要多少次操作，才能把矿车准确地停在前方1米远的地方。
//请填写为了达成目标，最少需要操作的次数。
//注意，需要提交的是一个整数，不要填写任何无关内容（比如：解释说明等）
public class 七C语言B一步之遥 {
public static boolean check(int i,int j){
if((i*97-j*127)==1)
return true;
return false;
}
public static void main(String[] args) {
for(int i=0;i<100;i++){
for(int j=0;j<100;j++){
if(check(i,j)){
System.out.println(i+j);
}
}
}
}
}
import java.math.BigInteger;
//阶乘位数
//9的阶乘等于：362880
//它的二进制表示为：1011000100110000000
//这个数字共有19位。
//请你计算，9999 的阶乘的二进制表示一共有多少位？
//注意：需要提交的是一个整数，不要填写任何无关内容（比如说明解释等）
public class 七JavaA阶乘位数 {
public static void main(String[] args) {
BigInteger a=f(9999);
String n=Integer.toBinaryString(a.intValue());
System.out.println(a.bitLength());
}
public static BigInteger f(int n){
if(n>1){
return BigInteger.valueOf(n).multiply(f(n-1));
}else{
return BigInteger.ONE;
}
}
}
//愤怒小鸟
//
//X星球愤怒的小鸟喜欢撞火车！
//
//一根平直的铁轨上两火车间相距 1000 米
//两火车 （不妨称A和B） 以时速 10米/秒 相对行驶。
//
//愤怒的小鸟从A车出发，时速50米/秒，撞向B车，
//然后返回去撞A车，再返回去撞B车，如此往复....
//两火车在相距1米处停车。
//
//问：这期间愤怒的小鸟撞 B 车多少次？
//
//注意：需要提交的是一个整数（表示撞B车的次数），不要填写任何其它内容。
public class 七JavaB愤怒小鸟 {
public static void main(String[] args) {
double s=1000;
int count=0;
while(s>=1)
{
s=(s-(s/60)*20);
count++;
}
System.out.println(s+","+count);
//count表示撞击的次数，如果是奇数则答案为（count+1）/2，如果是偶数则是count/2；
}
}
//平方末尾
//能够表示为某个整数的平方的数字称为“平方数”
//比如，25,64
//虽然无法立即说出某个数是平方数，但经常可以断定某个数不是平方数。
//因为平方数的末位只可能是：[0, 1, 4, 5, 6, 9] 这6个数字中的某个。
//所以，4325435332必然不是平方数。
//如果给你一个2位或2位以上的数字，你能根据末位的两位来断定它不是平方数吗？
//请计算一下，一个2位以上的平方数的最后两位有多少种可能性？
//注意：需要提交的是一个整数，表示2位以上的平方数最后两位的不同情况数。
//不要填写任何多余内容（比如，说明解释文字等）
import java.util.Arrays;
public class 七JavaC平方末尾 {
static int a[]=new int [100];
static int count=1;
public static void main(String[] args) {
for(int i=10;i<100;i++)
{
a[i]=(i*i)%100;
}
Arrays.sort(a);
for(int i=0;i<99;i++)
{
if(a[i]==a[i+1])a[i]=0;
}
Arrays.sort(a);
for(int i=0;i<100;i++)
{
if(a[i]>0)//System.out.println(a[i]);
count++;
}
System.out.println(count);
}
}
import java.util.Scanner;
//标题：36进制
//对于16进制，我们使用字母A-F来表示10及以上的数字。
//如法炮制，一直用到字母Z，就可以表示36进制。
//36进制中，A表示10，Z表示35，AA表示370
//你能算出 MANY 表示的数字用10进制表示是多少吗?
//请提交一个整数，不要填写任何多余的内容（比如，说明文字）
public class 八C语言B36进制 {
public static void main(String[] args) {
int sum=22*36*36*36+10*36*36+23*36+34;
System.out.println(sum);
}
}
//标题：哥德巴赫分解
//
//哥德巴赫猜想认为：不小于4的偶数都可以表示为两个素数的和。
//
//你不需要去证明这个定理，但可以通过计算机对有限数量的偶数进行分解，验证是否可行。
//
//实际上，一般一个偶数会有多种不同的分解方案，我们关心包含较小素数的那个方案。
//对于给定数值范围，我们想知道这些包含较小素数方案中最大的素数是多少。
//
//比如，100以内，这个数是19，它由98的分解贡献。
//
//你需要求的是10000以内，这个数是多少？
//
//注意，需要提交的是一个整数，不要填写任何多余的内容（比如，说明性的文字）
import java.util.Arrays;
public class 八C语言C哥德巴赫猜想 {
public static boolean zhishu(int n){
for(int i=2;i<=n/2;i++)
if(n%i==0)
return false;
return true;
}
static int z[]=new int [10001];
public static void main(String[] args) {
for(int i=4;i<=10000;i+=2){
for(int a=2;a<=(i-2);a++){
if(zhishu(a)&&zhishu(i-a)){
z[i]=a;
break;
}
}
}
Arrays.sort(z);
System.out.println(z[10000]);
}
}
//标题：图书排列
//将编号为1~10的10本书排放在书架上，要求编号相邻的书不能放在相邻的位置。
//请计算一共有多少种不同的排列方案。
//注意，需要提交的是一个整数，不要填写任何多余的内容。
public class 八JavaA图书排列 {
static int a[]= {1,2,3,4,5,6,7,8,9,10};
static int ans=0;
static void f(int a[],int k)
{
if(k==10)
{
check(a);
}
for(int i=k;i<10;i++)
{
int t=a[k];a[k]=a[i];a[i]=t;
f(a,k+1);
t=a[k];a[k]=a[i];a[i]=t;
}
}
static void check(int a[])
{
for(int i=0;i<9;i++)
{
if(Math.abs(a[i]-a[i+1])==1)
{
return ;
}
}
ans++;
}
public static void main(String[] args) {
f(a,0);
System.out.println(ans);
}
}
//标题：平方十位数
//
//由0~9这10个数字不重复、不遗漏，可以组成很多10位数字。
//这其中也有很多恰好是平方数（是某个数的平方）。
//
//比如：1026753849，就是其中最小的一个平方数。
//
//请你找出其中最大的一个平方数是多少？
//
//注意：你需要提交的是一个10位数字，不要填写任何多余内容。
public class 八JavaB平方十位数
{
public static void check(long a[])
{
if(a[0]==0)return;
long x=a[0]*1000000000+a[1]*100000000+a[2]*10000000+a[3]*1000000+a[4]*100000+a[5]*10000+a[6]*1000+a[7]*100+a[8]*10+a[9];
long y=(int)(Math.sqrt(x));
if(y*y==x)
System.out.println(y+","+x);
}
public static void f(long sz[],int k)
{
if(k>=10)
{
check(sz);
return;
}
for(int j=k;j<10;j++)
{
long t;
t=sz[k];sz[k]=sz[j];sz[j]=t;
f(sz,k+1);
t=sz[k];sz[k]=sz[j];sz[j]=t;
}
}
static long sz[]= {0,1,2,3,4,5,6,7,8,9};
public static void main(String[] args) {
f(sz,0);
}
}
//标题：数位和
//数学家高斯很小的时候就天分过人。一次老师指定的算数题目是：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!
//注意：你需要提交的是一个整数，不要填写任何多余的内容（比如：说明性文字）
public class 八JavaC数位和 {
static int ans=0;
static void f(int n)
{
do{
ans+=(n%10);
n=n/10;
}while(n>0);
}
public static void main(String[] args) {
for(int i=1;i<101;i++)
f(i);
System.out.println(ans);
}
}
emmm。。估计没人能认真看完。。
哈哈哈，完成目的了，本周简书+1
