My Memory

儿时谜语记录

9/12/2024 07:26:00 下午 |

谜面

地上一杆枪，走来走去不敢趟(tāng)；
青树青棵，就地盘窝，我又不是什么仙桃仙果，为什么踮着脚够(gòu)我

其他的等我想起来再更新

谜底

蛇
苍耳草

最好的时代

11/26/2022 09:26:00 上午 | 生活纪实 |

这是最好的时代

这个时代充满了美好

物内人群热闹，屋外鸟语花香

家庭美满幸福，邻里友好互助

亲戚相互祝福，朋友常常沟通

事业蒸蒸日上，经济欣欣向荣

当有一天下起了雪，也没有那该死的脚印去践踏

这是我们盼望中的纯洁

我们有幸见证伟大的时代

让我们一起赞美，这最美好的世界

我开心的回头找你

你为何在墙角哭泣？

知识的边界

2/23/2022 05:40:00 下午 | 感想 |

我是一个普通人，能观察到的也是普通人。

小孩子的快乐各不相同，学习却是通用的苦恼。

这里我突然想到一个问题，人所能达到的知识的边界在哪里？

如果一个智商正常的人，从出生开始学习，

而且一直对某一个领域进行研究，如此不断。

直至小孩子从出生到死亡也无法学习完关于这个领域的全部知识的时候

是不是边界就出现了？

如果是这样的话，知识的范围就好像一个限定范围的高斯球。

阶段性胜利

4/12/2021 08:07:00 下午 | 感想 |

最近在找实习，感觉自己没有特别的优势，终于腾讯到了hr面还因为非全被打了回来。

我有时候就想，是不是我的运气太差，考研报考的时候哪一个选择变化的话都能考上全日制。

我又觉得这是上天的安排。

最后还是回归理性，是我准备的还不够，觉得差不多够了的时候就有些松懈，我文科和理科发展的也差距有些大。

理性告诉我，我应该更努力的学。

懒惰也催促我快些玩耍，放松。

我偶尔回忆经历过的一些小小的“成功”与“失败”。

我发现成功不过几年，失败也并不绝对。

现在有些焦虑，焦虑看不到后面的路。

虽然我知道，后面总有路。

全都是阶段性胜利和失败。

胜利的欢呼能振奋人心。

失败的沮丧别打垮你的信心。

祝你幸福，人们。

n的阶乘在m进制下末尾有多少零

4/09/2021 04:45:00 下午 |

题目来源于CSDN，只是改编为Java版本

推荐看看简单版本：n的阶乘末尾有多少零

代码如下：

import java.util.Arrays;
import java.util.Scanner;

public class Main {

    // 寻找的质数的范围，即 [2, maxn]
    static int maxn = 10010;
    // 存所有质数
    static int[] prime;
    static boolean[] isPrime;
    // a存所求数的所有质因子
    static int[] a;
    // b存每个质因子的个数
    static int[] b;
    // num是maxn范围内素数的个数
    static int num, cnt;

    public static void init(){
        a = new int[maxn+1];
        b = new int[maxn+1];
        prime = new int[maxn+1];
        isPrime = new boolean[maxn+1];
        num = 0;cnt = 0;

        // 这里是寻找 maxn 以内的质数
        Arrays.fill(isPrime, true);
        for (int i = 2; i <= maxn; i++) {
            if(isPrime[i]){
                prime[num++] = i;
                for (int j = i*i; j <= maxn; j+=i) {
                    isPrime[j] = false;
                }
            }
        }
    }

    // 找到所有可疑的质数
    private static void decom(int m){
        cnt = 0;
        for (int i = 0; i < num; i++) {
            if(prime[i] > m) break;
            int d = m;
            while (d%prime[i] == 0){
                a[cnt] = prime[i];
                b[cnt]++;
                d /= prime[i];
            }
            if(d < m)
                cnt++;
        }
    }

    // 计算 n! 里面有多少 x，比如8!里面有7个2
    private static long cal(long n, long x){
        if(n == 0 || n == 1){
            return 0;
        }
        long answer = 0;
        while(n != 0){
            answer += n/x;
            n /= x;
        }
        return answer;
    }

    private static long solve(long n, int m){
        decom(m);
        long answer = Long.MAX_VALUE;
        for (int i = 0; i < cnt; i++) {
            long t = cal(n, a[i]);
            answer = Math.min(answer, t/b[i]);
        }
        return answer;
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()){
            String[] tmp = in.nextLine().split(" ");
            long n = Long.parseLong(tmp[0]);
            int m = Integer.parseInt(tmp[1]);
            init();
            System.out.println(solve(n,m));
        }
    }
}

携程提前批笔试2021

3/19/2021 10:26:00 上午 | 算法 |

一、两名字的缘分值

题目：缘分值定义：两个名字（字符串）通过删除字符，使得留下的子串一直，所删除的ASCII之和最小值为两个名字的缘分值。

输入描述：输入两行名字，上下两行对应位置名字进行缘分值计算。

2<=每个名字的长度<=10,

2<=每个名字的<=20

输出描述：输出总缘分值。

样例输入:

Zhang San

Zhan Ai

样例输出:

563

说明：

第一组名字，删除‘g’使其相等 ASCII =103，第二组都不同全要删掉，ASCII=290+170=460，总操作数103+460=563。

分析：

1.该题有些误导，其主要过程是如果A的名字和B的名字的每个字的拼音分别相比较，而且区分大小写。

2.动态规划计算最长相同子序列，只是求完之后存下相同的char和出现频率

3.结果相加

ac 100%

import java.util.HashMap;import java.util.Scanner;

public class Main {

    /**
     * 获取字符串的全部asc值
     * @param str 输入
     * @return 该字符串的asc值
     */
    static int getStrAsc(String str){
        int answer = 0;
        int len = str.length();
        for(int i = 0; i < len; i++){
            answer += (int)str.charAt(i);
        }
        return answer;
    }

    /**
     * 获取 strs 位于[start, end)之间的字符串asc值之和
     * @param strs 字符串数组
     * @param start 包含
     * @param end 不包含
     * @return 区间内asc之和
     */
    static int getStrsAsc(String[] strs, int start, int end){
        int answer = 0;
        for(int i = start; i < end; i++){
            answer += getStrAsc(strs[i]);
        }
        return answer;
    }

    /**
     * 主要计算函数
     * @param name1
     * @param name2
     * @return
     */
    static int calcSimilarity(String name1, String name2) {
        String[] name1s = name1.split(" ");
        String[] name2s = name2.split(" ");
        int len1 = name1s.length;
        int len2 = name2s.length;

        int answer = 0;
        // 算一下多出去的那部分字符串的asc值
        if(len2 > len1){
            answer += getStrsAsc(name2s, len1, len2);
        }else if(len1 > len2){
            answer += getStrsAsc(name1s, len2, len1);
        }
        int len = Math.min(len1, len2);

        for(int i = 0; i < len; i++){
            // 获得最长公共子序列的map，包含字符和出现次数
            HashMap<Character, Integer> map = getMap(name1s[i], name2s[i]);
            answer += getStrAsc(name1s[i]);
            answer += getStrAsc(name2s[i]);
            // 加和之和减去两倍公共的就是答案了
            for(Character item : map.keySet()){
                answer = answer - 2 * (int)item * map.get(item);
            }
        }

        return answer;
    }

    /**
     * 获得name1和name2的最长公共子序列的map，包含字符和次数
     * @param name1
     * @param name2
     * @return map
     */
    static HashMap<Character, Integer> getMap(String name1, String name2) {
        HashMap<Character, Integer> answer = new HashMap<>();

        int len1 = name1.length();
        int len2 = name2.length();
        int[][] dp = new int[len1+1][len2+1];
        // 记录这个最小值从哪里来，为了反向寻找
        int[][] from = new int[len1+1][len2+1];

        for(int i = 1; i <= len1; i++){
            for (int j = 1; j <= len2; j++) {
                if(name1.charAt(i-1) == name2.charAt(j-1)){
                    dp[i][j] = dp[i-1][j-1] + 1;
                    // 来自 i-1,j-1
                    from[i][j] = 0;
                }else if(dp[i-1][j] > dp[i][j-1]){
                    dp[i][j] = dp[i-1][j];
                    // 来自 i-1,j
                    from[i][j] = 1;
                }else{
                    dp[i][j] = dp[i][j-1];
                    // 来自 i,j-1
                    from[i][j] = 2;
                }
            }
        }
        
        int max = dp[len1][len2];
        // 反向寻找
        while(max > 0){
            int nexti = len1;
            int nextj = len2;
            // 下面的判断是找该节点来自哪里
            if(from[len1][len2] == 0){
                nexti--;
                nextj--;
            }else if(from[len1][len2] == 1){
                nexti--;
            }else {
                nextj--;
            }

            // 相同说明没贡献，找到第一个对最长序列有贡献的点就是最后一个相同的点
            if(dp[len1][len2] == dp[nexti][nextj]){
                len1 = nexti;
                len2 = nextj;
            }else {
                answer.put(name1.charAt(len1-1), answer.getOrDefault(name1.charAt(len1-1), 0)+1);
                len1 = nexti;
                len2 = nextj;
                max--;
            }
        }

        return answer;
    }


    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()) {
            String name1 = in.nextLine();
            String name2 = in.nextLine();

            int sum = calcSimilarity(name1, name2);
            System.out.println(sum);
        }
    }
}

选择性忘记

6/13/2020 09:26:00 上午 | 感想 |

不知道你有没有同感，当你回忆少年时期遇到的可怕事情，只记得事情发生的前后，那件让你疼痛的事情的具体事情却怎么也记不清楚了。

有一件事情记得很清楚，在我比较小的时候，我们家里晚上在院子里乘凉，因为我们院子有枣树，所以时常会有“洋辣子”掉在地上，可能每个地方给它的称呼不一样，当然我们这里也并不叫这个，但是它带来的恐惧应该是相同的，这个小东西只在有汗毛的皮肤上有效，在手心上放一个其实是不会有事的。

不过我那会还不知道这些，或者说我知道，但是晚上比较黑了，我没看的很清楚。

我看到地上有一个蛹一样的东西，长得很是奇怪，现在都记得很清楚，那个东西表面呈椭圆形状，表面很粗糙，沿着圆的方向有一圈圈的纹路，有点像木头。

我对这个玩意很好奇，就拿在手上仔细观察，感觉我从来没有见过，越来越好奇，后来我已经不知道为什么了，我居然会：

我把这个玩意当作肥皂一样在我自己身上涂来涂去！！！接下来当天晚上后面发生了什么我已经完全记不起来了。我的记忆接下来记得的就是第二天早上我的身上涂满了牙膏在家里的水井旁边玩。第二天其实还是有些疼的。

据我爸说那天晚上我突然大哭，然后带着我去看医生，晚上也哭。不过我是怎样都想不起来了。

这些最痛苦的时候虽然忘记了，但是这种恐惧是一直存在的，删掉了一部分记忆不可能删掉每个人的记录，事情发生了总有人记得，我无法张口同别人讲述，别人同我也一样。

闭嘴！

春雨 --- by 哲

4/25/2020 09:29:00 下午 | 小诗 |

春雨

昨夜一场春雨，
桃红柳绿，
蝴蝶吸食着甘甜的雨露，
鸟儿在枝头唱起乐曲。

我迈着轻快的步伐，
我享受着温暖的阳光，
享受着雨后清新的空气，
感谢昨夜一场春雨带来的快乐与美好。

无需root隔离手机的垃圾软件(自启软件)

1/11/2020 08:26:00 下午 | 安卓, 手机 |

1.为什么有这个需求？

首先么，你有没有一些你必须安装但是又不想要安装的软件？

那，如果有的话，你怎么处理呢？

2.这篇帖子之前我是怎么处理的？

就在前些天之前我就安装在我的手机里咯，必须用能怎么样咯。。。

3.帖子的目标。

让你的手机有一个专门的空间来安装这些app，利用的原理是安卓work空间，这个功能主要是给这种情景使用的：你是一个老板，你想让员工使用一些软件，但是又想控制一些软件的具体权限，比如chrome的某种权限，或者给员工的邮箱stmp地址自动配好。这样就可以很好的控制这些软件的权限了，等你的员工离职后你可以删掉他的work空间内容。

如果你想自己建一个demo公司，使用本来的功能，你可以访问这里来创建一个demo。不过呢，这之前你要保证你的网络（注意，是你的网络，因为work空间是独立的，网络也无法使用你自己的某些上网软件）可以访问Google。