centos使用代理编译hadoop

centos 编译hadoop 设置代理

1.on  ~/.bashrc

export http_proxy=”http://proxy01.cd.intel.com:911″
export https_proxy=”http://proxy01.cd.intel.com:911″
export ftp_proxy=$http_proxy
export ANT_OPTS=”-Dhttp.proxyHost=proxy01.cd.intel.com -Dhttp.proxyPort=911 -Dhttps.proxyHost=proxy01.cd.intel.com -Dhttps.proxyPort=911″

alias m2proxy=”mvn $ANT_OPTS”
alias m2install=”m2sucks install -DskipTests”
alias m2test=”m2sucks test”

 

2.use the command  “m2proxy” instead of  “mvn”

db_backup

#/bin/bash
mysqldump –user=root –databases blog_sundp_me| gzip > /home/sundp/mysql/blog_sundp_me-`date +%Y%m%d%H%M`.sql.gz
mysqldump –user=root –databases mediawiki| gzip > /home/sundp/mysql/mediawiki-`date +%Y%m%d%H%M`.sql.gz
mysqldump –user=root –databases yourls| gzip > /home/sundp/mysql/yourls-`date +%Y%m%d%H%M`.sql.gz
find /home/sundp/mysql/ -name “*.gz” -mtime +14 -exec /bin/rm {} ;

面试算法题一则

就是给定三个字符串A,B,C;判断C能否由AB中的字符组成,同时这个组合后的字符顺序必须是A,B中原来的顺序,不能逆序;例如:A:mnl,B:xyz;如果C为mnxylz,就符合题意;如果C为mxnzly,就不符合题意,原因是z与y顺序不是B中顺序。

/**
 * User: SunDP
 * Date: 12-12-15
 * Time: 下午11:14
 */
public class StringTest {

    public static void main(String[] args) {
        int flagX = 0, flagY = 0;
        String a = "aaaaaaaa";
        String b = "aaaaaaba";
        String c = "aaaaaaaabaaaaaaa";
        if (a.length() + b.length() != c.length())
            System.out.println(false);
        else
            System.out.println(dsp(flagX, flagY, a, b, c));
    }

    private static boolean dsp(int flagX, int flagY, String a, String b, String c) {
        if (flagX == a.length() && flagY == b.length())
            return true;
        if (flagX != a.length() && a.charAt(flagX) == c.charAt(flagX + flagY))
            if (dsp(flagX + 1, flagY, a, b, c))
                return true;
        if (flagY != b.length() && b.charAt(flagY) == c.charAt(flagX + flagY))
            if (dsp(flagX, flagY + 1, a, b, c))
                return true;
        return false;
    }
}

一道算法题

问题,有两个有序int数组A,B,长度均为k,
求一个新有序数组C,C中元素为A中取一个元素与B中取一个元素的和~
比如
a = {1, 2, 3, 4, 5, 6, 7};
b = {1, 2, 3, 4, 5, 6, 7};

结果为
1+1=2
1+2=3
2+1=3
1+3=4
2+2=4
1+4=5
2+3=5

我的解题思路

设置一组指针数组pointA ,表示A值和B组合以后的位置

pointA[0]=0表示指向a1 b1的点
pointA[3]=4表示指向a4 b5的点
pointA[4]=-1表示a5和任意b的组合都不用考虑

指针不断向下向右走,判断所有指针上点,取个和最小的就是结果

A
^  指针  1   2   3   4   5   6   7  > B
1   0   2   3
2   0   3
3  -1
4  -1
5  -1
6  -1
7  -1

下面附带上我写的代码

/**
 * Created with IntelliJ IDEA.
 * User: SunDP
 * Date: 12-11-6
 * Time: 下午10:44
 * To change this template use File | Settings | File Templates.
 */
public class Sort {

    static int pointRound = 2;

    public static void main(String[] args) {
        int[] a = {1, 2, 3, 5, 7 , 9, 11,15,24,99};
        int[] b = {2, 3, 6, 8, 10, 11,13,17,19,20};
        int[] result = new int[a.length];
        int[] pointA = new int[a.length];
        for (int i = 0; i < a.length; i++) {
            pointA[i] = -1;
        }
        pointA[0] = 0;
        pointA[1] = 0;

        for (int i = 0; i < a.length; i++) {
            compare(pointA, a, b, result, i, pointRound);
        }
    }

    public static void compare(int[] pointA, int[] a, int[] b, int[] result, int round, int tempPointRound) {
        int temp = 10000000;
        int tempPoint = 0;
        for (int i = 0; i < tempPointRound; i++) {
            if (pointA[i] != -1) {
                if (a[i] + b[pointA[i]] < temp) {
                    temp = a[i] + b[pointA[i]];
                    tempPoint = i;
                }
            }
        }
        result[round] = a[tempPoint] + b[pointA[tempPoint]];
        System.out.println(a[tempPoint] + "+" + b[pointA[tempPoint]] + "=" + result[round]);
        if (pointA[tempPoint] == 0 && tempPoint < pointA.length - 1) {
            pointA[tempPoint + 1] = 0;
            pointRound = tempPointRound+1;
        }
        if (pointA[tempPoint] < a.length - 1) {
            pointA[tempPoint]++;
        } else {
            pointA[tempPoint] = -1;
        }
    }
}

这个时间复杂度是k平方,貌似又不是k平方,求高人帮计算~

后续:没事的时候思考了一下,把他想象成一个汉诺塔,塔的编号分别是b0,b1,b2….横竖都是有序的,所以左下角的点一定是最小值,

a6 a6 a6 a6 a6 a6 a6
a5 a5 a5 a5 a5 a5 a5
a4 a4 a4 a4 a4 a4 a4
a3 a3 a3 a3 a3 a3 a3
a2 a2 a2 a2 a2 a2 a2
a1 a1 a1 a1 a1 a1 a1
a0 a0 a0 a0 a0 a0 a0
------------------------------
b0 b1 b2 b3 b4 b5 b6

最小值为a0+b0,将这个值取出,此时计算所有柱子上最底下元素的值,
即a1+b0,a0+b1,a0+b2,a0+b3,a0+b4,a0+b5,a0+b6
此时a0+b1,a0+b2,a0+b3,a0+b4,a0+b5,a0+b6一定是有序的,这时,我们可以看成把a1+b0进行插入排序

a6 a6 a6 a6 a6 a6 a6
a5 a5 a5 a5 a5 a5 a5
a4 a4 a4 a4 a4 a4 a4
a3 a3 a3 a3 a3 a3 a3
a2 a2 a2 a2 a2 a2 a2
a1 a1 a1 a1 a1 a1 a1
a0 a0 a0      a0 a0 a0
——————————
b1 b2 b3 b0 b4 b5 b6

(假设b0+a1的位置在b3+a0和b4+a0之间)

那么此时最小值一定是 a0+b1,在b1中取出a0,再次进行排序,不断执行,直到n次。

算法分析:折半查找时间复杂度是log(n),共要执行n次,所以该算法的时间复杂度是n*log(n)

 

 

 

 

Question 1:

为什么折半查找时间复杂度是log(n):

Answer:

假设对n个元素的折半查找需要消耗的时间为t(n)。容易知道:
如果n = 1,则t(n) = c1
如果n > 1,则t(n) = t(n/2) + c2
其中n/2需要取整,c1、c2都是常数

对于正整数n,可以有:
t(n) = t(n/2) + c2
= t(n/4) + 2*c2
= t(n/8) + 4*c2
= …
= t(n/(2的k次方)) + k*c2
一直推演下去,直到n/(2的k次方)等于1,也就是k = log2(n),此时等式变为:
t(n) = t(1) + k*c2
= c1 + log2(n)*c2

于是时间复杂度为log2(n)。注意log2(n)和log(n)其实是同样的复杂度,因为它们之间仅仅差了一个常量系数而已。

这个是不严格的推导,因为没有考虑整数除以2之后可能有余数的情况。但即使有余数,也是不影响时间复杂度的。

2013新浪哈尔滨笔试总结(转帖)

过程很纠结,估计新浪让很多同学心寒了~不表

笔试题很基础,40道选择,包括Java基础、读程序、数据库基础、linux基础
感觉怎么也能对个30+吧
一道程序设计题
题目大概是这样的 有个Attention类保存的是一个微博用户的关注列表,请你完成这个结构,要求能保存uid(Long)和关注时间,并实现共同关注这个功能SetgetSameAttentions(Attention user1,Attention user2)
但是觉得这题没什么
直接写代码

import java.util.Date;
import java.util.HashMap;

/**
 * Created with IntelliJ IDEA.
 * User: SunDP
 * Date: 用户关注类,Key是uid,Value是关注时间
 */
public class Attention extends HashMap< Long,Date  >{

}
Set< Long > getSameAttentions(Attention user1,Attention user2){
     Set< Long > sameAttentions = new HashSet< Long >();
     for(Long uid : user1.keySet()){
          if(user2.containsKey(uid)){
                sameAttention.add(uid);
          }
     }
     return sameAttetion;
}

结果面试木有进!!
反思啊~~~~~~~~
觉得问题应该出在最后一题上,问题出在哪呢,我猜sina的大大们是不是在考大数据处理的问题捏,比如两个同时有2000个关注的人,但是只有一个相同关注….

一道面试题,连续输入错误5次(转帖)

面试某支付网站:之前还算比较谈得来,都是些项目相关的问题,最后,面试官和蔼地问我这样一个问题:很多银行网站都有这样的功能,一个小时内不能连续输入5次以上错误密码,如果让你去做,如何实现这样的功能。

问题分析:“一个小时内”是这个题比较“阴险”的地方,嘿嘿~我确认了面试官的意思是

1:错误:9:00
2:错误:9:10
3:错误:9:11
4:错误:9:40
5:错误:9:55

这时10点之前输入密码以后都不再去验证~
但是10:10分以后还可以验证一次~

这时就不能单纯地记录次数和过期时间,我的第一反应是每次输入错误都要记录,然后就蒙了~太紧张鸟~ =。=
当时回答的不怎么好,有点丢人~~

下午回到实验室,把思路整理一下

数据库db肯定是要保存每次验证失败的时间了,至少要一个uid和timestamp
Memcached中保存的key应该是用户id,值的话我们想了这样一个结构
“循环队列”(5个节点)

1:错误:9:00
2:错误:9:10
3:错误:9:11
4:错误:9:40
5:错误:9:55

当用户登录时,我们去判断队列是否满了,如果没满,继续登录验证;
如果满了就拿出队列的头,判断是否时间够了一个小时的时间差。如果时间够一个小时了,继续登录验证;否则,直接返回

这就是我设计的结构,使用memcache以后,应该可以支持一定的并发量,欢迎大家拍砖

iptables学习心得

Iptables进程服务命令:

service iptables save 保存iptables设置,对iptables规则编辑后一定要保存。

service iptables restart 保存设置以后不重启则设置不生效,要设置生生效请重启。

service iptables status 检查iptables的设置。类似于iptable –L命令。

Iptables基本的链操作命令:

-L 列出某个链或者表中的规则: service iptables status 把这个命令和-L比较下

iptables –L:显示filter表中的规则等同于iptables –t filter -L

iptables –t nat –L :显示nat表的中的设置:

-F 删除某个链或者表中的规则:

iptables –F (iptables –t filter –F) 删除filter表中的所有规则;

iptables –t nat –F 删除nat表中的所有规则;

iptables –t nat –F POSTROUTING 删除nat表中POSTROUTING链的所有规则;

-A添加一条规则(在当前的规则后添加,也就是排在所有规则后):

iptables -A INPUT –s 192.168.0.1 –j DROP

和实例图中的功能相同,丢弃来自192.168.0.1的数据包,这里省略了-t filter。

添加该语句后,保存设置并重新启动iptalbes 服务,并通过-L的命令查看,就会发现刚添加的这条规则排列在所有规则后。

———–iptables的匹配规则是按顺序排列的。

-I在制定位置插入一条规则:

(如果有回环规则(iptables –A INPUT –I lo –j ACCEPT,则回环永远是第一条)

iptables –I 作为第一条规则插入。

iptables X 作为第X条规则插入,X这里代表规则顺序号。

iptables –A INPUT –p tcp –s 192.168.0.1 –dport 22 –j ACCEPT

允许192.168.0.1 通过22端口访问该主机,把它作为第一条规则插入iptables规则列表。

———–iptables的匹配规则是按顺序排列的。

-P 分配连接策略。

iptables –P INPUT DROP 禁止任何输入的数据包。这句慎用。

iptables –P OUTPUT ACCEPT 允许所有输出的数据包。

-D删除某一条规则:

Iptables –D X 删除某个链的第几条规则

iptables –D INPUT 3 删除INPUT链上的第3条规则。

iptables –P INPUT DROP 这个不能使用删除语句删除,只能到本机输入iptables –P INPUT ACCEPT

Iptables中的匹配:

iptables –A INPUT –p tcp –s 192.168.0.1 –dport 22 –j ACCEPT

这个命令我们在上面已经看过了,我们来看下其他的一些匹配参数。

-p protocol 匹配网络协议,例子中匹配tcp协议。

-s IP地址或者网段 匹配源IP地址或者网段

例子中师匹配一个IP的,如果要匹配一个网段则如下

-s 192.168.0.1/24

如果是除这个网段之外的所有则为:! -s 192.168.0.1/24

如果是除这个IP之外的所有则为:! -s 192.168.0.1

-d IP地址或者网段 匹配目的IP地址或者网段

–dport X 匹配目的端口号,X代表具体端口号。

–sport X 匹配源端口号,X代表具体端口号。

Iptables中的目的:

我们已经在前面看到过-j 后面跟的就是目的。

ACCEPT:允许数据包通过。

DROP:直接丢弃数据包。

REJECT:丢弃数据包,同时发送响应报文通知发送方。

设置Iptables预设规则(本地机防火墙):

1、清除iptables设置:iptables –F

2、设置回环规则,没有这个规则好多服务不能启动:

iptables –A INPUT –i lo –j ACCETP

3、连接跟踪设置:作用允许连线出去后对方主机回应进来的封包。

iptables -A INPUT -m state –state ESTABLISHED,RELATED -j ACCEPT

NEW:想要新建连接的数据包

INVALID:无效的数据包,例如损坏或者不完整的数据包

ESTABLISHED:已经建立连接的数据包

RELATED:与已经发送的数据包有关的数据包

4、iptables -p INPUT DROP 允许进入数据包—-慎用该句。

5、iptables -p FORWARD DROP 禁止转发数据包

6、iptables -P OUTPUT ACCEPT 允许外发数据包

7、设置好以后就可以根据情况开放相应的端口了

iptables –A INPUT –p tcp –dport 20:21 –j ACCEPT 开放FTP的20、21端口。

iptables –A INPUT –P tcp –dport 80 –j ACCEPT 开放http的80端口。

iptables –I INPUT –p tcp –dport 22 –j ACCEPT 开放SSH服务的22端口。

设置Iptables FORWORD规则:

一般情况FORWORD链式DROP的,但是当用来做NAT的时候我们就需要设置他了。

首先要开启转发功能:编辑/etc/sysctl.conf文件

Iptables转发功能(在做NAT时,FORWARD默认规则是DROP时,必须做)

# iptables -A FORWARD -i eth0 -o eth1 -m state –state RELATED,ESTABLISHED -j ACCEPT

# iptables -A FORWARD -i eth1 -o eh0 -j ACCEPT

丢弃坏的TCP包。

#iptables -A FORWARD -p TCP ! –syn -m state –state NEW -j DROP

处理IP碎片数量,防止攻击,允许每秒100个。

#iptables -A FORWARD -f -m limit –limit 100/s –limit-burst 100 -j ACCEPT

设置ICMP包过滤,允许每秒1个包,限制触发条件是10个包。

#iptables -A FORWARD -p icmp -m limit –limit 1/s –limit-burst 10 -j ACCEPT

我在前面只所以允许ICMP包通过,就是因为我在这里有限制。

连接跟踪:提供对数据包“状态”的检查

可以识别的状态:

NEW:想要新建连接的数据包

INVALID:无效的数据包,例如损坏或者不完整的数据包

ESTABLISHED:已经建立连接的数据包

RELATED:与已经发送的数据包有关的数据包

连接跟踪的模块

ip_conntrack_ftp:自动跟踪FTP连接,并自动打开它需要通过防火墙的高端端口。

Ip_conntrack_tftp:和上面功能类似不过是TFTP服务。

Ip_nat_ftp:修改NAT保护的计算机的FTP数据包。

Ip_nat_tftp:和上面类似不是TFTP数据包。

可以通过修改/etc/sysconfig/iptables-config 文件

修改IPTABLES_MODULES=”ip_conntrack_tftp ip_nat_ftp”

也可以通过modprobe ip_conntrack_tftp 不过重启以后将失效。

连接跟踪实例:

允许建立连接:

iptables -A INPUT -m state –state ESTABLISHED,RELATED -j ACCEPT

跟踪规则:

iptables -A INPUT -m state –state NEW -p tcp –dport 25 -j ACCEPT

阻止所有其他进入的链接:

iptables -A INPUT -m state –state NEW -j DROP

NAT网络地址转换:将一个IP转换成另一个 IP(输入和输出)

网络地址转换类型:

目的地 NAT(DNAT):DNAT修改包的目的地位址的时机,必须在包即将被送到本机行程之前,或是要被转送其它电脑之前;所以,使用DNAT为目标的规则,必须设置于nat表格的PREROUTING链结。

源 NAT(SNAT,MASQUERADE):SNAT必须在封包即将离开核心的前一刻,即时修改其来源位址(或通讯端口),所以SNAT规则的设置地点必须是在nat表格的POSTROUTING链结。

NAT实例:

iptables -t nat -A PREROUTING -i ethl -p tcp – -dport 80 -j DNAT – – to -destination 192.168.1.3:8080

把要进入eth1(eth1连接外网)80端口的数据包,重新定向到192.168.1.3的8080端口。

iptables -t nat -A PREROUTING -i eth1 -p tcp –dport 80 -j DNAT

–to-dest 192.168.1.3 –to-dest 192.168.1.4 –to-dest 192.168.1.5

上面这句第一个请求被发到192.168.1.3,第二个发到192.168.1.4如此循环,实现载量平衡。

上面的语句可以使外网的访问内网开通8080端口的WEB 服务器,那么内网的WEB服务器如何将数据传出去呢?这个时候要通过SNAT来实现了。

iptables -t nat -A POSTROUTING -j SNAT

iptables -t nat -A POSTROUTING -j SNAT –to-source 192.168.1.3-192.168.1.9

iptables -t nat -A POSTROUTING -j SNAT –to-source 192.168.1.3:123

iptables -t nat -A POSTROUTING -j SNAT –to-source 192.168.1.3:123-234

iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

第一种方法是直接使用SNAT为目标,这种方法适合用在具有固定IP地址的网关器,另一种方法是使用是使用MASQUERADE为目标,适合用于只有动态IP地址的网关器(例如,使用PPPoE协定的ADSL连线)。由于由于MASQUERADE能够应付网络界面忽然离线,然后以另一个地址恢复上线的情况,所以它转换逻辑比较复杂些,需要耗损比较多的CPU运算能力,因此,如果你有固定的IP地址,就应该尽量使用SNAT来代替MASQUERADE。