头像

y总保佑

$AcW \ Uni$




离线:2小时前


最近来访(39)
用户头像
公输阁主
用户头像
.doge.
用户头像
Aluomolo
用户头像
喵喵酱
用户头像
照相YU师傅
用户头像
嘉然今天不吃了
用户头像
张李浩
用户头像
陈平安
用户头像
大雪莱
用户头像
FingerOne
用户头像
Arthur_5
用户头像
zhuzuojun
用户头像
Dimly_dust
用户头像
nicol_zjy
用户头像
normal
用户头像
invisible-pat.
用户头像
爱吃面条的阿泽
用户头像
要是爱情也有算法这么简单就好了
用户头像
mazhixian
用户头像
cmz

活动打卡代码 AcWing 241. 楼兰图腾

树状数组蓝书讲解

附一个很棒的帖子:树状数组学习笔记

一、树状数组的概念

如果一个正整数 $x$ 的二进制表示为 $a_{k-1}a_{k-2}\cdots a_{2}a_{1}a_{0}$,其中等于 $1$ 的位是 ${ a_{i_{1}}, a_{i_{2}}, \cdots, a_{i_{m}} }$,则正整数 $x$ 可以被“二进制分解”成:

$x = 2^{i_{1}} + 2^{i_{2}} + \cdots + 2^{i_{m}}$

不妨设 $i_{1} > i_{2} > \cdots > i_{m}$,进一步地,区间 $[1,x]$ 可以分成 $\log_{}{x}$ 个小区间:

  1. 长度为 $2^{i_{1}}$ 的小区间 $\left [1, 2^{i_{1}} \right]$
  2. 长度为 $2^{i_{2}}$ 的小区间 $\left [2^{i_{1}} + 1, 2^{i_{1}} + 2^{i_{2}} \right]$
  3. 长度为 $2^{i_{3}}$ 的小区间 $\left [2^{i_{1}} + 2^{i_{2}} + 1, 2^{i_{1}} + 2^{i_{2}} + 2^{i_{3}}\right]$

    $\cdots$

m. 长度为 $2^{i_{m}}$ 的小区间 $\left [2^{i_{1}} + 2^{i_{2}} + \cdots + 2^{i_{m-1}} + 1, 2^{i_{1}} + 2^{i_{2}} + \cdots + 2^{i_{m}}\right]$

这些小区间的共同特点是:若区间结尾为 $R$,则区间长度就等于 $R$ 的“二进制分解”下最小的 $2$ 的次幂,即 $lowbit(R)$。

例如 $x = 7 = 2^{2} + 2^{1} + 2^{0}$,区间 $[1, 7]$ 可以分成 $[1, 4]$、$[5, 6]$ 和 $[7, 7]$ 三个小区间,长度分别是 $lowbit(4) = 4$、$lowbit(6) = 2$ 和 $lowbit(7) = 1$。

树状数组(Binary Indexed Trees) 就是基于上述思想的数据结构,期基本用途是维护序列的前缀和。对于给定的序列 $a$,我们建立一个数组 $c$,其中 $c[x]$ 保存序列 $a$ 的区间 $[x - lowbit(x) + 1, x]$ 中所有数的和,即 ${\textstyle \sum_{i=x-lowbit(x)+1}^{x}a[i]}$。

树状数组_2.png

事实上数组 $c$ (图中是用 $t$ 表示) 可以看作一个如下图所示的树形结构,途中最下边一行是 $N$ 个叶节点($N = 16$),代表数值 $a[1\sim N]$。该结构满足以下性质:

  1. 每个内部节点 $c[x]$ 保存以它为根的子树中所有叶节点的和。
  2. 每个内部节点 $c[x]$ 的子节点个数等于 $lowbit(x)$ 的位数。
  3. 除树根外,每个内部节点 $c[x]$ 的父节点是 $c[x+lowbit(x)]$。
  4. 树的深度为 $O(\log_{}{N})$。

二、树状数组支持的两个操作

树状数组支持的基本操作有两个,第一个操作是 查询前缀和,即序列 $a$ 第 $1\sim x$ 个数的和。按照我们刚才提出的方法,应该求出 $x$ 的二进制表示中每个等于 $1$ 的位,把 $[1,x]$ 分成 $O(\log_{}{n})$ 个小区间,而每个小区间的区间和都已经保存在数组 $c$ 中。

树状数组支持的第二个基本操作是 单点增加,意思是给序列中的一个数 $a[x]$ 加上 $v$,同时正确维护序列的前缀和。根据上面给出的树形结构和它的性质,只有节点 $c[x]$ 及其所有祖先节点保存的 “区间和” 包含 $a[x]$,而任意一个结点的祖先至多只有 $O(\log_{}{N})$ 个,我们逐一对它们的 $c$ 值进行更新即可。

为了简便,比较一般的初始化方法是:直接建立一个全为 $0$ 的数组 $c$,然后对每个位置 $x$ 执行 $add(x, a[x])$,就完成了对原始序列 $a$ 构造树状数组的过程,时间复杂度为 $O(N\log_{}{N})$。

树状数组模板

int n;
vector<int> tr;

int lowbit(int x) {
    return x & -x;
}

int query(int x) {
    int presum = 0;
    for (int i = x; i; i -= lowbit(i))
        presum += tr[i];
    return presum;
}

void add(int x, int v) {
    for (int i = x; i <= n; i += lowbit(i))
        tr[i] += v;
}



四、ssh 和 scp

ssh登录

基本用法
远程登录服务器:

ssh user@hostname
  • user:用户名
  • hostname:IP地址或域名

第一次登录时会提示:

The authenticity of host '123.57.47.211 (123.57.47.211)' can't be established.
ECDSA key fingerprint is SHA256:iy237yysfCe013/l+kpDGfEG9xxHxm0dnxnAbJTPpG8.
Are you sure you want to continue connecting (yes/no/[fingerprint])?

输入 yes,然后回车即可。
这样会将该服务器的信息记录在 ~/.ssh/known_hosts 文件中。
然后输入密码即可登录到远程服务器中。

默认登录端口号为 22。如果想登录某一特定端口:

ssh user@hostname -p 22

配置文件

创建文件 ~/.ssh/config
然后在文件中输入:

Host myserver1
    HostName IP地址或域名
    User 用户名

Host myserver2
    HostName IP地址或域名
    User 用户名

之后再使用服务器时,可以直接使用别名 myserver1myserver2

密钥登录

创建密钥:

ssh-keygen

然后一直回车即可。

执行结束后,~/.ssh/ 目录下会多两个文件:
- id_rsa:私钥
- id_rsa.pub:公钥

之后想免密码登录哪个服务器,就将 AC Terminal 的公钥传给哪个服务器即可。
例如,想免密登录 myserver 服务器。则将公钥中的内容,复制到 myserver 中的 ~/.ssh/authorized_keys 文件里即可。

也可以使用如下命令一键添加公钥:

ssh-copy-id myserver

执行命令

命令格式:

ssh user@hostname command

例如:

ssh user@hostname ls -a

或者

# 单引号中的$i可以求值
ssh myserver 'for ((i = 0; i < 10; i ++ )) do echo $i; done'

scp传文件

基本用法

命令格式:

scp source destination

source 路径下的文件复制到 destination

一次复制多个文件:

scp source1 source2 destination

复制文件夹:注意 -r 一定要放在前面

scp -r ~/tmp myserver:/home/acs/

将本地家目录中的 tmp 文件夹复制到 myserver 服务器中的 /home/acs/ 绝对路径目录下。

scp -r ~/tmp myserver:homework/

将本地家目录中的 tmp 文件夹复制到 myserver 服务器中的 ~/homework/ 相对路径目录下。

scp -r myserver:homework .

myserver 服务器中的 ~/homework/ 文件夹复制到本地的当前路径下。. 为当前目录。

举例:

#将本地文件夹tmp传给服务器
acs@b5a9f3bd0333:~$ scp -r tmp myserver:

#将服务器文件夹tmp传给本地当前位置
acs@b5a9f3bd0333:~$ scp -r myserver:tmp .

#将服务器文件夹tmp传给本地绝对路径位置
acs@b5a9f3bd0333:~$ scp -r myserver:/home/acs_2865/tmp .

#将服务器文件夹tmp内的文件a.txt传给本地当前位置
acs@b5a9f3bd0333:~$ scp myserver:tmp/a.txt .

指定服务器的端口号:注意scp的服务器端口号用的是大P,ssh的是是小p

scp -P 22 source1 source2 destination

注意: scp-r -P 等参数尽量加在 sourcedestination 之前。

使用 scp 配置其他服务器的 vimtmux

scp ~/.vimrc ~/.tmux.conf myserver:
#或写成
scp .vimrc .tmux.conf myserver:

小妙招:可以显示文件夹目录结构的命令 tree

tree        # 直接输
tree .      # . 表示当前文件夹目录
tree dir/   # 或者加文件夹

作业

创建好作业后,先进入文件夹 /home/acs/homework/lesson_4/,然后:
(0) 进入 homework_0 文件夹,要求:
[1] 该文件夹内容为空
[2] 配置服务器账号的密钥登陆方式。服务器信息可以通过如下命令获得:
homework 4 getinfo
将服务器账号的名称(Host)配置成:myserver

配置服务器别名

~/.ssh目录下创建文件:config

内容:

Host myserver
    HostName IP地址或域名
    User 用户名    

配置密钥登录

ssh-keygen
ssh-copy-id myserver

(1) 进入 homework_1 文件夹,下列描述中的“本地”均表示当前文件夹。要求:
[1] 在 myserver 服务器上创建并清空文件夹:~/homework/lesson_4/homework_1/
[2] 将本地的 main.cpp 文件上传到 myserver 中的 ~/homework/lesson_4/homework_1/ 目录中。
[3] 在本地创建文件夹 dir
[4] 将 myserver 中的 /etc/lsb-release 文件复制到 dir 中。

在myserver端

mkdir ~/homework/lesson_4/homework_1/ -p # -p 表示如果没有某个文件的话会创建出来

在本地

scp main.cpp myserver:homework/lesson_4/homework_1
mkdir dir
scp myserver:/etc/lsb-release dir

(2) 进入 homework_2 文件夹,下列描述中的“本地”均表示当前文件夹,要求:
[1] 在 myserver 服务器上创建并清空文件夹:~/homework/lesson_4/homework_2/
[2] 将本地的 dir 文件夹上传到 myserver 中的 ~/homework/lesson_4/homework_2/ 目录中。

在myserver端

cd homework/lesson_4
mkdir homework_2

在本地

scp -r dir/  myserver:homework/lesson_4/homework_2

(3) 进入 homework_3 文件夹,下列描述中的“本地”均表示当前文件夹,要求:
[1] 在本地创建文件夹 dir
[2] 将 myserver 中的 /var/lib/locales/supported.d 文件夹下载到本地 dir 文件夹中。

在本地

mkdir dir
scp -r myserver:/var/lib/locales/supported.d dir

(4) 进入 homework_4 文件夹,编写脚本 remote_mkdir.shremote_rmdir.sh,要求:
[1] 在 myserver 服务器上创建并清空文件夹:~/homework/lesson_4/homework_4/
[2] 本地目录下仅包含 remote_mkdir.shremote_rmdir.sh
[3] remote_mkdir.shremote_rmdir.sh 具有可执行权限
[4] remote_mkdir.sh 接收一个传入参数。格式为 ./remote_mkdir.sh directory_name
该操作可以在 myserver 服务器上的 ~/homework/lesson_4/homework_4/ 目录下,创建一个名为 directory_name 的文件夹
[5] remote_rmdir.sh 接收一个传入传输。格式为 ./remote_rmdir.sh directory_name
该操作可以将 myserver 服务器上的 ~/homework/lesson_4/homework_4/ 目录下的名为 directory_name 的文件夹删掉。
[6] 注意:传入的文件参数可能包含空格。两个脚本均不需要判断传入参数的合法性。

在myserver端

mkdir homework_4

在本地

vim remote_mkdir.sh
vim remote_rmdir.sh
chmod +x * #批量加可执行权限

remote_mkdir.sh

#! /bin/bash

ssh myserver mkdir homework/lesson_4/homework_4/\"$1\"

注意:由于shell在执行命令时会先把字符串处理一遍,会解析掉引号,所以在服务器上还是没有双引号,所以引号需要转义

remote_rmdir.sh

#! /bin/bash

ssh myserver rm homework/lesson_4/homework_4/\"$1\" -r


活动打卡代码 AcWing 4.0. homework_0

作业

创建好作业后,先进入文件夹 /home/acs/homework/lesson_4/,然后:
(0) 进入 homework_0 文件夹,要求:
[1] 该文件夹内容为空
[2] 配置服务器账号的密钥登陆方式。服务器信息可以通过如下命令获得:
homework 4 getinfo
将服务器账号的名称(Host)配置成:myserver

配置服务器别名

~/.ssh目录下创建文件:config

内容:

Host myserver
    HostName IP地址或域名
    User 用户名    

配置密钥登录

ssh-keygen
ssh-copy-id myserver

(1) 进入 homework_1 文件夹,下列描述中的“本地”均表示当前文件夹。要求:
[1] 在 myserver 服务器上创建并清空文件夹:~/homework/lesson_4/homework_1/
[2] 将本地的 main.cpp 文件上传到 myserver 中的 ~/homework/lesson_4/homework_1/ 目录中。
[3] 在本地创建文件夹 dir
[4] 将 myserver 中的 /etc/lsb-release 文件复制到 dir 中。

在myserver端

mkdir ~/homework/lesson_4/homework_1/ -p # -p 表示如果没有某个文件的话会创建出来

在本地

scp main.cpp myserver:homework/lesson_4/homework_1
mkdir dir
scp myserver:/etc/lsb-release dir

(2) 进入 homework_2 文件夹,下列描述中的“本地”均表示当前文件夹,要求:
[1] 在 myserver 服务器上创建并清空文件夹:~/homework/lesson_4/homework_2/
[2] 将本地的 dir 文件夹上传到 myserver 中的 ~/homework/lesson_4/homework_2/ 目录中。

在myserver端

cd homework/lesson_4
mkdir homework_2

在本地

scp -r dir/  myserver:homework/lesson_4/homework_2

(3) 进入 homework_3 文件夹,下列描述中的“本地”均表示当前文件夹,要求:
[1] 在本地创建文件夹 dir
[2] 将 myserver 中的 /var/lib/locales/supported.d 文件夹下载到本地 dir 文件夹中。

在本地

mkdir dir
scp -r myserver:/var/lib/locales/supported.d dir

(4) 进入 homework_4 文件夹,编写脚本 remote_mkdir.shremote_rmdir.sh,要求:
[1] 在 myserver 服务器上创建并清空文件夹:~/homework/lesson_4/homework_4/
[2] 本地目录下仅包含 remote_mkdir.shremote_rmdir.sh
[3] remote_mkdir.shremote_rmdir.sh 具有可执行权限
[4] remote_mkdir.sh 接收一个传入参数。格式为 ./remote_mkdir.sh directory_name
该操作可以在 myserver 服务器上的 ~/homework/lesson_4/homework_4/ 目录下,创建一个名为 directory_name 的文件夹
[5] remote_rmdir.sh 接收一个传入传输。格式为 ./remote_rmdir.sh directory_name
该操作可以将 myserver 服务器上的 ~/homework/lesson_4/homework_4/ 目录下的名为 directory_name 的文件夹删掉。
[6] 注意:传入的文件参数可能包含空格。两个脚本均不需要判断传入参数的合法性。

在myserver端

mkdir homework_4

在本地

vim remote_mkdir.sh
vim remote_rmdir.sh
chmod +x * #批量加可执行权限

remote_mkdir.sh

#! /bin/bash

ssh myserver mkdir homework/lesson_4/homework_4/\"$1\"

注意:由于shell在执行命令时会先把字符串处理一遍,会解析掉引号,所以在服务器上还是没有双引号,所以引号需要转义

remote_rmdir.sh

#! /bin/bash

ssh myserver rm homework/lesson_4/homework_4/\"$1\" -r


新鲜事 原文

y总的回复和鼓励确实承包了我一天的快乐 ! 课程很棒,对于自学的人省去了四处求爷爷告奶奶的麻烦~
图片



shell语法y总课程讲义链接

先贴个通过的截图镇楼0.0
sp20211125_110427_312.png

三、Shell语法

1. 概论

Linux中常见的shell脚本有很多种,常见的有:

  • Bourne Shell(/usr/bin/sh/bin/sh)
  • Bourne Again Shell(/bin/bash)
  • C Shell(/usr/bin/csh)
  • K Shell(/usr/bin/ksh)
  • zsh

  • Linux系统中一般默认使用bash,所以接下来讲解bash中的语法。
    文件开头需要写 #! /bin/bash,指明bash为脚本解释器。

脚本示例
新建一个test.sh 文件,内容如下:

#! /bin/bash (这是用来指明默认的解释器)
echo "Hello World!"

运行方式
作为可执行文件

acs@3f287c29e730:~$ ls -l test.sh
-rw-rw-r-- 1 acs acs 33 Nov 13 20:18 test.sh
-作者权限-同组权限-其他用户权限
注:没有第三个权限,文件无法执行
acs@9e0ebfcd82d7:~$ chmod +x test.sh  # 使脚本具有可执行权限

acs@9e0ebfcd82d7:~$ ./test.sh  # 当前路径下执行
Hello World!  # 脚本输出
acs@9e0ebfcd82d7:~$ /home/acs/test.sh  # 绝对路径下执行
Hello World!  # 脚本输出
acs@9e0ebfcd82d7:~$ ~/test.sh  # 家目录路径下执行
Hello World!  # 脚本输出

用解释器执行(不需要权限也可以)

acs@9e0ebfcd82d7:~$ bash test.sh
Hello World!  # 脚本输出

2. 注释

单行注释
每行中 # 之后的内容均是注释。

# 这是一行注释

echo 'Hello World'  #  这也是注释

多行注释
格式:

:<<EOF
第一行注释
第二行注释
第三行注释
EOF

其中 EOF 可以换成其它任意字符串。例如:

:<<abc
第一行注释
第二行注释
第三行注释
abc

:<<!
第一行注释
第二行注释
第三行注释
!

3. 变量

定义变量
定义变量,不需要加 $ 符号,等号左右不能加空格,例如:

name1='yxc'  # 单引号定义字符串
name2="yxc"  # 双引号定义字符串
name3=yxc    # 也可以不加引号,同样表示字符串

使用变量
使用变量,需要加上 $ 符号,或者 ${} 符号。$相当于取值。花括号是可选的,主要为了帮助解释器识别变量边界。shell里字符串不加双引号。

name=yxc
echo $name  # 输出yxc
echo ${name}  # 输出yxc
echo ${name}acwing  # 输出yxcacwing

只读变量
使用 readonly 或者 declare 可以将变量变为只读。(类似C++里的const)可以输 type 来查看shell函数的属性。

name=yxc
readonly name
declare -r name  # 两种写法均可

name=abc  # 会报错,因为此时name只读

删除变量
unset 可以删除变量。

name=yxc
unset name
echo $name  # 输出空行

变量类型

  1. 自定义变量(局部变量)
    子进程不能访问的变量
  2. 环境变量(全局变量)
    子进程可以访问的变量

自定义变量改成环境变量:

acs@9e0ebfcd82d7:~$ name=yxc  # 定义变量
acs@9e0ebfcd82d7:~$ export name  # 第一种方法
acs@9e0ebfcd82d7:~$ declare -x name  # 第二种方法
bash #开个子进程,原来的bash睡眠掉
echo $name #输出name

环境变量改为自定义变量:

acs@9e0ebfcd82d7:~$ export name=yxc  # 定义环境变量
acs@9e0ebfcd82d7:~$ declare +x name  # 改为自定义变量

字符串
字符串可以用单引号,也可以用双引号,也可以不用引号。
单引号与双引号的区别:

  • 单引号中的内容会原样输出,不会执行、不会取变量;
  • 双引号中的内容可以执行、可以取变量;
name=yxc  # 不用引号
echo 'hello, $name \"hh\"'  # 单引号字符串,输出 hello, $name \"hh\"
echo "hello, $name \"hh\""  # 双引号字符串,输出 hello, yxc "hh"

获取字符串长度

name="yxc"
echo ${#name}  # 输出3

提取子串

name="hello, yxc"
echo ${name:0:5}  # 提取从0开始的5个字符

4. 默认变量

文件参数变量

在执行shell脚本时,可以向脚本传递参数。$1 是第一个参数,$2 是第二个参数,以此类推。特殊的,$0 是文件名(包含路径)。例如:

创建文件 test.sh

#! /bin/bash

echo "文件名:"$0
echo "第一个参数:"$1
echo "第二个参数:"$2
echo "第三个参数:"$3
echo "第四个参数:"$4

然后执行该脚本:

acs@9e0ebfcd82d7:~$ chmod +x test.sh 
acs@9e0ebfcd82d7:~$ ./test.sh 1 2 3 4
文件名:./test.sh
第一个参数:1
第二个参数:2
第三个参数:3
第四个参数:4

其它参数相关变量

参数 说明
$# 代表文件传入的参数个数,如上例中值为4
$* 由所有参数构成的用空格隔开的字符串,如上例中值为 "$1 $2 $3 $4"
$@ 每个参数分别用双引号括起来的字符串,如上例中值为 "$1" "$2" "$3" "$4"
$$ 脚本当前运行的进程ID
$? 获取退出状态:上一条命令的退出状态(注意不是stdout,而是exit code)。0表示正常退出,其他值表示错误
$(command) 获取输出:返回 command 这条命令的stdout(可嵌套)
`command` 获取输出:返回 command 这条命令的stdout(不可嵌套)

例如:

#! /bin/bash
# 两条都是输出 ls 命令的结果
echo $(ls)#homework test.sh
echo `ls` #homework test.sh

5. 数组

数组中可以存放多个不同类型的值,只支持一维数组,初始化时不需要指明数组大小。数组下标从0开始

定义
数组用小括号表示,元素之间用空格隔开。例如:

array=(1 abc "def" yxc)

也可以直接定义数组中某个元素的值:

array[0]=1
array[1]=abc
array[2]="def"
array[3]=yxc

读取数组中某个元素的值
格式:

${array[index]}

例如:

array=(1 abc "def" yxc)
echo ${array[0]}
echo ${array[1]}
echo ${array[2]}
echo ${array[3]}

读取整个数组
格式:

${array[@]}  # 第一种写法
${array[*]}  # 第二种写法

例如:

array=(1 abc "def" yxc)

echo ${array[@]}  # 第一种写法
echo ${array[*]}  # 第二种写法

数组长度
类似于字符串

${#array[@]}  # 第一种写法
${#array[*]}  # 第二种写法

例如:

array=(1 abc "def" yxc)

echo ${#array[@]}  # 第一种写法
echo ${#array[*]}  # 第二种写法

6. expr命令

expr 命令用户求表达式的值,格式为:

expr 表达式

表达式说明:
- 用空格隔开每一项
- 用反斜杠放在shell特定的字符前面(发现表达式运行错误时,可以试试转义)
- 对包含空格和其他特殊字符的字符串要用引号括起来
- expr会在 stdout 中输出结果。如果为逻辑关系表达式,则结果为真,stdout 为1,否则为0。
- expr的 exit code:如果为逻辑关系表达式,则结果为真,exit code 为0,否则为1。

字符串表达式

  • length STRING
    返回 STRING的长度

```shell
#! /bin/bash
str=”Hello World!”
echo $(expr length “$str”) #对包含空格和其他特殊字符的字符串要用引号括起来

acs@3c9f019c1188:~$ ./test.sh
12
```

  • index STRING CHARSET
    CHARSET 中任意单个字符在 STRING 中最前面的字符位置,下标从1开始。如果在 STRING 中完全不存在CHARSET 中的字符,则返回0。

`shell #! /bin/bash str="Hello World!" echo `expr index "$str" aWd` #除了用 $(),也可以用

acs@3c9f019c1188:~$ ./test.sh
9
```

  • substr STRING POSITION LENGTH
    返回 STRING 字符串中从 POSITION 开始,长度最大为 LENGTH 的子串。如果 POSITIONLENGTH 为负数,0或非数值,则返回空字符串。

``shell #! /bin/bash str="Hello World!" echoexpr substr “$str” 2 3

acs@3c9f019c1188:~$ ./test.sh
ell
```

str="Hello World!"

echo `expr length "$str"`  # ``不是单引号,表示执行该命令,输出12
echo `expr index "$str" aWd`  # 输出7,下标从1开始
echo `expr substr "$str" 2 3`  # 输出 ell

整数表达式
expr 支持普通的算术操作,算术表达式优先级低于字符串表达式,高于逻辑关系表达式。
- + -
加减运算。两端参数会转换为整数,如果转换失败则报错。

  • * / %
    乘,除,取模运算。两端参数会转换为整数,如果转换失败则报错。

  • ()
    可以该表优先级,但需要用反斜杠转义

#! /bin/bash
a=3
b=4

echo `expr $a + $b`  # 输出7
echo `expr $a - $b`  # 输出-1
echo `expr $a \* $b` # 输出12,*需要转义
echo `expr $a / $b`  # 输出0,整除
echo `expr $a % $b`  # 输出3
echo `expr \( $a + 1 \) \* \( $b + 1 \)` # 输出20,值为 ( a + 1 ) * ( b + 1 )

逻辑关系表达式
- |
如果第一个参数非空且非0,则返回第一个参数的值,否则返回第二个参数的值,但要求第二个参数的值也是非空或非0,否则返回0。如果第一个参数是非空或非0时,不会计算第二个参数。

  • &
    如果两个参数都非空且非0,则返回第一个参数,否则返回0。如果第一个参为0或为空,则不会计算第二个参数。

  • < <= = == != >= >
    比较两端的参数,如果为true,则返回1,否则返回0。”==”是”=”的同义词。”expr”首先尝试将两端参数转换为整数,并做算术比较,如果转换失败,则按字符集排序规则做字符比较。

  • ()
    可以该表优先级,但需要用反斜杠转义

示例:

a=3
b=4

echo `expr $a \> $b`  # 输出0,>需要转义
echo `expr $a '<' $b`  # 输出1,也可以将特殊字符用引号引起来
echo `expr $a '>=' $b`  # 输出0
echo `expr $a \<\= $b`  # 输出1

c=0
d=5

echo `expr $c \& $d`  # 输出0
echo `expr $a \& $b`  # 输出3
echo `expr $c \| $d`  # 输出5
echo `expr $a \| $b`  # 输出3

7. read命令

read 命令用于从标准输入中读取单行数据。当读到文件结束符时,exit code 为1,否则为0。

#! /bin/bash
read name  # 读入name的值
echo Hello, $name  # 输出name的值

yxc
Hello, yxc

参数说明
- -p:后面可以接提示信息
- -t:后面跟秒数,定义输入字符的等待时间,超过等待时间后会自动忽略此命令

#! /bin/bash
read -p "What's your name? " -t 5 name # -p 提示信息;-t 5 等待5秒
echo Hello, $name

acs@3c9f019c1188:~$ ./test.sh 
What's your name? gyh
Hello, gyh

8. echo命令

echo 用于输出字符串。命令格式:

echo STRING

显示普通字符串

echo "Hello AC Terminal"
echo Hello AC Terminal  # 引号可以省略

Hello AC Terminal
Hello AC Terminal

显示转义字符

echo "\"Hello AC Terminal\""  # 注意只能使用双引号,如果使用单引号,则不转义
echo \"Hello AC Terminal\"  # 也可以省略双引号

"Hello AC Terminal"
"Hello AC Terminal"

显示变量

name=yxc
echo "My name is $name"  # 输出 My name is yxc

显示换行

acs@3c9f019c1188:~$ echo "hello\nworld"
hello\nworld
acs@3c9f019c1188:~$ echo -e "hello\nworld" # -e 开启转义
hello
world

显示不换行

echo -e "Hi \c" # -e 开启转义 \c 不换行
echo "acwing"

输出结果:

Hi acwing

显示结果定向至文件

echo "Hello World" > output.txt  # 将内容以覆盖的方式输出到output.txt中

原样输出字符串,不进行转义或取变量(用单引号)

name=acwing
echo '$name\"'

输出结果

$name\"

显示命令的执行结果

echo `date`

输出结果:

Wed Sep 1 11:45:33 CST 2021

9. printf命令

printf 命令用于格式化输出,类似于 C/C++ 中的 printf 函数。
默认不会在字符串末尾添加换行符

命令格式:

printf format-string [arguments...]

用法示例
脚本内容:

printf "%10d.\n" 123  # 占10位,右对齐
printf "%-10.2f.\n" 123.123321  # 占10位,保留2位小数,左对齐
printf "My name is %s\n" "yxc"  # 格式化输出字符串
printf "%d * %d = %d\n"  2 3 `expr 2 \* 3` # 表达式的值作为参数

输出结果:

       123.
123.12    .
My name is yxc
2 * 3 = 6

10. test命令与判断符号[]

逻辑运算符&&||
- && 表示与,|| 表示或
- 二者具有短路原则:
expr1 && expr2:当 expr1 为假时,直接忽略 expr2
expr1 || expr2:当 expr1 为真时,直接忽略 expr2
- 表达式的 exit code 为 0,表示真;为非零,表示假。(与C/C++中的定义相反)

test命令
在命令行中输入 man test,可以查看 test 命令的用法。
test 命令用于判断文件类型,以及对变量做比较。
test 命令用 exit code 返回结果,而不是使用 stdout。0表示真,非0表示假。

例如:

test 2 -lt 3  # 为真,返回值为0
echo $?  # 输出上个命令的返回值,输出0
acs@3c9f019c1188:~$ ls
homework  test.sh
acs@3c9f019c1188:~$ test -e test.sh && echo "exist" || echo "Not exist"
exist
acs@3c9f019c1188:~$ test -e test2.sh && echo "exist" || echo "Not exist"
Not exist

文件类型判断
命令格式:

test -e filename  # 判断文件是否存在
测试参数 代表意义
-e 文件是否存在
-f 是否为文件
-d 是否为目录
acs@3c9f019c1188:~$ ls
homework  test.sh
acs@3c9f019c1188:~$ test -f test.sh
acs@3c9f019c1188:~$ echo $?
0 # 真,test.sh 是文件
acs@3c9f019c1188:~$ test -f homework
acs@3c9f019c1188:~$ echo $?
1 # 假,homework 不是文件
acs@3c9f019c1188:~$ test -d homework
acs@3c9f019c1188:~$ echo $?
0 # 假,homework 是目录

文件权限判断
命令格式:

test -r filename  # 判断文件是否可读
测试参数 代表意义
-r 文件是否可读
-w 文件是否可写
-x 文件是否可执行
-s 是否为非空文件

整数间的比较
命令格式:

test $a -eq $b  # a是否等于b
测试参数 代表意义
-eq a是否等于b
-ne a是否不等于b
gt a是否大于b
lt a是否小于b
-ge a是否大于等于b
-le a是否小于等于b

字符串比较

测试参数 代表意义
test -z STRING 判断STRING是否为空,如果为空,则返回true
test -n STRING 判断STRING是否非空,如果非空,则返回true(-n可以省略)
test str1 == str2 判断str1是否等于str2
test str1 != str2 判断str1是否不等于str2
acs@3c9f019c1188:~$ test -z "" && echo "true" || echo "false"
true
acs@3c9f019c1188:~$ test -z "gyh" && echo "true" || echo "false"
false
acs@3c9f019c1188:~$ test -n "" && echo "true" || echo "false"
false
acs@3c9f019c1188:~$ test -n "gyh" && echo "true" || echo "false"
true
acs@3c9f019c1188:~$ test "gyh" && echo "true" || echo "false"
true
acs@3c9f019c1188:~$ s1=yxc
acs@3c9f019c1188:~$ s2=abc
acs@3c9f019c1188:~$ test "$s1" == "$s2" && echo "true" || echo "false"
false
acs@3c9f019c1188:~$ test "$s1" != "$s2" && echo "true" || echo "false"
true
acs@3c9f019c1188:~$ test "$s1" \< "$s2" && echo "true" || echo "false"
false
acs@3c9f019c1188:~$ test "$s1" \> "$s2" && echo "true" || echo "false"
true

多重条件判定
命令格式:

test -r filename -a -x filename
测试参数 代表意义
-a 两条件是否同时成立
-o 两条件是否至少一个成立
! 取反。如 test ! -x file,当 file 不可执行时,返回 true。
acs@3c9f019c1188:~$ ls
homework  test.sh
acs@3c9f019c1188:~$ test -r test.sh -a -x test.sh && echo "true" || echo "false" # -a,是否同时可读且可执行
true

判断符号 []
[]test 用法几乎一模一样,更常用于 if 语句中。另外 [[]][] 的加强版,支持的特性更多。

例如:

[ 2 -lt 3 ]  # 为真,返回值为0
echo $?  # 输出上个命令的返回值,输出0
acs@9e0ebfcd82d7:~$ ls  # 列出当前目录下的所有文件
homework  test.sh
acs@9e0ebfcd82d7:~$ [ -e test.sh ] && echo "exist" || echo "Not exist"
exist  # test.sh 文件存在
acs@9e0ebfcd82d7:~$ [ -e test2.sh ] && echo "exist" || echo "Not exist"
Not exist  # testh2.sh 文件不存在

注意:
- [] 内的每一项都要用空格隔开
- 中括号内的变量,最好用双引号括起来
- 中括号内的常数,最好用单或双引号括起来

name="acwing yxc"
[ $name == "acwing yxc" ]  # 错误,等价于 [ acwing yxc == "acwing yxc" ],参数太多
[ "$name" == "acwing yxc" ]  # 正确

11. 判断语句

if…then形式
类似于 C/C++ 中的 if-else 语句。

单层if
命令格式:

if condition
then
    语句1
    语句2
    ...
fi

示例:

a=3
b=4

if [ "$a" -lt "$b" ] && [ "$a" -gt 2 ]
then
    echo ${a}在范围内
fi

输出结果:

3在范围内

单层 if-else
命令格式

if condition
then
    语句1
    语句2
    ...
else
    语句1
    语句2
    ...
fi

示例:

a=3
b=4

if ! [ "$a" -lt "$b" ]
then
    echo ${a}不小于${b}
else
    echo ${a}小于${b}
fi

输出结果:

3小于4

多层 if-elif-elif-else
命令格式

if condition
then
    语句1
    语句2
    ...
elif condition
then
    语句1
    语句2
    ...
elif condition
then
    语句1
    语句2
else
    语句1
    语句2
    ...
fi

示例:

a=4

if [ $a -eq 1 ]
then
    echo ${a}等于1
elif [ $a -eq 2 ]
then
    echo ${a}等于2
elif [ $a -eq 3 ]
then
    echo ${a}等于3
else
    echo 其他
fi

输出结果:

其他

case…esac 形式
类似于C/C++中的switch语句。
命令格式

case $变量名称 in
    值1)
        语句1
        语句2
        ...
        ;;  # 类似于C/C++中的break
    值2)
        语句1
        语句2
        ...
        ;;
    *)  # 类似于C/C++中的default
        语句1
        语句2
        ...
        ;;
esac

示例:

a=4

case $a in
    1)
        echo ${a}等于1
        ;;
    2)
        echo ${a}等于2
        ;;
    3)
        echo ${a}等于3
        ;;
    *)
        echo 其他
        ;;
esac

输出结果:

其他

12. 循环语句

for…in…do…done
命令格式:

for var in val1 val2 val3
do
    语句1
    语句2
    ...
done

示例1,输出a 2 cc,每个元素一行:

for i in a 2 cc
do
    echo $i
done

示例2,输出当前路径下的所有文件名,每个文件名一行:

for file in `ls`
do
    echo $file
done
#! /bin/bash

for i in `ls` # 或写成 for i in $(ls)
do
    echo $i                                                                                                                                    
done
-------------
acs@3c9f019c1188:~$ ls
homework  test.sh
acs@3c9f019c1188:~$ ./test.sh 
homework
test.sh

示例3,输出1-10

for i in $(seq 1 5)
do
    echo $i
done
--------------------
acs@3c9f019c1188:~$ ./test.sh 
1
2
3
4
5
acs@3c9f019c1188:~$ seq 1 5 # 也可以直接输命令
1
2
3
4
5

示例4,使用 {1..10} 或者 {a..z}

for i in {a..z} # 也可以输出倒序
do
    echo $i
done

for ((…;…;…)) do…done
命令格式:

for ((expression; condition; expression))
do
    语句1
    语句2
done

示例,输出1-10,每个数占一行:

for ((i=1; i<=10; i++))
do
    echo $i
done

while…do…done循环
命令格式:

while condition
do
    语句1
    语句2
    ...
done

示例,文件结束符为 Ctrl+d,输入文件结束符后 read 指令返回 false

while read name
do
    echo $name
done

until…do…done循环
当条件为真时结束。
命令格式:

until condition
do
    语句1
    语句2
    ...
done

示例,当用户输入 yes 或者 YES 时结束,否则一直等待读入。

until [ "${word}" == "yes" ] || [ "${word}" == "YES" ]
do
    read -p "Please input yes/YES to stop this program: " word
done

break命令

跳出当前一层循环,注意与 C/C++ 不同的是:break 不能跳出 case 语句。

示例

# break跳出来的是for循环,;; 跳出的是case
while read name
do
    for ((i=1;i<=10;i++))
    do
        case $i in
            8)
                break
                ;;
            *)
                echo $i
                ;;
        esac
    done
done
--------------------------
acs@3c9f019c1188:~$ ./test.sh 
acwing
1
2
3
4
5
6
7
gyh
1
2
3
4
5
6
7
^C

该示例每读入非EOF的字符串,会输出一遍1-7。
该程序可以输入 Ctrl+d 文件结束符来结束,也可以直接用 Ctrl+c 杀掉该进程。

continue命令
跳出当前循环。
示例:

for ((i=1;i<=10;i++))
do
    if [ `expr $i % 2` -eq 0 ]
    then
        continue
    fi
    echo $i
done

该程序输出1-10中的所有奇数。

死循环的处理方式
如果AC Terminal可以打开该程序,则输入 Ctrl+c 即可。
否则可以直接关闭进程:

  1. 使用 top 命令找到进程的PID,或者 ps aux 返回当前打开的所有进程
  2. 输入 kill -9 PID 即可关掉此进程,PID是一串数字。

13. 函数

bash 中的函数类似于 C/C 中的函数,但 return 的返回值与 C/C 不同,返回的是 exit code,取值为0-255,0表示正常结束。
如果想获取函数的输出结果,可以通过 echo 输出到 stdout 中,然后通过 $(function_name) 来获取 stdout 中的结果。
函数的 return 值可以通过 $? 来获取。
命令格式:

[function] func_name() {  # function关键字可以省略
    语句1
    语句2
    ...
}

不获取 return 值和 stdout
示例

func() {
    name=yxc
    echo "Hello $name"
}

func

输出结果:

Hello yxc

获取 return 值和 stdout
不写 return 时,默认 return 0
示例

func() {
    name=yxc
    echo "Hello $name"

    echo $0 # 输出 $0,返回的是文件名

    return 123
}

output=$(func)
ret=$?

echo "output = $output"
echo "return = $ret"

输出结果:

output = Hello yxc
./test.sh
return = 123

函数的输入参数
在函数内,$1 表示第一个输入参数,$2 表示第二个输入参数,依此类推。
注意:函数内的 $0 仍然是文件名,而不是函数名。
示例:

#! /bin/bash
func() {  # 递归计算 $1 + ($1 - 1) + ($1 - 2) + ... + 0
    if [ $1 -le 0 ] 
    then
        echo 0
        return 0
    fi  

    sum=$(func $(expr $1 - 1))
    echo $(expr $sum + $1)
}

echo $(func 10) # 输出 55
// 相当于C++中的↓↓↓
#include <iostream>

using namespace std;

int func(int n)
{
    if (n <= 0) return 0;
    return n + func(n - 1);
}

int main()
{
    cout << func(10) << endl;
    return 0;
}

14. exit命令

exit 命令用来退出当前 shell 进程,并返回一个退出状态;使用 $? 可以接收这个退出状态。
exit 命令可以接受一个整数值作为参数,代表退出状态。如果不指定,默认状态值是 0。
exit 退出状态只能是一个介于 0~255 之间的整数,其中只有 0 表示成功,其它值都表示失败。

示例:
创建脚本 test.sh,内容如下:

#! /bin/bash

if [ $# -ne 1 ]  # 如果传入参数个数等于1,则正常退出;否则非正常退出。
then
    echo "arguments not valid"
    exit 1
else
    echo "arguments valid"
    exit 0
fi
acs@3c9f019c1188:~$ chmod +x test.sh 
acs@3c9f019c1188:~$ ./test.sh acwing # 传入一个参数,则正常退出,exit code为0
arguments valid
acs@3c9f019c1188:~$ echo $?
0
acs@3c9f019c1188:~$ ./test.sh 1 2 3
arguments not valid
acs@3c9f019c1188:~$ echo $? # 传入参数个数不是1,则非正常退出,exit code为1
1
acs@3c9f019c1188:~$ ./test.sh # 0个也不行
arguments not valid
acs@3c9f019c1188:~$ echo $?
1

15. 文件重定向

注意:在编辑时将输入重定向到file中 read n < $input_file 记得加上 $;同理,输出重定向到file中时 echo $sum > $output_file 也要加上 $

每个进程默认打开3个文件描述符:
- stdin 标准输入,从命令行读取数据,文件描述符为0
- stdout 标准输出,向命令行输出数据,文件描述符为1
- stderr 标准错误输出,向命令行输出数据,文件描述符为2
可以用文件重定向将这三个文件重定向到其他文件中。

重定向命令列表

命令 说明
command > file stdout 重定向到 file
command < file stdin 重定向到 file
command >> file stdout 以追加方式重定向到 file
command n> file 将文件描述符 n 重定向到 file
command n>> file 将文件描述符 n 以追加方式重定向到 file

输入和输出重定向

echo -e "Hello \c" > output.txt  # 将stdout重定向到output.txt中
echo "World" >> output.txt  # 将字符串追加到output.txt中

read str < output.txt  # 从output.txt中读取字符串

echo $str  # 输出结果:Hello World
acs@3c9f019c1188:~$ ls
homework  input.txt  test.sh
acs@3c9f019c1188:~$ cat input.txt 
123
acs@3c9f019c1188:~$ read a < input.txt
acs@3c9f019c1188:~$ echo $a
123

同时重定向stdin和stdout
创建bash脚本:

#! /bin/bash

read a
read b

echo $(expr "$a" + "$b")

创建input.txt,里面的内容为:

3
4

执行命令:

acs@9e0ebfcd82d7:~$ chmod +x test.sh  # 添加可执行权限
acs@9e0ebfcd82d7:~$ ./test.sh < input.txt > output.txt  # 从input.txt中读取内容,将输出写入output.txt中
acs@9e0ebfcd82d7:~$ cat output.txt  # 查看output.txt中的内容
7

16. 引入外部脚本

类似于 C/C++ 中的 include 操作,bash 也可以引入其他文件中的代码。
语法格式:

. filename  # 注意点和文件名之间有一个空格

或

source filename

示例
创建 test1.sh,内容为:

#! /bin/bash

name=yxc  # 定义变量name

然后创建 test2.sh,内容为:

#! /bin/bash

source test1.sh # 或 . test1.sh

echo My name is: $name  # 可以使用test1.sh中的变量

执行命令:

acs@9e0ebfcd82d7:~$ chmod +x test2.sh 
acs@9e0ebfcd82d7:~$ ./test2.sh 
My name is: yxc

17. 作业:

创建好作业后,先进入文件夹 /home/acs/homework/lesson_3/,然后:
(0) 进入 homework_0 文件夹,编写自动完成lesson_1作业的脚本 helper.sh。要求:
[1] 当前目录下仅包含 helper.sh
[2] helper.sh 具有可执行权限:chmod +x helper.sh
[3] 在任意路径依次执行下列命令后,lesson_1 的作业可以得到满分:
1) homework 1 create
2) /home/acs/homework/lesson_3/homework_0/helper.sh

cd homework  # 进入作业目录
vim helper.sh  # 创建作业脚本
chmod +x helper.sh  # 添加可执行权限

小技巧:如何将服务器中的文件整体复制出来?

  1. 退出 tmux
  2. cat filename:展示 filename 的文件内容
  3. 鼠标选中文本开头的若干字符
  4. 用滚轮滑到文件结尾
  5. 按住 Shift,同时鼠标点击文件结尾,此时会选中文件所有内容
  6. Windows/Linux下,按 Ctrl + insert 可以复制全文;Mac下,按 Command + c 可以复制全文。

helpers.sh 的内容

#! /bin/bash

# ********* homework_0 **********

dir0=/home/acs/homework/lesson_1/homework_0

# homework 1 create 0

for i in dir_a dir_b dir_c
do
    mkdir $dir0/$i
done

# ********* homework_1 **********
# homework 1 create 1

dir1=/home/acs/homework/lesson_1/homework_1

for i in a.txt b.txt c.txt
do
    cp ${dir1}/${i} ${dir1}/${i}.bak
done


# ********* homework_2 **********
# homework 1 create 2

dir2=/home/acs/homework/lesson_1/homework_2

for i in a b c
do
    mv ${dir2}/${i}.txt ${dir2}/${i}_new.txt
done

# ********* homework_3 **********
# homework 1 create 3

dir3=/home/acs/homework/lesson_1/homework_3

for i in a.txt b.txt c.txt
do
    mv ${dir3}/dir_a/$i ${dir3}/dir_b/
done

# ********* homework_4 **********
# homework 1 create 4

dir4=/home/acs/homework/lesson_1/homework_4

rm ${dir4}/*

# ********* homework_5 **********
# homework 1 create 5

dir5=/home/acs/homework/lesson_1/homework_5

rm ${dir5}/* -r

# ********* homework_6 **********
# homework 1 create 6

dir6=/home/acs/homework/lesson_1/homework_6

mv ${dir6}/task.txt "${dir6}/done.txt"
mkdir ${dir6}/dir_a
mv "${dir6}/done.txt" ${dir6}/dir_a

# ********* homework_7 **********
# homework 1 create 7

dir7=/home/acs/homework/lesson_1/homework_7

for ((i=0;i<3;i++))
do
    mkdir ${dir7}/dir_${i}
    for j in a b c
    do
        cp ${dir7}/${j}.txt ${dir7}/dir_${i}/${j}${i}.txt
    done
done

# ********* homework_8 **********
# homework 1 create 8

dir8=/home/acs/homework/lesson_1/homework_8

rm ${dir8}/dir_a/a.txt
mv ${dir8}/dir_b/b.txt ${dir8}/dir_b/b_new.txt
cp ${dir8}/dir_c/c.txt ${dir8}/dir_c/c.txt.bak

# ********* homework_9 **********
# homework 1 create 9

dir9=/home/acs/homework/lesson_1/homework_9

rm ${dir9}/*.txt

homework 1 test

(1) 进入 homework_1 文件夹,编写脚本 check_file.sh。要求:
[1] 当前目录下仅包含 check_file.sh
[2] check_file.sh 具有可执行权限。
[3] check_file.sh 接收一个传入参数。格式为 ./check_file.sh file
[4] 判断传递参数,分别在标准输出中输出如下内容(不包括双引号):
1 如果传入参数个数不是$1$,则输出一行:”arguments not valid“,然后退出,退出状态等于 1
2 如果 file 文件不存在,则输出一行:”not exist“,然后退出,退出状态等于 2
3 如果 file 文件存在,则输出分别进行如下5个判断,然后退出,退出状态等于 0
1] 如果 file 为普通文件,则输出一行:”regulare file
2] 如果 file 为目录(文件夹),则输出一行:”directory
3] 如果 file 具有可读权限,则输出一行:”readable
4] 如果 file 具有可写权限,则输出一行:”writable
5] 如果 file 具有可执行权限,则输出一行:”executable

cd homework  # 进入作业目录
vim check_file.sh  # 创建作业脚本
chmod +x helper.sh  # 添加可执行权限

$# # 代表文件传入的参数个数
#! /bin/bash

if [ $# -ne 1 ]                                                                                                                                                    
then
    echo arguments not valid
    exit 1
fi

if [ ! -e "$1" ]
then
    echo not exist
    exit 2
fi

if [ -f "$1" ]                                                                                                                                                     
then
    echo regular file #注意标答的拼写是regulare
fi

if [ -d "$1" ]
then
    echo directory
fi

if [ -r "$1" ]
then
    echo readable                                                                                                                                                  
fi

if [ -w "$1" ]
then
    echo writable
fi

if [ -x "$1" ]
then
    echo executable
fi

(2) 进入 homework_2 文件夹,编写脚本 main.sh。要求:
[1] 当前目录下仅包含 main.sh
[2] main.sh 具有可执行权限
[3] 该文件从 stdin (标准输入)中读取一个整数 n
[4] 在 stdout (标准输出)输出斐波那契数列的第 n 项。即:a[0] = 1, a[1] = 1, a[i] = a[i - 1] + a[i - 2], 求 a[n]
[5] 数据保证 0 <= n <= 20,脚本不需要判断 n 的合法性。

cd homework  # 进入作业目录
vim main.sh  # 创建作业脚本
chmod +x main.sh  # 添加可执行权限
#! /bin/bash

read n

a[0]=1
a[1]=1

for ((i = 2; i <= n; i++))
do
    x=$(expr $i - 1)
    y=$(expr $i - 2)
    a[$i]=$(expr ${a[$x]} + ${a[$y]})
done

echo ${a[$n]}

#输入4 输出5;输入7 输出21 等等

(3) 进入homework_3 文件夹,编写脚本 main.sh。要求:
[1] 当前目录下仅包含 main.sh
[2] main.sh 具有可执行权限
[3] 该文件从 stdin (标准输入)中读取两行整数 nm
[4] 在 stdou (标准输出)中输出 1~n 的按字典序从小到大的顺序数第 m 个全排列,输出一行,用空格隔开所有数,行末可以有多余空格。
[5] 数据保证 1 <= n <= 10, 1 <= m <= min(100, n!),脚本不需要判断数据的合法性。

//C++的全排列写法
#include <iostream>

using namespace std;

const int N = 110;

int n, m;
int path[N];
bool st[N];

bool dfs(int u)
{
    if (u == n) //枚举完所有的数
    {
        m --;
        if(!m) //m==0表示已经找到第m个全排列
        {
            for (int i = 0; i < n; i ++) cout << path[i] << ' ';
            cout << endl;
            return true;
        }
        return false;
    }
    for (int i = 1; i <= n; i ++)
        if (!st[i])
        {
            path[u] = i;
            st[i] = true;
            if (dfs(u + 1)) return true;
            st[i] = false;
        }
    return false;
}

int main()
{
    cin >> n >> m;    
    dfs(0);    
    return 0;
}
#! /bin/bash

read n
read m

for ((i = 1; i <= n; i++))
do
    st[$i]=0
done

dfs(){
    echo $1 
    read tmp #为了防止递归死循环崩掉,用read tmp 这样每递归一层停一下

    if [ $1 -eq $n ]
    then
        m=`expr $m - 1`
        if [ $m -eq 0 ]
        then
            for ((i = 0; i < n; i++))
            do
                echo -e "${path[$i]} \c"
            done
            echo ''
            return 0
        fi
        return 1
    fi

    #-----上面的if条件判断还可以写成:-----#
    #知识点:读取整个数组
    # echo ${array[@]}  # 第一种写法
    # echo ${array[*]}  # 第二种写法
    if [ $1 -eq $n ]
    then
        m=`expr $m - 1`
        if [ $m -eq 0 ]
        then
            echo ${path[@]} #
            return 0
        fi
        return 1
    fi    
    #--------------------------------#

    local j=0 #设置local变量是因为dfs时会将上层的j变量修改掉(因为是同一个变量)
    for (( j = 1; j <= n; j ++))                 
    do
        if [ ${st[$j]} -eq 0 ]
        then
            path[$1]=$j
            st[$j]=1
            if dfs `expr $1 + 1`
            then
                return 0
            fi
            st[$j]=0
        fi
    done

    return 1
}

dfs 0

(4) 进入 homework_4 文件夹,编写脚本 main.sh。要求:
[1] 当前目录下仅包含 main.sh
[2] main.sh 具有可执行权限
[3] main.sh 接收两个传入参数。格式为 ./main.sh input_file output_file
[4] 从 input_file 中读取一个正整数 n,然后将前 n 个正整数的平方和写入 output_file
[5] 数据保证 1 <= n <= 100,脚本不需要判断所有数据的合法性。

#! /bin/bash

input_file=$1
output_file=$2

read n < $input_file

sum=0

for ((i = 1; i <= n; i++))
do
    sqr=`expr $i \* $i`
    sum=`expr $sum + $sqr`
done

echo $sum > $output_file

acs@b5a9f3bd0333:~/homework/lesson_3/homework_4$ echo 10 > input.txt
acs@b5a9f3bd0333:~/homework/lesson_3/homework_4$ ./main.sh input.txt output.txt
acs@b5a9f3bd0333:~/homework/lesson_3/homework_4$ ls
input.txt  main.sh  output.txt
acs@b5a9f3bd0333:~/homework/lesson_3/homework_4$ cat input.txt 
10
acs@b5a9f3bd0333:~/homework/lesson_3/homework_4$ cat output.txt 
385
acs@b5a9f3bd0333:~/homework/lesson_3/homework_4$ rm *.txt


活动打卡代码 Linux 3.4. homework_4

(4) 进入 `homework_4` 文件夹,编写脚本 `main.sh`。要求:
    [1] 当前目录下仅包含 `main.sh`
    [2] `main.sh` 具有可执行权限
    [3] `main.sh` 接收两个传入参数。格式为 `./main.sh input_file output_file`
    [4] 从 `input_file` 中读取一个正整数 `n`,然后将前 `n` 个正整数的平方和写入 `output_file` 中
    [5] 数据保证 `1 <= n <= 100`,脚本不需要判断所有数据的合法性。

```shell
#! /bin/bash

input_file=$1
output_file=$2

read n < $input_file

sum=0

for ((i = 1; i <= n; i++))
do
    sqr=`expr $i \* $i`
    sum=`expr $sum + $sqr`
done

echo $sum > $output_file

acs@b5a9f3bd0333:~/homework/lesson_3/homework_4$ echo 10 > input.txt
acs@b5a9f3bd0333:~/homework/lesson_3/homework_4$ ./main.sh input.txt output.txt
acs@b5a9f3bd0333:~/homework/lesson_3/homework_4$ ls
input.txt  main.sh  output.txt
acs@b5a9f3bd0333:~/homework/lesson_3/homework_4$ cat input.txt 
10
acs@b5a9f3bd0333:~/homework/lesson_3/homework_4$ cat output.txt 
385
acs@b5a9f3bd0333:~/homework/lesson_3/homework_4$ rm *.txt

```



活动打卡代码 AcWing 3.3. homework_3

(3) 进入homework_3 文件夹,编写脚本 main.sh。要求:
[1] 当前目录下仅包含 main.sh
[2] main.sh 具有可执行权限
[3] 该文件从 stdin (标准输入)中读取两行整数 nm
[4] 在 stdou (标准输出)中输出 1~n 的按字典序从小到大的顺序数第 m 个全排列,输出一行,用空格隔开所有数,行末可以有多余空格。
[5] 数据保证 1 <= n <= 10, 1 <= m <= min(100, n!),脚本不需要判断数据的合法性。

//C++的全排列写法
#include <iostream>

using namespace std;

const int N = 110;

int n, m;
int path[N];
bool st[N];

bool dfs(int u)
{
    if (u == n) //枚举完所有的数
    {
        m --;
        if(!m) //m==0表示已经找到第m个全排列
        {
            for (int i = 0; i < n; i ++) cout << path[i] << ' ';
            cout << endl;
            return true;
        }
        return false;
    }
    for (int i = 1; i <= n; i ++)
        if (!st[i])
        {
            path[u] = i;
            st[i] = true;
            if (dfs(u + 1)) return true;
            st[i] = false;
        }
    return false;
}

int main()
{
    cin >> n >> m;    
    dfs(0);    
    return 0;
}
#! /bin/bash

read n
read m

for ((i = 1; i <= n; i++))
do
    st[$i]=0
done

dfs(){
    echo $1 
    read tmp #为了防止递归死循环崩掉,用read tmp 这样每递归一层停一下

    if [ $1 -eq $n ]
    then
        m=`expr $m - 1`
        if [ $m -eq 0 ]
        then
            for ((i = 0; i < n; i++))
            do
                echo -e "${path[$i]} \c"
            done
            echo ''
            return 0
        fi
        return 1
    fi

    #-----上面的if条件判断还可以写成:-----#
    #知识点:读取整个数组
    # echo ${array[@]}  # 第一种写法
    # echo ${array[*]}  # 第二种写法
    if [ $1 -eq $n ]
    then
        m=`expr $m - 1`
        if [ $m -eq 0 ]
        then
            echo ${path[@]} #
            return 0
        fi
        return 1
    fi    
    #--------------------------------#

    local j=0 #设置local变量是因为dfs时会将上层的j变量修改掉(因为是同一个变量)
    for (( j = 1; j <= n; j ++))                 
    do
        if [ ${st[$j]} -eq 0 ]
        then
            path[$1]=$j
            st[$j]=1
            if dfs `expr $1 + 1`
            then
                return 0
            fi
            st[$j]=0
        fi
    done

    return 1
}

dfs 0


新鲜事 原文

今天感恩节,y总是我最想感恩的人之一,谢谢你开发了这么多高质量的好课,你是我编程学习路上的灯塔!@yxc


活动打卡代码 Linux 3.2. homework_2

(2) 进入 homework_2 文件夹,编写脚本 main.sh。要求:
[1] 当前目录下仅包含 main.sh
[2] main.sh 具有可执行权限
[3] 该文件从 stdin (标准输入)中读取一个整数 n
[4] 在 stdout (标准输出)输出斐波那契数列的第 n 项。即:a[0] = 1, a[1] = 1, a[i] = a[i - 1] + a[i - 2], 求 a[n]
[5] 数据保证 0 <= n <= 20,脚本不需要判断 n 的合法性。

cd homework  # 进入作业目录
vim main.sh  # 创建作业脚本
chmod +x main.sh  # 添加可执行权限
#! /bin/bash

read n

a[0]=1
a[1]=1

for ((i = 2; i <= n; i++))
do
    x=$(expr $i - 1)
    y=$(expr $i - 2)
    a[$i]=$(expr ${a[$x]} + ${a[$y]})
done

echo ${a[$n]}

#输入4 输出5;输出7 输出21 等等


活动打卡代码 AcWing 3.1. homework_1

(1) 进入 homework_1 文件夹,编写脚本 check_file.sh。要求:
[1] 当前目录下仅包含 check_file.sh
[2] check_file.sh 具有可执行权限。
[3] check_file.sh 接收一个传入参数。格式为 ./check_file.sh file
[4] 判断传递参数,分别在标准输出中输出如下内容(不包括双引号):
1 如果传入参数个数不是$1$,则输出一行:”arguments not valid“,然后退出,退出状态等于 1
2 如果 file 文件不存在,则输出一行:”not exist“,然后退出,退出状态等于 2
3 如果 file 文件存在,则输出分别进行如下5个判断,然后退出,退出状态等于 0
1] 如果 file 为普通文件,则输出一行:”regulare file
2] 如果 file 为目录(文件夹),则输出一行:”directory
3] 如果 file 具有可读权限,则输出一行:”readable
4] 如果 file 具有可写权限,则输出一行:”writable
5] 如果 file 具有可执行权限,则输出一行:”executable

cd homework  # 进入作业目录
vim check_file.sh  # 创建作业脚本
chmod +x helper.sh  # 添加可执行权限

$# # 代表文件传入的参数个数
#! /bin/bash

if [ $# -ne 1 ]                                                                                                                                                    
then
    echo arguments not valid
    exit 1
fi

if [ ! -e "$1" ]
then
    echo not exist
    exit 2
fi

if [ -f "$1" ]                                                                                                                                                     
then
    echo regular file #注意标答的拼写是regulare
fi

if [ -d "$1" ]
then
    echo directory
fi

if [ -r "$1" ]
then
    echo readable                                                                                                                                                  
fi

if [ -w "$1" ]
then
    echo writable
fi

if [ -x "$1" ]
then
    echo executable
fi