月份:2017年4月

SBOX_TESTTOOL

SBOX_TESTTOOL

最近给一个比赛写的,不过有不少地方没处理好感觉

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TestProject
{
    class TestTool
    {
        private UInt32[] SBOX;
        public TestTool(UInt32[] Sbox)
        {
            SBOX = new UInt32[256];
            try
            {
                Sbox.CopyTo(SBOX, 0);
            }
            catch
            {
                throw new Exception("Data Copy Error");
            }
        }
        public class NonlinearDegree
        {
            UInt32[] Table = new UInt32[256];
            void SetTable()
            {
                UInt32 flag;
                for (UInt32 i = 0; i < 256; i++)
                {
                    flag = i;
                    for (int j = 0; j < 8; j++)
                    {
                        if (((flag >> j) & 0x01) != 0)
                        {
                            Table[i]++;
                        }
                    }
                }
            }
            public UInt32 Test(UInt32[] SBOX)
            {
                UInt32 U, A, x, b, temp, nonlin = 256;
                SetTable();
                for (U = 1; U < 256; U++)
                {
                    for (A = 1; A < 256; A++)
                    {
                        for (b = 0; b < 2; b++)
                        {
                            temp = 0;
                            for (x = 0; x < 256; x++)
                            {
                                if (((Table[x & A] + b) % 2) != (Table[SBOX[x] & U] % 2))
                                {
                                    temp++;
                                }
                                
                            }
                            if (nonlin > temp)
                            {
                                nonlin = temp;
                            }
                        }

                    }
                }
                return nonlin;
            }
        }
        public class FixedPoint
        {
            public UInt32 Test(UInt32[] SBOX)
            {
                UInt32 count = 0;
                for (int i = 0; i < 256; i++)
                {
                    if (SBOX[i] == i)
                    {
                        count++;
                    }
                }
                return count;
            }
        }
        public class DifferentialUniform
        {
            UInt32[,] DTable = new UInt32[256, 256];
            public UInt32 Test(UInt32[] SBOX)
            {
                UInt32 differ = 0;
                DTable[0, 0] = 256;
                for (int alpha = 1; alpha < 256; alpha++)
                {
                    for (int x = 0; x < 256; x++)
                        DTable[alpha, SBOX[x] ^ SBOX[x ^ alpha]]++;
                    for (int x = 0; x < 256; x++)
                        if (DTable[alpha, x] > differ)
                            differ = DTable[alpha, x];
                }
                return differ;
            }
        }
        public class AlgebraDegree
        {
            UInt32[] Table = new UInt32[256];
            void SetTable()
            {
                int flag;
                for (int i = 0; i < 256; i++)
                {
                    flag = i;
                    for (int j = 0; j < 8; j++)
                    {
                        if (((flag >> j) & 0x01) != 0)
                        {
                            Table[i]++;
                        }
                    }
                }
            }
            public UInt32 Test(UInt32[] SBOX)
            {
                UInt32 Degree = 0;
                int[,] function = new int[8, 256];
                SetTable();
                for (int flag = 0; flag < 8; flag++)
                {
                    int[] term = new int[256];
                    UInt32 degree = 0;
                    for (int X = 0; X < 256; X++)
                    {
                        for (int a = 0; a < 256; a++)
                        {
                            if (((SBOX[a] >> flag) & 0x01) != 0)
                            {
                                int temp = 0x01;
                                for (int x = 0; x < 8; x++)
                                {
                                    if (((~X >> x) & 0x01) != 0)
                                    {
                                        if (((a >> x) & 0x01) != 0)
                                        {
                                            temp = 0x00;
                                            break;
                                        }
                                    }
                                }
                                term[X] ^= temp;
                            }
                        }
                        function[flag, X] = term[X];
                    }
                    for (int i = 0; i < 256; i++)
                    {
                        if ((function[flag, i] == 0x01) && (Table[i] > degree))
                            degree = Table[i];
                        if (Degree < degree)
                            Degree = degree;
                    }
                }
                return Degree;
            }

        }
        public class IterativePeriod
        {
            public UInt32[] Test(UInt32[] SBOX)
            {
                UInt32 temp;
                int[] js = new int[8];
                UInt32[] ot = new UInt32[256];
                for (int i = 0; i < 256; i++)
                {
                    temp = SBOX[i];
                    do
                    {
                        temp = SBOX[temp];
                        ot[i]++;
                    } while (temp != SBOX[i]);
                }
                return ot;
            }
        }
        public class Robust
        {
            UInt32[,] DTable = new UInt32[256, 256];
            public double Test(UInt32[] SBOX)
            {
                int num = 0;
                UInt32 max = 0;
                double robustdegree = 0;
                DTable[0, 0] = 256;
                for (int alpha = 1; alpha < 256; alpha++)
                {
                    for (int x = 0; x < 256; x++)
                        DTable[alpha, SBOX[x] ^ SBOX[x ^ alpha]]++;
                    for (int x = 0; x < 256; x++)
                        if (DTable[alpha, x] > max)
                            max = DTable[alpha, x];
                }
                for (int i = 0; i < 256; i++)
                    if (DTable[i, 0] != 0) num++;
                robustdegree = ((1 - (num + 0.0) / 256) * (1 - (max + 0.0) / 256));
                return robustdegree;
            }           
        }
        public class Balance
        {
            UInt32[] Table = new UInt32[256];
            void SetTable()
            {
                int flag;
                for (int i = 0; i < 256; i++)
                {
                    flag = i;
                    for (int j = 0; j < 8; j++)
                    {
                        if (((flag >> j) & 0x01) != 0)
                        {
                            Table[i]++;
                        }
                    }
                }
            }
            public bool Test(UInt32[] SBOX)
            {
                SetTable();
                int testnum = 0xFF;
                UInt32 count = 0;
                for (int i = 0; i < 256; i++)
                    count += Table[testnum & SBOX[i]];
                if (count - 1024 != 0) return false;
                else return true;
            }
        }
        public class StrictAvalancheCriterion
        {
            public double[,] sac = new double[8, 8];
            public void Test(UInt32[] SBOX)
            {
                int n = 8;
                int i, j, k, bt, nN, sx, sy;
                //double[,] sac = new double[8, 8];
                int[] js = new int[8];
                bt = 1;
                nN = (int)Math.Pow(2, n);
                for (i = 0; i < n; i++)
                {
                    for (k = 0; k < n; k++) js[k] = 0;
                    for (j = 0; j < nN; j++)
                    {
                        sx = (int)SBOX[j];
                        sy = (int)SBOX[j ^ bt];
                        for (k = 0; k < n; k++) if ((sx >> k & 1) != (sy >> k & 1)) js[k]++;
                    }
                    bt <<= 1;
                    for (k = 0; k < n; k++) sac[i, k] = (js[k] * 1.0) / 256;
                }
            } 
        }
    }
}

[LeetCode]Encode and Decode TinyURL

[LeetCode]Encode and Decode TinyURL

很简单
dictionary就可以了

	public class Codec
	{
		Dictionary<string,string> dictUrl = new Dictionary<string,string> ();
		List<char> charSet = new List<char> ();

		public Codec ()
		{
			for (int i = 65; i <= 90; i++) {
				charSet.Add ((char)i);
			}
			for (int i = 97; i <= 122; i++) {
				charSet.Add ((char)i);
			}
			for (int i = 48; i <= 57; i++) {
				charSet.Add ((char)i);
			}
		}
		//EUREKA
		private string genUrl ()
		{
			Random rand = new Random ();
			string subUrl = "";
			for (int i = 0; i < 6; i++) {
				subUrl += charSet [rand.Next () % (charSet.Count)];
			}
			return "http://tinyurl.com/" + subUrl;
		}
		// Encodes a URL to a shortened URL
		public string encode (string longUrl)
		{
			if (dictUrl.ContainsKey (longUrl))
				return dictUrl [longUrl];
			while (true) {
				string shortUrl = genUrl ();
				if (dictUrl.ContainsValue (shortUrl))
					continue;
				else {
					dictUrl.Add (longUrl, shortUrl);
					break;
				}
			}
			return dictUrl [longUrl];
		}

		// Decodes a shortened URL to its original URL.
		public string decode (string shortUrl)
		{
			if (!dictUrl.ContainsValue (shortUrl))
				return "";
			foreach (var temp in dictUrl) {
				if (temp.Value == shortUrl)
					return temp.Key;
			}
			return "";
		}
	}
Stand Alone Complex

Stand Alone Complex

突然想写这篇文章,大概不仅仅是“写写攻壳机动队动漫相关的思考?”这一句话产生的动力。
真人版电影是昨天看的。不得不承认,在动作戏方面,电影相对于动画有着先天的优势,再加上梦工厂的实力,的确是远远超过了原版动画的水平,单看动作场景,甚至可以给出一个不错的分数。然而原著的名字叫做攻壳机动队,它不是一部动作片。
电影外在的部分,的确是非常优秀的。角色辨识度很高,看过动画的话基本一眼都能认出来。而原作中城市中cyberpunk风格也体现得淋漓尽致,颓败的大楼上闪动的全息投影广告和川流在楼宇之间的未来汽车。加上一些场景和原作相比的高度还原:少佐的跳楼,隐身追逐战,潜水,手撕机甲。这些方面来说电影的确是相当精细,也让我们这些老粉有一种不一样的体验。尽管如此,作为一部商业电影,却不得不砍掉原作的一些深度来迎合更为普遍的观影人群,诚然,在电影不到两个小时的时间中要达到押井守和神山动画那样的高度是非常困难的,也是不公平的,对世界观的刻画自然是远不如动画那样入木三分,这也是让动画粉有些失望的地方。此外,全篇最大的问题在于文化的杂糅,在一个设定为日本的世界中,素子可以无缝使用英语和荒卷这样一个典型日本老头交流,而日式的文化和环境中听着英语和日语混杂的对话也是让人觉得尴尬不堪。对于普通观众而言,他们希望看到的精彩打斗和特技都看到了,电影本身的目的也达到了。而在原作中协同合作的、每个人都有各自过去和性格的九课被一笔带过,陀古萨作为唯一全身人类的存在的特异性和在团队中的作用也没有很好地体现出来。而作为AI觉醒的傀儡王,也因篇幅改成了素子的邻家小哥。而本身原作中有黑有白的角色们,在电影中却被明显划了一条线。
攻壳机动队的核心是ghost in the shell,当你的思维都能被操作,那如何证明灵魂还存在。
而电影,只有shell。
写在看完真人版《攻壳机动队》之后。

[读书笔记]枪炮、病菌与钢铁

[读书笔记]枪炮、病菌与钢铁

怎样利用历史阐述是一个和阐述本省完全不同的问题。为了努力改变某个结果,了解是比再现或保持这种结果更经常使用的方法。这就是为什么心理学家要努力了解杀人犯和强奸犯的心理,为什么社会历史学家要努力去了解灭绝种族的大屠杀,为什么精神病学家要努力去了解人类疾病的起因。这些人之所以去调查研究,并不是想为谋杀、强奸、灭绝种族的大屠杀以及疾病进行辩护。相反,他们是想利用他们对因果链的了解来打断这个锁链。
所谓的文明的福祉是由正反两个方面的因素构成的。
整个现代社会都是由一边倒的结果来塑造的。
造成粮食生产传播速度差异的一个重大因素竟是大陆的轴线方向:欧亚大陆主要是东西向,而美洲和非洲主要是南北向。
现代人口最大的变迁是欧洲人对新大陆的移民。
粮食是生产枪炮、病菌和钢铁发展的一个先决条件。因此,在不同大陆的族群是否或何时变成农民和牧人方面的地理差异,在很大程度上说明了他们以后截然不同的命运。
第一个因果关系是最直接的因果关系:能够获得更多可消耗的卡路里就意味着会有更多的人。……结果每英里就能养活多得多的牧人和农民——一般要比狩猎采集为生的人多10倍到100倍。这些没有感情的数字所产生的力量,就是生产粮食的部落取得对狩猎采集部落的许多军事优势中的第一个优势。
……所有这些都是由于动植物驯化比狩猎采集的生活方式能产生出更多的食物从而导致更稠密人口的一些直接因素。
定居生活的另一个结果是人们可以把多余的粮食贮藏起来,因为如果人们不能留在附近看管贮藏的粮食,那么贮藏就是毫无意义的。