练习Day——2

小数第n位（PREV-52）

题目描述
我们知道，整数做除法时，有时得到有限小数，有时得到无限循环小数。
如果我们把有限小数的末尾加上无限多个0，它们就有了统一的形式。
本题的任务是：在上面的约定下，求整数除法小数点后的第n位开始的3位数。

输入
一行三个整数：a b n，用空格分开。a是被除数，b是除数，n是所求的小数后位置（0<a,b,n<1000000000）

输出
一行3位数字，表示：a除以b，小数后第n位开始的3位数字。

样例输入
1 8 1

样例输出
125

import java.util.Scanner;

public class Main {
	public static void main(String[]args) {
		Scanner scan=new Scanner(System.in);
		int a,b,n;
		a=scan.nextInt();//被除数
		b=scan.nextInt();//除数
		n=scan.nextInt();//所求的效数后位置
		
		a%=b;//只计算小数点后
		
		//与笔除法一样
		for(int i=1;i<n;i++) {
			a*=10; //每向下取一位向后借一位0
			a%=b;
		}
		for(int i=0;i<3;i++) {
			a*=10;
			System.out.print(a/b);
			a%=b;
		}
	}
}

猴子吃包子

问题描述
从前，有一只吃包子很厉害的猴子，它可以吃无数个包子，但是，它吃不同的包子速度也不同；肉包每秒钟吃x个；韭菜包每秒钟吃y个；没有馅的包子每秒钟吃z个；现在有x1个肉包，y1个韭菜包，z1个没有馅的包子；问：猴子吃完这些包子要多久？结果保留p位小数。

输入格式
输入1行，包含7个整数，分别表示吃不同包子的速度和不同包子的个数和保留的位数。

输出格式
输出一行，包含1个实数，表示吃完所有包子的时间。
　　
样例输入
4 3 2 20 30 15 2

样例输出
22.50

数据规模和约定
0<x<100;0<y<100;0<z<100;0<x1<=1000000;0<y1<=10000000;0<z1<=10000000;0<p<=1000

import java.util.Scanner;
//猴子吃包子
public class Main {
	public static void main(String[]args) {
		Scanner scan=new Scanner(System.in);
		int p;
		double x,y,z,x1,y1,z1;
		
		x=scan.nextDouble();//肉包每秒钟吃x个
		y=scan.nextDouble();//韭菜包每秒钟吃y个
		z=scan.nextDouble();//没有馅的包子每秒钟吃z个
		
		x1=scan.nextDouble();//x1个肉包
		y1=scan.nextDouble();//y1个韭菜包
		z1=scan.nextDouble();//z1个没有馅的包子
		
		p=scan.nextInt();//结果保留p位小数
		
		double t=x1/x+y1/y+z1/z;
		
		System.out.printf("%."+p+"f",t);
	}
}

Torry的困惑(提高型)

题目描述
Torry从小喜爱数学。一天，老师告诉他， 像2、3、5、7……这样的数叫做质数。Torry突然想到一个问题，前10、100、1000、10000……个质数的乘积是多少呢？他把这个问题告诉 老师。老师愣住了，一时回答不出来。于是Torry求助于会编程的你，请你算出前n个质数的乘积。不过，考虑到你才接触编程不久，Torry只要你算出这 个数模上50000的值。

输入
仅包含一个正整数n，其中n< =100000。

输出
输出一行，即前n个质数的乘积模50000的值。

样例输入
1

样例输出
2

import java.util.Scanner;

public class Main {
	public static void main(String[]args) {
		Scanner scan=new Scanner(System.in);
		int n=scan.nextInt();
		long sum=1;
		int num[]=new int[100000];
		for(int i=0,j=2;i<n;i++,j++) {
			if(isprime(j)) {
				num[i]=j;
			}
			else
				i--;
		}
		for(int i=0;i<n;i++) {
			sum*=num[i]%50000;
			sum%=50000;  //提前模，否则会溢出  ab%c=((a%c)*(b%c))%c;
		}
		System.out.println(sum);
	}

	private static boolean isprime(int j) {//判断是否是质数
		for(int k=2;k*k<=j;k++) {
			if(j%k==0)
				return false;
		}
		return true;
	}
}

大小写转换

题目描述
编写一个程序，输入一个字符串（长度不超过20），然后把这个字符串内的每一个字符进行大小写变换，即将大写字母变成小写，小写字母变成大写，然后把这个新的字符串输出。

输入
输入一个字符串，而且这个字符串当中只包含英文字母，不包含其他类型的字符，也没有空格。

输出
输出经过转换后的字符串。

样例输入
AeDb

样例输出
aEdB

import java.util.Scanner;

//大小写转换
public class Main {
	public static void main(String[]args) {
		Scanner scan=new Scanner(System.in);
		String str=scan.nextLine();
		
		transform(str);
	}

	private static void transform(String str) {
		char ch[]=str.toCharArray();
		
		for(int i=0;i<ch.length;i++) {
			if(ch[i]>='a' && ch[i]<='z') {
				ch[i]-=32;
			}
			else if(ch[i]>='A' && ch[i]<='Z') {
				ch[i]+=32;
			}
		}
		System.out.print(ch);
	}

}

矩阵乘法

问题描述
输入两个矩阵，分别是m *s，s * n大小。输出两个矩阵相乘的结果。

输入格式
第一行，空格隔开的三个正整数m,s,n（均不超过200）。
接下来m行，每行s个空格隔开的整数，表示矩阵A（i，j）。
接下来s行，每行n个空格隔开的整数，表示矩阵B（i，j）。
　　
输出格式
m行，每行n个空格隔开的整数，输出相乘後的矩阵C（i，j）的值。

样例输入
2 3 2
1 0 -1
1 1 -3
0 3
1 2
3 1

样例输出
-3 2
-8 2

提示
矩阵C应该是m行n列，其中C(i,j)等于矩阵A第i行行向量与矩阵B第j列列向量的内积。
例如样例中C(1,1)=(1,0,-1)*(0,1,3) = 1 * 0 +0 * 1+(-1)*3=-3

import java.util.Scanner;

//矩阵乘法
public class Main {
	public static void main(String[]args) {
		Scanner scan=new Scanner(System.in);
		int m=scan.nextInt();
		int s=scan.nextInt();
		int n=scan.nextInt();
		
		int n1[][]=new int[m][s];
		int n2[][]=new int[s][n];
		int c[][]=new int[m][n];
		
		for(int i=0;i<m;i++) {
			for(int j=0;j<s;j++) {
				n1[i][j]=scan.nextInt();
			}
		}
		
		for(int i=0;i<s;i++) {
			for(int j=0;j<n;j++) {
				n2[i][j]=scan.nextInt();
			}
		}
		
		for(int i=0;i<m;i++) {
			for(int j=0;j<n;j++) {
				for(int k=0;k<s;k++) {
					c[i][j]+=n1[i][k]*n2[k][j];
				}
			}
		}
		
		for(int i=0;i<m;i++) {
			for(int j=0;j<n;j++) {
				System.out.print(c[i][j]+" ");
			}
			System.out.println();
		}
	}
}

P1103

编程实现两个复数的运算。设有两个复数 和 ，则他们的运算公式为：
要求：（1）定义一个结构体类型来描述复数。
（2）复数之间的加法、减法、乘法和除法分别用不用的函数来实现。
（3）必须使用结构体指针的方法把函数的计算结果返回。

输入
运算符号(+,-,*,/) a b c d

输出
a+bi，输出时不管a,b是小于0或等于0都按该格式输出，输出时a,b都保留两位。

样例输入
- 2.5 3.6 1.5 4.9
-
样例输出
1.00±1.30i

import java.io.IOException;
import java.util.Scanner;
 
public class Main {
	public static void main(String[] args) {
		class Complex {
			double real;
			double image;
 
			Complex() {
			}
 
			Complex(double real, double image) {
				this.real = real;
				this.image = image;
			}
 
			private void Complex(double real, double image) {
				this.real = real;
				this.image = image;
			}
 
			public double getReal() {
				return real;
			}
 
 
			public double getImage() {
				return image;
			}
 

			Complex add(Complex a) {
				double r=real+a.getReal();
				double i=image+a.getImage();
				Complex newcomplex = new Complex(r, i);
				return newcomplex;
			}
 
			Complex sub(Complex a) {
				double r=real-a.getReal();
				double i=image-a.getImage();
				Complex newcomplex = new Complex(r, i);
				return newcomplex;
			}
 
			Complex mul(Complex a) {
				double r=real*a.getReal()-image*a.getImage();
				double i=image*a.getReal()+real*a.getImage();
				Complex newcomplex = new Complex(r, i);
				return newcomplex;
			}
 
			Complex div(Complex a) {
				double r = (real *a.getReal()+ image *a.getImage()) / (a.getReal()*a.getReal()+a.getImage()*a.getImage());
				double i = (image *a.getReal()- real *a.getImage()) / (a.getReal()*a.getReal()+a.getImage()*a.getImage());
				Complex newcomplex = new Complex(r, i);
				return newcomplex;
			}
 
			public void print() {
				System.out.printf("%.2f+%.2fi",real,image);
			}
		}
		
		Scanner sc = new Scanner(System.in);
		//输入运算符
		char ch=0;
		try {
			ch=(char)System.in.read();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		double real=sc.nextDouble();
		double image=sc.nextDouble();
		
		double real1=sc.nextDouble();
		double image1=sc.nextDouble();
		
		
		Complex a=new Complex(real,image);
		Complex b=new Complex(real1,image1);
		
		switch (ch) {
		case '+':
			Complex result = a.add(b);
			result.print();
			break;
		case '-':
			Complex result1 = a.sub(b);
			result1.print();
			break;
		case '*':
			Complex result2 = a.mul(b);
			result2.print();
			break;
		case '/':
			Complex result3 = a.div(b);
			result3.print();
			break;
		default:
			break;
		}
	}
}