JIAYX 发布的文章

闲来无事把周五商老板说的面试题解了一下
具体代码如下(Golang)

package main

import (
    "fmt"
)

const SIZE = 6
var a = [SIZE][SIZE] int {
    {2, 2, 3, 3, 5, 6},
    {2, 1, 3, 3, 4, 6},
    {2, 2, 2, 1, 1, 6},
    {1, 2, 4, 4, 5, 5},
    {2, 2, 2, 1, 1, 5},
    {1, 4, 4, 1, 3, 3},
}

var count int = 0 // 计数
var mark = [SIZE][SIZE] int {} // 用来标记该数字是否被遍历过

func main() {

    fmt.Println("原数据:", "\n")
    lenA := len(a); 
    for i := 0; i < lenA ; i++ {
        fmt.Println(a[i])
    }

    fmt.Println("\n计算结果:")

    for i := 0; i < lenA; i++ {
        lenX := len(a[i])
        for j := 0; j < lenX; j++ {
            if mark[i][j] == 0 {
                findSame(i, j, a[i][j])
                count ++
            }
        }
    }

    fmt.Printf("共%d个簇\n\n", count)

    fmt.Println("具体情况如下:\n")
    lenMark := len(mark)
    for i := 0; i < lenMark ; i++ {
        fmt.Println(mark[i])
    }
}

func findSame(i, j, x int) {

    tempI := i
    tempJ := j
    if mark[i][j] == 0 {

        mark[i][j] = count + 1
        // 往上找相同的数
        for {
            i--
            if i < 0 || a[i][j] != x {
                break
            }
            findSame(i, j, a[i][j])
        }
        // 往下
        i = tempI
        for {
            i++
            if i > SIZE - 1 || a[i][j] != x {
                break
            }
            findSame(i, j, a[i][j])
            
        }
        // 往左
        i = tempI
        for {
            j--
            if j < 0 || a[i][j] != x {
                break
            }
            findSame(i, j, a[i][j])
        }
        // 往右
        j = tempJ
        for {
            j++
            if j > SIZE - 1 || a[i][j] != x {
                break
            }
            findSame(i, j, a[i][j])
        }
    }
}

更新

经商老板指点,findSame中的for循环没必要。下面是改过之后的findSame

func findSame(i, j, x int) {

    if mark[i][j] == 0 {
        mark[i][j] = count + 1
        // 往上找相同的数
        if i-1 >= 0 && a[i-1][j] == x {
            findSame(i-1, j, a[i-1][j])
        }
        // 往下
        if i+1 < SIZE && a[i+1][j] == x {
            findSame(i+1, j, a[i+1][j])
        }
        // 往左
        if j-1 >= 0 && a[i][j-1] == x {
            findSame(i, j-1, a[i][j-1])
        }
        if j+1 < SIZE && a[i][j+1] == x {
            findSame(i, j+1, a[i][j+1])
        }
    }
}

对递归理解还是不够到位啊~不过现在应该OK了^_^

今天刷票,没想到公司ip被12306封了,看到鱼大的刷票软件支持socks5代理,于是想到用服务器搞个代理试试。
步骤如下

  1. 安装 apt-get install dante-server
  2. 创建日志文件夹 mkdir /var/log/sockd
  3. 修改配置文件 vi /etc/danted.conf 写入以下内容

    logoutput: /var/log/sockd/sockd.log
    internal: 服务器ip port = 1080
    external: 服务器ip
    method: username none
    user.privileged: proxyuser
    user.notprivileged: nobody
    user.libwrap: nobody
    client pass {
        from: 0.0.0.0/0 to: 0.0.0.0/0
        log: connect disconnect
    }
    pass {
        from: 0.0.0.0/0 to: 0.0.0.0/0 port gt 1023
        command: bind
        log: connect disconnect
    }
    pass {
        from: 0.0.0.0/0 to: 0.0.0.0/0
        command: connect udpassociate
        log: connect disconnect
    }
    block {
        from: 0.0.0.0/0 to: 0.0.0.0/0
        log: connect error
    }
  4. 启动 /etc/init.d/danted start
  5. 检测是否启动成功 netstat -anp | grep 1080

有个问题就是端口暴露出来 会被各种人扫到。。所以千万不能一直开着

梦到大学的时候了。。也不梦点有意思的,偏偏梦到要考试了,心里那个着急,啥都不会T_T,大学学得太差了!真是捉鸡。

1、以管理员身份登录mysql
mysql -u root -p

2、选择mysql数据库
use mysql

3、创建用户并设定密码
insert into user (Host,User,Password) values ('localhost', 'test',password('1234'))

4、使操作生效
flush privileges

5、为用户创建数据库
create database testdb

6、为用户赋予操作数据库testdb的所有权限
grant all privileges on testdb.* to test@localhost identified '1234'

7、使操作生效
flush privileges

8、用新用户登录
mysql -u test -p

MySQL的事务支持不是绑定在MySQL服务器本身,而是与存储引擎相关。

  1. MyISAM:不支持事务,用于只读程序提高性能
  2. InnoDB:支持ACID事务、行级锁、并发
  3. Berkeley DB:支持事务

一个事务是一个连续的一组数据库操作,就好像它是一个单一的工作单元进行。换言之,只有该组内的每个单独的操作都是成功的,才是完整的事务。如果在事务的任何操作失败,则整个事务将失败。

事务 ACID Atomicity(原子性)、Consistency(一致性)、Isolation(隔离性)、Durability(持久性)
事务有以下四个标准属性的缩写ACID,通常被称为:
原子性: 确保工作单元内的所有操作都成功完成,否则事务将被中止在故障点,和以前的操作将回滚到以前的状态。
一致性: 确保数据库正确地改变状态后,成功提交的事务。
隔离性: 使事务操作彼此独立的和透明的。
持久性: 确保提交的事务的结果或效果的系统出现故障的情况下仍然存在。

1、事务的原子性
一组事务,要么成功;要么撤回。

2、一致性
有非法数据(外键约束之类),事务撤回。

3、隔离性
事务独立运行。
一个事务处理后的结果,影响了其他事务,那么其他事务会撤回。
事务的100%隔离,需要牺牲速度。

4、持久性
软、硬件崩溃后,InnoDB数据表驱动会利用日志文件重构修改。

原文链接