发表于 | 分类于 | 阅读次数:
字数统计: 284 | 阅读时长 ≈ 1

二维数组的查找 java解法

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


    public class Solution {
        
       public boolean Find(int target, int [][] array) {
       // 特殊情况处理
       if (array == null || array.length == 0 || array[0].length == 0) {
            return false;
        }

        int h = array.length - 1;
        int w = array[0].length - 1;

        // 如果目标值小于最小值 或者 目标值大于最大值，那肯定不存在
        if (array[0][0] > target || array[h][w] < target) {
            return false;
        }
        return binarySearchIn2DArray(array, target, 0, h, 0, w);
    }


     public static boolean binarySearchIn2DArray(int[][] array, int target, int startX, int endX, int startY, int endY) {
        if (startX > endX || startY > endY) {
            return false;
        }
        //首先，根据二分法找出中间行
        int x = startX + (endX - startX) / 2;
        //对该行进行二分查找
        int result = binarySearch(array[x], target, startY, endY);
        //找到的值位于 x 行，result 列
        if (array[x][result] == target) {
            return true; // 如果找到则成功
        }
        //对剩余的两部分分别进行递归查找
        return binarySearchIn2DArray(array, target, startX, x - 1, result + 1, endY)
                || binarySearchIn2DArray(array, target, x + 1, endX, startY, result);
    }

     public static int binarySearch(int[] array, int target, int start, int end) {
        int i = start + (end - start) / 2;
        if (array[i] == target || start > end) { 
            return i;
        } else if (array[i] > target) {
            return binarySearch(array, target, start, i - 1);
        } else {
            return binarySearch(array, target, i + 1, end);
        }
    }
}

发表于 | 分类于 | 阅读次数:
字数统计: 123 | 阅读时长 ≈ 1 
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
class Solution(object):
    def orangesRotting(self, A):
        R, C = len(A), len(A[0])

        # queue - all starting cells with rotting oranges
        queue = collections.deque()
        for r, row in enumerate(A):
            for c, val in enumerate(row):
                if val == 2:
                    queue.append((r, c, 0))

        def neighbors(r, c):
            for nr, nc in ((r-1,c),(r,c-1),(r+1,c),(r,c+1)):
                if 0 <= nr < R and 0 <= nc < C:
                    yield nr, nc

        d = 0
        while queue:
            r, c, d = queue.popleft()
            for nr, nc in neighbors(r, c):
                if A[nr][nc] == 1:
                    A[nr][nc] = 2
                    queue.append((nr, nc, d+1))

        if any(1 in row for row in A):
            return -1
        return d

发表于 | 分类于 | 阅读次数:
字数统计: 176 | 阅读时长 ≈ 1

beego 的模块化设计-grace

grace 模块是 beego 新增的一个独立支持热重启的模块。

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

import(
   "log"
    "net/http"
    "os"
    "strconv"

   "github.com/astaxie/beego/grace"
 )

  func handler(w http.ResponseWriter, r *http.Request) {
      w.Write([]byte("WORLD!"))
      w.Write([]byte("ospid:" + strconv.Itoa(os.Getpid())))
  }

  func main() {
      mux := http.NewServeMux()
      mux.HandleFunc("/hello", handler)

      err := grace.ListenAndServe("localhost:8080", mux)
      if err != nil {
           log.Println(err)
        }
      log.Println("Server on 8080 stopped")
         os.Exit(0)
    }

打开两个终端

一个终端输入：ps -ef|grep 应用名

一个终端输入请求：curl “http://127.0.0.1:8080/hello“

热升级

kill -HUP 进程 ID

打开一个终端输入请求：curl “http://127.0.0.1:8080/hello?sleep=0“

发表于 | 分类于 | 阅读次数:
字数统计: 376 | 阅读时长 ≈ 1

beego 的模块化设计-session

session 模块是用来存储客户端用户，session 模块目前只支持 cookie 方式的请求，如果客户端不支持 cookie，那么就无法使用该模块。

session 模块参考了 database/sql 的引擎写法，采用了一个接口，多个实现的方式。目前实现了 memory、file、Redis 和 MySQL 四种存储引擎。

通过下面的方式安装 session：

go get github.com/astaxie/beego/session

初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14

func init() {
        sessionConfig := &session.ManagerConfig{
    CookieName:"gosessionid", 
    EnableSetCookie: true, 
    Gclifetime:3600,
    Maxlifetime: 3600, 
    Secure: false,
    CookieLifeTime: 3600,
    ProviderConfig: "./tmp",
    }
    globalSessions, _ = session.NewManager("memory",sessionConfig)
    go globalSessions.GC()
}

一个 JSON 字符串,传入 Manager 的配置信息

  1. cookieName: 客户端存储 cookie 的名字。
  2. enableSetCookie,omitempty: 是否开启 SetCookie,omitempty 这个设置
  3. gclifetime: 触发 GC 的时间。
  4. maxLifetime: 服务器端存储的数据的过期时间
  5. secure: 是否开启 HTTPS，在 cookie 设置的时候有 cookie.Secure 设置。
  6. sessionIDHashFunc: sessionID 生产的函数，默认是 sha1 算法。
  7. sessionIDHashKey: hash 算法中的 key。
  8. cookieLifeTime: 客户端存储的 cookie 的时间，默认值是 0，即浏览器生命周期。
  9. providerConfig: 配置信息，根据不同的引擎设置不同的配置信息，详细的配置请看下面的引擎设置

最后的逻辑处理

1
2
3
4
5
6
7
8
9
10
11
12

func login(w http.ResponseWriter, r *http.Request) {
    sess, _ := globalSessions.SessionStart(w, r)
    defer sess.SessionRelease(w)
    username := sess.Get("username")
    if r.Method == "GET" {
        t, _ := template.ParseFiles("login.gtpl")
        t.Execute(w, nil)
    } else {
        sess.Set("username", r.Form["username"])
    }
}

发表于 | 分类于 | 阅读次数:
字数统计: 359 | 阅读时长 ≈ 1

golang 制霸云计算

  1. go语言是现代的、快速的 带有一个强大的标准库
  2. 内置对并发的支持
  3. 使用接口作为代码复用的基础模块
  • 包是组织代码的基本单位
  • 环境变量GOPATH决定了go源码在磁盘上被保存、编译和安装的位置
  • 可以为每个工程设置不同的GOPATH 以保持源代码和依赖的隔离
  • go get获取他人的包
  • 将源代码放到公用代码库 遵守简单规则 可以供他人使用
  • 分享代码作为语言的核心动力和驱动力
  • 依赖管理工具 godep vender gb
  • 数组是构造切片和映射的基石
  • 切片经常来处理数据的集合，映射用来处理具有键值对结构的数据
  • make用来创建切片和映射，并指定原始的长度和容量
  • 切片有容量限制 可以使用append函数扩展容量
  • 映射的增长没有容量或者任何限制
  • len可以取切片和映射的长度
  • cap只能用于切片
  • 通过组合 可以创建多维数组和多维切片 也可以使用切片或者其他映射作为映射的值 但是切片不能作为映射的键
  • 将切片或者映射传递給函数成本很小，并且不会复制底层的数据结构