GithubHelp home page GithubHelp logo

arts's Introduction

ARTS

ARTS 鸽友打卡🐦

  1. Algorithm：每周至少做一个 leetcode 的算法题，或者参加codeforces比赛

  2. Review：阅读并点评至少一篇英文技术文章

  3. Tip：学习至少一个技术技巧

  4. Share：分享一篇有观点和思考的技术文章，每月一篇博客，每周一次分享

arts's People

Contributors

hitolz avatar hyponet avatar

Stargazers

avatar avatar

Watchers

avatar avatar avatar avatar avatar avatar

arts's Issues

Codeforce #574 解题报告

就写了两题_(:з」∠)_

A 题

思路与 @Coderhypo 一致，不过在接收输入的时候，用 map 进行存储，省掉了统计的过程。

package main

import "fmt"

func drinkChoosing(sNum int, dNum int, sFav map[int]int) int {
	result := 0
	t := 0
	for _, v := range sFav {
		result += v - v % 2
		t += v % 2
	}
	result += t / 2 + t % 2
	return result
}

func main() {
	var sNum, dNum int

	_, err := fmt.Scanln(&sNum, &dNum)
	if err != nil {
		fmt.Println(err)
	}

	sFav := make(map[int]int)
	for k := 0; k < sNum; k++ {
		a := 0
		_, err := fmt.Scanln(&a)
		if err != nil {
			fmt.Println(err)
		}
		sFav[a] ++
	}
	result := drinkChoosing(sNum, dNum, sFav)
	fmt.Println(result)
}

B 题

思路一

i：加糖果的步数；
j：吃糖果的步数(即最后所求)；
a：当前所有加的糖果(1+2+3...+i)；
candy：当前盒子里的糖果；

满足的条件：

  1. i + j = moveNum
  2. a >= j
  3. candy = a - j
package main

import (
	"fmt"
)

func main() {
	var moveNum, candyNum int

	_, err := fmt.Scanln(&moveNum, &candyNum)
	if err != nil {
	}

	for i := 1; i <= moveNum; i++ {
		j := moveNum - i
		a := (i +1) * i /2
		if a < j {
			continue
		}
		candy := a - j
		if (candy - candyNum) == 0 {
			fmt.Println(j)
		}
	}

}

然后没过， test 11 挂了，不懂_(:з」∠)_
到第二天才知道 test 11 是 999999994 108004280，发现可能是 a := (i +1) * i /2 这一步 乘法溢出了。

尝试了两种方法：

  1. 将所有涉及到运算的变量，转换成 int64。---> 超时了
  2. 分成奇偶数求 a 值：
package main

import (
	"fmt"
)

func main() {
	var moveNum, candyNum int

	_, err := fmt.Scanln(&moveNum, &candyNum)
	if err != nil {
	}

	for i := 1; i <= moveNum; i++ {
		j := moveNum - i
		a := 0
		if i%2 == 0 {
			a = (i + 1) * (i / 2)
		} else {
			a = ((i + 1) / 2) * i
		}
		if a < j {
			continue
		}
		candy := a - j
		if (candy - candyNum) == 0 {
			fmt.Println(j)
		}
	}
}

这才过了，但耗时太长，1809 ms 。
发现以 i 求循环不妥，因为 i 的取值通常比 j 大，所需循环次数更大，所以换成了 j 求循环，最后耗时 1747 ms，节省了近 100ms，但还是很大。

思路二

将上述条件全部换成成以 j 为变量的方程，直接对 j 求方程：

package main

import (
	"fmt"
)

func candyPut(moveNum int, candyNum int) int {
	var j int
	a := 2*candyNum - moveNum*moveNum - moveNum
	for j = 0; j <= moveNum; j++ {
		if (j*j - 3*j - 2*moveNum*j) == a {
			return j
		}
	}
	return j
}

func main() {
	var moveNum, candyNum int

	_, err := fmt.Scanln(&moveNum, &candyNum)
	if err != nil {
	}

	fmt.Println(candyPut(moveNum, candyNum))
}

耗时 686 ms。

总结

  1. 尽量避免乘法运算
  2. 将公式推导到最后一步 = = ！

leetcode第一题解题报告

地址：https://leetcode-cn.com/problems/two-sum/
`public int[] twoSum(int[] nums, int target) {

    int[] re = new int[2];
    Map<Integer,Integer> map = new HashMap<>();
    for(int i = 0;i < nums.length;i++){
        map.put(nums[i],i + 1);
    }

    for(int i = 0;i < nums.length;i++){
        int sub = target - nums[i];
        if(map.containsKey(sub)){
            re[0] = i;
            re[1] = map.get(sub) - 1;
            if(re[0] == re[1]){
                continue;
            }
            break;
        }
    }
    return re;
}`

本题可以暴力求解，也可以用Map**来解题，一开始有一种情形没考虑到，导致一次失误，
[3,2,4] 6
期望值是[1,2]，而我的结果是：[0,0]，还需要多多考虑一些特殊情况啊。

Building your own kubernetes CRDs

原文：https://itnext.io/building-your-own-kubernetes-crds-701de1c9a161

这篇文章讲解如果通过 kubebuilder 构建自己的 CRD，CRD 是 Kubernetes 里的自定义资源，随着 K8s 对核心 API 精简，越来越多的功能会以 CRD 的方式提供，而逐渐完善的周边功能，允许用户自己定义 controller 来拓展 Kube 集群

kubebuilder 是一个 controller 的快速构建工具，核心功能就是在 informer 注册，然后让用户自己实现一个 handle

Codeforces Round #575 周赛

A 题

A 题就是两个人平分三份糖果，保最后两人一样多，全加起来除以 2，再向下取整。

代码不贴了。

B 题

题意：给你 n 个数据，把他们分成 k 组，每组和为奇数，如果满足不了要求，就输出 NO，如果可以分，输出 YES 和任何一种分法。
思路：找出所有奇数所在位置，组成数组 result[]，该数组长度为 l；
1. 如果 l < k，直接输出 NO；
2. 如果 (l-k) % 2 == 1，也输出 NO；
3. 如果 (l-k) % 2 == 0，输出 YES，并取 result 的前 k-1 个和 n 为最后输出。

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	input := bufio.NewReader(os.Stdin)
	var num int

	_, err := fmt.Fscanf(input, "%d\n", &num)
	if err != nil {
	}

	for num > 0 {
		num -= 1
		var n, k, j int

		_, err := fmt.Fscanf(input, "%v %v\n", &n, &k)
		if err != nil {
		}

		var arr = make([]int, n)
		var result = make([]string, n)

		for i := 0; i < n; i++ {
			_, err := fmt.Fscanf(input, "%v", &arr[i])
			if err != nil {
			}

			if arr[i]%2 == 1 {
				result[j] = strconv.Itoa(i + 1)
				j++
			}
		}
		_, err = fmt.Fscanf(input, "\n")
		if err != nil {
		}

		if j < k || (j-k)%2 != 0 {
			fmt.Println("NO")
			continue
		}
		fmt.Println("YES")

		total := result[:k-1]
		total = append(total, strconv.Itoa(n))

		fmt.Println(strings.Join(total, " "))
	}
}

总结：Go 语言获取输入要用 bufio，否则数据量大起来就超时了。

win10 Home安装注意事项

1.win10 Home版包含在customer edition中，下载镜像要选择带customer edition的
2.win10 Home安装要选择Legency模式，选择UEFI的话，安装U盘不会被识别
3.原装出厂的系统最适合当前笔记本，一般都是经过厂家做过兼容性测试的

Go 中函数间传递数组的注意事项

Go 中函数间传递数组，尽量避免用数组，用指针和切片更好。
原因：函数间传递参数传递的是值，直接传递数组会增大不必要的内存；用指针传递的话只会开辟一个指针的内存，而切片也是只占用头指针的内存。
如下：

func test(a [12]int){} // 避免
func test(a []int){}
func test(a *[12]int){}

kubelet 报错：孤儿 pod volume path 一直存在

通过 cronjob 产生的 pod 完成后状态变成了 completed，此时变成了孤儿 pod。如果其用了 volume，他的 volume path 没有被删除，根本原因是 kubelet 的 housekeeper 逻辑被删除。

该问题没有被彻底解决，workarond：将 pod 的元数据（/var/lib/kuebet/pods/<pod_id>）删除。

Netty In Action

Netty实战英文版。
中文版读起来感觉理解有点费劲,2333

Codeforces Round #576 周赛

看错时间错过了比赛_(:з」∠)_，想起来的时候做了两题，权当比赛了。

A 题

题意：已知夏天有 n 天，市长有未卜先知的能力，知道每天的降雨量，要选出一天 d 当庆祝盛典的节日，要求这一天 d 的前 x 天和前 y 天内，d 的降雨量最少。需要注意的是 d < x 和 d + y > n 都是可以的。
解法：没啥特殊技巧，应算。

package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
)

func main() {
	input := bufio.NewReader(os.Stdin)
	var n, x, y int

	_, err := fmt.Fscanf(input, "%d %d %d\n", &n, &x, &y)
	if err != nil {
	}

	arr := make([]int, n)
	min := math.MaxInt32
	var xx, yy, index int
	index = 1
	for i := 0; i < n; i++ {
		_, err := fmt.Fscanf(input, "%v", &arr[i])
		if err != nil {
		}

		if (xx >= x || index-x <= 0) && yy >= y {
			fmt.Println(index)
			return
		}

		if arr[i] < min {
			min = arr[i]
			index = i + 1
			xx += 1
			yy = 0
		} else {
			yy += 1
		}

	}
	fmt.Println(index)
	_, err = fmt.Fscanf(input, "\n")

}

B 题

题意：一株睡莲，垂直生成的话高出水面 h，斜着长到刚好贴着水面，距离垂直位置长度为 l，求水深，要求误差不超过 1e-6。
解法：勾股定理求出表达式即可。

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	input := bufio.NewReader(os.Stdin)
	var h, l int64
	var result float64

	_, err := fmt.Fscanf(input, "%d %d\n", &h, &l)
	if err != nil {
	}

	result = (float64(l*l) / float64(2*h)) - float64(h)/2.0
	fmt.Printf("%.13f", result)

}

需要注意的是，要先把 int 转成 float，再带入公式运算，否则会有整形溢出的问题。

AuthN/AuthZ with OIDC and a Little Help From Keycloak

原文链接：https://medium.com/@mrbobbytables/kubernetes-day-2-operations-authn-authz-with-oidc-and-a-little-help-from-keycloak-de4ea1bdbbe

文章详细介绍了在 Kubernetes 中使用 OIDC 协议。

K8s 只提供了配置 OIDC 的入口，他并不是 Identity Provider；对 kube 来说，用 oidc 通常是要支持 AD/LDAP 的，可以对 kube 做用户管理，而权限控制是 kube 内置的，不需要 OIDC 来做；对 K8s 原生支持的 OIDC 功能来说，使用起来并不人性化，需要用户自己将 ID token 和 refresh token 填写进 kubeconfig 文件，不过现在已经有相当多周边工具可以配置 kubectl 来实现这一步的自动化。

文章不仅详解了 OIDC 的过程，在 K8s 中的配置，还细数了支持 K8s 使用 OIDC 的周边工具，好文。

Educational Codeforces Round 69

A 题

给了 n 个木板，求最大能搭建几节梯子，题目很简单，被 GO（或者后台测试数据格式）坑了

最后用 Py 过的：

def main():
    test_case = int(input())
    while test_case:
        test_case -= 1
        num = int(input())
        p = list(map(int,input().split()))

        p = sorted(p)

        m = p[-2]
        print(min(num - 2, m - 1))


if __name__ == "__main__":
    main()

被 @BLF2 修改过的 Go 代码，据说能过了：

package main

import (
	"fmt"
	"sort"
)

func main() {

	var testCase int

	if _, err := fmt.Scan(&testCase); err != nil {
	}

	for testCase > 0 {
		testCase -= 1
		var plankNum int
		if _, err := fmt.Scan(&plankNum); err != nil {
		}

		planks := make([]int, plankNum)
		for i := 0; i < plankNum; i += 1 {
			if _, err := fmt.Scan(&planks[i]); err != nil {
			}
		}

		if plankNum < 3 {
			fmt.Println(0)
			continue
		}

		sort.Ints(planks)
		m := planks[plankNum-2]

		if m-1 < plankNum-2 {
			fmt.Println(m - 1)
		} else {
			fmt.Println(plankNum - 2)
		}
	}
}

查看日志尽量少使用vim

查看日志尽量少使用vim，尤其是日志文件比较大的时候。
因为vim操作会加载整个文件到内存中。
替代命令less、more、grep -n

CoreDNS 使用与架构分析

原文：https://zhengyinyong.com/coredns-basis.html

Kubernetes 的服务发现功能有两种，一种是环境变量注入，一种是 DNS。CoreDNS 在 1.3 版本后取代了 Kube-dns 成为了 Kube 的默认 DNS 服务器。

文章主要介绍了 coreDNS 的安装、Corefile 组成及其处理 DNS 请求的过程。Corefile 部分介绍的比较详细，可以对 coreDNS 配置文件有初步的全局化的认识，并可尝试对 CoreDNS 的 configMap 添加自定义配置，支持 pod 间互相访问的*操作。

Pod 中的 pause 容器不可以被 docker restart

在 Kube 中的 Pod，一般是 pause 容器 + 业务容器。其中，pause 容器尽量不要用 docker restart 重启，因为重启后 docker 会将其网络配置重置，由于没有走 pod 创建的正常流程，kubelet 不会为其配置预设的网络配置。

Educational Codeforces Round 69

昨天死在 A 题上了_(:з」∠)_

A 题

题意：给你 n 个木棍 ，求出可以组成楼梯的最大台阶数。
根据题意可列出方程：

  1. k <= max2 -1 (max2 为第二大数)
  2. k <= n - 2
    即求得 max2 - 1 和 n - 2 取最小就好了。
package main

import "fmt"

func main() {
	var tesNum int

	_, err := fmt.Scanln(&tesNum)
	if err != nil {
	}

	var vKey = 0
	for i := 0; i < tesNum; i++ {
		_, err := fmt.Scanln(&vKey)
		if err != nil {
		}
		var vValue = make([]int, vKey)
		var max = [2] int{0, 0}

		for j := 0; j < vKey; j++ {
			_, err = fmt.Scan(&vValue[j])
			if err != nil {
			}

			if vValue[j] > max[0] {
				max[1] = max[0]
				max[0] = vValue[j]
				continue
			}
			if vValue[j] > max[1] {
				max[1] = vValue[j]
			}
		}

		v1 := max[1] - 1
		v2 := vKey - 2
		if v1 <= v2 {
			fmt.Println(v1)
		} else {
			fmt.Println(v2)
		}
	}
}

然后！第一个 case 就挂！！最后经 @BLF2 同学指导，发现是输入可能以空格结束，用 Scan 可以，用 Scanln 就不行。(╯‵□′)╯︵┻━┻

后来用 Py 过的：

if __name__ == "__main__":
    test_num = int(input())
    while test_num:
        test_num -= 1

        arr_num = int(input())
        arr = input()
        num = [int(n) for n in arr.split()]

        num = sorted(num)
        result = min(num[-2] - 1, arr_num - 2)
        print(result)

总结：
不用 Scanln 获取输入！！！

https://codeforces.com/contest/1199/problem/A

前x天，后y天，中间这天降雨量最少，求这天的数组下标。
一开始的思路是分割数组找两边最小的值与中间值进行比较，比较麻烦，也没AC。后面看了两位大佬的。。。


import java.util.Scanner;
 
public class Cf576A {
 
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n, x, y;
        n = scanner.nextInt();
        x = scanner.nextInt();
        y = scanner.nextInt();
        int[] a = new int[n + 1];
 
        for (int i = 1; i < n + 1; i++) {
            a[i] = scanner.nextInt();
        }
 
        boolean exist = false;
        for (int i = x; i <= n; i++) {
            int minBefore = findMin(a, i - x, x);
            if (a[i] > minBefore) {
                continue;
            }
            if (i + y <= n) {
                int minAfter = findMin(a, i + 1, y);
                if (a[i] > minAfter) {
                    continue;
                }
            }
            System.out.println(i);
            exist = true;
            break;
        }
        if (!exist) {
            System.out.println(n);
        }
 
    }
 
    private static int findMin(int[] a, int startIndex, int num) {
        int min = 999999999;
        for (int i = startIndex; i < startIndex + num; i++) {
            if (min > a[i]) {
                min = a[i];
            }
        }
        return min;
    }
}

golang 的内存分配

原文：https://mp.weixin.qq.com/s?__biz=MjM5OTcxMzE0MQ==&mid=2653372575&idx=1&sn=b9ec90402e6f8777f9fa19557404bb56&chksm=bce4a0858b932993c09f37d65697ce9d12fc1825fa51d04771159186131ed6ddb5a34099c81b&mpshare=1&scene=1&srcid=#rd

图解 Golang 内存。
内存包括：span(存储指针，指向 areana 中的对象) + bitmap(标记 areana 中存储的对象是否有地址及是否被 gc) + arena(堆，分页存放)

go的内存管理组件主要有： mspan、 mcache、 mcentral 和 mheap

Consul Service Mesh 的7层网络可观察性

原文地址：https://www.servicemesher.com/blog/layer-7-observability-with-consul-service-mesh/

如果说容器以及编排平台解决了分发、调度、配置等静态的问题，那么 Service Mesh 将是着手于 流量、鉴权、观察等动态的问题。

Consul 本身是一个流行的配置/注册中心，支持 KV 存储，基于 DNS 的服务发现等，在 1.2 后推出的 connect 开始布局 Service Mesh。

现在的 Service Mesh 就像 16 年左右的编排平台一样，布局的人很多，很难说谁会成为主流，但是将 复杂而常用的能力 下降到平台、到基础设施是大势所趋，比如原来靠注册中心才能有的服务注册于发现，Kubernetes 原生自带，靠对接 tracing 才能拿到的调用链，Service Mesh 可以实时生成。

Istio 以及 Service Mesh 的入门可以看我的一篇总结：
https://blog.ihypo.net/15445280820219.html

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.