git整理commit的基本方法

觉得整理commit还是非常重要的一种技能,看到有人已经很好地整理过了,也搬运到自己的博客中,以备不时之需。本文转载自:Git整理Patch的一些经验

U-Boot升级到了最后,需要将之前比较杂乱的commit重新整理,有的需要整合,有的需要拆分。在这个过程中深刻的体会到了git的强大和灵活性。这里总结一下大的步骤和中间用到的各种小技巧。

步骤

commands usage
git checkout –b 新建一个branch来做整理的工作,保持原来的branch作为工作记录
git rebase –i 在新建的branch上,用rebase -i接squash的方法,将所有零碎的commit合成一个
git reset –soft HEAD~1 这一步只将object store还原到working_base上。所有需要整理的改动都留在index上,以备下一步做stash
git stash save “stash message” 将所有的改动放进stash中

至此,我们有了一个工作的基础,所有杂乱的commit被合成一个,并被放进stash中,以备后面一点点的commit进去。

C++贪吃蛇

借鉴自C++贪吃蛇的实现,同时修改了其中的2个问题:

  • 其一,随机生成食物时应检查是否生成在蛇节点上;
  • 其二,检查碰撞时除与外围墙碰撞外,还需检查蛇头与蛇身的碰撞。

A-star算法概述及其在游戏开发中的应用分析

首先需要感谢Amit’s A star PageA-star算法中译本,让我能够全面地了解A-star算法,下面大部分内容也是由原文及中译文中提炼而得。

1. 从Dijkstra算法和最佳优先搜索到A-star算法

1.1 Dijkstra算法

核心思想:

每次都选取距离起始点最近的点,并加入完成列表。算法的效率并不高,但对于没有负数权值边的情况能够得到从起始点到大部分点的最短路径。Dijkstra算法相当于启发式函数h(x) = 0的A-star算法(在后面会详细说明)。

适用领域:

相对于A-star算法,Dijkstra算法也有它适用的领域。当移动单位需要找到从其当前位置出发到N个分散目的地中的一个的最短路径(比如盟军只需抢占N个据点中的任意一个就能取胜,此时盟军需要选择一个离自己最近的据点i即可),Dijkstra算法会比A-star算法更为合适。

原因在于,Dijkstra对所有中间节点一视同仁,并不考虑它们到目的地的实际代价,这就导致该算法会偏执地选择离起点最近的节点,而当当前扩展节点集中出现了任意一个目的地i,算法就可以终止,而得到的目的地i就是N个目的地中距起始点最近的目的地。相反地,A-star算法则需要找到从起始点出发到所有目的地的最短路径,通过比较得到所有最短路径中的最小值。而实际上我们并不需要知道除了最近的目的地之外的其他目的地的路径就是如何。

总而言之,A-star算法更适用于单点对单点的寻径;Dijkstra算法更适用于单点到多点的寻径。

Pseudo-random algorithm

计算机产生的大多数随机数都是伪随机数。是按照分布概率产生随机数字的过程,数字在概率分布上满足随机要求,但实际上是计算机通过随机函数模拟产生的。生成的方法包括直接法逆转法接受拒绝法等。本篇要介绍的是prd伪随机算法基于rsa的伪随机算法

Pseudo Random Distribution

这种伪随机算法在游戏中的应用非常广泛。游戏希望角色间应互相制衡,同时为增加游戏的不确定性,故引入了随机概念,如暴击率、回避率等都是一个随机概率的表现。prd伪随机算法能够尽量使触发事件的情况均匀地分布在多次事件中,从而避免了连续多次的暴击或回避,也可以减少长时间不暴击情况的发生。

实际上Pseudo Random Distribution是来自Warcraft3引擎,同时在dota2中得到了发扬。prd伪随机算法是计算触发角色特殊能力的概率的算法。对于普通的伪随机算法,我们能够发现,每次触发事件的概率都相同。但对于prd伪随机算法而言,每次触发事件的概率却不相同,它会随着暴击事件或非暴击事件的触发而改变。但在均摊概率上来说,却是满足角色能力要求的,也是满足随机概率要求的。

一定程度上prd算法改善了暴击的发生的频次和分布,使其更为均匀,从而保证了游戏的公平性和趣味性。

Android Studio应用指南

0、引言

本文转载自关于Android Studio,你需要知道的9件事

1、如何构建你的项目

点击Build然后选择Make Project,最后点击右下方的Gradle Console查看打印信息。

2、Gradle Tasks的使用

点击右侧的Gradle,依次展开项目名–>:app,可以查看所有的Gradle任务,比如双击assembleRelease,就可以执行此task。双击assemble,表示同时执行assembleDebugassembleRelease,会在目录app/build/apk/生成对应的debug和release的APK。

生成的APK命名规则:app-<flavor>-<buildtype>.apk; 比如: app-full-release.apkapp-demo-debug.apk.

也可以在左下角点击控制台进行相应的任务命令:比如输入gradle tasks命令可以查看所有的task、输入gradle build命令表示同时执行assemblecheck;同时命令还支持驼峰匹配:比如gradle aR等同于gradle assembleRelease

3、运行配置

点击Run选择Edit Configuration,展开Android Application,可以新建一个配置或者编辑一个现有的配置:可以配置是否自动启动默认Activity,启动特定Activity,部署目标是否手动选择,比如可以自动部署到USB(真机);模拟器网速控制:

网速规则如下所示:

1
None: no latency
2
GPRS: GPRS (min 150, max 550 milliseconds)
3
EDGE: EDGE/EGPRS (min 80, max 400 milliseconds)
4
UMTS: UMTS/3G (min 35, max 200 milliseconds)

同时可以配置模拟器启动时的额外命令行:

比如启动适配屏幕:-scale 96dpi;还有logcat配置:比如是否每次启动时自动清空。

CRC循环冗余校验码

Cyclic redundancy check

A cyclic redundancy check (CRC) is an error-detecting code commonly used in digital networks and storage devices to detect accidental changes to raw data. Blocks of data entering these systems get a short check value attached, based on the remainder of a polynomial division of their contents. On retrieval, the calculation is repeated and, in the event the check values do not match, corrective action can be taken against data corruption.

循环冗余校验CRC简介

  • CRC为校验和的一种,是两个字节数据流采用二进制除法(没有借位和进位,使用异或来代替减法)相除所得到的余数。
  • 其中被除数是需要计算校验和的信息数据流的二进制表示;除数是一个长度为(n+1)的预定义二进制数,通常用多项式的系数来表示。
  • 在做除法之前,要在信息数据之后先加上n个0。冗余码的位数是n位。冗余码的计算方法是,先将信息码后面补0,补0的个数是生成多项式最高次幂;将补零之后的信息码用模二除法(非二进制除法)除以G(X)对应的2进制码,注意除法过程中所用的减法是模2减法(注意是高位对齐),即没有借位的减法,也就是异或运算。
  • 当被除数逐位除完时,得到比除数少一位的余数。此余数即为冗余位,将其添加在信息位后便构成CRC码字。

例如,假设信息码字为11100011,生成多项式$G(X)=X^5+X^4+X+1$,计算CRC码字。$G(X)=X^5+X^4+X+1$,也就是110011,因为最高次是5,所以,在信息码字后补5个0,变为1110001100000。

用1110001100000模二除法除以110011,余数为11010,即为所求的冗余位。因此发送出去的CRC码字为原始码字11100011末尾加上冗余位11010,即 1110001111010。

接收端收到码字后,采用同样的方法验证,即将收到的码字用模二除法除以110011(是$G(X)$对应的二进制生成码),发现余数是0,则认为码字在传输过程中没有出错。

尽管在错误检测中非常有用,CRC并不能可靠地校验数据完整性(即数据没有发生任何变化),这是因为CRC多项式是线性结构,可以非常容易地故意改变量据而维持CRC不变。

浅谈Prisoner's Dilemma

转自How to beat the Prisoner’s Dilemma in the TV game show Golden Balls

Golden Balls is an amusing British game show. Especially interesting is the final contest which is a version of the Prisoner’s Dilemma.

If you’re never seen the show, here is how it works. Each of two contestants independently chooses to split or steal the final prize. If both choose split, then the prize is divided evenly. If one chooses split and the other steal, the person who steals gets the entire prize. If both choose steal, however, then both walk away with nothing.

Here’s the normal form representation of the game:

game matrix

How should you play this game?
One contestant had an amazingly brilliant strategy.

The wrong way to play the game

Contestants are allowed to discuss strategy before picking split or steal.

Both realize that split gives a fair 50 percent share to each side, but each also sees the advantage of back-stabbing and stealing the prize.

The discussion usually involves the following strategy. Each person tries to convince the other person to split, and they promise to do the same.

I discussed an example of this in a previous post: strategy in Golden Balls.
In that episode, both were promising they would split the prize, but then one person decided at the last minute to steal all the money. She said she was not proud of the decision, but she herself did not want to be cheated.

So trying to split the money in a conventional way doesn’t work. Is there a better strategy?

Loading data from multiple sources with RxJava

Simply copy from Loading data from multiple sources with RxJava

Suppose I have some Data

  • that I query from the network. I could simply hit the network each time I need the data, but caching the data on disk and in memory would be much more efficient.
  • More specifically, I want a setup that:
    Occasionally performs queries from the network for fresh data.
    Retrieves data as quickly as possible otherwise (by caching network results).

I’d like to present an implementation of this setup usingRxJava.

Basic Pattern

Given an Observable<Data> for each source (network, disk and memory), we can construct a simple solution using two operators, concat() and first().

concat() takes multiple Observables and concatenates their sequences. first() emits only the first item from a sequence. Therefore, if you use concat().first(), it retrieves the first item emitted by multiple sources.

Let’s see it in action:

1
// Our sources (left as an exercise for the reader)
2
Observable<Data> memory = ...;  
3
Observable<Data> disk = ...;  
4
Observable<Data> network = ...;
5
6
// Retrieve the first source with data
7
Observable<Data> source = Observable  
8
  .concat(memory, disk, network)
9
  .first();

The key to this pattern is that concat() only subscribes to each child Observable when it needs to. There’s no unnecessary querying of slower sources if data is cached, sincefirst() will stop the sequence early. In other words, if memory returns a result, then we won’t bother going to disk or network. Conversely, if neither memory nor disk have data, it’ll make a new network request.

Note that the order of the source Observables in concat() matters, since it’s checking them one-by-one.

Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×