问题标签 [j]

该i.原语产生一个整数列表：

如果我想连续生成几个短列表，我这样做：

（我想要的结果）

拳击（that each）在这里是一个拐杖，因为没有它，就会i."0产生一个矩阵。

（我不想要的结果）

有没有更好的方法可以不i."0将输出格式化为矩阵，而是数组？

我在 J 中维护了一个大型代码库，一些罕见的函数和变量以__（两个下划线）结尾。

通常，__用于引用语言环境中的某些内容。

但是，我有这个：

声明为：

这是静态函数的另一种语法吗？所有语言环境都可以访问吗？

编辑：

据我所知，它不是本地的。如此声明的变量：

可以被另一个函数引用，尽管=.它看起来是本地的。同样，任何“进入语言环境”声明始终是“全局语言环境”（Foo__Bar =.并且Foo__Bar =:是相同的）。

假设一个包含各种类型的盒装矩阵：

和一个列描述符：

我想根据类型逐列在这个矩阵上应用动词。我将使用动词 DoString 和 DoNum：

编辑：列描述符很重要，决定使用哪个动词是基于它们，而不是类型本身。实际上，我可以有几种类型的字符串、数字，甚至日期（在 J 中是数字）。

我如何申请chain每一行matrix？动词本身可以处理传递的值是否被装箱，这很好。另外，我宁愿避免转置矩阵 ( |:)，因为它可能非常大。

我为 J 修改了 boot.ijs 脚本，它允许 J 响应来自 Apache 的请求。

本质上，在 httpd.conf 中，我有这个：

这告诉 Apache 将所有 *.ijs url 发送给 J。这只是上下文。

然后 J 可以通过写入标准输出来回答：

我有我创建的二进制数据（一个 Excel 文件），然后想要发送回提问者的浏览器，如这里详述。但是，在文件本身中，所有 LF 都更改为 CRLF。

这种行为可以在 jconsole.exe 中“观察到”。输入上面的 echo 声明，然后发送命令：

您会看到在每个 之后还有一行echo LF，因为在控制台中 CR 只是写成一行。本质上，J 将 LF 转换为 CRLF。

问题：如何关闭它，让 J 尊重实际要求输出的内容？

我在玩 J 中的副词和连词，遇到了一个奇怪的问题。我定义了一个简单的副词，叫做persistence它可以用来查看在计算数字乘积或数字的数字总和时生成的数字的进程。

+ S 234给我们234 9。然后我用它来创建另一个副词来计算数字的持久性。

+ P 234给我们1。现在，假设我们想要找到所有低于 30 且附加持久性为 2 的数字，然后查看S为每个数字生成的列表，例如，

这会生成以下列表：

到目前为止，一切都很好。现在，我想把它变成一个连词，它的左侧包含用于持久性的动词，而右侧包含用于限制列表的数字。（2在上面的例子中。）这是我对那个连词的定义：

如果我在 J 控制台中输入表达式+ Q 2，我会得到以下信息：

这是完全正确的，如果我使用诸如 的参数运行完整的表达式i.30，它可以正常工作：

但是，当我将表达式输入+ Q 2 i.30J 控制台时，我得到一个“长度错误”。为什么？！不+ Q 2完全等同于+/@:("."0)@":^:a:"0 I. 2 = <:@#@(+/@:("."0)@":^:a:"0)"0?

我完全被难住了。我错过了什么？我在连词的定义内部和外部都玩过排名。我只是不明白。

假设我有两个列表，一个是文本t，一个是字符列表c。我想计算每个字符在文本中出现的次数。

这可以通过以下 APL 代码轻松完成。

然而它很慢。它取外积，然后对每一列求和。

这是一个 O(nm) 算法，其中 n 和 m 是 和 的t大小c。

当然，我可以在 APL 中编写一个程序程序，t逐个字符读取并在 O(n+m) 中解决这个问题（假设完美散列）。

有没有办法在没有循环（或条件）的情况下在 APL 中更快地做到这一点？我也接受 J 中的解决方案。

编辑： 实际上，我这样做是因为文本比字符列表短得多（字符是非 ascii）。我正在考虑文本长度为 20 且字符列表长度为数千的位置。

鉴于 n 小于 m ，有一个简单的优化。

w 仅包含 t 中的字符，因此表大小仅取决于 t 而不是 c。该算法在 O(n^2+m log m) 中运行。其中 m log m 是进行交叉操作的时间。

但是，以防万一有人给出一个巨大的文本文件，仍然首选二次算法。

以上是成语。最后是痕迹和最终结果。我知道这个短语是一个单子，我知道因为 ~ 它有一个左右参数。如果您运行“15 7 3 1(2&*) 15 7 3 1”，则会发生相同的输出。我还知道正确的表格是 2 的 1、3、7、15 的幂，其他条目是它们的基数乘以 2 的幂，但我就是不明白为什么。

在相关的说明中，这是来自 Rosetta Code 网站上的 ethopian 乘法的短语（实际上，这也是，我在试图弄清楚这一点时已经走了这么远）和 '(1>.<.@-:)^： a:' 是短语。

但是 (1>.<.@-:)^: 27 返回一个盒子的版本，我希望它运行 27 次。

在三个相关问题中的最后一个（这些都与分解 Ethopian 乘法代码有关），完整代码如下：

并且可以简单地替换为：

这很好用！成功地冲了上去，当我想到有一个在命令行上工作的一元替身时，我完全从悬崖上掉下来了：

而且双精度运算符必须比带有附加常量的双精度运算符快，也许双精度运算符只是移位，所以我认为

会工作......但它没有。

我尝试过大写字母、连词等，但没有任何效果，它总是说“域错误”。我开始认为代码依赖于二元调用的 monad 以一种我不明白的方式创建加倍表。

唯一的好处是 J 动词奇数与测试奇数无关。

任何人都可以向我解释这些事情，也许用英语解释程序是如何工作的？不是算法如何工作，而是如何实现算法。我记得当我在 1970 年玩 IBM 1130 APL 时。这是一个以 8k 字运行的 APL 解释器，不用说，它是有限的。例如，它有一个滚动但没有交易。解释器逐步进出内存，1130 支持代码覆盖，它将您的子例程分成组，当一个组调用另一个组时，它将从磁盘加载新组（是的，8k 中的伪交换）。因此，我使用各种方案编写了 deal 的版本，并且随机地，我们会找到一个可以逐步进入和退出而无需搜索的版本，而那个版本，无论写得多么糟糕，有多少行和多少解释器操作都会运行 10 次和其他任何东西一样快。我不知道自己在做什么，我会不断地添加 ravels 和无意义的作业，并跨行打破陈述或将它们组合起来，直到我得到一个无需查找即可运行的语句。（正在寻求的 52 交易 52 可能需要 45 秒）。

然后昨晚我计算了 J 中的第 150,000 个斐波那契数。它必须是 64 位版本，并且花了 1 小时 17 分钟。我用了精确的算术，这个数字有 31349 位，它从 1012838344936638038 开始......我意识到 1130 永远不可能计算出这个，这个数字不合适，因为你需要三个，而最大的一个有 32k 16 位字。我想学习可以做到这一点的语言，但是文档中缺少一些我没有得到的东西。

斐波那契脚注：

我总是得到索引错误。

关键是输出两个数字，一个与列表中的第一个数字相同，第二个与该数字重复的次数相同。

所以这很有效：

我将第一个数字与列表的其余部分进行比较。然后我插入一个和压缩 - 只要我有一个完整的 1 字符串，这给我一个 1，一旦它打破和失败并且零出现。

我认为然后我可以添加另一组括号，再次从列表中获取前导元素，并以某种方式记录这些数字，最终的想法是有另一个阶段，我将向量的逆应用于原始列表，并且然后使用 $: 返回相同动词的递归应用。有点像快速排序的例子，我想我有点理解，但我想我不明白。

但我什至无法靠近。我将把它作为一个单独的问题提出，以便人们得到适当的回答。

我一直在使用 J 中的 lookandsay (OEIS A005150) 的实现。我制作了两个版本，都非常简单，使用while.类型控制结构。一个重复，另一个循环。因为我是强迫症，我开始在版本上运行比较计时。

看看并说是序列 1 11 21 1211 111221 that s，一一，二一，等等。

对于列表的早期元素（最多约 20 个），循环版本获胜，但数量很少。大约 30 的时间会导致递归版本获胜，如果堆栈空间足够支持递归版本，则可能会优先选择递归版本。我研究了原因，我相信这与处理中间结果有关。序列中的第 30 个数字有 5808 位。（第 32 个数字，9898 位，第 34 个，16774。）

当你用递归解决问题时，你可以在递归调用中保存中间结果，最后的unstacking构建结果，以便对结果进行最少的处理。

在列表版本中，您需要一个变量来保存结果。每次循环迭代都会导致您需要向结果中添加两个元素。

正如我所看到的，问题是我无法在 J 中找到任何方法来修改现有数组而不完全重新分配它。所以我说

将一个元素放入 o 中，当我们开始时 o 可能没有值。这可能明显慢于

关键是，如果没有散布，结果就会出现错误的形状，或者看起来是这样。它以某种方式从 i.0 继承了一个形状。

但即使像 } amend 这样的函数也不会修改列表，它们会返回一个对其进行了修改的列表，如果要保存列表，则需要分配它。随着分配列表的大小增加（当您将数字从头到尾进行下一个数字时），分配似乎需要更多的时间和更多的时间。这个赋值确实是我唯一能看到的，它会使元素 32、9898 位在递归版本中花费更少的时间，而元素 20（408 位）在循环版本中花费更少的时间。

递归版本通过以下方式构建返回：

上面的行既是函数的返回行，也是递归行，所以整个返回向量在调用到达字符串末尾并且所有内容都取消堆栈时立即构建。

在 APL 中，我认为可以按以下顺序说：

但是当我在 NARS2000 中尝试这个时，我发现它会导致索引错误。我无法访问任何其他 APL，我可能记得 APL Plus 中的这个成语，我怀疑它在 APL\360 或 APL\1130 中是否以这种方式工作。我可能完全记错了。

我在 J 中找不到这样做的方法。可能没有办法做到这一点，但下一个想法是预先分配一个可以保存结果的数组，并更改单个条目。我也看不出有什么办法——也就是说，J 似乎不支持 APL 成语：

这是由于语言纯度而被禁止的副作用之一吗？

解释器是否将a=. a,foo其或其某些变体识别为应该在a[>:#a]=.foo内部快速路径的事物？

这是递归版本，只是为了它。我尝试了很多不同的版本，我相信程序越长越慢，通常越复杂越慢。一般来说，程序可以被链接起来，这样如果你想要第 n 个数字，你可以做lookandsay^: n ] y。我已经尝试了许多优化，但我遇到的问题是我无法判断我将输出发送到什么环境。如果我知道我将它发送到程序的下一次迭代，我会将它作为一个数字数组而不是一个大数字发送。

我还怀疑，如果我能弄清楚如何制作一个默认版本的代码，它会运行得更快，因为我发现当我在代码中添加一些应该让它更短的东西时，它会运行得更长。

我对产生的数字的特征很感兴趣。我发现如果你从 1 开始，数字永远不会高于 3。如果你从高于 3 的数字开始，它将作为单例存在，你也可以通过从某事开始将一个数字放入生成的数字中就像 888888888 一样，它将生成一个数字，其中包含一个 9，数字末尾有一个 8。但除了单例之外，没有数字高于 3。

编辑：我做了更多的测量。我最初编写程序以接受向量或标量，其想法是在内部我将使用向量。我曾考虑将向量从一层代码传递到另一层，但我仍然可能使用左参数来控制代码。当我通过顶层向量时，代码运行得非常快，所以我的猜测是大部分 CPU 都被从向量转换为数字的长数字所消耗。递归例程在递归时总是向下传递一个向量，这可能就是它几乎与循环一样快的原因。

这并没有改变我的问题。

我有一个答案，我不能发布三个小时。然后我会发布它，请不要做大量研究来回答它。

我正在学习 J 并从一些基本的东西开始；将 3 和 5 的倍数加到 100 以下。我用这段代码得到了它：

但似乎应该有一个更简单的方法。有没有办法让这段代码更干净？谢谢。