Notes

tags: 技术 设计原则 SOLID 好的架构 我认为好的架构 能够无心智障碍的编写运行单元测试 从一起作业看好的架构 应该能够让任何开发人员方便的随时上线和回滚 面对上线对基础设施没有心理压力 完备的监控

需要熟悉股市相关概念进行扫盲。 粗读要点 树立安全边际，跟随格雷厄姆 寻找好的困难股，降低触底难度，加大触底区间，预测底部区间，分 5 档抄底，最好在 1-3 档就能完成抄底 每次只买总资产的 1% 盈利后可以将本金提出，只留底仓等待顶峰信号后抛出赚取高额利润的前提下保障本金 总是留 25%-40% 的现金 做长线 分析财报看毛利、营收增长率、负债率可以确定一个好股，然后就等一些情况下这只股遇到困难触底 看行业处于哪个周期：萌发、成长啥的 不做重仓 复读要点完善 安全边际 跟随格雷厄姆 偏离：更保守或更激进 大赚小赔不如小赚不赔：不亏钱 困境好企 做有把握的事，不啃硬骨头，广撒网，多捞鱼，选取一批困境好企来实现从小盘大稳定增长股 行业中的好企业标准 行业很关键 需求无限，供给有限 关注行业周期 大周期：新生->成长->成熟->衰落->消亡 小周期：大周期各个过程中的景气与萧条（一两年、三五年甚至一二十年） 消亡之前会有死灰复燃，大周期中成长阶段会有萧条，注意区分。 门槛高，竞争少 只有少数寡头，估值会高 唯一或第一 成熟行业比较简单，成长行业比较困难。 通过企业原则、经营原则、财务原则和市场原则衡量。- P28 生活经验活常识也很重要。 落难好企 行业顺境，某些原因导致的猜疑导致股价下跌 行业遭遇整体困境：偶然事件，反转时间比好把握 个股困境，主打产品破灭：有无法度过的风险 财务数据衡量困境好企能否度过难关 - P32 负债率越低越好：不能超过 50% 资产中的现金越多越好：高于股东权益的 1/3，刚上市的好过上市很久的老企业（把钱折腾光了） 产品的毛利率越高越好：市场有需求 应收账款越少越好：钱可能收不回来 通过季报发现反转时机 季报时间长，抗短期干扰，一季度定调、二季度（半年）纠偏或修正、三季度出结果（更好或更差）、四季度（年报）成果汇报和新的起点用于比较第一季度。 一季度和半年狠重要。 通过 营业收入 发现转机。困境表现为净利润增速下滑，之前是好企可能会市盈率过高。 容错寻底 不亏钱的情况下寻找极限底部，保障安全、带来最大利润、带来良好心态 变种“不破买价”：买入的价格很难再跌回原来的位置 变成左侧交易者，不追涨 大盘底与个股底的关系 同步性：大盘筑底个股也在筑底，大盘达到最低位时，个股也先后到达最低位 差异性 大盘下跌蓝筹股先跌到位，大盘下跌过程中小盘成长股与稳定增长股少许跟跌或逆市上扬。 市场反弹小盘成长股与稳定增长股开始杀跌。 耦合性：大盘底出现时次新股出现底部的概率大，老股形成底部可能需要好几年 – P56 ...

tags: Bigdata 相关知识点 概念组成 Producer 消息产生者，往指定 Topic 的指定 Partition 发送消息 Consumer Group 消费指定 Topic 的消息 Consumer 消费指定 Topic 下某一分区的消息 Topic 区分不同消息主题 Partition 保证同一分区的有序性 Connector 消息可被不同的 Consumer Group 重复消费（广播或订阅）。同一 Consumer Group 下的不同 Consumer 分别消费不同的 Partition，Consumer 数量不能超过 Partition 数量。 数据被持久化并分片成功后发送 ACK 保证里数据不被丢失。 设计 持久化 基于文件系统 基于队列是顺序的和磁盘的顺序访问要比内存的随机访问要快（参见 The Pathologies of Big Data）， Kafka 采用在磁盘文件系统上尾部写头部读的方式。 Kafka 没有采用 BTree 存储数据因为 BTree 的操作是 O(log N) ，而且对磁盘的 seek 操作要慢，且同时只能进行一次限制了并行，所以实际操作比 O(log N) 要慢 基于磁盘的顺序访问进行在尾部写和头部读，可以实现读写都是 O(1) 的时间复杂度，并且读写互不干扰 基于以上实现，Kafka 可以不必在消息一经消费就删除，而是可以保留消息一段相对较长的时间（比如一周） 高效 并且采用统一的日志格式，可以方便的使用 sendfile 避免字节拷贝以在各个组件之间高效的交换日志文件 ...

tags: Learning,Algorithm

tags: LeetCode

tags: Linux 原文连接：Linux Virtual Memory Management Chapter 2 Describing Physical Memory：描述物理内存 独立于平台架构的方式描述内存 — 更好的支持多平台 本章包含描述存储器、内存页的结构体（structures）和一些影响 VM 行为的标识位（flags） VM 中普遍（prevlent）认为第一重要（principal）的概念是 NUMA。 大型机器中内存访问速度取决于 CPU 到内存的距离。比如一组（bank）内存分配给每一个处理器或者一组内存非常适合靠近的 DMA 设备卡。 这里的每组（bank）内存被称为节点（node）并且这个概念在 Linux 中通过 struct pglist_data（typedef pg_data_t) 表示，即使在 UMA 架构下也是如此。每一个节点是一个由 NULL 结尾的链表，通过 pg_data_t->next_node 指向下一个节点。 每一个节点都被分割成多个块（block）称为分区（zone）用于表示内存中的范围。分区使用 struct zone_struct(typedef zone_t) 结构体描述，每一个分区都是以下三种类型的一种 ZONE_DMA 开始 16MB 内存，供 ISA 设备使用 ZONE_NORMAL 16MB - 896MB，由内核直接映射到线性地址空间的上部区域（将在第四章讨论） ZONE_HIGHMEM 896MB - END，剩余不由内核直接映射的系统可用内存， 大部分内核操作都只能使用这种类型的分区，所以这里也是这里也是最关键的性能区域（most performance critical zone） 每一个物理页帧（physical page frame）都使用结构体 struct page 表示，所有的结构体都保存在全局数组 mem_map 中，mem_map 通常存储在 ZONE_NORMAL 的开始处； 结构体之间的关系 内存节点 Linux 在分配内存页的时候采用 本地节点分配策略（node-local allocation policy） 通过最靠近当前运行 CPU 的节点去分配内存。同时进程也会趋向于采用同一 CPU 运行。 ...

tags: Algorithm 状态转移方程 无后效性 如果给定某一阶段的状态，则在这一阶段以后过程的发展不受这阶段以前各段状态的影响。 一旦 \(f(n)\) 确定，“我们如何凑出 \(f(n)\) ”就再也用不着了： 要求出 \(f(15)\)，只需要知道 \(f(14)\),\(f(10)\),\(f(4)\) 的值， 而 \(f(14)\),\(f(10)\),\(f(4)\) 是如何算出来的，对之后的问题没有影响。 “未来与过去无关”，这就是无后效性。 最优子结构 大问题的最优解可以由小问题的最优解推出，这个性质叫做“最优子结构性质”： \(f(n)\) 的定义需要蕴含“最优”，利用 \(f(14)\),\(f(10)\),\(f(4)\) 的最优解，我们即可算出 \(f(15)\) 的最优解。 能将大问题拆成几个小问题，且满足无后效性、最优子结构性质。 DP 思路 参见 LeetCode 讨论： 先写出穷举的方法 找出不必要的重复计算 写出 DP 练习 0x00 硬币找零 描述 假设有几种硬币，如1、3、5，并且数量无限。请找出能够组成某个数目的找零所使用最少的硬币数。 状态转移公式 公式 \(f(n)=min\{f(n-1),f(n-3),f(n-5)\} + 1\) 检查是否满足上面提到的两个特性： 无后效性：对于 \(n\)，一旦 \(f(n)\) 确定，以后只关心 \(f(n)\) 的值，不关心怎么计算的； 最优子结构：对于 \(n\)，只要 \(n - 1\) \(n - 3\) \(n - 5\) 能是最优解，那么就能计算出 n; 推导过程 假设找零 15： 若优先使用 5 元硬币 \(cost = f(10) + 1 = 2 + 1 = 3\) ...

tags: Algorithm,Sorting Wikipedia: 归并排序

alias: Algorithm

tags: Over the Wall,HTTPs 这里以新增 vd.linuxzen.com 为例。 新增 DNS 解析 通过 DNSPOD 新增 DNS 解析 A 记录 调整 Nginx 新增 HTTP 站点 Nginx 参考配置 server { listen 80; server_name vd.linuxzen.com; include /etc/nginx/snippets/letsencrypt-acme-challenge.conf; } 新增签发证书 $ acme.sh --force --issue -d linuxzen.com -d www.linuxzen.com -d cwiki.linuxzen.com -d monitor.linuxzen.com -d v.linuxzen.com -d vd.linuxzen.com -d d.linuxzen.com -d piwik.linuxzen.com -d t.linuxzen.com -d wiki.linuxzen.com -d note.linuxzen.com -w /var/www/letsencrypt/ 安装证书 $ acme.sh --install-cert -d linuxzen.com --cert-file /etc/nginx/certs/linuxzen.com/cert.pem --key-file /etc/nginx/certs/linuxzen.com/privkey.pem --fullchain-file /etc/nginx/certs/linuxzen.com/fullchain.pem --reloadcmd "sudo service nginx reload && docker restart ipsec-vpn-ssl && docker restart v2ray && docker restart v2ray2" 调整 Nginx 配置文件应用证书 server { listen 80; server_name vd.linuxzen.com; return 301 https://$server_name$request_uri; } server { listen 443 http2 ssl fastopen=3 reuseport; server_name vd.linuxzen.com; ssl_certificate /etc/nginx/certs/linuxzen.com/fullchain.pem; ssl_certificate_key /etc/nginx/certs/linuxzen.com/privkey.pem; ssl_protocols TLSv1 TLSv1.1 TLSv1.2; ssl_prefer_server_ciphers on; ssl_dhparam /etc/ssl/certs/dhparam.pem; ssl_ciphers 'ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:AES:CAMELLIA:DES-CBC3-SHA:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!aECDH:!EDH-DSS-DES-CBC3-SHA:!EDH-RSA-DES-CBC3-SHA:!KRB5-DES-CBC3-SHA'; ssl_session_timeout 1d; ssl_session_cache shared:SSL:50m; ssl_stapling on; ssl_stapling_verify on; add_header Strict-Transport-Security max-age=15768000; access_log /var/log/nginx/vd.linuxzen.com.log; location / { root /srv/www/vd.linuxzen.com; index index.html index.htm; } location /passport { proxy_redirect off; proxy_pass http://v2ray; proxy_http_version 1.1; proxy_read_timeout 300s; proxy_send_timeout 300s; proxy_set_header Upgrade $http_upgrade; proxy_set_header Connection "Upgrade"; proxy_set_header Host $http_host; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; } include /etc/nginx/snippets/letsencrypt-acme-challenge.conf; }

tags: Over the Wall,Tools 架构 Client -> DIDIYun(HAProxy) -> HK 滴滴云 HAPorxy 配置 117.51.146.119 frontend v_linuxzen_com bind *:6697 option tcplog mode tcp default_backend v_linuxzen_com_nodes backend v_linuxzen_com_nodes mode tcp balance roundrobin option ssl-hello-chk server webserver1 45.115.36.35:443 check 客户端改动 需要调整 hosts $ echo '117.51.146.119 v.linuxzen.com' | sudo tee -a /etc/hosts HK V2Ray Docker 启动 $ docker run -d -p 127.0.0.1:25001:25001 --name v2ray --restart always -v /etc/v2ray:/etc/v2ray v2ray/official HK Let’s Encrypt 证书 $ acme.sh --issue -d linuxzen.com -d www.linuxzen.com -d cwiki.linuxzen.com -d monitor.linuxzen.com -d v.linuxzen.com -d d.linuxzen.com -d piwik.linuxzen.com -d t.linuxzen.com -d wiki.linuxzen.com -d note.linuxzen.com -w /var/www/letsencrypt/ $ acme.sh --install-cert -d linuxzen.com --cert-file /etc/nginx/certs/linuxzen.com/cert.pem --key-file /etc/nginx/certs/linuxzen.com/privkey.pem --fullchain-file /etc/nginx/certs/linuxzen.com/fullchain.pem --reloadcmd "sudo service nginx reload && docker restart ipsec-vpn-ssl && docker restart v2ray && docker restart v2ray2" HK V2Ray 配置 { "log": { "loglevel": "debug", "access": "/var/log/v2ray/access.log", "error": "/var/log/v2ray/error.log" }, "inbounds": [ { "port": 25001, "listen":"0.0.0.0", "protocol": "vmess", "settings": { "clients": [ { "id": "1fde12b8-0cfd-11ea-a4b3-acde48001122", "alterId": 64 } ] }, "streamSettings": { "network": "ws", "wsSettings": { "path": "/passport" } } } ], "outbounds": [ { "protocol": "freedom", "settings": {} } ] } HK Nginx 配置 server { listen 80; server_name v.linuxzen.com; return 301 https://$server_name$request_uri; } upstream v2ray { server 127.0.0.1:25001; server 127.0.0.1:25002; } server{ listen 443 http2 ssl fastopen=3 reuseport; # listen 80; server_name v.linuxzen.com; ssl_certificate /etc/nginx/certs/linuxzen.com/fullchain.pem; ssl_certificate_key /etc/nginx/certs/linuxzen.com/privkey.pem; ssl_protocols TLSv1 TLSv1.1 TLSv1.2; ssl_prefer_server_ciphers on; ssl_dhparam /etc/ssl/certs/dhparam.pem; ssl_ciphers 'ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:AES:CAMELLIA:DES-CBC3-SHA:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!aECDH:!EDH-DSS-DES-CBC3-SHA:!EDH-RSA-DES-CBC3-SHA:!KRB5-DES-CBC3-SHA'; ssl_session_timeout 1d; ssl_session_cache shared:SSL:50m; ssl_stapling on; ssl_stapling_verify on; add_header Strict-Transport-Security max-age=15768000; access_log /var/log/nginx/v.linuxzen.com.log; location / { root /srv/www/v.linuxzen.com; index index.html index.htm; } location /passport { proxy_redirect off; proxy_pass http://v2ray; proxy_http_version 1.1; proxy_read_timeout 300s; proxy_send_timeout 300s; proxy_set_header Upgrade $http_upgrade; proxy_set_header Connection "Upgrade"; proxy_set_header Host $http_host; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; } include /etc/nginx/snippets/letsencrypt-acme-challenge.conf; } 新增一个域名用于单独的滴滴云加速 使用一个单独的域名 vd.linuxzen.com 用于滴滴云加速，参见Let’s Encrypt。

tags: Over the Wall,Network xinetd 代理 SMTP 和 IMAP 通过 xinetd 代理 SMTP 和 IMAP 实现 gmail 翻墙。 配置服务端 service imap { type = UNLISTED port = 993 bind = 0.0.0.0 socket_type = stream wait = no user = nobody redirect = imap.gmail.com 993 per_source = UNLIMITED cps = 100 2 } service smtp-465 { type = UNLISTED port = 465 bind = 0.0.0.0 socket_type = stream wait = no user = nobody redirect = smtp.gmail.com 465 per_source = UNLIMITED cps = 100 2 } service smtp-587 { type = UNLISTED port = 587 bind = 0.0.0.0 socket_type = stream wait = no user = nobody redirect = smtp.gmail.com 587 per_source = UNLIMITED cps = 100 2 } 本机修改 hosts ...

股分类 个股：投资资金来自个人的股票（还有国家股、法人股） 蓝筹股：明星股 小盘 市值比较低的股票 小盘价值股：格低于价值的股票，被低估的股票，长期看来值得投资的股票。 小盘成长股：成长潜力很大，公司发展处于较快阶段，但不确定性也比较高，业绩波动可能会很大。 稳定增长股：小盘具有一定品牌效应后的快销品，达到一定统治地位，最好在行业的繁荣周期顶峰卖出 周期股 相关指标 市盈率（P/E 或 PER）= 每股市值 / 每股盈余 每股市价处于每股盈余（EPS），评估股价是昂贵还是便宜。市盈率越低代表投资者能够以相对较低的价格购入股票。 Wikipedia: https://zh.wikipedia.org/wiki/%E5%B8%82%E7%9B%88%E7%8E%87 市净率（PBR，P/B） = 总市值 / 净资产 评估高风险企业，企业资产大量为实物资产的企业时收到重视。 市销率（PSR，P/S） = 总市值 / 营收 公司市值除以上一财年（或季度）的营业收入，或等价地，以公司股价除以每股营利收入，越小（小于 1）通常被认为投资价值越高。可以付出比单位营收更少的钱购买股票。 Wikipedia: https://zh.wikipedia.org/zh-hans/%E5%B8%82%E9%94%80%E7%8E%87 相关链接 简单直观的解释一下市盈率和市净率的意思

适合人群：穷人、笨人、忙人、好人 为什么 通胀太高，股票战胜通胀的重要工具 绝大多数人不具备择时能力 避免高点买入 核心逻辑：放弃择时，持续小额买入，降低成本 缺点：在市场上涨、高位震荡过程中，虽然盈利大幅提高，但持仓成本也在快速提高。一旦市场转向熊市，整体会迅速亏本。 单边上涨：定投盈利少于一次性投资 先震荡后上涨：定投盈利少于一次性投资 先上涨后下跌：定投亏损多于一次性投资 单边下跌：定投亏损少于一次性投资 震荡：定投与一次性投资持平 先下跌再震荡：定投亏损少于一次性投资 除了坚持，还在于止盈策略，牛市中成本不断提高，需要及时止盈，防止下跌时候的亏损 错误理念 定投不是万能，需要防止“倒微笑曲线周期” 巴菲特说指数基金难以超越仅限于美股，A 股与之相反 定投组合包含债券基金：定投适合波动较大的权益类资产（股票、商品），债卷等固定收益类产品本身波动小，一次性买入和定投基本没区别 月定投不够还要周定投：基本没差别 定投是懒人投资，坚持即可：还需要主动管理，如定投的标的不再适合定投，该换要换。 一次性投资止损不止赢，定投止赢不止损。 定投只买开放式基金：还可以宽基指数基金、主题指数基金、行业指数基金、风格指数基金、策略指数基金、QDII 指数基金、商品指数基金。此外，还有折价的封闭式基金、定增基金，适当的配置会非常好玩。 策略 定投买入，止盈不止损： 需要在可能出现的“倒微笑曲线周期”及时止盈。 制订量化估值标准 技术分析 通过MA、MACD、RSI等各种技术指标，判断目前市场从长期看，是相对低位还是高位 趋势上涨原则：MA(30)>MA(60)>MA(120)； 趋势下跌原则：MA(30)<MA(60)<MA(120)。 均线偏离法：根据指数价格对均线偏离的程度决定投资额度的多少。 P>MA(120)：正偏离，减少投资额度； P<MA(120)：负偏离，增加投资额度。 基本面分析 根据指数相关基本面指标，判断股市处于高估或者低估。如市盈率、市净率、整体ROI等地。在股市高估时，降低投资额度，在股市低估时，增加投资额度。 定期不定额策略 在上述策略的基础上，如目前市场明显在历史地点，原来每个月投1000的，这时不妨投2000。如市场明显高估，每个月投1000的可以投500。如果涨的都害怕了，可以不投甚至卖出一部分。 产品池管理 构建“核心——卫星”组合 技巧 部分基金可以场内购买（炒股账号购买），交易时间短手续费低 Links 基金定投，看这篇就够了

tags: AI What is the Difference Between CNN and RNN?

Machine Learning Deep Learning 《机器学习实战》读书笔记 How to Train Really Large Models on Many GPUs?

积累财富首先要改变思维，学习复利的力量。 粗读要点 实践 10/50 懒人储蓄投资自己，工资 10% 奖金 50% 存储单独的账户用户投资自己 开辟单独基金用于存放房租、孩子学费和自我投资 不懂不投，宁愿错过，不犯过错 画出自己的财富水池 为自己购买保险规避风险（大病和死亡），完成家庭保险配置 理清房贷还款计划，怎么将还款金额降低到收入到 1/3 （9000）以下，可以考虑先提前还房贷减轻房贷利息压力

反映与居民生活有关的产品及劳务价格统计出来的物价变动指标，衡量通货膨胀的主要指标之一： 超过 3% 为通货膨胀 超过 5% 就是比较严重的通货膨胀 Links 消费者物价指数

tags: Emacs 'foo vs #'foo https://emacs.stackexchange.com/a/10943 #’ on symbols will cause the byte-compiler to emit a warning if the function is not defined.

基金 基金定投 股市相关概念 相关书籍 《巴比伦富翁新解》读书笔记 《百箭穿杨》读书笔记 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) }