基本算法题目汇总(不断追加中..)

最新推荐文章于 2022-07-12 22:05:55 发布
最新推荐文章于 2022-07-12 22:05:55 发布
阅读量233 收藏
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y101101101/article/details/84042120
版权
1.一道简单16进制加密算法 

/**
 * 简单加密解密算法
 * 任意十六进制字符ascii转换，转换规则：
 * 当前index位置的数加上index，如果结果超出F则从0重新开始循环
 * 比如： "3A4E"应该被转换为"3B61"
 *   3在0位置，所以保持不变,
 *   A在1位置，转化为B,
 *   4在2位置，转化为6,
 *   E在3位置，转化为1,
 * 然后倒转字符，比如"3B61"转换为"16B3"
 */
public class Encryption {
	public static void main(String[] args) {
		System.out.println(Decrypt2(encrypt2("3A4E46ABAE829")));  
        System.out.println(encrypt2("3A4E"));  
        System.out.println(Decrypt2("16B3"));
	}

	//encrypt 加密
	public static String encrypt2(String hexStr){
		String template = "0123456789ABCDEF";
		int len = hexStr.length();
		char[] result = new char[len];
		int index = 0;
		int ch = 0;
		for(int i=0;i<len;i++){
			ch = hexStr.charAt(i);
			index = (i + template.indexOf(ch))%16;
			result[i] = template.charAt(index);
		}
		result = reverse(result);
		return new String(result);
	}

	//Decrypt 解密
	public static String Decrypt2(String hexStr){
		String template = "FEDCBA9876543210";
		char[] argStr = hexStr.toCharArray();
		argStr = reverse(argStr);

		char[] result = new char[argStr.length];
		int index = 0;
		for(int i=0;i<argStr.length;i++){
			index = (i + template.indexOf(argStr[i]))%16;
			result[i] = template.charAt(index);
		}
		return new String(result);
	}

	//reverse the char array
	public static char[] reverse(char[] chs){
		char temp;
		for(int i=0;i<chs.length/2;i++){
			temp = chs[i];
			chs[i] = chs[chs.length-1-i];
			chs[chs.length-1-i] = temp;
		}
		return chs;
	}
}



2.上机试题三则 

public class HaweiQuestion {
	public static void main(String[] args) {
		HaweiQuestion q = new HaweiQuestion();
		int[] input = {3, 6, 1, 9, 7, 8}; 
		int[] output = new int[input.length];
		q.sort(input, input.length, output);
		for(int i=0;i<input.length;i++){
			System.out.print(output[i]+" ");
		}
		System.out.println();
		int[] task = {0, 30, 155, 1, 80, 300, 170, 40, 99};
		int[] system_task = new int[task.length];
		int[] user_task = new int[task.length];
		q.scheduler(task, task.length, system_task, user_task);

	}

	/**
	 * 选秀节目打分，分为专家评委和大众评委，score[] 数组里面存储每个评委打的分数，
	 * judge_type[] 里存储与 score[] 数组对应的评委类别，judge_type[i] == 1，表示专家评委，
	 * judge_type[i] == 2，表示大众评委，n表示评委总数。
	 * 打分规则如下：专家评委和大众评委的分数先分别取一个平均分（平均分取整），
	 * 然后，总分 = 专家评委平均分 * 0.6 + 大众评委 * 0.4，总分取整。如果没有大众评委，
	 * 则 总分 = 专家评委平均分，总分取整。函数最终返回选手得分。
	 */
	public int cal_score(int score[], int judge_type[], int n)  {
		int proNum=0;
		int peoNum=0;
		int total=0;
		int peoCount=0;
		for(int i=0;i<n;i++){
			if(judge_type[i]==1){
				proNum += score[i];
			}else{
				peoNum += score[i];
				peoCount++;
			}
		}
		if(peoCount!=0)
			total = (int)(proNum * 0.6 + peoNum * 0.4);
		else
			total = proNum / n ;
		return total;
	}


	/**
	 * 给定一个数组input[] ，如果数组长度n为奇数，
	 * 则将数组中最大的元素放到 output[] 数组最中间的位置，
	 * 如果数组长度n为偶数，则将数组中最大的元素放到 output[] 数组中间两个位置偏右的那个位置上，
	 * 然后再按从大到小的顺序，依次在第一个位置的两边，按照一左一右的顺序，依次存放剩下的数。
     * 例如：input[] = {3, 6, 1, 9, 7} output[] = {3, 7, 9, 6, 1}; 
     * input[] = {3, 6, 1, 9, 7, 8} output[] = {1, 6, 8, 9, 7, 3}
	 */
	 public void sort(int input[], int n, int output[]){
		 //首先按从大到小的顺序排列input
		 for(int i=0; i < n;i++){
			 for(int j = i;j > 0;j--){
				 if(input[j] > input[j-1]){	//大数上浮
					 swap(input,j,j-1);
				 }
			 }
		 }

		int count = 0;
		for (int i = n / 2, j = n / 2; i >= 0 && j < n; i--, j++) {
			if (i == j) {
				output[i] = input[count++];
			} else {
				output[i] = input[count++];
				output[j] = input[count++];
			}
		}
		if(n%2 == 0){	//偶数还有一个值
			output[0] = input[count];
		}

	 }

	private void swap(int[] input, int j, int i) {
		int temp = input[j];
		input[j] = input[j-1];
		input[j-1] = temp;

	}


	/**
	 * 操作系统任务调度问题。操作系统任务分为系统任务和用户任务两种。
	 * 其中，系统任务的优先级 < 50，用户任务的优先级 >= 50且 <= 255。
	 * 优先级大于255的为非法任务，应予以剔除。
	 * 现有一任务队列task[]，长度为n，task中的元素值表示任务的优先级，数值越小，优先级越高。
	 * 函数scheduler实现如下功能，将task[] 中的任务按照系统任务、用户任务依次存放到 system_task[]数组和 
	 * user_task[] 数组中（数组中元素的值是任务在task[] 数组中的下标），
	 * 并且优先级高的任务排在前面，优先级相同的任务按照入队顺序排列（即先入队的任务排在前面），
	 * 数组元素为-1表示结束。
     * 例如：task[] = {0, 30, 155, 1, 80, 300, 170, 40, 99} 
     * system_task[] = {0, 3, 1, 7, -1} user_task[] = {4, 8, 2, 6, -1}
	 */
	public void scheduler(int task[], int n, int system_task[], int user_task[]){
		int[] indexs = new int[n];	//用来保存下标
		for(int i=0;i<n;i++){	//初始化
			indexs[i] = i ;
		}
		//按从小到大的顺序排列task
		 for(int i=0; i < n;i++){
			 for(int j = i;j > 0;j--){
				 if(task[j] < task[j-1]){	//小数上浮，相等不交换
					 swap(task,j,j-1);
					 swap(indexs,j,j-1);	//同时交换下标
				 }
			 }
		 }
		 int sysPoint = 0;
		 int userPoint = 0;
		 for(int i=0;i<n;i++){
			 if(task[i] < 50){
				 system_task[sysPoint++] = indexs[i];
			 }else if(task[i]<=255){
				 user_task[userPoint++] = indexs[i];
			 }else{
				 //do nothing
			 }
		 }
	}
}



3.将1-9组成三个特殊三位数 

/*
 *  将1-9九个数字组合成三个三位数。
 *  要求1-9每个数字只使用一次，且第二个数是第一个数的两倍，第三个数是第一个数的三倍。
 *  符合条件的数有几组？将他们打印出来。
 * */
public class FindGroup {
	public static void main(String[] args) {
		int maxNumber = 987/3;   //不重复最大数为987
		int count = 0;
		for(int i=123;i<maxNumber;i++){
			if(isRepeat(i+""+i*2+""+i*3)){   //无重复
				count++;
				System.out.println(i+" "+i*2+" "+i*3);
			}
		}
	}

	public static boolean isRepeat(String str){       //判断是否有重复数字
		char[] chs = str.toCharArray();
		String reserve = "";
		for(int i=0;i<chs.length;i++){
			if(reserve.indexOf(chs[i])==-1){
				reserve+=chs[i];
			}
		}
		return chs.length==reserve.length()?true:false;
	}
}



4.超大数相加 

public class AddBigNumber {
	public static void main(String[] args) {
		String data1 = "123456";
        String data2 = "22";
        String result = add(data1,data2);
        System.out.println(result);

	}

	public static String add(String data1, String data2) {
		int store = 0;
		int len1 = data1.length();
		int len2 = data2.length();
		StringBuffer sb = new StringBuffer();
		for(int i=0;i<(len1>len2?len1:len2);i++){
			int d1 = getLowerNumber(i,data1);
			int d2 = getLowerNumber(i,data2);
			int sum = d1 + d2 + store;

			store = sum/10;       //有进位就存下来
			sb.append(sum%10);
		}
		if(store!=0)sb.append(store);     //考虑最高位进位
		return sb.reverse().toString();
	}

	public static int getLowerNumber(int i,String str){
		if(i>=str.length())return 0;
		String s = str.charAt(str.length()-1-i)+"";
		return Integer.parseInt(s);
	}
}



5.求喝饮料数与求日期 

package com.algorithm;

/**
 * @author 
 * http://topic.csdn.net/u/20111012/20/1c402221-028c-4920-b2fc-0b63b839d256.html?38410
 */
public class BottleDay {
	/**
	 * 20块钱，1块钱1瓶，两个空瓶子可以换一瓶，问最多可以喝几瓶？
	 */
	public static void maxDrink(){
		int sum = 20;
		int bottle = sum;
		while (bottle > 1) {
			System.out.println(bottle+" "+bottle/2);
		    sum += bottle/2;
		    bottle = bottle%2 + bottle/2;
		}
		System.out.println(sum);
	}


	/**
	 * 有一名员工发现日历已经7天没有翻了，
	 * 于是他连着翻了7页，7天的总和刚好是138，问这一天是几号？
	 */
	public static void getSpecialDay() {
		int[] end = { 28, 29, 30, 31 };		//可能的月末最後一天
		int days = 138;
		int count = 0;
		int day; 
		int max;
		boolean found = false;	//标志位
		for (int i = 0; i < end.length; i++) {
			max = end[i] + 7;	//7号
			day = 1;
			while (max > 0) {
				count = 0;
				for (int j = day; j < day + 7; j++) {
					if (j > end[i]) {
						count += j % end[i];
					} else {
						count += j;
					}
				}
				if (count == days) {
					found = true;
					for (int j = day; j < day + 7; j++) {
						System.out.printf("%d, ", j > end[i] ? j % end[i] : j);
					}
					break;
				}
				day++;
				max--;
			}
			if (found) {
				System.out.printf("------end=%d\n", end[i]);
				break;
			}
		}
		if (!found) {
			System.out.println("error");
		}
	}

	public static void main(String[] args) {
		maxDrink();
		System.out.println("--------");
		getSpecialDay();
	}
}



6.正则表达式按要求切割代码
文件名：test.txt,这是要切割的代码 

#include<iostream>
int main()
{
    int c[20];
    int a=5;
    int b=a+12;
    for(int i=0;i<=10;i++)
    {
        c[i]=i;  
    }
    return 0;
}

算法如下 

package com.algorithm;


import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * author:yunan
 */
public class SpiltCode {
	//你要保留的连续的字符
	private String[] codes = {"==","++","--",">=","+=","<="};  //等等..
	ArrayList<String> saveTable = new ArrayList<String>();	//保存所有切割出来的串

	public static void main(String[] args) {
		new SpiltCode().spiltCode();
	}

	private BufferedReader getBuffreader(String path){
		File file = new File(path);
		FileInputStream in;
		BufferedReader reader=null;
		try {
			in = new FileInputStream(file);
		    reader = new BufferedReader(new InputStreamReader(in));
		} catch (Exception e) { 
			e.printStackTrace();
		}
		return reader;
	}

	public  void spiltCode(){
		BufferedReader reader = getBuffreader("test.txt");
		String regex = "\\w+|\\p{Punct}";	//这个可以把单词和一个一个特殊字符全切出来
		Pattern p = Pattern.compile(regex);
		Matcher m = null;
		String line = null;
		String pre = "";	//上一个匹配的串
		int index = 0;
		try {
			while((line=reader.readLine())!=null){
				m = p.matcher(line);
				while(m.find()){
					String chars = m.group();
					if(isInCodes(pre+chars)){ 
						saveTable.set(--index, pre+chars);
					}else{ 
						saveTable.add(chars);
					}
					pre = chars;
					index++;
				}
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		printTable();	//打印
	}

	private boolean isInCodes(String code){
		for(int i=0;i<codes.length;i++){
			if(codes[i].equals(code)){
				return true;
			}
		}
		return false;
	}

	private void printTable(){
		for(String sav:saveTable){
			System.out.println(sav);
		}
	}
}
结果如下：
[code="java"]
#
include
<
iostream
>
int
main
(
)
{
int
c
[
20
]
;
int
a
=
5
;
int
b
=
a
+
12
;
for
(
int
i
=
0
;
i
<=
10
;
i
++
)
{
c
[
i
]
=
i
;
}
return
0
;
}


[/code]


7.超大数相乘的两种方法 

//方法一
public static void testMul()  {
		String p1 = "123456789012345678901234123456789012345678901234";// "123456789012345678901234";
		String p2 = "987654321098765432109876543210987654123456789012345678901234";// "987654321098765432109876543210987654";
		int ASCII = 48;
		char[] result = new char[p1.length() + p2.length()];
		for (int i = 0; i < result.length; i++) {
			result[i] = '0';
		}
		char ctemp = ' ';
		char[] pc1 = p1.toCharArray();
		for (int i = 0; i < pc1.length / 2; i++) {	//交换位置，如45689变98654
			ctemp = pc1[i];
			pc1[i] = pc1[pc1.length - 1 - i];
			pc1[pc1.length - 1 - i] = ctemp;
		}

		char[] pc2 = p2.toCharArray();
		for (int i = 0; i < pc2.length / 2; i++) {
			ctemp = pc2[i];
			pc2[i] = pc2[pc2.length - 1 - i];
			pc2[pc2.length - 1 - i] = ctemp;
		}
		int temp = 0;// 临时结果
		int step = 0;// 进位
		int time = 0;// 次数
		int bit = 0;// 位数
		for (char c1 : pc1) {	//021
			time = bit;
			for (char c2 : pc2) {	//654
				temp = (c1 - ASCII) * (c2 - ASCII);	//0
				temp = temp + result[time] - ASCII;	//0
				if (temp > 9) {// 进位
					int i = 0;
					do {
						result[time + i] = (char) (temp % 10 + ASCII);
						step = (temp - temp % 10) / 10;
						i++;
						temp = result[time + i] - ASCII + step;
					} while (temp > 9);
					result[time + i] = (char) (temp + ASCII);
				} else {
					result[time] = (char) (temp + ASCII); //result[0] = '0'
				}
				time++;
			}
			bit++;
		}
		System.out.println("##############################");
		System.out.print(p1 + " x " + p2 + " = ");
		for (int i = result.length - 1; i >= 0; i--) {
			System.out.print(result[i]);
		}
		System.out.println();
		System.out.println("##############################");
	}



	//方法二
	public static void bigNumberMulti(){
		String num1 = "123456789012345678901234123456789012345678901234";
		String num2 = "987654321098765432109876543210987654123456789012345678901234";

		char[] cp1 = num1.toCharArray();
		char[] cp2 = num2.toCharArray();

		char[] result = new char[cp1.length+cp2.length];   //用于存储每位的值

		//矩阵存储计算的值
		int sum = cp1.length+cp2.length;	//竖排总数
		char[][] caculate = new char[cp1.length][sum];  
		for(int i=0;i<caculate.length;i++){
			for(int j=0;j<caculate[0].length;j++){
				caculate[i][j] = ' ';
			}
		}

		int bit = 0;   //位数
		int level = 0;  //层数
		int temp = 0;  //临时存储的数据
		int ASIIC0 = 48;  //0的asiic码值
		int carry = 0; //进位
		for(int i=cp1.length-1;i>=0;i--){	//9
			bit = sum-1;	
			for(int j=cp2.length-1;j>=0;j--){	//6
				temp = (cp1[i]- ASIIC0) * (cp2[j]-ASIIC0) + carry;
				carry = 0;
				if(temp>9){
					carry = temp / 10;
					temp = temp % 10 ;
				}
				caculate[level][bit--] = (char) (temp + ASIIC0);
			}
			//如果最后一位还有进位
			if(carry>0){
				caculate[level][bit] =  (char)(carry + ASIIC0);
				carry=0;
			}
			sum--;
			level++;
		}

		int carry2 = 0;
		for(int y=caculate[0].length-1;y>=0;y--){
			int value = 0;
			for(int x=0;x<caculate.length;x++){
				if(caculate[x][y]>='0' && caculate[x][y]<='9'){
					value += caculate[x][y] - ASIIC0;
				}
			}
			value += carry2;
			carry2 = 0;
			if(value>9){
				carry2 = value / 10;
				value = value % 10;
			}
			result[y] = (char)(value + ASIIC0);
		}
		System.out.println(result);

		System.out.println("====================用于显示=======================");
		for(int i=0;i<caculate.length;i++){
			for(int j=0;j<caculate[0].length;j++){
				System.out.print(caculate[i][j]+" ");
			}
			System.out.println();
		}
		for(int i=0;i<caculate[0].length;i++){
			System.out.print("--");
		}
		System.out.println();
		for(char re:result){
			System.out.print(re+" ");
		}

	}
y101101101
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python面试题目：2019年最新总结，阿里，腾讯，百度，美团，头条等技术面试题目，以及答案，专家出题人分析汇总。
11-02
5. **文件操作**：掌握文件的读写、追加、关闭等基本操作，理解缓冲区概念，以及如何处理文件异常。 6. **列表推导式与生成器**：这两种高效的数据处理方式经常出现在面试中，要求应聘者能理解和编写复杂的列表推导...
仪器仪表管理c语言仪器仪表管理课程设计报告书.doc
07-19
9. **文档编写**：课程设计报告包含了完整的目录，体现了良好的文档编写规范，包括题目要求、需求分析、总体设计、详细设计、上机操作、总结和参考文献等部分，这些都是软件开发过程中的重要环节。 10. **编程实践*...
经典算法题收集一
小仙儿
04-30 2603
约瑟夫环问题
经典算法题汇总
qq_36696761的博客
09-14 5943
算法题经典汇总 1. 判断一颗二叉树是否为二叉搜索树和完全二叉树 // 二叉搜索树：每个节点左边节点小于右边节点，左子树的最大值一定小于根节点，小于右子树的最大值；通过中序遍历，严格递增 // 完全二叉树：层序遍历，除了最后的一层，每层都是满的。采用层序遍历，一旦出现null，则队列中剩余的节点必须为叶子节点 import java.util.*; /* * public class TreeNode { * int val = 0; * TreeNo...
常见的算法题目
qq_44788119的博客
10-23 221
1：括号匹配 function isMatch(str) { var map=new Map(); map.set('(',')'); map.set('{','}'); map.set('[',']'); var k=[]; for(let i=0;i<str.length;i++) { if(str[i]=='('||str[i]=='['||str[i]=='{') { k.push(str[i]); }else{
常见算法题
路漫漫其修远兮，吾将上下而求索
03-07 5267
1.二分查找（简单）（重要） 13 给定有序数组 找某个数的位置 //二分查找 public class BInarySort { public static void main(String[] args) { int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 , 11, 12, 13,14,15,16,17,18,19,20 }; int resIndex = binarySearch(arr, 0, arr.length - 1, 12);
C++ 第十二周上机任务-特殊的三位数
RSwky1220的专栏
11-16 700
/* * 程序的版权和版本声明部分 * Copyright (c)2012, 烟台大学计算机学院学生 * All rightsreserved. * 文件名称： fun.cpp * 作 者：王锴英 * 完成日期：2012 年11 月 16日 * 版本号： v1.0 * 对任务及求解方法的描述部分：运用函数解决问题 * 输入描述：略 * 问题描述：略 * 程序输
c语言编程题目汇总.pdf
09-30
C语言编程题目汇总 C语言是一种基础且强大的编程语言，广泛应用于系统开发、软件工程、嵌入式系统等领域。以下是一些从给定文件中提取的C语言编程知识点： 1. **形参与内存管理**：在C语言中，形参（函数参数）在...
C语言网基础题题解汇总(含解题思路和注意要点)
最新发布
11-10
总的来说，这些题目的解题思路和注意要点覆盖了C语言的基本语法、数据结构、算法和文件操作等多个方面，对于学习C语言的人来说是很好的实践素材。通过这样的练习，可以提升对C语言的理解和编程能力。
2021-2022计算机二级等级考试试题及答案No.9772.docx
11-04
6. 面向对象设计方法的基本原理是使用现实世界的概念抽象地思考问题，强调概念而不是具体的算法。 7. 如果x=5，y=10，则x=y的逻辑值为true和false，这涉及到布尔逻辑运算。 8. TCP/IP协议是因特网上不同网络和...
经典算法题大全
04-22
这是本人考蓝桥杯的时候收集的各种算法题，有小伙伴知道蓝桥杯吗，哈哈，虽然比赛不怎么样，可是资源可都是经典算法大集合欧
算法面试题
09-12
在一个二位数组中，每一行都按照从左到右 递增的顺序排序，每一列都按照从上到下递增的顺 序排序。输入一个链表的头结点，从尾到头反过来打 印出每个结点的值。 输入某二叉树的前序遍历和中心遍历的结 果，请重建该二叉树。：实现函数double Power(double base,int exponent),求base的exponent次方。不得使用库 函数，同时不需要考虑大数问题。：请实现一个函数，输入一个整数，输出该数二进制表示中1的个数。：给定单向链表的头指针和一个结点指针，定 义一个函数在O(1)时间删除该结点。：定义一个函数，输入一个链表的头结点，反转该链表并输出反转后链表
动态规划算法经典题目
09-15
几道动态规划的经典算法 非常经典 值得分享
《信息学奥赛一本通》分治算法 找数 例题
Alex
01-25 4243
【描述】 给一个长度为n的单调递增的正整数序列，即序列中每一个数都比前一个数大。 有m个询问，每次询问一个x，问序列中最后一个小于等于x的数是什么？ 【输入】 第一行两个整数n，m。 接下来一行n个数，表示这个序列。 接下来m行每行一个数，表示一个询问。 【输出】 输出共m行，表示序列中最后一个小于等于x的数是什么。 假如没有，则输出-1. 【样例输入】 5 3 1 2 3 4 6 5 1 3 ...
C语言经典算法100道实战题
热门推荐
C/C++编程指南
07-12 2万+
C语言经典算法100道实战题
有一名员工发现日历已经7天没有翻了，于是他连着翻了7页，7天的总和刚好是138，问这一天是几号？...
06-20 465
public static int day(int sum, int n, int d) { int test = n * (n - 1) / 2; int test2 = (sum - test) % n; if (test2 == 0) { ...
算法题目
qq_26890109的博客
07-12 237
leetcodepython快速排序：def quickSort(num):    if num.__len__() &lt; 2:        return num    left,right = [],[]    base = num.pop()    for val in num:        if val &lt; base:            left.append(val)  ...
程序员必备三十道算法题（1~10题）
weixin_55014779的博客
02-02 3748
程序员必备三十道算法题 1、题目：有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？ 程序分析：可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去 掉不满足条件的排列。 <script> var arry=[1,2,3,4]; for(var a=1;a<=arry.length;a++){ for(var b=1;b<=arry.length;b++){ if(a==
【Killua笔试面试题整理】连翻7张日历之和为138
异ﾘ度ｭ空ｳ間（镜像站）
10-18 1228
【试题描述】 有一名员工发现日历已经7天没有翻了，于是他连着翻了7页，7天的总和刚好是138，问这一天是几号？   【试题分析】 1）假设7天在同一个月，设第一天为X，那么应该满足等差数列之和(2X+6)*7/2 = 138,得到的X不为整数，所以应该是跨两个月。 2） 假设跨到第二个月1号，那么天数之和应该为(2X+5)*6 + 1 = 138,不满足条件 3） 假设跨到第二个月2号
. 算法设计的基本步骤是什么？
06-10
算法设计是指根据问题的特点和要求，设计出一种能够有效解决问题的算法。一般来说，算法设计的基本步骤如下： ...总的来说，算法设计是一个迭代的过程，需要不断地调整和优化算法，直到达到预期的效果为止。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值