基金 基金定投 股市相关概念 相关书籍 《巴比伦富翁新解》读书笔记 《百箭穿杨》读书笔记 To Read 《布雷迪报告》

tags: Programming Language 柯里化 func max(a, b int) int { if a > b { return a } return b } func currying(a int) func(int) int { return func(b int) int { return max(a, b) } }

tags: Go Channel Directions func demo(readOnlyStream <-chan bool, writeOnlyStream chan<- bool) { }

tags: Emacs 如何从历史跳到其他命令列表 Key binds C-o See also: https://emacs.stackexchange.com/questions/18173/how-to-jump-from-emacs-command-history-to-emacs-commands-in-helm

Links A Makefile for Emacs Packages

Makefile SSH macOS max open files macOS TimeMachine 日志 macOS 问题解决三板斧

将资金交给投资经理人进行投资盈利跑赢 CPI 或赚取更多利润。 分类 交易方式划分： 开放式基金（活期） 封闭式基金（死期） 投资对象划分: 货币基金：余额宝 股票型、债卷型：依靠基金经理管理基金的能力 指数型：被动型基金，依靠大盘指数，美股属于长牛短熊型能跑赢主动型，A 股属于短牛长熊跑赢主动型比较困难。 股票 VS 基金 股票：想一夜暴富（也可能一夜暴亏） 基金：财富增值，门槛低，风险低 如何选基 市场研判 股市走熊：债卷基金 牛市初中：股票基金和指数基金 自身情况 稳健型 激进型 技巧 基金评级 国外渠道 晨星 国内渠道 银河证劵 海通证劵 济安金信 招商证劵 历史业绩 将基金收益与股票大盘走势进行比较； 将基金收益与其他同类基金的收益进行比较； 将基金的当期收益与历史收益进行比较。 一些指标 夏普比率 > 0 基金报酬大于风险，< 0 风险大过报酬 标准差越小，投资风险越低 天天基金网等三方平台上都能看，晨星网上更全。天天基金网的特色数据一栏可以看，晨星网的基金工具里包括阿尔法系数等指标都有标识。 Links 〈如何买基金？基金入门，学会这几招就够了〉

Wikipedia: https://zh.wikipedia.org/wiki/%E5%A4%8D%E5%88%A9

它是用来衡量金融资产绩效基金表现的一个指标，核心思想就是选择收益率相近的基金承担的风险越小越好，选择风险水平相同的基金则收益率越高越好。总之，夏普比率越大，说明这只基金的绩效越好。 > 0 基金报酬大于风险 < 0 基金风险大过报酬

又称标准偏差、均方差，数学符号 sigma。概率统计中最常使用作为测量一组数值的离散程度。 定义：为方差开算数平方根，反应组内个体间的离散程度。 用在基金上反映了基金总回报率的波动幅度大小，数值越大，表明波动程度越厉害，稳定度越小，投资风险就越高。 越小，投资风险越低 越大，投资风险越高

:Tags: Financial Management 消费者物价指数

tags: 正在读的书,读书笔记,DDD 前言和目录 好的软件需要控制复杂性，好的领域模型可以帮助控制复杂性。 什么样的项目需要 DDD？尝试型的小型项目应该不需要 DDD，但是一旦上了规模考虑后续迭代则需要 DDD。 本书组织方式： 领域建模 领域建模的过程就是消化知识的过程，这个过程应该贯穿整个开发过程，需要持续学习。 模型用来描绘人们所关注的实现或想法的某个方面，比如地图就是模型。 模型是一种简化，是对实现的解释：把与解决问题密切相关的方面抽象出来，而忽略无关的细节。 软件问题建模的区域就是软件的领域 物质世界的领域：机票预订程序涉及的飞机乘客。 无形的领域：会计程序的金融领域。 领域涉及知识信息超载的问题，模型这种知识对知识进行了选择性的简化和有意的结构化。 领域模型将领域专家头脑中的支持严格的组织且有选择的抽象，并不是尽可能建立一个符合“现实”的模型。 模型表示 关联 规定一个遍历方向：存在双向联结时（地址 -> 人 或 人 -> 地址）尽量只用一种，并避免互相关联 添加一个限定符，以便有效减少多重关联 消除不必要的关联 表示方式 领域模式 实践 MODEL-DRIVEN DESIGN 隔离领域：引入应用层 应用 LAYERED ARCHITECTURE 把领域层划分出来，通过应用层类来处理应用程序功能。应用层类是协调者，负责提问，领域层负责回答。 将 ENTITY 和 VALUE OBJECT 区分开 依次考虑对象是必须跟踪的 ENTITY 还是表示一个 VALUE OBJECT。 AGGREGATE 边界 识别模型中的 AGGREGATE 根和对应的边界。 选择 REPOSITORY 为 AGGREGATE 根对象建立 REPOSITORY。 场景走查 根据应用程序特性复核建模，进行场景走查，确保能够有效地解决应用问题。可以走查一些正常和异常业务场景进行复核。 对象创建 如果对象复杂则创建单独的 FACTORY 类进行对象创建，简单对象可以直接在 AGGREGATE 根上通过 FACTORY METHOD 进行创建。 停一下，重构 建模和设计需要经常进行重构：利用新知识来改进模型和设计。 ...

tags: LeetCode 移除小写字母中重复的字母，让所有字母都只出现一次，并且结果是所有结果中按照字典序排序最小的那个。 Example 1 Input: “bcabc” Output: “abc” Example 2 Input: “cbacdcbc” Output: “acdb” 解法之一: 通过一个数组对每一个出现的字母进行计数 遍历每一个字母放入栈，并将该字母的计数减 1 查看栈底的字母有没有比当前字母大且该字母的计数不为 0 的（有比当前更小的字典序），从栈底弹出该字母 func removeDuplicateLetters(s string) string { var countOfEachLetter [26]int var visited [26]bool stack := make([]byte, 0) stackBottom := 0 bytesArr := []byte(s) for _, c := range bytesArr { countOfEachLetter[getIndex(c)]++ } for _, c := range bytesArr { index := getIndex(c) countOfEachLetter[index]-- if visited[index] { continue } // countOfEachLetter[getIndex(stack[stackBottom])] > 0 后面还有该字符 for len(stack[stackBottom:]) > 0 && stack[stackBottom] > c && countOfEachLetter[getIndex(stack[stackBottom])] > 0 { // 标记为未访问用于后面的字符加入结果 visited[getIndex(stack[stackBottom])] = false // 移动栈底 stackBottom++ } // 加入到结果栈 stack = append(stack, c) visited[index] = true } return string(stack[stackBottom:]) } func getIndex(b byte) int { return int(b - 'a') } 通过上面解法遇到如下错误： ...

tags: LeetCode 解法 1 找到中间节点依次往左右扩散： 向左边扩散，如果左边的大于当前元素，那么当前元素即为最小值 向右边扩散，如果右边的小于当前元素，那么右边元素即为最小值 如果以上不成立则第一个元素为最小元素（未旋转），以下是代码 func findMin(nums []int) int { length := len(nums) if length == 1 { return nums[0] } // 从中间开始确定方向 mid := length / 2 - 1 left, right := mid, mid for left - 1 >= 0 || right + 1 < length { if left - 1 >= 0 { if nums[left - 1] > nums[left] { return nums[left]; } left-- } if right + 1 < length { if nums[right] > nums[right + 1] { return nums[right + 1] } right++ } } return nums[0] } 优化 参考答案后可通过二分查找做如下优化，首先判断是否被旋转： 如果数组尾部的元素大于首部的元素则表示数组未被旋转，可以直接返回第一个元素。 由于是从一个有序数组旋转的，所以以上条件可以保证。 然后再判断方向： 如果所取中间元素大于数组的第一个元素则最小元素在右边 否则最小元素在左边 func findMin(nums []int) int { length := len(nums) if nums[0] <= nums[length - 1]{ return nums[0] } if length == 2 { return nums[1] } left, right := 0, length - 1 for left < right { mid := left + ((right - left) / 2) if nums[mid] > nums[mid + 1] { return nums[mid + 1] } if nums[mid - 1] > nums[mid] { return nums[mid] } if nums[mid] > nums[0] { left = mid + 1 } else { right = mid - 1 } } return -1 }

tags: LeetCode 思路 这个是 LeetCode: 153.Find Minimum in Rotated Sorted Array 扩展，增加了以下几种边界情况： ‘[2, 2, 2, 2, 1]’ ‘[3, 1, 3]’ ‘[1, 1, 1]’ ‘[10, 1, 10, 10, 10]’ 但核心依然是判断最小值是在左边还是右边。假设如下数组： ‘[3, 3, 3, 1, 3]’ left[0]=3, right[4]=3, mid[2]=3, 这时候不确定最小值在哪边但是 right– 是安全的，所以执行 right– left[0]=3, right[3]=1, mid[2]=3, 这时候 mid < right 说明最小值在 mid 的右边，所以调整 left = mid + 1 左右两边索引一致终止循环 实现 func findMin(nums []int) int { length := len(nums) left, right := 0, length - 1 for left < right { mid := (left + right) / 2 if nums[mid] > nums[right] { left = mid + 1 } else if nums[mid] < nums[right] { right = mid } else { right-- } } return nums[right] }

tags: LeetCode 准备 动态规划 实践 字符串 “abcabcbb” 根据索引有如下关系 a b c a b c b b 0 1 2 3 4 5 6 7 \(f(0,1)=f(0,0) + 1\) \(f(0,2)=f(0,1) + 2\) 在所有字符都不重复的情况下有如下公式 \(f(s,e)=f(s,e-1) + e\) 若遇到重复的情况则，3 索引于当前字串 的 0 重复则表明当前字串已经到头，需要记录并偏移 s，s=1： \(f(1,3)=f(1,2)+3\) 假设： s - 开始字符索引 e - 结束字符索引 若遇到当前字符于前面 r 字符重复则： \[ f(r,e)=f(s,e - 1) + e; s=r \] 解法 func lengthOfLongestSubstring(s string) int { if len(s) == 0 { return 0 } appearedIndexes := [256]int{} for i := 0; i < 256; i++{ appearedIndexes[i] = -1 } longest, start, end := 0, 0, 0 b := []byte(s) for cIndex, c := range b { index := int(c) appearedIndex := appearedIndexes[index] end = cIndex // 出现过需要截断 if appearedIndex != -1 { // 重置已出现的字符 for i := start; i <= appearedIndex; i++{ appearedIndexes[b[i]] = -1 } length := end - start if length > longest { longest = length } start = appearedIndex+1 } appearedIndexes[index] = cIndex } if end - start + 1 > longest { longest = end - start + 1 } return longest }

tags: LeetCode 思路 归并排序 代码 func findMedianSortedArrays(nums1 []int, nums2 []int) float64 { nums := mergeSort(nums1, nums2) length := len(nums) if length % 2 != 0 { return float64(nums[(length - 1) / 2]) } i := length / 2 return (float64(nums[i]) + float64(nums[i - 1])) / 2 } func mergeSort(nums1 []int, nums2 []int) []int { l1 := len(nums1) l2 := len(nums2) result := make([]int, 0, l1 + l2) i, j := 0, 0 for i < l1 && j < l2 { if nums1[i] < nums2[j] { result = append(result, nums1[i]) i++ } else { result = append(result, nums2[j]) j++ } } result = append(result, nums1[i:]...) result = append(result, nums2[j:]...) return result }

tags: LeetCode > https://leetcode.com/problems/longest-palindromic-substring/description/ 思路 直接暴力往两边搜索 func longestPalindrome(s string) string { buf := []byte(s) length := len(buf) if length == 0 { return s } start, end := 0, 0 for ci, _ := range buf { i, j := ci, ci // 无法处理 "aaaa" 和 "noon" 这种情况 for i > 0 && j < length - 1 && buf[i - 1] == buf[j + 1] { i-- j++ } // 考虑 "bba" 这种情况 if i == j && ci > 0 && buf[ci] == buf[ci - 1] { i, j = ci-1, ci } // 考虑 "abb" 这种情况 if i == j && ci < length - 1 && buf[ci] == buf[ci + 1] { i, j = ci, ci + 1 } if i != j && j - i >= end - start { start, end = i, j } } return string(buf[start:end + 1]) } 上面代码无法处理 “aaaa” 和 “noon” 这种情况，只要把下面处理 “bba” 和 “abb” 情况的代码放到上面即可 ...

tags: LeetCode srouce: https://leetcode.com/problems/zigzag-conversion/description/ 先根据行数计算列数： \(column=length / (row + 2) + bool(length \mod (row + 2))\) 每一行必然有点的位置为： \(i \mod (row - 1)\) 为 0

tags: 读书笔记,Rust 语句和表达式 所有权 引用和借用 结构体 枚举 模式匹配 if let 模块化 错误处理 Traits 生命周期 闭包 迭代器 智能指针 Rust 宏 Rust 并发 函数指针 fn 区分闭包的 Fn 特性，函数指针都实现来三个闭包的特性。 fn do(f: fn(i32) -> i32, arg: i32) -> i32 { f(arg) + f(arg) }