2024 BUAA-OO Unit1表达式展开总结

已于 2024-03-19 18:50:52 修改
阅读量924 收藏 21
点赞数 28
文章标签： java intellij-idea
于 2024-03-19 18:35:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75328141/article/details/136851113
版权

前言

本次面向对象设计与构造第一单元的三次作业通过迭代实现了对输入的表达式进行展开和计算的功能。通过本单元学习，我对于递归下降和深克隆等等有了更深的认识。

架构设计体验

第一次作业

本次作业需要完成的任务为：读入一个包含加、减、乘、乘方以及括号（其中括号的深度至多为 1 层）的单变量表达式，输出恒等变形展开所有括号后的表达式。

第一次作业的要求不算复杂，最大的难点在于理解课程组给出的关于表达式、项和因子的层次化表达以及递归下降的方法。在我看来第一次作业可以拆解成两大模块：表达式的解析、展开后的计算和合并。

解析这部分的核心就是Lexer和Parser两个类，Lexer作为分词器负责将输入的表达式的组成部分识别和提取出来，在这里我借鉴了oolens公众号推文中的做法，在初始化Lexer时就将输入的字符串input解析好存入ArrayList<Token>中，之后在Parser中每次调用Lexer.nextToken()方法将ArrayList的下标加一即可。

//Lexer.java
public class Lexer{
    private int pos = 0;
    private final String input;
    private int indexOfToken = 0;
    private ArrayList<Token> tokens;
  
  	public Lexer(String input) {
       	//TODO
    }
  	
  	public void nextToken(){
      	indexOfToken++;
    }
  	
  	public Token curToken(){
      	return tokens.get(indexOfToken);
    }
}

Parser将我们拆分好的token解析成对应的因子、项和表达式。这部分给我带来的最大的收获就是“铁路警察，各管一段”的思想，当parseExpr()的时候需要得到构成这个Expr的各个项，但是我们只需要直接调用parseTerm()就好，不必去考虑parseTerm()实现的具体细节，同理当parseTerm()的时候也不必去思考parseFactor()是怎么实现的，真正使得各个方法各司其职。

而到了展开计算这部分，我借鉴了往届学长博客的思路，因为我们最后得到的结果都是形如
∑ a ∗ x b \sum{a*x^b} ∑a∗xb
这样的形式，所以我用Unit类来存储a*x^b这样的单项式，用Poly类来存储求和后的多项式，在Poly类中设置addPoly()和mulPoly()进行加法乘法计算，对应的在Unit中也要实现mulUnit()方法。

//Unit.java
public class Unit{
  	private BigInteger coe;  //系数
  	private BigInteger expo; //x的指数
  
  	public Unit mulUnit(Unit other) {
        return new Unit(coe.multiply(other.coe), expo.multiply(other.expo));
    }
}

第二次作业

本次作业中需要完成的任务为：读入一系列自定义函数的定义以及一个包含幂函数、指数函数、自定义函数调用的表达式，输出恒等变形展开所有括号后的表达式。相较于第一次作业改变比较大，尤其体现在最后多项式的加法乘法以及合并同类项的逻辑上。

自定义函数部分

在自定义函数部分我设计了两个类，CustomDefiner和FuncFactor类，分别负责处理自定义函数以及在解析的时候转化为函数因子。

CustomDefiner

由于我们定义的函数并不为某一个因子所特有，而是在这一表达式中通用，联想到课上荣文戈老师举出的选课系统的例子加上往届学长的优秀博客的启发，我打算采用一个静态的工具类来存储自定义函数的相关信息，如函数名、函数的形参以及函数的定义式，并且它并不实例化对象，所以所有的属性和方法都设置成static。

在该类中包含两个HashMap属性:

  • func2def通过函数名寻找到函数的定义式
  • func2virtual通过函数名寻找到形参列表。
public class CustomDefiner {
    private static HashMap<String, String> func2def = new HashMap<>();
    private static HashMap<String, ArrayList<String>> func2virtual = new HashMap<>();
}

同时该类包含两个方法:

  • addFunc负责在标准输入自定义函数中将函数相关信息进行解析和存储。
  • callFunc负责解析表达式中的函数因子时将实参代入进行表达式替换
//CustomDefiner.java
public static void addFunc(String input){
  	//TODO//
}
public static String callFunc(String name, ArrayList<Factor> actualParameters){
  	//TODO//
}

值得一提的是，在callFunc中进行表达式替换时我并没有采取replaceAll的方式，因为这样可能导致字母替换的混乱，所以在这里我采取了一种朴素的略显笨拙的方案，就是建立一个从形参到实参的HashMap映射，然而遍历函数的定义式字符串，如果遇到形参就替换成实参，其中遇到exp的时候要特殊处理，具体实现如下：

//CustomDefiner.java
//callFunc
	StringBuilder sb = new StringBuilder();
	HashMap<String, Factor> vir2actual = new HashMap<>();
	for (int i = 0; i < parameters.size(); i++) {
		vir2actual.put(parameters.get(i), actualParameters.get(i));
	}
	for (int i = 0; i < definition.length(); i++) {
        String cur = String.valueOf(definition.charAt(i));
  		if(cur.equals("e")) {
        	sb.append("exp(");
            i+=3;
        }
        else if (vir2actual.containsKey(cur)) {
        	Factor factor = vir2actual.get(cur);
            sb.append(factor.toPoly().toString());
        } else {
            sb.append(cur);
        }
    }
	return sb.toString();
FuncFactor

在FuncFactor类中只包含一个Expr属性funcExpr, 意为将表达式中的函数替换后得到的表达式：

//FuncFactor.java
public class FuncFactor implements Factor {
    private Expr funcExpr;

    public FuncFactor(String name, ArrayList<Factor> actualParameters) {
        String funcString = CustomDefiner.callFunc(name,actualParameters);
        Lexer lexer = new Lexer(PreProcess.process(funcString));
        Parser parser = new Parser(lexer);
        funcExpr = parser.parseExpr();
    }
指数函数和合并同类项

指数函数因子的实现比较简单，和第一次作业区别不大，这里不再赘述。

在我看来本次作业最大的难点在于最后答案的形式发生很大的变化，每一个最小单元加入了exp(factor)^n，最后的形式变成了
∑ a ∗ x b ∗ e e x p E x p o \sum {a*x^b*e^{expExpo}} ∑a∗xb∗eexpExpo
因此加法乘法和合并同类项的逻辑需要一些变动：

Unit类

  • Unit类中，首先加入了指数函数括号外的指数expExpo以及exp括号内的多项式inside，为了方便运算，直接把inside定义为Poly类型的。

    //Unit.java
public class Unit {
    private BigInteger coe;
    private BigInteger expo;
    private Poly inside;
    private BigInteger expExpo;
}

  • 在运算时涉及到了深克隆的问题，如果直接在原对象上修改会产生一些意料之外的后果，于是我添加了一个深克隆方法

    //Unit.java
public Unit deepClone() {
        BigInteger newCoe = new BigInteger(coe.toString());
        if (inside.Empty() || inside.isZero() || expExpo.compareTo(zero) == 0) {
            return new Unit(newCoe, expo);
        } else {
            Poly newInside = inside.deepClone();
            BigInteger newExpExpo = new BigInteger(expExpo.toString());
            return new Unit(newCoe, expo, newInside, newExpExpo);
        }
    }

  • 由于要判断是否可以合并同类项，这里我重写了equals方法进行判断

Poly类

  • 这里很多同学采用的HashMap来存储Unit来快速地进行合并同类项，我在采用HashMap的时候出现了很多问题，最后才用了ArrayList来存储，通过双重for循环来合并同类项。

  • 在Poly类中同样需要实现深克隆，由于Unit中inside为Poly类型，所以深克隆的时候进行递归的调用

    //Poly.java
public Poly deepClone() {
        Poly poly = new Poly();
        for (Unit unit : this.units) {
            Unit newUnit = unit.deepClone();
            poly.addUnit(newUnit);
        }
        return poly;
    }

第三次作业

本次作业中需要完成的任务为：读入一系列自定义函数的定义以及一个包含幂函数、指数函数、自定义函数调用、求导算子的表达式，输出恒等变形展开所有括号后的表达式。

在前两次作业架构的基础上，第三次作业实现起来比较容易，在求导这一问题上，我认为有两种方法，一种是层次化求导，也就是在Expr, Term和Factor类中实现derive()方法，遇到dx()就调用对应的derive()；另一种是在最后转换成多项式后再求导也就是在Unit和Poly中实现derive()方法。这里我选择的是前者。

层次化求导的derive()方法比较好实现，为了解析求导因子，我建了个Derivation类来存储求导信息，其中要注意的是当求导因子嵌套的时候，要将Derivation存储的表达式转换成字符串，再用lexer和parser重新解析一次。

//Derivation.java
public class Derivation implements Factor {
    private Expr expr;

    private Poly result;

    public Derivation(Expr expr) {
        this.expr = expr;
        this.result = expr.derive();
    }

    @Override
    public Poly toPoly() {
        return result;
    }

    @Override
    public Poly derive() {
        Lexer lexer = new Lexer(this.toPoly().toString());
        Parser parser = new Parser(lexer);
        return parser.parseExpr().derive();
    }

    @Override
    public Factor deepClone() {
        return new Derivation(this.expr.deepClone());
    }
}

新的迭代场景

  • 如果加入新的因子，可以直接实现Factor的接口，然而修改Unit中的属性、输出逻辑以及Poly类中的加法乘法即可
  • 如果加入新的变量，例如x, y, z等等，只需修改Unit中的toString()方法即可

bug分析

我的bug主要集中在第一次作业上，有的项在运算后系数会变为0，我在toString()时将其变为空串，但是在最后输出的时候忘记特判使得加号保留了下来。第二次和第三次没有出现正确性上的bug，但是会有没有合并同类项的情况导致性能分暴跌，我的设计中由于用ArrayList存储Unit，这就导致exp((x^2+2*x))和exp((2*x+x^2))无法合并掉。

在互测中我利用评测机对房间内的成员的代码评测，大致确定bug产生的原因，然后针对这个bug手动构造一些复杂度较低但是精确hack的数据。找到的bug大多是在优化输出长度的过程中产生的，例如寻找最大公因数的时候出现除0操作，还有形如exp(-x^2)这样的去掉括号过多导致输出不合法。

优化方面

考虑到性能分占比不大，而且在优化exp的时候要考虑到的情况比较复杂，所以第二次作业我没有进行太多优化，仅仅特判了一下exp内是数字的情况，例如exp(2)^2–>exp(4)，但是强测中有两个点的性能分直接爆零，其中一个测试点是exp内的多项式每一项的因数都相同，可以提取出去。所以在第三次作业中我特别处理了这种情况，以及优化了exp((4*x))–>exp(x)^4这类情况。

但是优化方面我在toString()中用到了很多if-else来进行特判，导致代码的简洁性和可读性不高，目前还没想到太好的解决方案，课后计划和同学探讨一下。

程序结构度量

第三次作业UML图

在这里插入图片描述

代码规模：

在这里插入图片描述

复杂度分析

方法复杂度：

MethodCogCev(G)iv(G)v(G)
CustomDefiner.addFunc(String)3.01.03.03.0
CustomDefiner.callFunc(String, ArrayList)7.03.05.05.0
Derivation.deepClone()0.01.01.01.0
Derivation.Derivation(Expr)0.01.01.01.0
Derivation.derive()0.01.01.01.0
Derivation.toPoly()0.01.01.01.0
ExpFactor.deepClone()0.01.01.01.0
ExpFactor.derive()0.01.01.01.0
ExpFactor.ExpFactor(Factor, BigInteger)0.01.01.01.0
ExpFactor.toPoly()0.01.01.01.0
ExpFactor.toString()1.02.01.02.0
Expr.addTerm(Term)0.01.01.01.0
Expr.deepClone()1.01.02.02.0
Expr.derive()14.01.07.07.0
Expr.Expr()0.01.01.01.0
Expr.setExpo(BigInteger)0.01.01.01.0
Expr.toPoly()6.02.04.04.0
Expr.toString()1.01.02.02.0
FuncFactor.deepClone()0.01.01.01.0
FuncFactor.derive()0.01.01.01.0
FuncFactor.FuncFactor(String, ArrayList)0.01.01.01.0
FuncFactor.FuncFactor(String, Expr)0.01.01.01.0
FuncFactor.toPoly()0.01.01.01.0
Lexer.back()0.01.01.01.0
Lexer.curToken()0.01.01.01.0
Lexer.getNumber()2.01.03.03.0
Lexer.haveNext()0.01.01.01.0
Lexer.Lexer(String)15.01.014.016.0
Lexer.nextToken()0.01.01.01.0
Lexer.notEnd()0.01.01.01.0
Main.main(String[])0.01.01.01.0
MyScan.MyScan(Scanner)0.01.01.01.0
MyScan.solve()1.01.02.02.0
Number.deepClone()0.01.01.01.0
Number.derive()0.01.01.01.0
Number.getValue()0.01.01.01.0
Number.Number(String)0.01.01.01.0
Number.toPoly()0.01.01.01.0
Number.toString()0.01.01.01.0
Parser.parseDerive()0.01.01.01.0
Parser.parseExpFactor()7.03.04.05.0
Parser.parseExpo()5.01.04.04.0
Parser.parseExpr()8.01.07.07.0
Parser.parseFactor()22.08.012.012.0
Parser.parseFuncFactor(String)5.01.04.04.0
Parser.Parser(Lexer)0.01.01.01.0
Parser.parseTerm(int)2.01.03.03.0
Poly.addPoly(Poly)2.01.03.03.0
Poly.addUnit(Unit)0.01.01.01.0
Poly.deepClone()1.01.02.02.0
Poly.divideCoe()1.01.02.02.0
Poly.Empty()0.01.01.01.0
Poly.equals(Object)1.01.02.02.0
Poly.getSameCoe()0.01.01.01.0
Poly.getUnits()0.01.01.01.0
Poly.hashCode()0.01.01.01.0
Poly.hasNoExp()1.02.02.02.0
Poly.hasOneFactor()1.02.02.02.0
Poly.hasOnlyNumber()1.01.02.02.0
Poly.haveSameCoe()3.03.02.03.0
Poly.isZero()1.01.02.02.0
Poly.mergePoly()8.01.05.05.0
Poly.mulPoly(Poly)3.01.03.03.0
Poly.Poly()0.01.01.01.0
Poly.toString()14.06.06.08.0
Power.deepClone()0.01.01.01.0
Power.derive()0.01.01.01.0
Power.Power(String, BigInteger)0.01.01.01.0
Power.toPoly()0.01.01.01.0
Power.toString()3.03.02.03.0
PreProcess.process(String)21.01.07.010.0
Term.addFactor(Factor)0.01.01.01.0
Term.deepClone()1.01.02.02.0
Term.derive()6.01.04.04.0
Term.Term(int)0.01.01.01.0
Term.toPoly()1.01.02.02.0
Token.getContent()0.01.01.01.0
Token.getType()0.01.01.01.0
Token.Token(Type, String)0.01.01.01.0
Unit.deepClone()3.02.04.04.0
Unit.equals(Object)2.01.04.04.0
Unit.getCoe()0.01.01.01.0
Unit.getExpo()0.01.01.01.0
Unit.getInsideMultiExpo()0.01.01.01.0
Unit.hasNoExp()1.01.03.03.0
Unit.hasOneFactor()5.03.04.06.0
Unit.hasOnlyNumber()1.01.02.02.0
Unit.haveSameExpo(Unit)0.01.01.01.0
Unit.isNegCoe()0.01.01.01.0
Unit.mulUnit(Unit)8.04.03.04.0
Unit.optimise(StringBuilder)6.01.04.04.0
Unit.setCoe(BigInteger)0.01.01.01.0
Unit.setEmpty()0.01.01.01.0
Unit.toString()42.03.022.023.0
Unit.Unit(BigInteger)0.01.01.01.0
Unit.Unit(BigInteger, BigInteger)0.01.01.01.0
Unit.Unit(BigInteger, BigInteger, Poly, BigInteger)0.01.01.01.0
Total237.0129.0229.0244.0
Average2.4432989690721651.32989690721649482.36082474226804132.515463917525773

其中由于输出逻辑比较复杂，导致Unit.toString()的复杂度比较高

类复杂度： |

classOCavgOCmaxWMC
CustomDefiner4.05.08.0
Derivation1.01.04.0
ExpFactor1.22.06.0
Expr2.57142857142857167.018.0
FuncFactor1.01.05.0
Lexer3.014.021.0
Main1.01.01.0
MyScan1.52.03.0
Number1.01.06.0
Parser3.87511.031.0
Poly2.16666666666666658.039.0
Power1.43.07.0
PreProcess8.08.08.0
Term2.04.010.0
Token1.01.03.0
Token.Type0.0
Unit2.333333333333333517.042.0
Total212.0
Average2.1855670103092785.37512.470588235294118

心得体会

有了上学期oopre学习的java语法和面向对象理念的基础，加上公众号和实验中对于递归下降的训练，第一单元的作业相对来说不是特别困难。我的收获主要是以下几点：

  • 使用递归下降的方法逻辑清晰，实现简单，同时”铁路警察，各管一段“的理念和面向对象的设计方式更加贴合
  • 学会利用工具类来处理类之间共用的属性(PreProcess, CustomDefiner)
  • 使用深克隆来避免在同一对象上进行错误修改
  • 单独使用一个类来进行输入(MyScan)
  • 在互测中找到其他同学bug以及修复自身bug来提升面向对象的能力

未来方向

建议课程组可以提供一些简单的编程练习题来训练Lexer和Parser之类的用法，第一次上手接触递归下降还是比较陌生。

ClarkBigD
关注
  • 28
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
BUAA-OO-Unit 1: 表达式展开
weixin_53468973的博客
03-23 814
自定义函数的定义形如f(x, y, z) = 函数表达式，比如f(y) = y^2。自定义函数的调用形如f(因子, 因子, 因子)，比如f(x^2)。首先，我们需要进行自定义函数的读入。在main类里将输入的函数以分割为两部分储存进HashMap。依据此我们需要得到其函数名、形参和函数表达式这三部分，并按创建三个List将其存储，以便之后调用。i++) {然后，在Parser部分，单独创建parseFunc。
2024 BUAA-OO Unit4UML以及课程总结
2201_75328141的博客
06-10 661
本次作业以一个图书馆管理系统为背景，锻炼我们对程序架构的设计和抽象能力，以及UML建模能力。
BUAA-OO-Unit1表达式化简单元总结
weixin_73548585的博客
03-23 1325
本次作业共包含三次迭代：第一次实现了包含加、减、乘、乘方、单层括号的表达式处理第二次实现了嵌套括号处理、自定义函数处理、指数函数处理第三次实现了表达式求导与自定义函数嵌套作业过程中的主体思路为递归下降算法，还包含有诸如字符串替换、SOLID法则的一些小细节，具体处理过程如下：预处理：对表达式字符串进行预处理。构造语法树：采用递归下降算法。第一层递归：分析表达式中的项（以+、-为分隔）。第二层递归：分析项中的因子（以*、^为分隔）。第三层递归：分析因子：表达式因子。
BUAA-OO-Unit1 表达式展开
weixin_63464358的博客
03-18 99
BUAA 面向对象设计与构造 第一单元作业反思与总结
BUAA-2020FW-C-Programming-Exercise1-Solution
06-16
BUAA-2020FW-C_Programming-Exercise1-Solution 北航-2020秋季学期-C语言程序设计-课程练习E1代码示例
BUAA-2020FW-C_Programming-Contest1-Solution
06-16
BUAA-2020FW-C_Programming-Contest1-Solution 北航-2020秋季学期-C语言程序设计-课程竞赛C1代码示例
BUAA-2020SS-Data_Structure_Programming-FinalProject
08-28
2020春季学期大作业(词频统计)示例-字典树/哈希双实现（非竞速版本）
BUAA-CO-P3-源代码
12-22
BUAA-CO-P3-源代码
buaa-CO-P3设计草稿
12-22
buaa-CO-P3设计草稿
简单的项目部署脚本（转载）
u010230019的博客
06-09 611
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
m0_74100417的博客
06-09 1273
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 422
修改菜品——后端Java
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
lx_nhs的博客
06-12 414
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
【Java02】Java中数组的定义与初始化
饮冰室
06-10 525
推荐第一种方式。这种方式容易让人理解，数据类型是type[]，对象名称是arrayName。第二种方式有些老旧了。由于数组是一种引用变量（也就是一个指针），所以定义的时候还没有指向任何有效的内存空间，因此在定义数组的时候不能指定数组的长度，也不能直接使用。必须进行初始化。可以使用var让系统自动推断变量类型，既可以用于静态初始化，也可以用于动态初始化。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
KK爱Coding的博客
06-11 282
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
微型操作系统内核源码详解系列四（3）：操作系统调度算法（FreeRTOS内核篇上）
最新发布
2301_77061352的博客
06-12 729
-uxTopPriority，被设定为是代表最大优先级的数字，自减操作代表从就绪列表最后一个链表（优先级最高的链表）开始查找，直到找到任务链表不为空的优先级任务，那么这个任务肯定也是所有任务中优先级最大的任务，然后获取这个任务的TCB并更新pxCurrentTCB（切换的具体函数），最后更新uxTopReadyPriority的值。容笔者说一下个人看法，从c语言和数据结构算法的层面学习，只能说是舍本逐末，透过Freertos这个小型系统，窥见庞大的操作系统架构的一角，这才是我们学习的重点。
Invalid keystore format，获取安全码SHA1值出错
yfy1907的博客
06-11 172
Invalid keystore format 错误
【Hydro】SCS-CN方法中径流曲线数的确定（下）
```On Earth, Be Water, By Coding```
06-11 46
在[【Hydro】SCS-CN方法中径流曲线数的确定（上）](https://blog.csdn.net/qq_25262697/article/details/133796329)中已经介绍了SCS-CN在SWAT和HMS中的应用，以下会补充SCS-CN在XPSWMM、InfoWorks ICM中的应用。以及使用软件计算SCS-CN的步骤。
buaa oo pre 配置ssh
09-10
buaa oo pre配置ssh的具体步骤如下： 1. 首先，需要在已配置GitHub ssh key的条件下再配置GitLab ssh key。根据参考的博客，在git bash中执行以下命令： ``` cd ~/.ssh ssh-keygen -t rsa -C "youremail@example.com" ``` 在输入存储ssh key的文件名时，可以直接按回车键跳过（除非有安全性要求）。 2. 接下来，需要将生成的ssh key添加到SSH Agent中，以便在使用GitLab时不需要输入密码。执行以下命令： ``` eval "$(ssh-agent -s)" ssh-add ~/.ssh/id_rsa ``` 这样就可以避免每次打开git bash都需要执行这两个命令。 3. 最后，如果在配置学校GitLab的ssh key时遇到问题，可能是因为之前已经配置过GitHub的ssh key。可以通过定位问题并解决来解决此类问题。根据作者的经验，在这种情况下，可以查看你的SSH配置文件（config文件）并检查是否有冲突或错误的设置。 总结起来，buaa oo pre配置ssh的步骤包括生成新的ssh key、将密钥添加到SSH Agent中以避免输入密码，并在需要时解决可能存在的冲突或错误。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值