以下是小编为大家整理的《算法及其实现》的备课教案（共含12篇），希望对您有所帮助。同时，但愿您也能像本文投稿人“K是朱朱”一样，积极向本站投稿分享好文章。
《算法及其实现》的备课教案
今天,我说课的内容是《信息技术基础（浙江教育出版社）》的第三章第四节内容，本节课为本节内容的第一课时内容包括3.4.1算法和3.4.2算法的表示。我从以下五个方面说明我对本节课的教学设想。
一、教材分析
（一）、教材所处的地位和作用
《算法及其实现》是普通高中课程标准实验教科书——《信息技术基础（浙江教育出版社）》的第三章第四节内容，该教材是按照高中信息技术课程标准编写的实验教材。
本节位于第三章《信息的加工》，学习本节之前，已经学习了利用计算机处理文字、表格、多媒体等信息。通过学习本节内容可以达到“初步掌握用计算机进行信息处理的几种基本方法，认识其工作过程与基本特征”的课程标准要求。
（二）、教学目标
（1）、知识与技能：
A、理解算法的含义；
B、了解算法的特点及表示方法；
C、学会用流程图表示算法。
（2）、过程与方法：
A、能初步利用算法解决简单的问题；
B、培养学生的理论联系实际能力和动手操作能力。
（3）、情感态度与价值观：
A、培养学生学习信息技术课程的兴趣；
B、培养学生主动探究和合作学习的意识和能力。
（三）、教学重点、难点
教学重点：算法的含义、及表示方法
教学难点：用流程图描述算法
二、学情分析
从思维品质上来说：高一学生已有使用计算机的感性经验，已经可以超越简单的技术操作，具备了接受更高层面文化的能力。学生的思维能力已接近成人，他们有旺盛的求知欲，较高的学习自觉性，并具备一定的自学能力，已具有较强抽象思维和逻辑推理能力。
从知识储备上来说：经过前面的学习，学生已经可以使用计算机处理一些实际问题，例如：利用计算机对文字、图片、多媒体信息的处理，但是学生还不了解了使用计算机解决问题的一般过程和解决方法，以及以何种方式来表示。
三、教法、学法分析
1、学案导学，自主学习
2、问题导入，激情引趣。
3、创设情境，任务驱动。
4、合作探究，交流提高。
四、教学过程分析
1、回顾已学，导入新课 回顾前面知识，提出疑问，引出本节内容。
2、完成游戏，引发兴趣 让同学小组合作完成“老农过河”的游戏，体验编写算法的乐趣，引起探究新知的兴趣。
3、自学新知，完成学案 根据学案的内容，教师引导学生自学新知，完成学案中内容。
4、强化练习，巩固提高 填写学案后，学生学会了如何使用流程图描述算法，紧接着安排练习，任务驱动。让学生在练习中巩固提高。
5、布置作业，拓展延伸 布置作业分为课内作业和课外拓展，让不同层次的学生能完成相应的作业。同时，为下一节的内容做好准备。
五、教学设计分析：
1、本节课的设计是围绕“以学生为主体，让学生动起来”的`思想，创设各种情境，设置多层次任务，让学生自主学习，主动探究。让学生真正成为学习的主人，而教师只起到主导的作用。
2、学案导学是本节课的一个特点。学生手中有学案，犹如学生有了一个学习的提纲，只要老师稍作引导，学生就会自主的完成学习任务，而不用像以前的教学一样学生总是等待老师讲解，也不会出现只要老师不讲，学生便无事可做的现象。
3、本节练习的设置体现梯度，让学生便于接受和乐于接受。因为流程图对于学生来说是新知识，不可能一下就应用熟练，这就需要在设置练习题上下功夫，我设计了三道练习题，第一道老师讲解，第二道学生自主完成，第三道老师讲解和学生完成相结合。三道题目的设置由易到难，而如果像课本一样只练习最后一道题，不但练习不够，而且难度增大，降低学习的效果。
-03-03python局部赋值的规则
-02-02python发布模块的步骤分享
2014-03-03Python 列表(List)操作方法详解
2014-02-02go和python调用其它程序并得到程序输出
2014-04-04python中的实例方法、静态方法、类方法、类变量和实例变量浅析
2014-05-05Python random模块（获取随机数）常用方法和使用例子
-12-12python cookielib 登录人人网的实现代码
-09-09Python httplib，smtplib使用方法
2013-11-11pyramid配置session的方法教程
2014-03-03python实现k均值算法示例(k均值聚类算法)
用python实现的去除win下文本文件头部BOM
Python实现的金山快盘的签到程序
python操作MySQL数据库具体方法
python操作日期和时间的方法
删除目录下相同文件的python代码(逐级优化
python 中的列表解析和生成表达式
Python实例分享：快速查找出被挂马的文件
python列表去重的二种方法
python查找第k小元素代码分享
Python 网络编程说明
Python入门教程 超详细1小时学会
python 中文乱码问题深入分析
比较详细Python正则表达式操作指
Python字符串的encode与decode研
Python open读写文件实现脚本
Python enumerate遍历数组示例应
Python 深入理解yield
Python+Django在windows下的开发
python 文件和路径操作函数小结
python 字符串split的用法分享
作者：atupal 字体：[增加 减小] 类型：
这篇文章主要介绍了python简单实现基数排序算法,仅用4行代码即可实现基数排序算法,非常简单实用,需要的朋友可以参考下
本文实例讲述了python简单实现基数排序算法，分享给大家供大家参考。具体实现方法如下：
from random import randintdef main: A = [randint(1, 99999999) for _ in xrange(9999)] for k in xrange(8): S = [ [] for _ in xrange(10)] for j in A:S[j / (10 ** k) % 10].append(j) A = [a for b in S for a in b] for i in A: print imain()
希望本文所述对大家的Python程序设计有所帮助，
-01-01python调用cmd命令行制作刷博器
-10-10python笔记（1） 关于我们应不应该继续学习python
2014-01-01python文件比较示例分享
-11-11python中文乱码的解决方法
2014-06-06测试、预发布后用python检测网页是否有日常链接
2014-02-02Python操作列表的常用方法分享
2014-06-06用python登录Dr.com思路以及代码分享
2013-11-11pyramid配置session的方法教程
2014-01-01python学习手册中的python多态示例代码
2014-01-01Python中for循环详解
Python操作Mysql实例代码教程在线版(查询
python中的对象拷贝示例 python引用传递
python类定义的讲解
windows系统中python使用rar命令压缩多个
php使用递归与迭代实现快速排序示例
教你安装python Django（图文）
python目录操作之python遍历文件夹后将结
linux系统使用python监测网络接口获取网络
python self,cls,decorator的理解
Python 字符串操作方法大全
Python入门教程 超详细1小时学会
python 中文乱码问题深入分析
比较详细Python正则表达式操作指
Python字符串的encode与decode研
Python open读写文件实现脚本
Python enumerate遍历数组示例应
Python 深入理解yield
Python+Django在windows下的开发
python 文件和路径操作函数小结
python 字符串split的用法分享
Josephus定义：假设N个人编号1－N，围成圈，从1号开始报数，报到M时，此人退出，然 后继续从1开始报数，直到所有人退出为止。简单的实现是使用循环单链表，设置一个计数器 count，当count == M ，删除当前节点，并将count重置。
假设M = 9,N = 5;
这里有两处地方可以优化：
1.当M>N时，取M`= M mod N，即M` = 9 % 5 = 4；报数到9与报数到4效果一致，但少遍历一次链表；
2.当M` >N / 2时，可逆 向走N - M' + 1步，此时反向走比正向走距离更近，但需要将数据结构设置为循环双链 表。
对于M = 9,N = 5，实现优化后流程如下：
---
链表:1 2 3 4 5
N = 5
M` = 9 mod 5 = 4
M` = 4 >N / 2 = 2
反走(5 - 4 + 1) = 2 步，删除节点4，此时起点在节点3;
---
链表:1 2 3 5
N = 4
M` = 9 mod 4 = 1
M' = 1 < N / 2 = 2
正走1步，删除节点5，此时起点在节点3;
---
链 表:1 2 3
N = 3
M` = 9 mod 3 = 0
M` = 0 < N / 2 = 1
正走0步，删除节点3，此时起点在节点2;
---
链表:1 2
N = 2
M` = 9 mod 2 = 1
M` = 1 = N / 2 = 1
正 走1步，删除节点1，此时起点在节点2;
---
链表:2
N = 1
M` = 9 mod 1 = 0
M` = 0 = N / 2 = 0
正走0步，删除节点2，此时 链表空;
算法C实现：
#include
#include “dlinkedlist.h”
#define SIZE 5
#define N SIZE
#define M 9
static List init;
void print(List l);
void process(List l);
int main()
{
List josephus = init();
print (josephus);
process(josephus);
return 0;
}
/* 初始化链表 */
static List init()
{
int i;
List josephus = CreateList(1);
Position p = josephus;
for (i = 2; i <= SIZE; i++)
{
Insert(i, josephus, p);
p = NextPosition(p);
}
return josephus;
}
/* 打印链表 */
void print(List l)
{
if (l == NULL)
return;
printf (“%d ”,Retrieve(l));
Position p = NextPosition(l);
while (p != l)
{
printf(“%d ”,Retrieve(p));
p = NextPosition(p);
}
printf(“n”);
}
/* Josephus处理 */
void process(List l)
{
int n = N;
int m = M % n;
int i;
Position p = l;
while (n >1)
{
if (m >n / 2)
{
for (i = 0; i < n - m + 1; i++)
p = PreviousPosition(p);
}
else
{
for (i = 0; i < m; i++)
p = NextPosition(p);
}
p = PreviousPosition(p);
printf (“%d outn”,Retrieve(NextPosition(p)));
Remove (NextPosition(p), &l);
n--;
m = M % n;
printf(“current: ”);
print(l);
}
}
测试结果：
1 2 3 4 5
4 out
current: 1 2 3 5
5 out
current: 1 2 3
3 out
current: 1 2
1 out
current: 2
这里给出循环双链表数据结构 ADT和实现
假定链表不带哨兵节点，
dlinkedlist.h
typedef int ElementType;
#ifndef DLINKEDLIST_H_INCLUDED
#define DLINKEDLIST_H_INCLUDED
struct Node;
typedef struct Node *PtrToNode;
typedef PtrToNode List;
typedef PtrToNode Position;
List CreateList (ElementType X);
void DisposeList(List L);
int IsEmpty(List L);
int IsLast(Position P, List L);
Position Find(ElementType X, List L);
void Delete(ElementType X, List L);
void Remove(Position P, List * L);
void Insert(ElementType X, List L, Position P);
void DeleteList(List L);
Position NextPosition(Position P);
Position PreviousPosition (Position P);
ElementType Retrieve(Position P);
#endif // DLINKEDLIST_H_INCLUDED
fatal.h
#ifndef FATAL_H_INCLUDED
#define FATAL_H_INCLUDED
#include
#include
#define Error(Str) FatalError(Str)
#define FatalError(Str) fprintf(stderr, “%sn”, Str), exit(1)
计算法简单实现crc校验
前一段时间做协议转换器的时间用到CRC-16校验，查了不少资料发现都不理想。查表法要建表太麻烦，而计算法觉得那些例子太罗嗦。最后只好自己写了，最后发现原来挺简单嘛：）两个子程序搞定。这里用的多项式为：
CRC-16 = X16 + X12 + X5 + X0 = 2^0+2^5+2^12+2^16=0x11021
因最高位一定为“1”，故略去计算只采用0x1021即可
CRC_Byte：计算单字节的CRC值
CRC_Data：计算一帧数据的CRC值
CRC_High CRC_Low：存放单字节CRC值
CRC16_High CRC16_Low：存放帧数据CRC值
;-------------------------------------------------------------
; Function: CRC one byte
; Input: CRCByte
; Output: CRC_High CRC_Low
;-------------------------------------------------------------
CRC_Byte:
clrf CRC_Low
clrf CRC_High
movlw 09H
movwf v_Loop1
movf CRCByte, w
movwf CRC_High
CRC:
decfsz v_Loop1 ；8次循环，每一位相应计算
goto CRC10
goto CRCend
CRC10
bcf STATUS, C
rlf CRC_Low
rlf CRC_High
btfss STATUS, C
; goto CRC ；为0不需计算
movlw 10H ;若多项式改变，这里作相应变化
xorwf CRC_High, f
movlw 21H ;若多项式改变，这里作相应变化
xorwf CRC_Low, f
goto CRC
CRCend:
nop
nop
return
;-------------------------------------------------------------
; CRC one byte end
;-------------------------------------------------------------
;-------------------------------------------------------------
; Function: CRC date
; Input: BufStart(A,B,C)（一帧数据的起始地址） v_Count （要做CRC的字节数）
; Output: CRC16_High CRC16_Low（结果）
;-------------------------------------------------------------
CRC_Data:
clrf CRC16_High
clrf CRC16_Low
CRC_Data10
movf INDF, w
xorwf CRC16_High,w
movwf &nb
sp; CRCByte
call CRC_Byte
incf FSR
decf v_Count ;需计算的字节数
movf CRC_High, w
xorwf CRC16_Low, w
movwf CRC16_High
movf CRC_Low, w
movwf CRC16_Low
movf v_Count, w ；计算结束？
btfss STATUS, Z
goto CRC_Data10
return
;-------------------------------------------------------------
; CRC date end
;-------------------------------------------------------------
说明： CRC 的计算原理如下（一个字节的简单例子）
11011000 00000000 00000000 <- 一个字节数据, 左移 16b
^10001000 00010000 1 <- CRC-CCITT 多项式, 17b
--------------------------
1010000 00010000 10 <- 中间余数
^1000100 00001000 01
-------------------------
10100 00011000 1100
^100
01 00000010 0001
-----------------------
101 00011010 110100
^100 01000000 100001
---------------------
1 01011010 01010100
^1 00010000 00100001
-------------------
01001010 01110101 <- 16b CRC
仿此，可推出两个字节数据计算如下：d 为数据，p 为项式，a 为余数
dddddddd dddddddd 00000000 00000000 <- 数据 D ( D1, D0, 0, 0 )
^pppppppp pppppppp p <- 多项式 P
-----------------------------------
...
aaaaaaaa aaaaaaaa 0 <- 第一次的余数 A’ ( A’1, A’0 )
^pppppppp pppppppp p
--------------------------
...
aaaaaaaa aaaaaaaa <- 结果 A ( A1, A0 )
由此与一字节的情况比较，将两个字节分开计算如下：
先算高字节：
dddddddd 00000000 00000000 00000000 <- D1, 0, 0, 0
^pppppppp pppppppp p <- P
-----------------------------------
...
aaaaaaaa aaaaaaaa <- 高字节部分余数 PHA1, PHA0
此处的部分余数与前面两字节算法中的第一次余数有如下关系，即 A’1 = PHA1 ^ D0, A’0 = PHA0：
aaaaaaaa aaaaaaaa <- PHA1, PHA0
^d
ddddddd <- D0
-----------------
aaaaaaaa aaaaaaaa <- A’1, A’0
低字节的计算：
aaaaaaaa 00000000 00000000 <- A’1, 0, 0
^pppppppp pppppppp p <- P
--------------------------
...
aaaaaaaa aaaaaaaa <- 低字节部分余数 PLA1, PLA0
^aaaaaaaa <- A’0 ， 即 PHA0
-----------------
aaaaaaaa aaaaaaaa <- 最后的 CRC ( A1, A0 )
总结以上内容可得规律如下：
设部分余数函数
PA = f( d )
其中 d 为一个字节的数据（注意，除非 n = 0 ，否则就不是原始数据，见下文）
第 n 次的部分余数
PA( n ) = ( PA( n - 1 ) << 8 ) ^ f( d )
其中的
d = ( PA( n - 1 ) >> 8 ) ^ D( n )
其中的 D( n ) 才是一个字节的原始数据。
公式如下：
PA( n ) = ( PA( n - 1 ) << 8 ) ^ f( ( PA( n - 1 ) >> 8 ) ^ D( n ) )
可以注意到函数 f( d ) 的参数 d 为一个字节，对一个确定的'多项式 P， f( d ) 的返回值 是与 d 一一对应的，总数为 256 项，将这些数据预先算出保存在表里，f( d )就转换为一 个查表的过程，速度也就可以大幅提高，这也就是查表法计算 CRC 的原理。
再来看 CRC 表是如何计算出来的，即函数 f( d ) 的实现方法。分析前面一个字节数据的 计算过程可发现，d 对结果的影响只表现为对 P 的移位异或，看计算过程中的三个 8 位 的列中只低两个字节的最后结果是余数，而数据所在的高&nbs
p;8 位列最后都被消去了，因其 中的运算均为异或，不产生进位或借位，故每一位数据只影响本列的结果，即 d 并不直接 影响结果。再将前例变化一下重列如下：
11011000
--------------------------
10001000 00010000 1 // P
^ 1000100 00001000 01 // P
^ 000000 00000000 000 // 0
^ 10001 00000010 0001 // P
^ 0000 00000000 00000 // 0
^ 100 01000000 100001 // P
^ 00 00000000 0000000 // 0
^ 1 00010000 00100001 // P
-------------------
01001010 01110101
现在的问题就是如何根据 d 来对 P 移位异或了，从上面的例子看，也可以理解为每步 移位，但根据 d 决定中间余数是否与 P 异或。从前面原来的例子可以看出，决定的条件是中间余数的最高位为0，因为 P 的最高位一定为1，即当中间余数与 d 相应位异或的最高位为1时，中间余数移位就要和 P 异或，否则只需移位即可。其方法如下例（上例的变形，注意其中空格的移动表现了 d 的影响如何被排除在结果之外）：
d --------a--------
1 00000000 00000000 <- HSB = 1
0000000 000000000 <- a <<= 1
0001000 000100001 <-不含最高位的 1
-----------------
1 0001000 000100001
001000 0001000010
000100 0000100001
-----------------
0 001100 0001100011 <- HSB = 0
01100 00011000110
-----------------
1 01100 00011000110 <- HSB = 1
1100 000110001100
0001 000000100001
-----------------
1 1101 000110101101 <- HSB = 0
101 0001101011010
-----------------
0 101 0001101011010 <- HSB = 1
&nb
sp; 01 00011010110100
00 01000000100001
-----------------
0 01 01011010010101 <- HSB = 0
1 010110100101010
-----------------
0 1 010110100101010 <- HSB = 1
0101101001010100
0001000000100001
-----------------
0100101001110101 <- CRC
结合这些，前面的程序就好理解了。
DLG内插等高线算法实现
本文针对DLG(Digital Line Graphic,数字线划地图)编辑过程中出现的等高线残缺,以及手绘实测等高线效率较低等问题,提出了一种用于地图编辑的等高线内插算法.文中介绍了算法的原理、实现,以及在编辑中可能遇到几种情况的'处理.算法充分利用了等高线相关知识,速度快、操作简单,内插出的等高线质量较高,且本算法已经用VC++6.0编程实现并作为地图编辑软件DLGMate的一个重要模块,投入实际应用.
作 者：曹颖 赵牡丹 CAO Ying ZHAO Mu-dan 作者单位：西北大学城市与资源学系,西安,710069 刊 名：测绘科学 ISTIC PKU英文刊名：SCIENCE OF SURVEYING AND MAPPING 年，卷(期)： 32(2) 分类号：P282 关键词：等高线 数字线划图 内插DES算法实现过程分析
1. 处理密钥:1.1 从用户处获得64位密钥.(每第8位为校验位,为使密钥有正确的奇偶校验,每个密钥要有奇 数个”1”位.(本文如未特指，均指二进制位)
1.2 具体过程:
1.2.1 对密钥实施变换,使得变换以后的密钥的各个位与原密钥位对应关系如下表所示:
表一为忽略校验位以后情况
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
20 21 22 23 24 25 26 27 28
57 49 41 33 25 17 9 1 58 50 42 34 26 18 10 2 59 51
43 35 27 19 11 3 60 52 44 36
29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
46 47 48 49 50 51 52 53 54 55 56
63 55 47 39 31 23 15 7 62 54 46 38 30 22 14 6 61
&nbs
p;53 45 37 29 21 13 5 28 20 12 4
1.2.2 把变换后的密钥等分成两部分,前28位记为C[0], 后28位记为D[0].
1.2.3 计算子密钥(共16个)， 从i=1开始。
1.2.3.1 分别对C[i-1],D[i-1]作循环左移来生成C[i],D[i].(共16次)。每次循环左移位数
如下表所示：
循环次数 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
左移位数 1 1 2 2 2 2 2 2 1 2 2 2 2 2 2 1
1.2.3.2 串联C[i],D[i]，得到一个56位数，然后对此数作如下变换以产生48位子密钥K[i]。
变换过程如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
17 18 19 20 21 22 23 24
14 17 11 24 1 5 3 28 15 6 21 10 23 19 12
4 26 8 16 7 27 20 13 2
25 26 27 28 29 30 31 &nbs
p; 32 33 34 35 36 37 38 39
40 41 42 43 44 45 46 47 48
41 52 31 37 47 55 30 40 51 45 33 48 44 49
39 56 34 53 46 42 50 36 29 32
1.2.3.3 按以上方法计算出16个子密钥。
2．对64位数据块的处理：
2．1 把数据分成64位的数据块，不够64位的以适当的'方式填补。
2．2对数据块作变换。
bit goes to bit bit goes to bit
58 1 57 33
50 2 49 34
42 3 41 35
34 4 33 36
26 5 25 37
18 6 17 38
10 7 9 39
2 8 1 40
60 9 59 41
52 10 51 42
44 11 43
43
36 12 35 44
28 13 27 45
20 14 19 46
12 15 11 47
4 16 3 48
62 17 61 49
54 18 53 50
46 19 45 51
38 20 37 52
30 21 29 53
22 22 21 54
14 23 13 55
6 24 5 56
64 25 63 57
56 26 55 58
48 27 47 59
40 28 39 60
32 29 31 61
24 30 23 62
16 31
15 63
8 32 7 64
2．3 将变换后的数据块等分成前后两部分，前32位记为L[0],后32位记为R[0]。
2．4 用16个子密钥对数据加密。
2．4．1 根据下面的扩冲函数E，扩展32位的成48位
bit goes to bit bit goes to bit bit goes to bit bit goes to bit
32 1 8 13 16 25 24 37
1 2 9 14 17 26 25 38
2 3 10 15 18 27 26 39
3 4 11 16 19 28 27 40
4 5 12 17 20 29 28 41
5 6 13 18 21 30 29 42
4 7
; 12 19 20 31 28 43
5 8 13 20 21 32 29 44
6 9 14 21 22 33 30 45
7 10 15 22 23 34 31 46
8 11 16 23 24 35 32 47
9 12 17 24 25 36 1 48
2．4．2 用E{R[i-1]}与K[i]作异或运算。
2．4．3 把所得的48位数分成8个6位数。1-6位为B[1]，7-12位为B[2],……43-48位为B[8]。
2．4．4 用S密箱里的值替换B[j]。从j=1开始。S密箱里的值为4位数，共8个S密箱
2．4．4．1 取出B[j]的第1和第6位串联起来成一个2位数，记为m.。m即是S密箱里用来替换
B[j]的数所在的列数。
2．4．4．2 取出B[j]的第2至第5位串联起来成一个4位数，记为n。n即是S密箱里用来替换
B[j]的数所在的行数。
2．4．4．3 用S密箱里的值S[j][ m][ n]替换B[j]。8个S密箱如下所示：
--------
S-BOXES1
Binary d1d6 => 00 01 10 11
\/ d2..d5 \/ Dec 0 1
; 2 3
0000 0 14 0 4 15
0001 1 4 15 1 12
0010 2 13 7 14 8
0011 3 1 4 8 2
0100 4 2 14 13 4
0101 5 15 2 6 9
0110 6 11 13 2 1
0111 7 8 1 11 7
1000 8 3 10 15 5
1001 9 10 6 12 11
1010 10 6 12 9 3
1011 11 12 11 7 14
1100 12 5 9 3 10
1101 13 9 5 10 0
1110 14 0 3 5 6
1111
15 7 8 0 13
--------
S-BOXES2
binary d1d6 => 00 01 10 11
\/ d2..d5 \/ dec 0 1 2 3
0000 0 15 3 0 13
0001 1 1 13 14 8
0010 2 8 4 7 10
0011 3 14 7 11 1
0100 4 6 15 10 3
0101 5 11 2 4 15
0110 6 3 8 13 4
0111 7 4 14 1 2
1000 8 9 12 5 11
1001 9 7 0 8 6
1010 10 2 1 12 7
1011 11 13 10 6 12
1100 12 12
6 9 0
1101 13 0 9 3 5
1110 14 5 11 2 14
1111 15 10 5 15 9
--------
S-BOXES3
binary d1d6 => 00 01 10 11
\/ d2..d5 \/ dec 0 1 2 3
0000 0 10 13 13 1
0001 1 0 7 6 10
0010 2 9 0 4 13
0011 3 14 9 9 0
0100 4 6 3 8 6
0101 5 3 4 15 9
0110 6 15 6 3 8
0111 7 5 10 0 7
1000 8 1 2 11 4
1001 9 13 8 1 &
nbsp; 15
1010 10 12 5 2 14
1011 11 7 14 12 3
1100 12 11 12 5 11
1101 13 4 11 10 5
1110 14 2 15 14 2
1111 15 8 1 7 12
--------
S-BOXES4
binary d1d6 => 00 01 10 11
\/ d2..d5 \/ dec 0 1 2 3
0000 0 7 13 10 3
0001 1 13 8 6 15
0010 2 14 11 9 0
0011 3 3 5 0 6
0100 4 0 6 12 10
0101 5 6 15 11 1
0110 6 9 0 7 13
0111 7
python基础入门详解(文件输入/输出 内建类
Python实现的金山快盘的签到程序
python中的yield使用方法
一个简单的python程序实例(通讯录)
python基础教程之基本内置数据类型介绍
Python删除指定目录下过期文件的2个脚本分
pycharm 使用心得（五）断点调试
python pickle 和 shelve模块的用法
python中的实例方法、静态方法、类方法、
python将xml xsl文件生成html文件存储示例
Python入门教程 超详细1小时学会
python 中文乱码问题深入分析
比较详细Python正则表达式操作指
Python字符串的encode与decode研
Python open读写文件实现脚本
Python enumerate遍历数组示例应
Python 深入理解yield
Python+Django在windows下的开发
python 文件和路径操作函数小结
python 字符串split的用法分享
python 实现堆排序算法代码
linux系统使用python监测系统负载脚本分享
python线程池的实现实例
win7安装python生成随机数代码分享
Python Web框架Pylons中使用MongoDB的例子
Python设计模式之单例模式实例
Python 错误和异常小结
python实现猜数字游戏(无重复数字)示例分
Python的print用法示例
python抓取京东商城手机列表url实例代码
Python入门教程 超详细1小时学会
python 中文乱码问题深入分析
比较详细Python正则表达式操作指
Python字符串的encode与decode研
Python open读写文件实现脚本
Python enumerate遍历数组示例应
Python 深入理解yield
Python+Django在windows下的开发
python 文件和路径操作函数小结
python 字符串split的用法分享
★ 备课教案
★ 高中生物备课教案
★ 高中历史备课教案
★ 初中英语备课教案
★ 高中英语备课教案
★ 初中历史备课教案
★ 初一英语备课教案
★ 坐井观天备课教案
★ 初三化学备课教案
