Java练习题

打印沙漏

写程序把给定数量的符号打印成最大沙漏的形状，并输出剩余的符号个数。例如给定17个“*”，要求按下列格式打印  

*****
\***/
||*||
/***\
*****

“沙漏形状”，是指每行输出奇数个输入的特定符号；各行符号中心对齐；相邻两行符号数差2；符号数先从大到小顺序递减到1，再从小到大顺序递增；首尾符号数相等。分别使用\和/填补两侧。特定符号个数为1时，使用'|'填补两侧。

给定任意N个符号，不一定能正好组成一个沙漏。要求打印出的沙漏能用掉尽可能多的符号。

输入格式:

输入在一行给出1个正整数N（≤1000）和一个符号，中间以空格分隔。

输出格式:

首先打印出由给定符号组成的最大的沙漏形状，最后在一行中输出剩下没用掉的符号数

输入 38 *

******* 
\*****/ 
\\***// 
|||*||| 
//***\\ 
/*****\ 
*******
7

import java.util.Scanner;

public class Main {
	public static void main(String [] arg){
		//在此实现测试代码
		Scanner scanner=new Scanner(System.in);
		int num=scanner.nextInt();
		char zm=scanner.next().charAt(0);
		int line=0;
		for(int i=0;num>=2*i-1;)
		{
			line++;
			i=line*line;
		}
		line--;
		
		int max=2*line-1;
		int tem=max;
		while(tem>0)
		{
			if(tem==1)
			{
				for(int i=0;i<(max-tem)/2;i++)
				{
					System.out.print('|');
				}
			}
			else {
				for(int i=0;i<(max-tem)/2;i++)
				{
					System.out.print('\\');
				}
			}
			for(int i=0;i<tem;i++)
			{
				System.out.print(zm);
			}
			if(tem==1)
			{
				for(int i=0;i<(max-tem)/2;i++)
				{
					System.out.print('|');
				}
			}
			else {
			for(int i=0;i<(max-tem)/2;i++)
			{
				System.out.print('/');
			}
			}
			System.out.print("\n");
			tem-=2;
		}
		tem=3;
		while(tem<=max)
		{
			for(int i=0;i<(max-tem)/2;i++)
			{
				System.out.print('/');
			}
			for(int i=0;i<tem;i++)
			{
				System.out.print(zm);
			}

			for(int i=0;i<(max-tem)/2;i++)
			{
				System.out.print('\\');
			}
			System.out.print("\n");
			tem+=2;
		}
		System.out.print(num-2*line*line+1);
	}
}

3D福彩

package Main;
import java.util.Random;
import java.util.Scanner;
import java.beans.IndexedPropertyDescriptor;
import java.security.DrbgParameters.NextBytes;
import java.util.Arrays;

abstract class Lottery {
	protected int winNumber[];
	protected int userNumber[];
	protected String userInput;

	Lottery() {
		winNumber = createWinNumber();
	}
	//在报告用不到
	Lottery(String s){
		winNumber=createWinNumber(s);
	}
	
	//生成随机中奖号
	int[] createWinNumber() {
		int[] winnu = new int[3];
		Random rd = new Random();
		for (int i = 0; i < 3; i++) {
			winnu[i] = rd.nextInt(10);
		}
		return winnu;
	}
	//在报告用不到
	int[] createWinNumber(String s) {
		int[] winnu = new int[3];
		try {
			Integer i = Integer.valueOf(s);
			if (i >= 0 && i < 1000) {
				for (int j = 0; j < 3; j++) {
					winnu[2 - j] = i % 10;
					i = i / 10;
				}
				return winnu;
			} 
			else
				return winnu;
		} 
		catch (Exception e) {
			return null;
		}
	}
	
	public boolean ifNumRight(String b) {
		boolean right = false;
		Integer i = Integer.valueOf(b);
		if (i>=0&&i<=999)
			right=true;
		return right;
	}
	
	public void getUserInput() {
		System.out.println("请输入0-999之间的整数");
		Scanner s=new Scanner(System.in);
		String str=s.next();
		while(!ifNumRight(str))
		{
			System.out.println("请输入正确的投注内容");
			str=s.next();
		}
		str = str.trim();
		userNumber= new int [3];
		userInput = str;
		for (int i = 0; i < 3; i++) 
		{
			char digitChar = str.charAt(i); 
			userNumber[i] = Character.getNumericValue(digitChar); 
		}
	}

	abstract int getwinlevel(int[] winnumber, String s);

	int getwinlevel() {
		return getwinlevel(this.winNumber, this.userInput);
	}
	int getwinlevel(String s) {
		return getwinlevel(this.winNumber,s);
	}

	public void setUserNumber(int[] userNumber) {
		this.userNumber = userNumber;
	}
	
	public void printwinNumber() {
		for(int i:winNumber)
		{
			System.out.print(i+' ');
		}
	}

}

class Group extends Lottery {
	Group(String s) {
		super(s);
	}
	Group() {
		super();
	}
	
	int[] arrange(int[] winnumber) {
		int[] newwinnumber = Arrays.copyOf(winnumber, winnumber.length);
		Arrays.sort(newwinnumber);
		return newwinnumber;
	}

	@Override
	int getwinlevel(int[] winnumber, String s) {
		int[] newwinnumber = arrange(winnumber);
		int[] newuserinput = arrange(this.userNumber);
		int maxequal = 0;
		int currequal = 0;
		for (int i = 0; i < newwinnumber.length - 1; i++) {
			if (newwinnumber[i] == newwinnumber[i + 1]) {
				currequal++;
				if (currequal > maxequal) {
					maxequal = currequal;
				}
			} else
				currequal = 0;
		}
		boolean equals = true;

		for (int i = 0; i < newwinnumber.length - 1; i++) {
			if (newwinnumber[i] != newuserinput[i]) {
				equals = false;
				break;
			}
		}
		if (equals) {
			switch (maxequal) {
			case 0:
				return 173;
			case 1:
				return 346;
			default:
				return 0;
			}
		} else
			return 0;
}

class Single extends Lottery {
	Single(String s) {
		super(s);
	}
	Single() {
		super();
	}
	@Override
	int getwinlevel(int[] winnumber, String s) {
			boolean win = false;
			for (int i = 0; i < userNumber.length; i++) {
				if (userNumber[i] == winnumber[i]) {
					win = true;
				} 
				else {
					win = false;
					break;
				}
			}
			if (win) {
				return 1040;

			} 
			else
				return 0;
	}

}

public class test {

	public static Lottery getusertype(String s) {
		Lottery l=null;
		switch (s) {
		case "group":
			l=new Group();
			break;
		//case "single":
		//	l = new Single();
			//break;
		}
		return l;
	}
	
	public static boolean ifType(String a) {
		String[] Type = {"single", "group", "oned", "guess1d", "towd","sum"};
		boolean found = false;
		for (String str : Type) 
		{
		    if (a.equals(str)) {
		        found = true;
		        break;
		    }
		}
		return found;
	}
	
	public static void Main(String[] arg) {
		System.out.println("请输入投注方式：");
		Scanner s=new Scanner(System.in);
		String type=s.next();
		while(!ifType(type))
		{
			System.out.println("您输入的投注方式不存在，请重新输入：");
			type=s.next();
		}
	
		Lottery l;
		l=getusertype(type);
		System.out.print("中奖号为：");
		l.printwinNumber();
		
		l.getUserInput();
		int curr=l.getwinlevel();
		System.out.print("您获得的奖金为"+curr);
	}
}
}

Java-LRU

package LRU;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Scanner;

public class main {
	static class linknode{
		Integer key;
		String value;
		linknode prev;
		linknode next;
		public linknode(Integer k,String v)
		{
			key=k;
			value=v;
		}
		public linknode(){}
	}

	public static class LRU{
		int capacity;
		int curNodeNum=0;
		Map<Integer, linknode>cache=new HashMap<>();
		linknode head,tail;

		public LRU(int n) {
			capacity=n;
			head=new linknode();
			tail=new linknode();
			head.next = tail;
	        tail.prev = head;
		}

		public void removenode(linknode a) {
			a.prev.next=a.next;
			a.next.prev=a.prev;
		}
		public linknode removetail(){
			linknode res=tail.prev;
			removenode(res);
			return res;
		}
		public void pushnode(linknode a) {
			a.prev=head;
			a.next=head.next;
			head.next.prev=a;
			head.next=a;
		}
		public void moveTohead(linknode a) {
			removenode(a);
			pushnode(a);
		}
		
		public void put(String input)
		{
			String[] keyValuePairs = input.split(";");
			for (String pair : keyValuePairs) {
				String[] keyValue = pair.split(",");
				Integer key = Integer.valueOf(keyValue[0]);
				String value = keyValue[1];
				
				linknode temNode = new linknode(key, value);
				linknode samekey=cache.get(key);

				if (samekey != null) {
					samekey.value=value;
					moveTohead(samekey);
				} else {
					if (curNodeNum == capacity) {
						linknode de=removetail();
						cache.remove(de.key);
						curNodeNum--;
					}
					cache.put(key, temNode);
					pushnode(temNode);
					curNodeNum++;

				}

			}
		}

		public void get(String input) {
			String[] keyValue = input.split(";");
			for (String key : keyValue) {
				Integer curKey = Integer.valueOf(key);
				linknode getNode=cache.get(curKey);
				
				if(getNode==null) {
					System.out.print("null;");
				}
				else {
					System.out.print(getNode.value + ";");
					moveTohead(getNode);
				}
			}
		}
	}
	
	public static void main(String arg[]) {
		Scanner s = new Scanner(System.in);
		int n=s.nextInt();//最大容量
		LRU cache=new LRU(n);
		int m=s.nextInt();//操作次数
		while(m>0)
		{
			String opString=s.next();
			String line=s.nextLine().trim();
			if(opString.equals("put")) {
				cache.put(line);
			}
			if(opString.equals("get")) {
				cache.get(line);
			}
			m--;
		}
	}
}