涓嬮潰緇欏嚭鎴戠殑瑙ｆ硶錛屽嚑涔庡彲浠ヤ竴姝ュ埌浣嶆眰鍑烘潵
瀹炵幇浠ｇ爜濡備笅錛?br />/**
*Author: Koth (http://weibo.com/yovn)
*Date: 2011-12-01
*/
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
int solve(int Y,int& X){
int m=0;
int t=Y;
if(Y<=0){
X=Y;
return 1;
}
while((t&1)==0){
m+=1;
t=t>>1;
}
if(m==32){
X=Y;
return 1;
}
int lastK=32;
for(;lastK>m+1;lastK--){
if(Y &(1<<(lastK-1))){
break;
}
}
//its a number st. exp(2,K)
if(lastK==(m+1)){
X=Y;
return 1;
}
int k=1<<(m+1);
int b=(Y>>m)-(1<<(lastK-m-1));
X=(1<<(lastK-m-2))+(b+1-k)/2;
if(X<=0){
k=k-1-((0-X)<<1);
X=0-X+1;
}
return k;
}
int main(int argc,char* argv[]){
if(argc<=1){
fprintf(stdout,"Usage:%s number\n",argv[0]);
return 0;
}
int Y=atoi(argv[1]);
int X=0;
int k=solve(Y,X);
fprintf(stdout,"%d=",Y);
for(int i=0;i<k;i++){
fprintf(stdout,"%d",X+i);
if(i<(k-1)){
fprintf(stdout,"+");
}
}
fprintf(stdout,"\n");
return 0;
}
*Author: Koth (http://weibo.com/yovn)
*Date: 2011-12-01
*/
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
int solve(int Y,int& X){
int m=0;
int t=Y;
if(Y<=0){
X=Y;
return 1;
}
while((t&1)==0){
m+=1;
t=t>>1;
}
if(m==32){
X=Y;
return 1;
}
int lastK=32;
for(;lastK>m+1;lastK--){
if(Y &(1<<(lastK-1))){
break;
}
}
//its a number st. exp(2,K)
if(lastK==(m+1)){
X=Y;
return 1;
}
int k=1<<(m+1);
int b=(Y>>m)-(1<<(lastK-m-1));
X=(1<<(lastK-m-2))+(b+1-k)/2;
if(X<=0){
k=k-1-((0-X)<<1);
X=0-X+1;
}
return k;
}
int main(int argc,char* argv[]){
if(argc<=1){
fprintf(stdout,"Usage:%s number\n",argv[0]);
return 0;
}
int Y=atoi(argv[1]);
int X=0;
int k=solve(Y,X);
fprintf(stdout,"%d=",Y);
for(int i=0;i<k;i++){
fprintf(stdout,"%d",X+i);
if(i<(k-1)){
fprintf(stdout,"+");
}
}
fprintf(stdout,"\n");
return 0;
}
]]>
璇佹槑錛?br /> 棣栧厛鎴戜滑璇佹槑鑻鏄礌鏁幫紝閭ｄ箞絳夊紡鎴愮珛錛屽浜嶯=2,榪欐槸寰堟槑鏄劇殑銆備互涓嬭瘉鏄嶯>2 鐨勬儏褰€?br /> 1錛夎嫢N鏄礌鏁幫紝閭ｄ箞鍏充簬N鍚屼綑鐨勪箻娉曠兢G={1,2,3....N-1}
緹姣忎釜鍏冪礌閮芥湁閫嗗厓錛屾槧灝?f:a -> a^-1 錛宖(a)=a^-1 鏄竴涓竴涓鏄犲皠銆傜幇鍦紝浠誨彇涓涓厓绱狅紝瀹冪殑閫嗗厓瑕佷箞鏄叾瀹冧竴涓厓绱狅紝鎴栬呮槸瀹冩湰韜?鎴戜滑鍋囪鍏朵腑鍏冪礌x鐨勯嗗厓鏄畠鏈韓錛岄偅涔坸*x ≡1(mod N) =>(x+1)*(x-1)=K*N,鑰孨鏄礌鏁幫紝鎵浠ヨ涔坸=N-1,瑕佷箞x=1銆備篃灝辨槸璇達紝闄や簡榪欎袱涓厓绱狅紝鍏跺畠鐨勫厓绱犵殑閫嗗厓閮芥槸鏄犲皠鍒板埆鐨勫厓绱犵殑銆傝孨>2,鏄鏁幫紝鎵浠ュ厓绱犲叡鏈塏-1涓紝涔熷氨鏄伓鏁頒釜鍏冪礌銆傝繖鏍鳳紝闄や簡1鍜孨-1澶栧墿浣欑殑N-3涓厓绱犲垰濂界粨鎴愪袱涓や竴瀵?x,y)(閫嗗厓鏄敮涓鐨勶級浣垮緱f(x)=y=x^-1,涔熷氨鏄痻y≡1(mod N).
鐜板湪鎶奊鐨勫厓绱犲叏閮ㄤ箻璧鋒潵錛岃浜掍負閫嗗厓鐨勫厓绱犵粍鎴愪竴瀵歸偅涔?N-1)!=1*(N-1)*(x1*y1)*(x2*y2)...(xk*yk)≡1*(N-1)*1*1...1 (mod N)≡-1(mod N).
榪欐牱錛屾垜浠瘉鏄庝簡涓涓柟鍚戜簡錛屼笅闈㈡垜浠瘉鏄庡彟涓涓柟鍚?br />
2錛夎嫢(N-1)! ≡ -1(mod N)鎴愮珛錛屽垯N鏄礌鏁幫紝鑻ヤ笉鐒訛紝浠?N鏄拰鏁般傚垯(N-1)!鑲畾鏁撮櫎N,鍥犱負N鐨勬瘡涓洜瀛恜婊¤凍p>1,p<N銆?br /> 鐜板湪浠?N-1)!=K1*N.鍙?N-1)! ≡ -1(mod N) => K1*N ≡ -1(mod N),鐢卞悓浣欐ц川鐭ワ紝瀛樺湪K2浣垮緱K1*N+1=K2*N,涓よ竟鍚屾椂闄や互N寰桲1+1/N=K2.鏄劇劧錛岃繖鏄笉鍙兘鐨勶紝鎵浠ヨ嫢(N-1)! ≡ -1(mod N)鎴愮珛錛屽垯N鏄礌鏁?br />
璇佹槑瀹屾瘯錛?br />
榪欓噷鐢ㄧ兢鐨勬蹇佃兘澶熺畝鍖栦竴瀹氱殑鎻忚堪錛屽叾瀹炲彲浠ュ畬鍏ㄤ笉鐢ㄧ兢鐨勬蹇電殑錛屽彧涓嶈繃榪欐牱涓鏉ワ紝鎻忚堪鏇撮暱鐐癸紝綣佺悙鐐癸紒
]]>
]]>
]]>
]]>
*
*/
import java.util.Stack;
import java.util.Vector;
/**
* @author yovn
*
*/
public class TreeDemo {
static interface NodeVistor
{
<T> void visit(BinaryTreeNode<T> node);
}
static class BinaryTree<T>
{
BinaryTreeNode<T> root;
public BinaryTree(BinaryTreeNode<T> root) {
this.root=root;
}
//no recursion ,pre-order
void NLRVisit(NodeVistor visitor)
{
BinaryTreeNode<T> pointer=root;
Stack<BinaryTreeNode<T>> stack=new Stack<BinaryTreeNode<T>>();
while(!stack.isEmpty()||pointer!=null)
{
if(pointer!=null)
{
visitor.visit(pointer);
if(pointer.rightChild!=null)
{
stack.push(pointer.rightChild);
}
pointer=pointer.leftChild;
}
//go to right child
else
{
pointer=stack.pop();
}
}
}
//no recursion , in-order
void LNRVisit(NodeVistor visitor)
{
BinaryTreeNode<T> pointer=root;
Stack<BinaryTreeNode<T>> stack=new Stack<BinaryTreeNode<T>>();
while(!stack.isEmpty()||pointer!=null)
{
if(pointer!=null)
{
stack.push(pointer);
pointer=pointer.leftChild;
}
//no left child here, then visit root and then go to right child
else
{
pointer=stack.pop();
visitor.visit(pointer);
pointer=pointer.rightChild;
}
}
}
//no recursion ,post-order,this one is the most complex one.
//we need know from which side ,it back(left or right)
void LRNVisit(NodeVistor visitor)
{
if(root==null)return;
BinaryTreeNode<T> pointer=root;
Stack<BinaryTreeNode<T>> stack=new Stack<BinaryTreeNode<T>>();
while(true)
{
//mark left
while(pointer!=null)
{
stack.push(pointer);
pointer=pointer.leftChild;
}
pointer=stack.pop();
while(pointer.visitedRight)//back from right child, so we can visit it now.
{
visitor.visit(pointer);
if(stack.isEmpty())return;
pointer=stack.pop();
}
pointer.visitedRight=true;
stack.push(pointer);
pointer=pointer.rightChild;
}
}
void levelOrder(NodeVistor visitor)
{
if(root==null)return;
BinaryTreeNode<T> pointer=root;
Vector<BinaryTreeNode<T>> queue=new Vector<BinaryTreeNode<T>>();
queue.add(pointer);
while(!queue.isEmpty())
{
BinaryTreeNode<T> node=queue.remove(0);
visitor.visit(node);
if(node.leftChild!=null)
{
queue.add(node.leftChild);
}
if(node.rightChild!=null)
{
queue.add(node.rightChild);
}
}
}
}
static class BinaryTreeNode<T>
{
BinaryTreeNode(T data)
{
this.data=data;
}
T data;
boolean visitedRight;
BinaryTreeNode<T> leftChild;
BinaryTreeNode<T> rightChild;
}
/**
*
*/
public TreeDemo() {
// TODO Auto-generated constructor stub
}
/**
* @param args
*/
public static void main(String[] args) {
BinaryTreeNode<String> root=new BinaryTreeNode<String>("A");
root.leftChild=new BinaryTreeNode<String>("B");
root.rightChild=new BinaryTreeNode<String>("C");
root.leftChild.leftChild=new BinaryTreeNode<String>("D");
root.rightChild.leftChild=new BinaryTreeNode<String>("E");
root.rightChild.rightChild=new BinaryTreeNode<String>("F");
root.rightChild.leftChild.rightChild=new BinaryTreeNode<String>("G");
root.rightChild.rightChild.leftChild=new BinaryTreeNode<String>("H");
root.rightChild.rightChild.rightChild=new BinaryTreeNode<String>("I");
NodeVistor visitor=new NodeVistor()
{
@Override
public <T> void visit(BinaryTreeNode<T> node) {
System.out.print("'"+node.data+"'");
}
};
BinaryTree<String> tree=new BinaryTree<String>(root);
System.out.println("pre-order visit");
tree.NLRVisit(visitor);
System.out.println();
System.out.println("in-order visit");
tree.LNRVisit(visitor);
System.out.println();
System.out.println("post-order visit");
tree.LRNVisit(visitor);
System.out.println();
System.out.println("level-order visit");
tree.levelOrder(visitor);
}
}
]]>
榪欎釜鐗堟湰璋冩暣浜嗕竴涓婰oader鐨勬満鍒訛紝淇濇寔EXE璺熺被鏂囦歡嫻戠劧涓浣撶殑鍚屾椂鍙堝彲浠ュ歡榪熷姞杞絚lass.
鍙﹀榪欎釜鐗堟湰鐨勫姞瀵嗗己搴︽彁楂樺緢澶氾紝鐢ㄦ潵浠ｆ浛閭ｄ簺class娣鋒穯杞歡搴旇涔熶笉閿欍傦細錛?nbsp; 闃呰鍏ㄦ枃
]]>
* Demonstrate KMP algorithm in Java
*
*
*/
public class KMP {
public static int indexOf(String target,String pattern)
{
int pLen=pattern.length();
int tLen=target.length();
//the fail function
int failFunc[]=new int[pLen];
failFunc[0]=-1;
//build fail function
for(int i=1;i<pLen;i++)
{
int j=failFunc[i-1];
while(pattern.charAt(i)!=pattern.charAt(j+1)&&j>=0)
{
//recursion
j=failFunc[j];
}
if(pattern.charAt(i)==pattern.charAt(j+1))
{
failFunc[i]=j+1;
}
else
{
failFunc[i]=-1;
}
}
int pPos=0,tPos=0;
while(tPos<tLen&&pPos<pLen)
{
if(target.charAt(tPos)==pattern.charAt(pPos))
{
//match ,then do forward
tPos++;
pPos++;
}
else if(pPos==0)
{
//target go forward
tPos++;
}
else
{
//target postion don't change,pattern go back
pPos=failFunc[pPos-1]+1;
}
}
if(pPos<pLen)return -1;
else return tPos-pLen;
}
}
]]>
3)gcc args:
gcc -Wall -O -fomit-frame-pointer -nostdinc -fno-builtin
4)link.ld
ld -T link.ld
OUTPUT_FORMAT("binary")
ENTRY(start)
phys = 0x00100000;
SECTIONS
{
.text phys : AT(phys) {
code = .;
*(.text)
*(.rodata)
. = ALIGN(4096);
}
.data : AT(phys + (data - code))
{
data = .;
*(.data)
. = ALIGN(4096);
}
.bss : AT(phys + (bss - code))
{
bss = .;
*(.bss)
. = ALIGN(4096);
}
end = .;
}
5)Bootable CDENTRY(start)
phys = 0x00100000;
SECTIONS
{
.text phys : AT(phys) {
code = .;
*(.text)
*(.rodata)
. = ALIGN(4096);
}
.data : AT(phys + (data - code))
{
data = .;
*(.data)
. = ALIGN(4096);
}
.bss : AT(phys + (bss - code))
{
bss = .;
*(.bss)
. = ALIGN(4096);
}
end = .;
}
mkisofs -R -b boot/grub/eltorito.s2 -no-emul-boot -boot-load-size 4 -boot-info-table -o yovnos.iso iso
]]>