问题标签 [tacit-programming]

我已经解决了 84 个 Project Euler 问题，主要是在 Haskell 中。我现在回去尝试在 J 中解决一些我已经在 Haskell 中解决的问题，作为学习 J 的练习。

目前，我正在尝试解决问题 56。让我强调一下，我已经知道正确答案是什么，因为我已经在 Haskell 中解决了它。这是一个非常简单、微不足道的问题。我不会在这里给出答案。

这是我在 J 中的解决方案：

这会产生一个小于预期结果的数字。换句话说，它在某种程度上是错误的。那里有J-ers知道为什么吗？我很困惑，因为它非常简单而且完全是蛮力。

我希望能够读写文件等。我该怎么做？

我来自 C、Fortran、Python、R、Matlab 和一些 Lisp 的背景——我读过一些关于 Haskell 的东西。有哪些用 J 或 APL 家族的其他语言编写的巧妙想法/示例，这些想法/示例是独一无二的，并且没有在更常见的语言中实现？我总是有兴趣找出我错过了什么......

I'm learning how to use J via online reading and doing some old Java assignments over again using this language, and would like to know how to make a verb that doesn't take any operands, or return any result. The reason being: I would like to allow myself the ability to type in a verb, let's call it go that would run a sequence of code on it's own and save whatever data it would produce in its execution, but would display nothing at all. The overall goal of this would be to eventually be able to reproduce my vending machine class and interface which requires at least the void returnChange() method.

是否曾经通过主流函数式语言的库尝试过通过动词、副词、分叉等方式模拟 J 风格的超浓缩默契编程？

如果是这样，结果有多成功？

如果没有，是否有技术问题使这成为不可能，还是不值得做？

我对分叉之类的结构特别感兴趣，这些结构似乎与函数式编程中的基本概念并不直接对应。

我一直在学习 Factor 和 J 语言来尝试无点编程。这些语言的基本机制似乎很清楚，但是要了解如何进行算法设计是一个挑战。

对我来说，一个特别的困惑来源是应该如何构造代码，以便轻松地尝试不同的参数。我的意思是 Mathematica 和 Matlab 非常擅长的那种东西。您设置了一个算法，然后操纵变量并观察会发生什么。

如果没有显式变量，你如何做到这一点？也许我在想这一切都是错的。我应该如何在无点编程中解决这个问题？

以上是成语。最后是痕迹和最终结果。我知道这个短语是一个单子，我知道因为 ~ 它有一个左右参数。如果您运行“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 都被从向量转换为数字的长数字所消耗。递归例程在递归时总是向下传递一个向量，这可能就是它几乎与循环一样快的原因。

这并没有改变我的问题。

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

考虑以下模板 Haskell 函数：

是否可以从等式右侧消除 lambda 表达式并composeQ使用无点样式编写？