蓝桥杯专题-真题版含答案-【制作表格】【5位黑洞数】【泊松分酒】【亲密数】

news2024/12/22 11:30:03
Unity3D特效百例案例项目实战源码Android-Unity实战问题汇总
游戏脚本-辅助自动化Android控件全解手册再战Android系列
Scratch编程案例软考全系列Unity3D学习专栏
蓝桥系列ChatGPT和AIGC

👉关于作者

专注于Android/Unity和各种游戏开发技巧，以及各种资源分享（网站、工具、素材、源码、游戏等）
有什么需要欢迎底部卡片私我，获取更多支持，交流让学习不再孤单。

CSDN-芝麻粒儿

👉实践过程

😜制作表格

在中文Windows环境下，控制台窗口中也可以用特殊符号拼出漂亮的表格来。
比如：
┌─┬─┐
│││
├─┼─┤
│││
└─┴─┘
其实，它是由如下的符号拼接的：
左上 = ┌
上 = ┬
右上 = ┐
左 = ├
中心 = ┼
右 = ┤
左下= └
下 = ┴
右下 = ┘
垂直 = │
水平 = ─
本题目要求编写一个程序，根据用户输入的行、列数画出相应的表格来。
例如用户输入：
3 2
则程序输出：
┌─┬─┐
│││
├─┼─┤
│││
├─┼─┤
│││
└─┴─┘
用户输入：
2 3
则程序输出：
┌─┬─┬─┐
││││
├─┼─┼─┤
││││
└─┴─┴─┘
要求考生把所有类写在一个文件中。调试好后，存入与考生文件夹下对应题号的“解答.txt”中即可。相关的工程文件不要拷入。请不要使用package语句。
另外，源程序中只能出现JDK1.5中允许的语法或调用。不能使用1.6或更高版本。

package Question20_29;
import java.util.Scanner;
publicclass Question28 {
	publicstaticvoid main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		int hang=scanner.nextInt(),lie=scanner.nextInt();
		for (int i = 0; i < hang; i++) {
			if(i==0){
				System.out.print("┌─");
				for (int j = 0; j < lie-1; j++) {
					System.out.print("┬─");
				}
				System.out.println("┐");
				for (int j = 0; j < lie; j++) {
					System.out.print("│ ");
				}
				System.out.println("│");
			}else {
				System.out.print("├─");
				for (int j = 0; j < lie-1; j++) {
					System.out.print("┼─");
				}
				System.out.println("┤");
				
				for (int j = 0; j < lie; j++) {
					System.out.print("│ ");
				}
				System.out.println("│");
			}
		}
		System.out.print("└─");
		for (int j = 0; j < lie-1; j++) {
			System.out.print("┴─");
		}
		System.out.println("┘");
		//System.out.print("┌");System.out.print("─");System.out.print("┬");System.out.print("─");System.out.print("┐");
	}
}
运行结果：
请输出两个数,行和列 ,例: 3 4 
3 4
┌─┬─┬─┬─┐
│││││
├─┼─┼─┼─┤
│││││
├─┼─┼─┼─┤
│││││
└─┴─┴─┴─┘


import java.util.Scanner;
public class WinGraph {
	//使用字符数组存放基本图形
	public static char[] gr={'┌','┬','┐','├','┼','┤','└','┴','┘','│','─'};
	public static void paintGraph(int row,int col){
		//打印表格上边框
		System.out.print(gr[0]);
		System.out.print(gr[10]);
		for(int i=1;i<col;i++){
			System.out.print(gr[1]);
			System.out.print(gr[10]);
			}
		System.out.println(gr[2]);
		//打印表格中间部分
		for(int i=0;i<=col;i++){
			System.out.print(gr[9]);
			System.out.print(" ");
			}
		System.out.println();
		for(int i=1;i<row;i++){
			System.out.print(gr[3]);
			System.out.print(gr[10]);
			for(int j=1;j<col;j++){
				System.out.print(gr[4]);
				System.out.print(gr[10]);
			}
			System.out.println(gr[5]);
			for(int k=0;k<=col;k++){
				System.out.print(gr[9]);
				System.out.print(" ");
				}
			System.out.println();
		}
		//打印表格下边框
			System.out.print(gr[6]);
		System.out.print(gr[10]);
		for(int i=1;i<col;i++){
			System.out.print(gr[7]);
			System.out.print(gr[10]);
			}
		System.out.println(gr[8]);
	}
	//main 方法
	public static void main(String args[]){
		int row, col;
		System.out.println("请输入表格列数 :");
		Scanner sc=new Scanner(System.in);
		row=sc.nextInt();
		System.out.println("请输入表格列数 :");
		col=sc.nextInt();
		paintGraph(row,col);
	}
}

😜5位黑洞数

任意一个5位数，比如：34256，把它的各位数字打乱，重新排列，可以得到
一个最大的数：65432，一个最小的数23456。
求这两个数字的差，得：41976，把这个数字再次重复上述过程（如果不足5位，则前边补0）。如此往复，数字会落入某个循环圈（称为数字黑洞）。
比如，刚才的数字会落入：[82962,75933, 63954, 61974]这个循环圈。
请编写程序，找到5位数所有可能的循环圈，并输出，每个循环圈占1行。
其中5位数全都相同则循环圈为[0]，这个可以不考虑。循环圈的输出格式仿照：
[82962,75933, 63954, 61974]其中数字的先后顺序可以不考虑。

package Question30_39;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Scanner;
import java.util.Set;
public class Question30TooDifficultMustRemember{
	public static int  MaxSubMin(int n) {
		StringBuffer sb=new StringBuffer(""+n);
		while (sb.length()<5) {
			sb.insert(0, '0');
		}
		char ch[]=(sb.toString()).toCharArray();
		Arrays.sort(ch);
		int max=(ch[4]-'0')*10000+(ch[3]-'0')*1000+(ch[2]-'0')*100+(ch[1]-'0')*10+ch[0]-'0';
		int min=(ch[0]-'0')*10000+(ch[1]-'0')*1000+(ch[2]-'0')*100+(ch[3]-'0')*10+ch[4]-'0';
		return max-min;
	}
	public static Set<Integer> blackHole(int n) {
		Set<Integer> set=new LinkedHashSet<Integer>();
		set.add(n);
		while(true){
			n=MaxSubMin(n);
			if(set.add(n)==false){
				Set<Integer>tSet=new LinkedHashSet<Integer>();
				for (Iterator iterator = set.iterator(); iterator.hasNext();) {
					Integer integer = (Integer) iterator.next();
					if(integer==n){
						break;
					}else {
						tSet.add(integer);
					}
				}
				set.removeAll(tSet);
				break;
			}
		}
		return set;
	}
	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
	//	int n=scanner.nextInt();
		Set<Set<Integer>>set=new LinkedHashSet<>();
		for (int i = 10000; i < 100000; i++) {
			set.add(blackHole(i));
		}
		
		for (Iterator iterator = set.iterator(); iterator.hasNext();) {
			Set<Integer> set2 = (Set<Integer>) iterator.next();
			System.out.println(set2);
		}
		
	}
}
运行结果：
[0]
[74943, 62964, 71973, 83952]
[63954, 61974, 82962, 75933]
[53955, 59994]


/* 
 * 任意一个5位数，比如：34256，把它的各位数字打乱，重新排列，可以得到 
 * 一个最大的数：65432，一个最小的数23456。 
 * 求这两个数字的差，得：41976，把这个数字再次重复上述过程（如果不足5位，则前边补0）。 
 * 如此往复，数字会落入某个循环圈（称为数字黑洞）。 
    比如，刚才的数字会落入：[82962,75933, 63954, 61974]这个循环圈。 
    请编写程序，找到5位数所有可能的循环圈，并输出，每个循环圈占1行。 
    其中5位数全都相同则循环圈为[0]，这个可以不考虑。循环圈的输出格式仿照： 
    [82962,75933, 63954, 61974] 
    其中数字的先后顺序可以不考虑。 
 */  
import java.util.ArrayList;  
import java.util.Arrays;  
import java.util.Collections;  
import java.util.Iterator;  
import java.util.LinkedHashSet;  
import java.util.List;  
import java.util.Set;  
  
public class BlackHole {  
    static Set<List<Integer>> sets = new LinkedHashSet<List<Integer>>();// 记录每个 循环圈   
    static int start = 0;   // 记录循环圈的开始位置   
    // 得到最大的数   
    public static int max(String s){  
        char[] c = s.toCharArray();  
        Arrays.sort(c);  
        StringBuffer sb = new StringBuffer(new String(c));  
        return Integer.parseInt(sb.reverse().toString());  
    }  
    // 得到最小的数   
    public static int min(String s){  
        char[] c = s.toCharArray();  
        Arrays.sort(c);  
        return Integer.parseInt(new String(c));  
    }  
    // 补零   
    public static String fillZero(String s){  
        if(s.length()<5) return s;   // 如果够五位的话,直接返回原数   
        StringBuffer sb = new StringBuffer(s);  
        int len = 5 - sb.length();  // 需要补 len 个零   
        for(int i=0;i<len;i++){  
            sb.insert(0, "0");  
        }  
        return sb.toString();  
    }  
    // 查找是否有循环圈   
    public static boolean find(int n,List<Integer> lis){  
        for(int i=0;i<lis.size();i++){  
            if(n==lis.get(i)){  
                start = i;  // 设置循环圈的开始   
                return true;  
            }  
        }  
        return false;  
    }  
    // 这个数字的五位是否都一样如:11111,22222,...   
    public static boolean same(int n){  
        char[] c = (""+n).toCharArray();  
        char t = c[0];  
        for(int i=1;i<c.length;i++){  
            if(t!=c[i]){  
                return false;  
            }  
        }  
        return true;  
    }  
    // 判断是否在sets元素里重复   
    public static boolean contain(List<Integer> tt){  
        boolean flag = false;  
        // 从sets头到尾扫描是是否包含tt元素组   
        Iterator<List<Integer>> iter = sets.iterator();  
        while(iter.hasNext()){  
            if(iter.next().containsAll(tt)){  
                flag = true;  
            }  
        }  
        return flag;  
    }  
    // 输出循环圈   
    public static void print(){  
        Iterator<List<Integer>> iter = sets.iterator();  
        while(iter.hasNext()){  
            System.out.println(iter.next());  
        }  
    }  
    // 进入黑洞测试*********   
    public static void bl(int n,List<Integer> lis){  
        String tt = fillZero(String.valueOf(n));  
        int a = max(tt);    // 得到最大的数   
        int b = min(tt);    // 得到最小的数   
        int c = a - b;      // 得到五位数 结果   
        if(find(c,lis)){    // 找到循环圈   
            lis.add(c);     // 把最后一个元素添加进去   
            List<Integer> temp = new ArrayList(); // 开辟新空间 并copy记录   
            temp.addAll(lis.subList(start, lis.size()-1));  
            if(!contain(temp)){ // 去重   
                sets.add(temp); // 记录一个循环圈   
            }  
            lis.clear();    // 清空   
            return ;  
        }  
        lis.add(c);  
        bl(c,lis);  // 递归探测   
    }  
    // 主函数============   
    public static void main(String[] args){  
        List<Integer> lis = new ArrayList();  // 保存记录   
        for(int i=10000;i<99999;i++){  
            if(!same(i))    //去掉不符合条件的元素:如(11111,22222,...)   
                bl(i,lis);  // 进入黑洞测试   
        }  
        print();        // 输出循环圈   
    }  
}  


运行结果:
[0]  
[74943, 62964, 71973, 83952]  
[63954, 61974, 82962, 75933]  
[53955, 59994]

😜泊松分酒

泊松是法国数学家、物理学家和力学家。他一生致力科学事业，成果颇多。
有许多著名的公式定理以他的名字命名，比如概率论中著名的泊松分布。
有一次闲暇时，他提出过一个有趣的问题，后称为：“泊松分酒”。
在我国古代也提出过类似问题，遗憾的是没有进行彻底探索，其中流传较多是：“韩信走马分油”问题。
有3个容器，容量分别为12升，8升，5升。其中12升中装满油，另外两个空着。
要求你只用3个容器操作，最后使得某个容器中正好有6升油。
下面的列表是可能的操作状态记录：
12,0,0
4,8,0
4,3,5
9,3,0
9,0,3
1,8,3
1,6,5
每行3个数据，分别表示12，8，6升容器中的油量
第一行表示初始状态，第二行表示把12升倒入8升容器后的状态，第三行是8升倒入5升，…
当然，同一个题目可能有多种不同的正确操作步骤。
本题目的要求是，请你编写程序，由用户输入：各个容器的容量，开始的状态，
和要求的目标油量，程序则通过计算输出一种实现的步骤（不需要找到所有可能的方法）。
如果没有可能实现，则输出：“不可能”。
例如，用户输入：
12,8,5,12,0,0,6
用户输入的前三个数是容器容量（由大到小），接下来三个数是三个容器开始时的油量配置，
最后一个数是要求得到的油量（放在哪个容器里得到都可以）
则程序可以输出（答案不唯一，只验证操作可行性）：
12,0,0
4,8,0
4,3,5
9,3,0
9,0,3
1,8,3
1,6,5
每一行表示一个操作过程中的油量状态。
注意：
请仔细调试！您的程序只有能运行出正确结果的时候才有机会得分！
请把所有类写在同一个文件中，调试好后，存入与【考生文件夹】下对应题号的“解答.txt”中即可。
相关的工程文件不要拷入。
请不要使用package语句。

package Question30_39;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import java.util.Vector;
public class Question36TooDifficultMustRemember {
	public static List<Integer> distribute(List<Integer> capacityList,List<Integer> oilSizeList,int where,int to) {
		List<Integer>tList =new ArrayList<Integer>();
		tList.addAll(oilSizeList);
		if(oilSizeList.get(where)==0){
			return null;
		}else if (oilSizeList.get(where)>=capacityList.get(to)-oilSizeList.get(to)) {
			tList.set(to, capacityList.get(to));
			tList.set(where, oilSizeList.get(where)-(capacityList.get(to)-oilSizeList.get(to)));
			return tList;
		}else if(oilSizeList.get(where)<=capacityList.get(to)-oilSizeList.get(to)){
			tList.set(to, oilSizeList.get(to)+oilSizeList.get(where));
			tList.set(where, 0);
			return tList;
		}
		return null;
	}
	public static boolean exeForward(Set<List<Integer>>set,List<Integer> capacityList,List<Integer> oilSizeList,int NeedOilSize) {
		
//		for (List<Integer> list : set) {
//			System.out.print(list+"  ");
//		}
//		System.out.println();
		
		
		for (Integer integer : oilSizeList) {
			if(integer==NeedOilSize){
				for (List<Integer> list : set) {
				//	System.out.print(list+" ");
				//	System.out.print(list.size()+" ");
					for (Iterator iterator = list.iterator(); iterator
							.hasNext();) {
						Integer integer2 = (Integer) iterator.next();
						System.out.print(integer2);
						if(iterator.hasNext()){
							System.out.print(",");
						}else {
							System.out.print("\n");
						}
						
					}
				}
				
				return true;
			}
		}
		Vector<List<Integer>>vector=new Vector<List<Integer>>();
		vector.add(distribute(capacityList, oilSizeList, 0, 1));
		vector.add(distribute(capacityList, oilSizeList, 0, 2));
		vector.add(distribute(capacityList, oilSizeList, 1, 0));
		vector.add(distribute(capacityList, oilSizeList, 1, 2));
		vector.add(distribute(capacityList, oilSizeList, 2, 0));
		vector.add(distribute(capacityList, oilSizeList, 2, 1));
		for (int i = 0; i < vector.size(); i++) {
			if(vector.get(i)!=null){
				
				if(set.add(vector.get(i))){
					
					if(exeForward(set, capacityList, vector.get(i), NeedOilSize)==true){
						return true;
					}
					set.remove(vector.get(i));
				}
			}
		}
		return false;
	}
	public static void main(String[] args){
		Scanner scanner=new Scanner(System.in);
		Set<List<Integer>>set=new LinkedHashSet<List<Integer>>();
		List<Integer>tList=new ArrayList<Integer>();
		for (int i = 0; i < 3; i++) {
			tList.add(0);
		}
		List<Integer> capacityList=new ArrayList<>(tList);
		List<Integer> oilSizeList=new ArrayList<>(tList);
		int NeedOilSize;
		
		String ts=scanner.nextLine();
		
		String tss[]=ts.split("\\,");
		for (int i = 0; i < capacityList.size(); i++) {
			capacityList.set(i, Integer.parseInt(tss[i]));
		}
		int totalOil=0;
		for (int i = 0; i < capacityList.size(); i++) {
			oilSizeList.set(i, Integer.parseInt(tss[i+3]));
			totalOil+=Integer.parseInt(tss[i+3]);
		}
		NeedOilSize=Integer.parseInt(tss[6]);
		
		if(NeedOilSize>totalOil){
			System.out.println("不可能");
			return;
		}
		boolean posible=false;
		for (int i = 0; i < capacityList.size(); i++) {
			if(capacityList.get(i)>NeedOilSize){
				posible=true;
				break;
			}
		}
		if(posible==false){
			System.out.println("不可能");
			return;
		}
		exeForward(set, capacityList, oilSizeList, NeedOilSize);
	}
}
运行结果：
输入数据（格式为7个数字用","号隔开,例：)12,8,5,12,0,0,6
12,8,5,12,0,0,6
12	0	0	
4	8	0	
4	3	5	
9	3	0	
9	0	3	
1	8	3	
1	6	5	
记录数:(7)


import java.util.Scanner;
public class C33 {
	public static void main(String[] args){
		int num[] = getNum();
		int d = gcd(num[1], num[2]);//中瓶和小瓶容量的最大公约数
		if(num[0]/2 <= num[1] + num[2] && (num[0]/2)%d == 0)
		{
			System.out.println(num[3] + " " + num[4] + " " + num[5]);
			fenjiu(num[3], num[4], num[5],num);	
		}
		else 
		{		
			System.out.println("不可能");
		}
	}
	static int[] getNum()
	{
		Scanner readerScanner = new Scanner(System.in);
		String string[] = readerScanner.nextLine().split(",");
		int i = 0;
		int num[] = new int[7];
		while(i < 7)
		{
			num[i] = Integer.parseInt(string[i]);
			i++;
		}
		return num;
	}
	static void fenjiu(int num1,int num2,int num3,int num[])
	{
		//C2*X - C3*Y = 1
		int b1 = num[1],c1 = num[2];
		int a = num1,b = num2,c = num3,result = num[6];
		if(b == result||c == result||a == result)
			System.out.print("");
		else {
			//12,8,5,12,0,0,6
//			1. 大瓶子只能倒入中瓶子
//			2. 中瓶子只能倒入小瓶子
//			3. 小瓶子只能倒入大瓶子
//			4. 小瓶子只有在已经装满的情况下才能倒入大瓶
//			5. 若小瓶子被倒空，则无论中瓶子是否满，应马上从中瓶子倒入小瓶子
			if(c == c1)
			{//		4. 小瓶子只有在已经装满的情况下才能倒入大瓶子
				a = a + c;
				c = 0;
				System.out.println(a + " " + b + " " + c);
				fenjiu(a, b, c, num);	
			}
			else {
				if(c == 0 && b > 0)
			{//		5. 若小瓶子被倒空，则无论中瓶子是否满，应马上从中瓶子倒入小瓶子
					if(b > c1)
					{
						c = c1;
						b = b - c1;
						System.out.println(a + " " + b + " " + c);
						fenjiu(a, b, c, num);
					}
					else {
						c = b;
						b = 0;
						System.out.println(a + " " + b + " " + c);
						fenjiu(a, b, c, num);
					}
			}
				else {
					if(b != b1)
					{
						a = a - b1 + b;
						b = b1;
						System.out.println(a + " " + b + " " + c);
						fenjiu(a, b, c, num);
					}
					else {
						b = b - c1 + c;
						c = c1;
						System.out.println(a + " " + b + " " + c);
						fenjiu(a, b, c, num);
					}
				}
			}			
		}			
	}
	public static int gcd(int m, int n) 
	{  
		int a  = n, b = m;
		while (true)
		{ 
			if ((a = a % b) == 0) 
				return b; 
			if ((b = b % a) == 0)  
				return a; 
		} 
		
	} 
}

😜亲密数

假设有a、b两个数，若a的所有因子之和等于b,b的所有因子之和等于a，
并且a不等于b，则称a和b是一对亲密数。如284和220就是一对亲密数。
分析：
若要找出10000以内的亲密数，可使用以下算法：
（1）对每一个数i，将其因子分解出来，并将因子保存到一个数组中，再将因子之和保存到变量b1。
（2）将因子之和b1再进行因子分解，并将因子保存到一个数组中，将因子之和保存到变量b2中。
（3）若b2等于i，并且b1不等于b2，则找到一对亲密数为i和b1，可将其输出。
（4）重复步骤（1）~（3），即可找出指定范围的亲密数。

package Question40_49;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Scanner;
import java.util.Set;
import java.util.Vector;
public class Question48 {
	public static int obtain(int n) {
		int sum = 0;
		for (int i = 1; i < n; i++) {
			if (n % i == 0) {
				sum += i;
			}
		}
		return sum;
	}
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		Set<Set<Integer>> sets = new LinkedHashSet<Set<Integer>>();
		for (int i = 1; i <= n; i++) {
			int t = obtain(i);
			if (i != t) {
				if (obtain(t) == i) {
					Set<Integer> set = new LinkedHashSet<Integer>();
					set.add(i);
					set.add(t);
					sets.add(set);
				}
			}
		}
		for (Iterator iterator = sets.iterator(); iterator.hasNext();) {
			Set<Integer> set = (Set<Integer>) iterator.next();
			for (Iterator iterator2 = set.iterator(); iterator2.hasNext();) {
				Integer integer = (Integer) iterator2.next();
				System.out.print(integer);
				if (iterator2.hasNext() == false) {
					System.out.println();
				} else {
					System.out.print("   ");
				}
			}
		}
	}
}
运行结果：
10000
220   284
1184   1210
2620   2924
5020   5564
6232   6368

👉其他

📢作者：小空和小芝中的小空
📢转载说明-务必注明来源：https://zhima.blog.csdn.net/
📢这位道友请留步☁️，我观你气度不凡，谈吐间隐隐有王者霸气💚，日后定有一番大作为📝！！！旁边有点赞👍收藏🌟今日传你，点了吧，未来你成功☀️，我分文不取，若不成功⚡️，也好回来找我。

温馨提示：点击下方卡片获取更多意想不到的资源。
空名先生

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1313736.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

UG NX二次开发(C++)-库缺少需要的入口点的原因与解决方案

UG NX二次开发(C++)-库缺少需要的入口点的原因与解决方案

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 1、前言2、“库缺少需要的入口点”错误展示3、可能出现的原因与解决方案3.1 对于采用CTRL+U方式调用3.2 对于menu菜单下调用1、前言 在UG NX二次开发过程中，有时会遇到形形色色的bug，比如有个读…
阅读更多...
可视化监控云平台/智能监控EasyCVR如何使用脚本创建ramdisk挂载并在ramdisk中临时运行

可视化监控云平台/智能监控EasyCVR如何使用脚本创建ramdisk挂载并在ramdisk中临时运行

视频云存储/安防监控EasyCVR视频汇聚平台基于云边端智能协同&#xff0c;支持海量视频的轻量化接入与汇聚、转码与处理、全网智能分发、视频集中存储等。安防管理视频平台EasyCVR拓展性强&#xff0c;视频能力丰富&#xff0c;具体可实现视频监控直播、视频轮播、视频录像、云存…
阅读更多...
【Spring Boot】内网穿透实现远程调用调试

【Spring Boot】内网穿透实现远程调用调试

文章目录 1. 本地环境搭建1.1 环境参数1.2 搭建springboot服务项目 2. 内网穿透2.1 安装配置cpolar内网穿透2.1.1 windows系统2.1.2 linux系统 2.2 创建隧道映射本地端口2.3 测试公网地址 3. 固定公网地址3.1 保留一个二级子域名3.2 配置二级子域名3.2 测试使用固定公网地址 4.…
阅读更多...
管理类联考——英语二——考点+记忆篇——大作文——表格

管理类联考——英语二——考点+记忆篇——大作文——表格

大作文Remarkablechangesconcerning主题词havebeenwitnessedinTheabovechartthoroughlyrevealedthefascinatingissue.Onecanseethat年份1,事物1wasonly数字1.ButwithinashortdurationofXyears,事物1bumpedto数字2in年份2.Apartfromthat,事物2hasenjoyedaslightdeclineduringthe…
阅读更多...
基于3D-CGAN的跨模态MR脑肿瘤分割图像合成

基于3D-CGAN的跨模态MR脑肿瘤分割图像合成

3D CGAN BASED CROSS-MODALITY MR IMAGE SYNTHESIS FOR BRAIN TUMOR SEGMENTATION 基于3D-CGAN的跨模态MR脑肿瘤分割图像合成背景贡献实验方法Subject-specific local adaptive fusion&#xff08;针对特定主题的局部自适应融合&#xff09;Brain tumor segmentation model 损失…
阅读更多...
外汇天眼：如果美元开始降息，会为市场带来哪些影响？

外汇天眼：如果美元开始降息，会为市场带来哪些影响？

一、美元降息的影响 美元一旦开始降息&#xff0c;将对全球经济产生重要影响。 降息政策将带动美国内部的消费和投资增长。 透过降低借贷成本&#xff0c;鼓励个人和企业增加支出&#xff0c;刺激经济活动。 以最新数据为例&#xff0c;美国的消费者信心指数正在上升&#xff…
阅读更多...
4.qml 3D-Light、DirectionalLight、PointLight、SpotLight、AxisHelper类深入学习

4.qml 3D-Light、DirectionalLight、PointLight、SpotLight、AxisHelper类深入学习

今天我们学习灯光类 首先来学习Light类&#xff0c;它是所有灯光的虚基类&#xff0c;该类是无法创建的&#xff0c;主要是为子类提供很多公共属性。 常用属性如下所示&#xff1a; ambientColor : color&#xff0c;该属性定义在被该光照亮之前应用于材质的环境颜色。默认值…
阅读更多...
Halcon参考手册异常检测知识总结

Halcon参考手册异常检测知识总结

1.1异常检测介绍 本章将介绍如何使用基于深度学习的异常检测和全局上下文异常检测。通过这两种方法&#xff0c;我们想要检测图像是否包含异常(异常是指偏离正常的事物&#xff0c;未知的事物)。 异常检测或全局上下文异常检测模型学习无异常图像的共同特征。经过训练的模型将…
阅读更多...
CentOS7 OpenSSL升级到OpenSSH9.5p1

CentOS7 OpenSSL升级到OpenSSH9.5p1

原文链接&#xff1a; CentOS7 OpenSSL升级1.1.1w&#xff1b;OpenSSH 升级 9.5p1 保姆级教程 openssl从3.1.0升级到3.1.1遇到的问题 注意操作时需要联网请参考如下链接 内网服务器联网安装依赖参见我的另一篇文章 一、 前言 OpenSSH 的加密功能需要用到OpenSSL&#xff0c;所…
阅读更多...
STM32-UART-DMA HAL库缓冲收发

STM32-UART-DMA HAL库缓冲收发

文章目录 1、说明1.1、注意事项&#xff1a;1.2、接收部分1.3、发送部分 2、代码2.1、初始化2.2、缓冲接收2.3、缓冲发送2.4、格式化打印 1、说明 1.1、注意事项&#xff1a; HAL库的DMA底层基本都会默认开启中断使能&#xff0c;如果在STM32CubeMx禁用了中断相关的功能&…
阅读更多...
基于ssm企业人事管理系统的设计与实现论文

基于ssm企业人事管理系统的设计与实现论文

摘 要 进入信息时代以来&#xff0c;很多数据都需要配套软件协助处理&#xff0c;这样可以解决传统方式带来的管理困扰。比如耗时长&#xff0c;成本高&#xff0c;维护数据困难&#xff0c;数据易丢失等缺点。本次使用数据库工具MySQL和编程技术SSM开发的企业人事管理系统&am…
阅读更多...
人工智能与天文：技术前沿与未来展望

人工智能与天文：技术前沿与未来展望

人工智能与天文&#xff1a;技术前沿与未来展望 一、引言 随着科技的飞速发展&#xff0c;人工智能&#xff08;AI&#xff09;在各个领域的应用越来越广泛。在天文领域&#xff0c;AI也发挥着越来越重要的作用。本文将探讨人工智能与天文学的结合&#xff0c;以及这种结合带…
阅读更多...
动态规划习题

动态规划习题

动态规划的核心思想是利用子问题的解来构建整个问题的解。为此&#xff0c;我们通常使用一个表格或数组来存储子问题的解&#xff0c;以便在需要时进行查找和使用。 1.最大字段和 #include <iostream> using namespace std; #define M 200000int main() {int n, a[M], d…
阅读更多...
STM32 寄存器配置笔记——I2C 读写AT24C02 EEPROM

STM32 寄存器配置笔记——I2C 读写AT24C02 EEPROM

一、简介 本文主要介绍STM32F10xx系列如何使用软件模拟I2C总线读写AT24C02的EEPROM数据。 二、概述 I2C协议是一种用于同步、半双工、串行总线(由单片机时钟线、单数据交换器数据线组成)上的协议。规定了总线空闲状态、起始条件、停止条件、数据有效性、字节格式、响应确认信号…
阅读更多...
设计模式之建造者模式（二）

设计模式之建造者模式（二）

目录 概述概念角色类图适用场景 详述画小人业务类的介绍代码解析 建造者基本代码类介绍代码解析 总结设计原则其他 概述 概念 建造者模式是一种创建型设计模式&#xff0c;它可以将复杂对象的构建过程与其表示分离&#xff0c;使得同样的构建过程可以创建不同的表示。 角色 …
阅读更多...
Win11 TensorRT环境部署

Win11 TensorRT环境部署

一、CUDA和CUDNN安装 cuda和cudnn网上有很多安装教程&#xff0c;这里列举了一些&#xff0c;就不详细说了&#xff0c;具体链接如下&#xff1a; csdn.net - CUDA安装教程&#xff08;超详细&#xff09; 原创 zhihu.com - 深度学习之CUDACUDNN详细安装教程 tencent.com - C…
阅读更多...
《地理信息系统原理》笔记/期末复习资料（13. 地理信息系统的发展趋势）

《地理信息系统原理》笔记/期末复习资料（13. 地理信息系统的发展趋势）

目录 13. 地理信息系统的发展趋势 13.1. 互操作GIS 13.1.1. 传统GIS在数据标准化上的缺陷和面临的新课题 13.1.2. GIS互操作的概念 13.1.3. 开放式地理信息系统&#xff08;OGIS&#xff09;及其特点 13.1.4. OGIS的组成部分 13.1.5. OGIS的实现技术 13.2. GIS的集成化…
阅读更多...
【C语言】C的面向对象

【C语言】C的面向对象

一、BREW接口实现 高通的BREW&#xff08;Binary Runtime Environment for Wireless&#xff09;是一个早期为手机设备开发的应用程序平台&#xff0c;用于开发在CDMA手机上运行的软件。尽管这个平台目前已经不太流行&#xff0c;但是在其使用高峰时期&#xff0c;开发者需要使…
阅读更多...
2024年甘肃省职业院校技能大赛信息安全管理与评估赛项二三阶段样题一

2024年甘肃省职业院校技能大赛信息安全管理与评估赛项二三阶段样题一

2024年甘肃省职业院校技能大赛高职学生组电子与信息大类信息安全管理与评估赛项样题一 第二阶段 任务书 任务描述 随着网络和信息化水平的不断发展&#xff0c;网络安全事件也层出不穷&#xff0c;网络恶意代码传播、信息窃取、信息篡改、远程控制等各种网络攻击 行为已严重…
阅读更多...
LVS负载均衡器（nat模式）+nginx（七层反向代理）+tomcat（多实例），实现负载均衡和动静分离

LVS负载均衡器（nat模式）+nginx（七层反向代理）+tomcat（多实例），实现负载均衡和动静分离

目录 前言 一、配置nfs共享存储 二、配置2个nginx节点服务的网页页面 节点1:192.168.20.10 步骤一&#xff1a;修改网关指向调度器的内网ip地址 步骤二&#xff1a;将nfs共享的目录进行挂载&#xff0c;并修改nginx的配置文件中location的root指向挂载点 步骤三&#xff…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023