codility

//lesson answer in python

http://codesays.com/solutions-to-training-by-codility/    

1、Prefix Sums

     该做法通常从后往前循环。例如pass car

//alg study

https://class.coursera.org/algs4partI-004/

//算法介绍文档

https://codility.com/media/train/4-Sorting.pdf

//详细题目介绍

http://blog.csdn.net/sunbaigui/article/category/1769905/1

http://blog.csdn.net/caopengcs/article/category/1502799

//老外的codility代码，python

https://github.com/bluemihai/my-codility-solutions

https://github.com/zjsxzy/Codility

//中国的介绍和详解

http://www.cnblogs.com/parapax/tag/codility/

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

*****//好像是codility公司员工在github上的代码，最全的，连pdf都有

https://github.com/kevinmore/Codility

==========================

QSORT

1. int compi(const void *a, const void *b)  
2. {  
3.     const int *p = a;  
4.     const int *q = b;  
5.   
6.     return *p - *q;  
7. }  
8.   
9. int compd(const void *a, const void *b)  
10. {  
11.     const int *p = a;  
12.     const int *q = b;  
13.   
14.     return (*p - *q) * (-1);  
15. }  
16.   
17.   
18. int main()  
19. {  
20.     int a[1000];  
21.     int i, len, type;  
22.   
23.     while(scanf("%d %d", &len, &type) != EOF)  
24.     {  
25.         for(i = 0; i < len; i ++)  
26.         {  
27.             scanf("%d", &a[i]);  
28.         }  
29.   
30.         switch(type)  
31.         {  
32.             case 1 :  
33.                 //递增排序  
34.                 qsort(a, len, sizeof(a[0]), compi);  
35.                 break;  
36.             case 2 :  
37.                 //递减排序  
38.                 qsort(a, len, sizeof(a[0]), compd);  
39.                 break;  
40.         }  
41.   
42.         if(type == 1)  
43.         {  
44.             printf("递增排序结果:\n");  
45.         }else  
46.         {  
47.             printf("递减排序结果:\n");  
48.         }  
49.         for(i = 0; i < len; i ++)  
50.         {  
51.   
52.             printf("%d ", a[i]);  
53.         }  
54.         printf("\n");  
55.     }  
56.     return 0;  
57. }   

=====================================================

搜索某个区间的和的最大值

Solution to Max-Slice-Sum by codility

Python

1

2

3

4

5

6

7

8

9

def solution(A):

    max_slice_ending_here = A[0]

    max_slice = A[0]

 

    for element in A[1:]:

        max_slice_ending_here = max(element, max_slice_ending_here+element)

        max_slice = max(max_slice, max_slice_ending_here)

 

    return max_slice

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

def solution(A):

    days = len(A)

 

    # If the number of days is zero or one, there

    # is no time to get profit.

    if days < 2:

        return 0

 

    max_price_from_here = A[days-1]

    max_profit = 0

    for index in xrange(days-2, -1, -1):

        # max_price_from_here-A[index] means the maximum

        # profit from current day to end.

        max_profit = max(max_profit, max_price_from_here-A[index])

        max_price_from_here = max(A[index], max_price_from_here)

 

    return max_profit

如果是取减法的最大值，则是反序遍历

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

def solution(A):

    days = len(A)

 

    # If the number of days is zero or one, there

    # is no time to get profit.

    if days < 2:

        return 0

 

    max_price_from_here = A[days-1]

    max_profit = 0

    for index in xrange(days-2, -1, -1):

        # max_price_from_here-A[index] means the maximum

        # profit from current day to end.

        max_profit = max(max_profit, max_price_from_here-A[index])

        max_price_from_here = max(A[index], max_price_from_here)

 

    return max_profit

===================================================
欧几里得算法，求最大gcd

When we met with an empty wrapper, we must have been this position for twice. We use i for the first time and j for the second time. Due to the modulo feature, there must be nature number, to say k, so that: i * M + k * N = j * M. Then we could easily prove that the smallest (earliest) i must be zero (for all i != 0, then (i-i) * M + k * N = (j-i) * M ). So the first eaten position would be first position that you meet again. Finally, the j would be the number of chocolates that you will eat.

Solution to Chocolates-By-Numbers by codility

Python

1

2

3

4

5

6

7

8

9

10

defgcd(a,b):

    # Get the greatest common divisor

    if(a%b==0):

        returnb

    else:

        returngcd(b,a%b)

 

defsolution(N,M):

    lcm=N*M/gcd(N,M)# Least common multiple

    returnlcm/M

====================================

Fibonacci numbers

Another solution to Ladder by codility

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

def solution(A, B):

    limit = len(A)                  # The possible largest N rungs

    result = [0] * len(A)           # The result for each query

    B = [(1<<item)-1 for item in B] # Pre-compute B for optimization

 

    # Compute the Fibonacci numbers for later use

    fib = [0] * (limit+2)

    fib[1] = 1

    for i in xrange(2, limit + 2):

        fib[i] = fib[i - 1] + fib[i - 2]

 

    for i in xrange(limit):

        # To climb to A[i] rungs, you could either

        # come from A[i]-1 with an one-step jump

        # OR come from A[i]-2 with a two-step jump

        # So from A[i] rungs, the number of different ways of climbing

        # to the top of the ladder is the Fibonacci number at position

        # A[i] + 1

        result[i] = fib[A[i]+1] & B[i]

 

    return result

=============================================================

Binary search algorithm  //二分查找算法

C++ solution to Min-Max-Division by codility

C++

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

#include <cmath>

 

intTestLargeSum(conststd::vector<int>&A,intK,intLargeSum)

{

    inti,n,j;

    n=A.size();

    longlongsum;

 

    sum=0;

    j=0;

    for(i=0;i<n;i++)

    {

        sum+=A[i];

        if(sum>LargeSum)

        {

            j++;

            if(j>(K-1))return0;

            sum=A[i];

        }

    }

 

    return1;

}

 

intsolution(intK,vector<int>&A)

{

    inti,n,Amax,LargeSum;

    intr,b,e,LargeSumR;

 

    n=A.size();

    LargeSum=0;

    for(i=K-1;i<n;i++)LargeSum+=A[i];

 

    Amax=0;

    for(i=0;i<n;i++)if(A[i]>Amax)Amax=A[i];

 

    if(K==n)returnAmax;

    LargeSum=max(Amax,LargeSum);

 

    b=Amax;

    e=LargeSum;

    if(e<b)swap(e,b);

    LargeSumR=e;

 

    // BinSearch

    while(b<=e)

    {

        LargeSum=(b+e)/2;

        r=TestLargeSum(A,K,LargeSum);

        if(r)

        {

            e=LargeSum-1;

            LargeSumR=LargeSum;

        }

        else

        {

            b=LargeSum+1;

        }

    }

    returnLargeSumR;

}

==============================================

前几天复习了一下对分查找（Binary Search），它提供了在 O(log N) 时间内的 Find （查找操作），先来看看对分查找的叙述要求：

      给定一个整数 X 和整数 ，后者已经预先排序，并且已经在内存中，求使得 的下标 i ，如果 X 不在数据之中，则返回 i = -1。

来看看实现源码：

int BinarySearch(const int A[],int X,int N)

{

    int Low, Mid, High;

    Low = 0; High = N - 1;

    while(Low <= High)

    {

        Mid = (Low + High) / 2;

        if(A[Mid] < X)

            Low = Mid + 1;

        else if(A[Mid] > X)

            High = Mid - 1;

        else

            return Mid;/*Found*/

    }

    return -1;/*Not Found: Return -1*/

}

这里要注意的是：作为参数的数组 A，在调用函数 BinarySearch 的时候，已经经过了一次排序。