程序博客网 > php网页计数器代码

cu tim哥大作 sed 用法

来源：互联网 发布：php网页计数器代码 编辑：程序博客网 时间：2024/04/28 11:15

在shell版混了3年多了，文本编辑方面小有心得，写出来与大家分享，黑哥等一笑而过。

读本文之前，需要对sed有一定了解，最好看过sed1line：
http://bbs.chinaunix.net/viewthread.php?tid=336126

本文所有用例的测试环境采用unix-center的ubuntu服务器
http://www.unix-center.net/

具体版本如下：

  1. ly5066113@ubuntu:~$ uname -a
  2. Linux ubuntu 2.6.24-22-generic #1 SMP Mon Nov 24 19:35:06 UTC 2008 x86_64 GNU/Linux
  3. ly5066113@ubuntu:~$ bash --version
  4. GNU bash, version 3.2.39(1)-release (x86_64-pc-linux-gnu)
  5. Copyright (C) 2007 Free Software Foundation, Inc.
  6. ly5066113@ubuntu:~$ sed --version
  7. GNU sed version 4.1.5
  8. Copyright (C) 2003 Free Software Foundation, Inc.
  9. This is free software; see the source for copying conditions.  There is NO
  10. warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE,
  11. to the extent permitted by law.
复制代码

下面结合实例介绍sed应用的几个方面。

一、标签

        b label ,无条件跳转到标签label,如果label没有指定,跳转到命令的结尾
        t label ,如果最后一次输入的最后一个 s/// 子命令执行成功,跳转到标签label,如果label没有指定,跳转到命令的结尾

        例1: 用标签完成 是AA就加上YES,不是AA就加NO
        http://bbs.chinaunix.net/viewthread.php?tid=1632469

        使用t命令：

  1. ly5066113@ubuntu:~$ cat urfile
  2. AA
  3. BC
  4. AA
  5. CB
  6. CC
  7. AA
  8. ly5066113@ubuntu:~$ sed '/^AA/s/$/ YES/;t;s/$/ NO/' urfile
  9. AA YES
  10. BC NO
  11. AA YES
  12. CB NO
  13. CC NO
  14. AA YES
复制代码

如果是AA，执行s/$/ YES/，s命令执行成功，执行t命令，没有标签，跳转到命令的结尾，这样将会跳过后面的s/$/ NO/
        如果不是AA，s/$/ YES/不执行，则t命令也不执行，只执行后面的s/$/ NO/

        使用b命令：

  1. ly5066113@ubuntu:~$ sed '/^AA/ba;s/$/ NO/;b;:a;s/$/ YES/' urfile
  2. AA YES
  3. BC NO
  4. AA YES
  5. CB NO
  6. CC NO
  7. AA YES
复制代码

如果是AA，执行ba，跳转到标签a处，这样会跳过中间的s/$/ NO/;b，只执行后面的s/$/ YES/
        如果不是AA，ba不执行，执行s/$/ NO/，执行b，没有标签，跳转到命令的结尾，这样将会跳过后面的s/$/ YES/


        例2: 合并行：
        http://bbs.chinaunix.net/viewthread.php?tid=1381004

  1. ly5066113@ubuntu:~$ cat urfile
  2. 114.113.144.2:
  3. 19ms
  4. 19ms
  5. 19ms
  6. 36ms
  7. 22ms
  8. 19ms
  9. 18ms
  10. 218.61.204.73:
  11. 0ms
  12. 0ms
  13. 0ms
  14. 0ms
  15. 0ms
  16. 0ms
  17. 0ms
  18. ly5066113@ubuntu:~$ sed ':a;$!N;/ms$/s//n/ /;ta;P;D' urfile
  19. 114.113.144.2: 19ms 19ms 19ms 36ms 22ms 19ms 18ms
  20. 218.61.204.73: 0ms 0ms 0ms 0ms 0ms 0ms 0ms
复制代码

实现思路：
        1、读入下一行数据
        2、判断是否以ms结尾
        3、如果是，替换/n为空格，跳转到1
        4、如果不是，打印本行数据，删除本行数据，跳转到1
       
        代码实现：
        :a                   #定义标签a
        $!N                  #不是最后一行，执行N命令
        /ms$/s//n/ /         #如果以ms结尾，将/n替换为空格
        ta                   #如果s///命令执行成功，跳转到标签a处
        P                    #打印pattern space的第一行
        D                    #删除pattern space的第一行，循环
       
        此代码是使用sed进行合并行操作的典型代码，对于不同的情况，只需要将/ms$/替换成需要的正则表达式即可，思路上是通用的。


        sed的标签类似于C语言中的goto，cjaizss兄说过，写代码的时候要有状态机的思想，代码只不过是一种实现。
        下面是他用sed写的加法，里面应用了大量的标签，有兴趣可以研究下：
        http://bbs.chinaunix.net/viewthread.php?tid=1063437


二、记数

        sed不同于awk，内部没有数学运算，是否可以实现记数器，答案是肯定的，因为sed是图灵完备的。

        例3：如何替换文中第2次和第4次出现的指定字符串
        http://bbs3.chinaunix.net/thread-1512243-1-1.html
        本例中采用的是这种方案：

  1. sed ':a ; N ; $!ba ;s/root/mmmm/4'
复制代码

但这个方案有2个弊端：
        1、需要将文本一次性读入到pattern space，如果文件很大，是不行的
        2、如果指定字符串在同一行内出现多次，那么这个方法也是不行的
       
        那么是否有其他的替代方案呢？让我们先从简单的开始。
        将文本中第1次出现a的行替换为b

  1. ly5066113@ubuntu:~$ cat urfile
  2. a
  3. a
  4. a
  5. a
  6. a
  7. a
  8. ly5066113@ubuntu:~$ sed '0,/a/{s//b/}' urfile
  9. b
  10. a
  11. a
  12. a
  13. a
  14. a
复制代码

我们可以利用0,/a/这样的地址区间来定位第一次出现a的行。
        好，现在提升难度，将文本中第2次出现a的行替换为b

  1. ly5066113@ubuntu:~$ sed '0,/a/b;s/a/b/;ta;b;:a;n;ba' urfile
  2. a
  3. b
  4. a
  5. a
  6. a
  7. a
复制代码

继续，将文本中第3次出现a的行替换为b

  1. ly5066113@ubuntu:~$ sed '0,/a/b;/a/ba;b;:a;n;s/a/b/;tb;ba;:b;n;bb' urfile
  2. a
  3. a
  4. b
  5. a
  6. a
  7. a
复制代码

利用0,/a/和标签，也实现了，但同时我们发现，随着次数的增加，代码将会变的越来越烦琐

        是时候另辟蹊径了，下面介绍一下我的方法，我为其命名为“打点记数法”
        主要的思路是这样的：
        利用sed的hold space，当遇到匹配行时，向hold space里面“打一个.”，使用 . 的个数来记录匹配的次数
        如果 . 的个数达到了要求，则执行相应的操作

  1. ly5066113@ubuntu:~$ sed '/a/{x;s/^/./;/^./{3/}$/{x;s/a/b/;b};x}' urfile
  2. a
  3. a
  4. b
  5. a
  6. a
  7. a
  8. ly5066113@ubuntu:~$ sed '/a/{x;s/^/./;/^./{4/}$/{x;s/a/b/;b};x}' urfile
  9. a
  10. a
  11. a
  12. b
  13. a
  14. a
  15. ly5066113@ubuntu:~$ sed '/a/{x;s/^/./;/^./{5/}$/{x;s/a/b/;b};x}' urfile
  16. a
  17. a
  18. a
  19. a
  20. b
  21. a
复制代码

我们可以看到，对于次数的增加，我们只需要调整需要匹配的数值即可。
        /a/{                 #匹配时，开始记数
                x                #交换pattern space与hold space
                s/^/./           #向hold space打一个 .
                /^./{3/}$/{      #判断 . 的个数是否达到要求
                        x            #如果达到要求，交换hold space与pattern space
                        s/a/b/       #进行替换
                        b            #跳转到代码结束
                }                #
                x                #交换hold space与pattern space
        }                    #


        接下来我们看看“打点记数法”的另一种应用：
        例4：提取函数
        http://bbs.chinaunix.net/viewthread.php?tid=1328688

  1. ly5066113@ubuntu:~$ cat urfile
  2. void
  3. foo(int a, int b) {
  4. //impl. skipped
  5. }
  8. void bigfunction() {
  9. int x1, x2, y1, y2, z1, z2;
  11. // after many lines
  12. bar(); foo (x1, x2);
  13. ly5066113@ubuntu:~$ sed -n 'N
  14. > /foo/{
  15. >         :a
  16. >         /{/{
  17. >                 x
  18. >                 s/^/./
  19. >                 x
  20. >         }
  21. >         /}/{
  22. >                 x
  23. >                 s/.//
  24. >                 /^$/{
  25. >                         x
  26. >                         p
  27. >                         q
  28. >                 }
  29. >                 x
  30. >         }
  31. >         p
  32. >         n
  33. >         ba
  34. > }
  35. > D' urfile
  36. void
  37. foo(int a, int b) {
  38. //impl. skipped
  39. }
复制代码

此代码的主要思路，就是我在原贴中的回复：
        当匹配 { 时，x;s/^/./;x ，向hold space里面放一个 .
        当匹配 } 时，x;s/.//;x ，将hold space里的 . 去掉一个
        就这样，当hold space再次为空时，就表示所有的 { 和 } 都配对了


三、lookup table

        在讲lookup table技术之前，先讲一下“回溯引用”
        回溯引用对于大家来说并不陌生，会经常用于 s/REGEXP/REPLACEMENT/ 中REPLACEMENT部分
        但回溯引用并不是只能用于REPLACEMENT部分，在REGEXP中也是可以使用的。
       
        例5：找出100以内，个位与十位相同的2位数

  1. ly5066113@ubuntu:~$ seq 100 | sed -n '/^/(./)/1$/p'
  2. 11
  3. 22
  4. 33
  5. 44
  6. 55
  7. 66
  8. 77
  9. 88
  10. 99
复制代码

我们可以看到，这个问题利用回溯引用很容易解决。
        /1表示前面/(./)中内容，换种说法就是/1与前面/(./)是相同的，那么就是个位与十位相同了


        在理解了REGEXP中的回溯引用之后，我们来看看lookup table技术
        lookup table就是回溯引用的方式进行前后定位，然后取出我们需要内容

        例6： AIX下怎么用DATE取上月的月份
        http://bbs.chinaunix.net/viewthread.php?tid=995655
        UNIX下一般都没有GNU date，即便有GNU date，在某些时间点(如3月31号)上进行取上月操作(-1 month)的时候也有问题

  1. ly5066113@ubuntu:~$ date +%m
  2. 08
  3. ly5066113@ubuntu:~$ date +%m | sed 's/$/b12a01a02a03a04a05a06a07a08a09a10a11a12/;s/^/(../)b.*/(../)a/1.*//2/'
  4. 07
复制代码

我们来看看这段代码是如何工作的：
        1、构造一个列表，字母a左边的2位数字是右边2位数字的上一个月
        2、利用lookup table取出上一个月

        pattern space初始为：
        08
        第一个s命令处理后pattern space变为：
        08b12a01a02a03a04a05a06a07a08a09a10a11a12
        下面我们重点来看看第二个s命令是怎么工作的：
        s/^/(../)b.*/(../)a/1.*//2/
        将pattern space里面的内容按照上面的正则表达式进行分解
        ^/(../)              08
        b.*                  b12a01a02a03a04a05a06a
        /(../)               07
        a/1                  a08
        .*                   a09a10a11a12
        整个过程就是通过第一个括号里面的内容 08 ，定位到后面的 a08 ，从而取出它前面的2位数字 07 ，也就是第二个括号里的内容 /2
        这种方法就称之为 lookup table


        例7：文本处理
        http://bbs.chinaunix.net/viewthread.php?tid=1385995

  1. ly5066113@ubuntu:~$ cat urfile
  2. 172.27.38.0&1=99&2=100
  3. 192.168.9.2&1=100&3=111
  4. 202.96.64.68&1=99&2=1&3=111
  5. 202.96.69.38&1=99&3=111&4=110
  6. 202.77.88.99&1=99&2=111&3=66&4=100&5=44
  7. ly5066113@ubuntu:~$ sed -r 's/&//n1/n2/n3/n4/n5&/;:a;s//n(.)(.*)&/1=([^&]+)//t/3/2/;ta;s//n.//t0/g' urfile
  8. 172.27.38.0     99      100     0       0       0
  9. 192.168.9.2     100     0       111     0       0
  10. 202.96.64.68    99      1       111     0       0
  11. 202.96.69.38    99      0       111     110     0
  12. 202.77.88.99    99      111     66      100     44
复制代码

整体思路，用原贴中dream3401的描述：
        1、产生1,2,3,4,5的"坐标"
        2、对每天"有坐标的赋值"中的值代入坐标
        3、对没有"赋值的坐标"代入0

        我们以第一行数据为例，看看这段代码是怎么工作的：
        pattern space初始为：
        172.27.38.0&1=99&2=100
        s/&//n1/n2/n3/n4/n5&/后：
        172.27.38.0/n1/n2/n3/n4/n5&1=99&2=100
        s//n(.)(.*)&/1=([^&]+)//t/3/2/后：
        172.27.38.0     99/n2/n3/n4/n5&2=100
        s命令执行成功，t命令执行，跳转到标签a处，再次执行s//n(.)(.*)&/1=([^&]+)//t/3/2/：
        172.27.38.0     99      100/n3/n4/n5
        s命令执行成功，t命令执行，跳转到标签a处，再次执行s//n(.)(.*)&/1=([^&]+)//t/3/2/，s命令执行失败，无替换
        t命令不执行，执行s//n.//t0/g：
        172.27.38.0     99      100     0       0       0

        对于以上步骤，第一个s命令和最后一个s命令都不难理解，关键是中间的这句：
        s//n(.)(.*)&/1=([^&]+)//t/3/2/
        那我们以第一次的执行为例，将pattern space里面的内容按照上面的正则表达式进行分解
        /n(.)                /n1
        (.*)                 /n2/n3/n4/n5
        &/1=                 &1=
        ([^&]+)              99
        利用第一个括号的数字1，定位到后面&1=中的数字1，从而取出=号后面的数字99
        172.27.38.0                /n1/n2/n3/n4/n5&1=99                &2=100
        172.27.38.0     99/n2/n3/n4/n5                                &2=100
        此正则表达式在工作的过程中，开头的 172.27.38.0 和结尾的 &2=100 都是没有处理的，处理的只是中间的一部分


        例7和例6虽然都是用的lookup table技术，但思路梢有不同。
        例6是构造一个列表，然后从列表中lookup出想要的值
        例7也是构造一个列表，但是将外面的值填充到列表中
        无论是那种方式，lookup table技术的基本做法都是先构造一个列表，然后用回溯引用定位，从而得到我们需要的值


四、GNU拓展

        最后，介绍几个GNU sed的拓展功能，个人认为比较实用：
       
        1、/U /L /u /l
        大小写转换

  1. ly5066113@ubuntu:~$ echo 'abc' | sed 's/.*//U&/'
  2. ABC
  3. ly5066113@ubuntu:~$ echo 'abc' | sed 's/.*//u&/'
  4. Abc
  5. ly5066113@ubuntu:~$ echo 'ABC' | sed 's/.*//L&/'
  6. abc
  7. ly5066113@ubuntu:~$ echo 'ABC' | sed 's/.*//l&/'
  8. aBC
复制代码

2、/REGEXP/I
        正则匹配忽略大小写

  1. ly5066113@ubuntu:~$ echo 'AbC' | sed -n '/abc/Ip'
  2. AbC
复制代码

3、FIRST~STEP
        取出奇数行或者偶数行

  1. ly5066113@ubuntu:~$ seq 10 | sed '0~2d'
  2. 1
  3. 3
  4. 5
  5. 7
  6. 9
  7. ly5066113@ubuntu:~$ seq 10 | sed '1~2d'
  8. 2
  9. 4
  10. 6
  11. 8
复制代码

每5行合并成1行，类似 xargs -n5

  1. ly5066113@ubuntu:~$ seq 20 | xargs -n5
  2. 1 2 3 4 5
  3. 6 7 8 9 10
  4. 11 12 13 14 15
  5. 16 17 18 19 20
  6. ly5066113@ubuntu:~$ seq 20 | sed ':a;N;s//n/ /;0~5b;ba'
  7. 1 2 3 4 5
  8. 6 7 8 9 10
  9. 11 12 13 14 15
  10. 16 17 18 19 20
复制代码

4、/%REGEXP%
        进行路径匹配时，使用此方法，可以剩去很多转义符/

  1. 16 17 18 19 20
  2. ly5066113@ubuntu:~$ echo 'a/b/c/d/e/f' | sed -n '/a//b//c//d/p'
  3. a/b/c/d/e/f
  4. ly5066113@ubuntu:~$ echo 'a/b/c/d/e/f' | sed -n '/%a/b/c/d%p'
  5. a/b/c/d/e/f
复制代码

5、ADDR1,+N
        地址 +行数，可以实现类似 grep -A N 的功能

  1. ly5066113@ubuntu:~$ seq 10 | grep -A2 '5'
  2. 5
  3. 6
  4. 7
  5. ly5066113@ubuntu:~$ seq 10 | sed -n '/5/,+2p'
  6. 5
  7. 6
  8. 7
复制代码

文笔有限，如果有描述不清的地方请大家见谅。希望本文会对大家学习sed有所帮助。




        关于sed记数，补充几个例子

        例8：实现 awk '{print NR,$0}' 的功能
        来自info sed中的examples(略有改动)

  1. ly5066113@ubuntu:~$ head sed.info | awk '{print NR,$0}'
  2. 1 File: sed.info,  Node: Top,  Next: Introduction,  Up: (dir)
  3. 2
  4. 3 sed, a stream editor
  5. 4 ********************
  6. 5
  7. 6 This file documents version 4.1.5 of GNU `sed', a stream editor.
  8. 7
  9. 8    Copyright (C) 1998, 1999, 2001, 2002, 2003, 2004 Free Software
  10. 9 Foundation, Inc.
  11. 10
  12. ly5066113@ubuntu:~$ head sed.info | sed -nf test.sed
  13. 1 File: sed.info,  Node: Top,  Next: Introduction,  Up: (dir)
  14. 2
  15. 3 sed, a stream editor
  16. 4 ********************
  17. 5
  18. 6 This file documents version 4.1.5 of GNU `sed', a stream editor.
  19. 7
  20. 8    Copyright (C) 1998, 1999, 2001, 2002, 2003, 2004 Free Software
  21. 9 Foundation, Inc.
  22. 10
  23. ly5066113@ubuntu:~$ cat test.sed
  24. #! /usr/bin/sed -f
  25. x
  26. 1s/^/1/
  27. G
  28. s//n/ /p
  29. s/ .*//
  30. /^9*$/s/^/0/
  31. s/.9*$/x&/
  32. h
  33. s/.*x//
  34. y/0123456789/1234567890/
  35. x
  36. s/x.*//
  37. G
  38. s//n//
  39. h
复制代码

x                              #交换pattern space与hold space，保存读入的内容
        1s/^/1/                        #如果是第一行，初始化行号1
        G                              #将保存的内容追加回pattern space
        s//n/ /p                       #将换行替换为空格，并打印
        s/ .*//                        #去处空格以后的所有内容，pattern space只剩下行号
        /^9*$/s/^/0/                   #如果行号都为9，在前面补0
        s/.9*$/x&/                     #用x分隔不需要改变和需要改变的数字
        h                              #将pattern space中的内容保存到hold space
        s/.*x//                        #删除不需要改变的数字
        y/0123456789/1234567890/       #对数字进行 +1 的操作
        x                              #交换pattern space与hold space
        s/x.*//                        #删除需要改变的数字
        G                              #将改变后的数字追加回pattern space
        s//n//                         #删除换行，得到新的行号
        h                              #保存新行号到hold space

        整体的思路：
        每读入一行记录，将保存在hold space中的行号(如果是第一行，需要初始化)，和本行记录合并输出
        然后将行号 +1 ，保存至hold space

        代码的核心部分就是实现“行号 +1”，具体做法：
        将行号分为2个部分，一部分保持不变(此部分可能没有)，一部分进行改变，然后将需要改变的部分进行处理
        将处理后的结果与前面不变的部分拼接在一起，形成新的行号，但这里有个情况需要考虑，就是进位
        我们已实际的例子来看看
        如果行号是 123
        那么首先将其分成2个部分变为  12x3
        x左边的12不需要改变，x右边的3需要变成4
        那么就对3进行y/0123456789/1234567890/的操作，将其变成4
        然后拼上前面的12变为 124
        如果行号是129(需要进位)
        那么首先将其分成2个部分变为  1x29
        x左边的1不需要改变，x右边的29需要变成30
        那么就对29进行y/0123456789/1234567890/的操作，将其变成30
        然后拼上前面的1变为 130
        这里面有个特殊情况需要考虑，就是如果行号都为9
        9， 99， 999 之类的情况，那么我们需要在前面加数字0用做进位用

        例9：实现 wc -c 的功能
        来自info sed中的examples(略有改动)

  1. ly5066113@ubuntu:~$ wc -c urfile
  2. 254 urfile
  3. ly5066113@ubuntu:~$ sed -nf test.sed urfile
  4. 254
  5. ly5066113@ubuntu:~$ cat test.sed
  6. #! /usr/bin/sed -f
  7. s/./a/g
  8. H
  9. x
  10. s//n/a/
  11. : a;  s/aaaaaaaaaa/b/g; t b; b done
  12. : b;  s/bbbbbbbbbb/c/g; t c; b done
  13. : c;  s/cccccccccc/d/g; t d; b done
  14. : d;  s/dddddddddd/e/g; t e; b done
  15. : e;  s/eeeeeeeeee/f/g; t f; b done
  16. : f;  s/ffffffffff/g/g; t g; b done
  17. : g;  s/gggggggggg/h/g; t h; b done
  18. : h;  s/hhhhhhhhhh//g
  19. : done
  20. $! {
  21.         h
  22.         b
  23. }
  24. : loop
  25. /a/! s/[b-h]*/&0/
  26. s/aaaaaaaaa/9/
  27. s/aaaaaaaa/8/
  28. s/aaaaaaa/7/
  29. s/aaaaaa/6/
  30. s/aaaaa/5/
  31. s/aaaa/4/
  32. s/aaa/3/
  33. s/aa/2/
  34. s/a/1/
  35. y/bcdefgh/abcdefg/
  36. /[a-h]/ b loop
  37. p
复制代码

此段代码虽然看起来烦琐，但思路却比上一例好理解。
        每读一行数据，将里面所有的字符都替换成字母a，因为sed读数据时会将换行符(/n)去掉
        所以我们利用H命令产生的/n将其补充回来，也替换成字母a，统一做字符统计
        为了节省内存开销，提高效率，这里做了进位的处理，就是将10个a替换成1个b，10个b替换成1个c 。。。
        这样到最后，字母a的个数就代表个位数字，字母b的个数就代表十位数字，字母c的个数代表百位数字。。。
        如果最后剩下是这样一串字符：
        ccbbbbbaaaa
        那么就表示总共的字符数为：254
        本段代码的统计是有上限的，如果字符数量超过1亿，将无法得到正确结果
        可以通过增加替换的次数来增加统计上限，如 s/hhhhhhhhhh/i/g ， s/iiiiiiiiii/j/g 。。。

        例10：实现 awk '{sum+=$1}END{print sum}'
        http://sed.sourceforge.net/grabbag/scripts/add_decs.sed

  1. ly5066113@ubuntu:~$ seq 100 | awk '{sum+=$1}END{print sum}'
  2. 5050
  3. ly5066113@ubuntu:~$ seq 100 | sed -nf test.sed
  4. 5050
  5. ly5066113@ubuntu:~$ seq 1000 | awk '{sum+=$1}END{print sum}'
  6. 500500
  7. ly5066113@ubuntu:~$ seq 1000 | sed -nf test.sed
  8. 500500
  9. ly5066113@ubuntu:~$ cat test.sed
  10. #! /usr/bin/sed -f
  12. # This is an alternative approach to summing numbers,
  13. # which works a digit at a time and hence has unlimited
  14. # precision.  This time it is done with lookup tables,
  15. # and uses only 10 commands.
  17. G
  18. s//n/-/
  19. s/$/-/
  20. s/$/;9aaaaaaaaa98aaaaaaaa87aaaaaaa76aaaaaa65aaaaa54aaaa43aaa32aa21a100/
  22. :loop
  23. /^--[^a]/!{
  24.         # Convert next digit from both terms into analog form
  25.         # and put the two groups next to each other
  26.         s/^/([0-9a]*/)/([0-9]/)-/([^-]*/)-/(.*;.*/2/(a*/)/2.*/)//1-/3-/5/4/
  27.         s/^/([^-]*/)-/([0-9a]*/)/([0-9]/)-/(.*;.*/3/(a*/)/3.*/)//1-/2-/5/4/
  29.         # Back to decimal, but keeping the carry in analog form
  30.         # /2 matches an `a' if there are at least ten a's, else nothing
  31.         #
  32.         #    1-------------                       3-      4----------------------
  33.         #                        2                                                5----
  34.         s/-/(aaaaaaaaa/(a/)/)/{0,1/}/(a*/)/([0-9]*;.*/([0-9]/)/3/5/)/-/2/5/4/
  35.         b loop
  36. }
  37. s/^--/([^;]*/);.*//1/
  38. h
  39. $p
复制代码

这段代码很巧妙，先是将需要相加的2个数字替换成对应的字母a的个数，然后将字母a合并在一起，
        在替换回相加后的结果数字，如果超过10就保留一个a表示进位。
        例如：123 + 456
        那么就先将3和6替换成aaa和aaaaaa，然后合并aaaaaaaaa
        这样在利用lookup table将aaaaaaaaa替换成9，就完成了加法的操作
        如果 125 + 456
        5和6相加最后就会变为a1，字母a回会在计算2加5的时候一并计算
        这样也就实现了进位。

php网页计数器代码 php网页计数器代码
原创粉丝点击
热门IT博客
苹果mac用户名怎么改苹果mac用户名怎么改
win10主题美化软件win10主题美化软件
七天网络阅卷登入账号
python怎么安装
海瑶seo工程师
数据对比分析
二合一沐浴露 知乎
6120ci软件
淘宝客服外包多少提成
淘宝店铺简介显示吗
武汉做网站找互赢网络
淘宝无线端宝贝分类
淘宝怎么绕过实拍保护
mysql数据迁移load
java对象转换成json
守望先锋mac版
飞车帝王数据
oa系统集成阿里云邮箱
神偷4优化补丁
百度贴吧论坛 源码
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 煤矿井下排水泵 惠而浦洗衣机排水泵 排水管材 排水软管 给水排水 h型排水管件 静音排水管材 排水hdpe管件 给排水管材生产厂家 pe给排水管材 同层排水管材管件 压力排水管材 地下排水管道 同层排水管件 pe排水管材价格 pe排水管件价格 排水管件大全 排水管道安装规范 洗衣机排水管更换图解 滚筒洗衣机排水管高度 海尔洗衣机排水管 空调排水管 净水器废水管一直排水 洗衣机接排水管安装步骤图 厕所排水管安装图 厕所排水管 hdpe排水管生产厂家 洗衣机更换排水管 柔性铸铁排水管 排水管图片 排水管配件 排水管价格表 排水管直径 给排水管 排水管规格型号 排水管疏通 家用排水管材料 排水管网 双壁波纹排水管 压力排水管 pe下水管

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里