谋事找手头宽裕的人，做事找手头拮据的人，ruby 论坛这里都是做事的，建议走出 IT 圈外找谋事的人和谋事的点子。

https://rubyinstaller.cn/ 打不开页面。 AI 选择 py，我理解有一个重要原因是两者的核心差异，ruby 太灵活，相对于 py 不那么适应大规模团队的协作，更适合于以一敌百的狮子，而 AI 需要不断的进化和团队协作，需要群狼、鬣狗。matz 和 dhh 创始人赋予了 ruby 这种基因。

岂止是经商，所有的人类有意识活动都是基于信仰的（或者叫“主观上的确信”），谁在这一块站在了金字塔顶端，引领了潮流，谁就自然而然的可以获得超出一般平均水平的更多的回馈。

品味是流量的敌人，这个是所有产品经理要铭记在心的的准则。 凤凰传奇的歌“土”，不妨碍它流行，某种程度上，或许“土”也是流行的密码。

@lehf 用你的方法试了一下，是可行的，也上传成功了。同时也找了一下 rails guide，发现其中也有这方面的指导，对应章节是“3.3 Attaching File/IO Objects3.3 附加文件/IO 对象”，非常感谢，在开发前期只注重了功能实现没有特别关注到这里，在应用时，发现很多原始数据、资料需要初始化导入或上传，这方面的功能就需要补足。

利用 watir 写了一个脚本，从前端直接上传了。如果不用 watir，使用 net/http 的话，对 post update user.avatar 的路由、params[:avatar] 参数、http 文件头等搞不定，还要继续学习网络方面的知识。

实在不行就只能用 watir 等自动化方式了。

这个有个国情在，国内目前还是倡导制造业，IT 信息产业的投融资并不顺遂，天使投资环境也不理想（基本上没有盈利的创业公司很难融到钱），大公司不仅不会扶持这些开源项目的尝试，还会积压开源项目的空间，同时这些创业公司要存活，就不得不在搞出工具、应用后马上进行商业应用尝试，并争取获得第一桶金，否则仅仅免费状态下，根本没有机会活到能够成长壮大的那一天。先要解决生存问题，再解决发展问题。 说投机也并没错，在千百次投机中，市场会作出选择。

支持，在需求中解决问题，在解决问题中求得进步。

恭喜你，有这种“悲哀”感悟的人，说明已经到了一定的境界了，新人则通常都是懵懂、混沌的，不会有这种感悟。其实哪个行业到了一定深度都有可能进入某种自我怀疑的状态，譬如医生即使医术再精深，也会感叹斗不过生老病死；律师学法再精，也会觉得斗不过陈规陋习。越过这个深水区，又可以更上一层境界。

以题目中的“1100110011001100000011000000111111001100111111001111110000000000000011001111110011111100111111000000110011001111110000001111110011001100000011”为例，会发现最短的也是 00 或者 11。这时候我们会发现很奇怪，难道嘀嗒之间不是 1 个 0 吗？滴不是应该一个 1 吗？怎么会出现最小两个 0 或两个 1 的情况？这不符合常理。

那么只能理解为，发送信号的发报员是个慢手，他发原本想发报一个 0，但是我们这边收到显示是两个 0；他原本想发送一个 1（嘀），但是我们收到两个 1（滴滴）。这就说明收报的速度是发报速率的两倍，同样时间，发报员发出一个信号，结果收到两个信号。这样的话，这个字符串就要 2 位折算为 1 位，也就是“11”替换为 1,“00”替换为 0。

按照速率折换后，上述字符串转换为字符串 B：10101010001000111010111011100000001011101110111000101011100011101010001。

再对上述字符串 B，按照 1-5 的规则，对应翻译一下，就是题目的“···· · −·−− ·−−− ··− −·· ·”，两者完全能对上

T'对应的摩尔斯电码是一个‘-’（三个时间单位），这里三个时间单位，翻译一下，其实你想表达的是，这里的‘-’（嗒）需要三个‘.’（嘀）的时间长度，我们假设一个时间单位是 1 微秒，也就是‘-’（111）需要 3 微秒；

假定一个时间单位可以传输 2 个比特位（11），也就是可以理解为接收方 1 微秒可以抄写 11（两个 1），这里结果应该是 3/2=1.5，这么变成了 6 了？是不是哪里概念梳理有误？

在我看来，’T'对应的摩尔斯电码是一个‘-’（三个时间单位），这里 3 个时间单位就可以理解为 3 个比特（111），要用连续的 111 来表示这个‘-’（嗒）时间很长。而‘.’（嘀）只要用一个 1 来表示即可。在嘀切换成嗒的时候，中间有停顿，信号中断（不中断怎么知道有嘀切换成了嗒？），所以这个停顿的信号中断可以表示为 0，也即在这个时间单位里边没有信号收到。（题目意思也是这样的，单词之间中断为 7 个时间单位，为 0000000）

1. "Dot" – is 1 time unit long. 嘀 1 个时间单位 1
2. "Dash" – is 3 time units long.嗒 3 个时间单位 111
3. Pause between dots and dashes in a character – is 1 time unit long.嘀嗒之间中断（间隔），1 个时间单位，即：0
4. Pause between characters inside a word – is 3 time units long.字母之间中断（间隔），3 个时间单位，即：000
5. Pause between words – is 7 time units long. 单词之间中断（间隔），7 个时间单位，即：0000000

假设我们在 11:01:00 至 11:01:05 之间截获了一段字符串 1110011111100100100111000

那么有个问题，这里的第 6 位到第 11 位之间有“111111”（6 个 1），那么这 6 个 111 是不是当然的就代表发送方想发送 TT 呢？（按照上面所述 111 代表‘-’（嗒），也就是代表字母 T）。实际上，这还真不一定，因为假若发送方是个非常手慢的电报发送员，正常人是三个时间单位发 111 就搞定 T 的发送，但是这个手慢的，慢慢腾腾，速度只有别人的一半速度，他可能需要双倍的时间才能发送一个他想发送的 1。但是在接收方看来，这两个时间单位都是有信号状态，所以记作 11，但实际上在手慢的发送方来看，他只想发一个 1，只不过耗费了双倍时间。

所以我们要想翻译这串 1110011111100100100111000，首先要搞清楚发送方是个手慢的还是手快的电报员，也就是“传输率”。“我没明白为啥找到 0 串和 1 串长度最小的那个”实际上就是找出嘀或者嘀嗒中间中断（间隔）的那个时间单位，因为嘀或嘀嗒之间中断（间隔）都是占用 1 个时间单位，是上述 5 种情形中最小的（对应 1 和 3 两种情形，时间单位为 1）。找到手慢的发报员的 1 个时间单位，再折算为标准的嘀嗒，最后换算为字母和字符串就翻译出来了。

摩尔斯电码实际上是一个声音，声音是有长、有短的，短点称“嘀”，长一些的称“嗒”，。嘀嗒实际上都是信号连通状态。题目中，有个自动化的设备，按照固定速度接收声音（想象一个接收员拿笔在纸上记录接听到的声音，该接收员 A 的听写记录速度是固定的，每分钟记录 60 次，每秒听一次记一次）。A 开始记录。

发送方开始发送：嘀嗒滴 暂停 答滴答。

熟练发送方：嘀（1 秒）停顿 嗒（3 秒）停顿 嘀（1 秒）暂停 嗒（3 秒）停顿 嘀（1 秒）停顿 嗒（3 秒）

由于记录方每秒记录一次，如果是接收到信号，就会记录 1，暂停时就会记录 0，所以记录方 A 会在纸上写：1011101000111010111（假设停顿为 0，暂停为 000）

不熟练方发送：嘀（2 秒）停顿 嗒（6 秒）停顿 嘀（2 秒）暂停 嗒（6 秒）停顿 嘀（2 秒）停顿 嗒（6 秒）

则记录方记录的为：1101111110110001111110110111111

可以看出，上面的传输同样的信息（都是滴答滴 嗒嘀嗒），不熟练发送方，记录方的记下的字符串要长的多，所以串长越小，速度越快（在速度固定的情况下，通常认为同一个发送方不会发送的忽快忽慢，是以固定速度发送，找到最短的就是发送速度）。

以上理解不知妥否，仅供探讨。

不降低 node.js 版本的情况下，环境变量设置解决：windows 系统是：系统属性 - 高级 - 环境变量 - 系统变量 - 新建 变量名填“NODE_OPTIONS”，变量值填“--openssl-legacy-provider“，确定即可。设置环境变量后，在命令行窗口重新执行 yarn start，问题解决。

改成https://github.com/hfpp2012copy/railstart了

def sceltoword(scel_file,out_path)  
  @file = scel_file
  @path = out_path

  source_file = File.open(@file,"rb")
  File.open(@path, 'wt', encoding: 'UTF-8') do |f|
    while true
        begin
            by = source_file.sysread(2) 
            by.force_encoding("utf-16le").encode!("utf-8")
            f.syswrite(by)
        rescue => e
            puts e.message
            break
        end
    end
  end 
  source_file.close
  File.open(@path,"r") do |lines|
    buffer = lines.read.scan(/\p{Han}+/u) 
    buffer.reject! {|word| word.size < 2 } 
    File.open(@path,"w") do |l|
      l.puts(buffer) 
    end
  end  
end

使用了一个投机取巧的办法，使用正则表达式，把 UTF-16 转成 UTF-8 之后的文件中的中文短语部分提取出来，就得到了想要的词汇 txt 文件。 这个办法不完美，无法精确对应每个短语的拼音，但是解决了提取搜狗词库中的中文 txt 短语的目的。 由于搜狗词汇庞大的词汇量，所以提取的词汇，可以用于关键词检索中的自动输入、自然语义分析的关键词、倒排索引等用途。应用场景如：通过提取法律词汇，建立关键词与法律法律法规条文的对应关系，根据法律关键词快速查找合适准确的法律条文。

cron 表达式：0 0 */3 9 0 应该是默认周日会执行，你可以换成 7 月份、8 月份、10 月份试下。

我是一名法务，负责公司法律工作，从一家小公司一致做到上市做了 13 年法务，接触 ruby 纯粹是爱好，因为我的原则是，相同的事情做好一遍即可，最早用过 VB、ACCESS，后来接触 ruby 也有六七年，写代码不是一个很容易的事情，冷板凳有时候一坐半天也不一定能解决，但是第二天或者后续的某个时刻突然顿悟，或者看到其他人的解释，突然理解一下子云开见日迎刃而解的感觉妙不可言，所以就一直没有放弃，慢慢看书查资料自学，现在可以独立的做一个 rails 的集成专利、商标、合同管理应用，也偶尔做一些其他小东西。ruby 的使用受众虽然不多，甚至在非专业的人员中，知道的人也不如 java、python 那么多，但是不妨碍我们自己的喜爱。困难都不是问题，唯有热爱，排山倒海，希望有更多的人喜欢 ruby，纯粹的喜欢。

import struct
import os
# 拼音表偏移，
startPy = 0x1540

# 汉语词组表偏移
startChinese = 0x2628

# 全局拼音表
GPy_Table = {}

# 解析结果
# 元组(词频,拼音,中文词组)的列表
GTable = []

# 原始字节码转为字符串
def byte2str(data):
    pos = 0
    str = ''
    while pos < len(data):
        c = chr(struct.unpack('H', bytes([data[pos], data[pos + 1]]))[0])
        if c != chr(0):
            str += c
        pos += 2
    return str

# 获取拼音表
def getPyTable(data):
    data = data[4:]
    pos = 0
    while pos < len(data):
        index = struct.unpack('H', bytes([data[pos],data[pos + 1]]))[0]
        pos += 2
        lenPy = struct.unpack('H', bytes([data[pos], data[pos + 1]]))[0]
        pos += 2
        py = byte2str(data[pos:pos + lenPy])

        GPy_Table[index] = py
        pos += lenPy

# 获取一个词组的拼音
def getWordPy(data):
    pos = 0
    ret = ''
    while pos < len(data):
        index = struct.unpack('H', bytes([data[pos], data[pos + 1]]))[0]
        ret += GPy_Table[index]
        pos += 2
    return ret

# 读取中文表
def getChinese(data):
    pos = 0
    while pos < len(data):
        # 同音词数量
        same = struct.unpack('H', bytes([data[pos], data[pos + 1]]))[0]

        # 拼音索引表长度
        pos += 2
        py_table_len = struct.unpack('H', bytes([data[pos], data[pos + 1]]))[0]

        # 拼音索引表
        pos += 2
        py = getWordPy(data[pos: pos + py_table_len])

        # 中文词组
        pos += py_table_len
        for i in range(same):
            # 中文词组长度
            c_len = struct.unpack('H', bytes([data[pos], data[pos + 1]]))[0]
            # 中文词组
            pos += 2
            word = byte2str(data[pos: pos + c_len])
            # 扩展数据长度
            pos += c_len
            ext_len = struct.unpack('H', bytes([data[pos], data[pos + 1]]))[0]
            # 词频
            pos += 2
            count = struct.unpack('H', bytes([data[pos], data[pos + 1]]))[0]

            # 保存
            GTable.append((count, py, word))

            # 到下个词的偏移位置
            pos += ext_len


def scel2txt(in_path,file_name):
    print('-' * 60)
    with open(in_path+file_name, 'rb') as f:
        data = f.read()

    print("词库名：", byte2str(data[0x130:0x338])) # .encode('GB18030')
    print("词库类型：", byte2str(data[0x338:0x540]))
    print("描述信息：", byte2str(data[0x540:0xd40]))
    print("词库示例：", byte2str(data[0xd40:startPy]))

    getPyTable(data[startPy:startChinese])
    getChinese(data[startChinese:])

if __name__ == '__main__':

    # scel所在文件夹路径
    in_path = u"C:/Users/Administrator/Desktop/test/"


    # 输出词典所在文件夹路径
    out_path = u"C:/Users/Administrator/Desktop/test/sogou_dict.txt"

    fin = [fname for fname in os.listdir(in_path) if fname[-5:] == ".scel"]


    # print(fin)
    for f in fin:
        scel2txt(in_path,f)

    # 保存结果
    with open(out_path, 'w', encoding='utf8') as f:
        f.writelines([word+'\n' for count, py, word in GTable])

上面 python 代码是能运行并得到正确结果。 现在想以 ruby 表达出来，以便更深入了解 ruby 的 encode。

抛砖引玉：一般是否均匀分布，都可考虑一下方差的概念及应用 1.假设 a,b,c,d，每个点的可挪动位置范围 [a_x，a_y](b,c,d 诸如此类） 2.某一个时间点 t, 每个点的位置是 a_t（b,c,d 诸如此类），a_t 要满足在 [a_x，a_y] 区间范围内。 3.a 到 b 的位置的距离记作 a_t - b_t 的绝对值，a 到 c 的位置记作 a_t - c_t 的绝对值，这样 a 获得到 b、c、d 三个绝对值距离，b 也同样获得三个绝对值距离，c,d 均如此。 4.要求这些距离尽量均匀，也就是方差尽可能小，算一下他们的均匀分布状态下的方差（方差），然后比较大小。 5.t 可以根据移动的距离 0.01 一点点迭代循环计算。

手动点赞，非专业开发人员，自学 ruby 和 rails，主要是辅助日常工作。如果想把完成的开发成果分享给非局域网的人，在他人电脑上安装 ruby 和 rails 环境安装就是一个非常费劲的问题（什么 docker、linux 根本不现实，也不想去注册域名、空间什么的，太费事），现场一蹲一个小时也不一定搞定，远程指导安装更是不可能，所以做出来的东西只能自嗨。希望这个能有用，解决在 windows 上的快速安装问题，感谢作者！

好东西，手动点赞

新上传，是指用户刚上传的那个或那几个文件，并不要求是系统里边创建时间最近的那个文件。 这个当时我的需求场景是，通过在 update 页面中，通过 active_storage 上传文件（update 页面也允许不上传文件），update 更新过程中读取更新后的对象的 files，并判断哪些是新上传的文件，并对新上传文件进行处理。

如果通过 id 最大或创建时间最新来判断，需要读取刚上传文件的 blob_id，读取对应的文件的创建时间等等，应该也能实现，但是如果用户一次同时更新上传好几个文件，或者几个用户同时进行了操作上传文件的操作，可能代码变复杂了。

有这个 previously_new_record？现成的功能，直接用起来也非常爽利。

有集成 rails 的主题就好了，小白面前，JavaScript 和 rails 结合太纠结，各种坑。

这样解释，整个人对这个问题点就通透了，否则光解决了问题，不通透还是不舒爽。

感谢回复，你的为避插入查询逻辑消耗性能的观点是正确的，相比代码简洁来说，插入索引列更有优势，查询性能更重要。

目前已经通过增加索引列解决了。因为 rails 查询接口的 where 后面只能接列名（对象属性），接其他的，都会显示没有该列名的查询错误。 原来有点期望类似如下这种简洁的查询方案，但实际上会出现错误。

search_result = trademarks.where(" Pinyin.t(name) like ? ", Pinyin.t(params[:name] ))

search_students = students.where("get_month(id_code) = '9'）

点赞

这个自愿是在地位不对等情况下被强加的自愿，是违背当事人意志的伪“自愿”，从根本上违反了民事活动过程中，当事人意思自治和平等的根本原则，所以无效。倘若这个自愿文件是董事长、总经理等签署，或者注明了公司以股权激励、年终奖等方式已经对加班时间的加班费进行了足额的替代性补偿，则这个自愿性的文件，是有可能得到法院的支持的。