【问题标题】：Which language understands 'variable a = 0 , 20, ..., 300'?哪种语言可以理解“变量 a = 0 , 20, ..., 300”？
【发布时间】：2010-06-14 13:25:17
【问题描述】：

哪种语言很聪明，可以理解variable a = 0 , 20, ..., 300？所以你可以很容易地创建数组，它给出 step start var last var （或者，最好没有最后一个变量（一个无限数组）），不仅适用于数字（甚至是复杂的数字和自定义结构，如 Sedenion's 你可能会定义自己作为一个班级或其他什么...）

重点是，找到一种语言或算法，该语言或算法可在一种语言中使用，该语言或算法可以缓存您给定的变量数组（或该变量的参数）如何变化的规律。并使用该定律构成一个结构，您可以从中获取任何变量。

致所有人 - 您提供的示例对所有初学者都非常有帮助。同时也是构建此类“智能阵列”课程所需的基础知识。非常感谢您的热心帮助。

作为JeffSahol noticed

所有可能的规则都可能包括一些需要评估部分/全部现有成员生成第 n 个会员。

所以这是一个很难的问题。而且我认为能够“自然地”做到这一点的语言会很好玩\一起工作，希望不仅适用于数学家。

【问题讨论】：

这不一定是一种智能语言的标志，而是一种将智能语言作为内置或核心库的一部分的语言。只需解析字符串即可轻松将其添加到任何语言的库中。
似乎大多数答案（Haskell 除外）都完全误解了这个问题。有趣的部分是不必明确给出步长，而是让语言根据模式自动计算它。你知道，问题的“聪明”部分？！？
@Stephen Furlani @'没有语言本身支持复数' 见_Imaginary in C, C99 standard
@Ole <complex.h> 是标准库的一部分，而不是语言。那里差别比较大。 en.wikipedia.org/wiki/Complex.h
@Ole Jak 没有语言本身支持复数？听说过 FORTRAN 吗？不，你可能没有，/

标签： list programming-languages arrays variables lazy-evaluation

【解决方案1】：

哈斯克尔：

Prelude> let a=[0,20..300]
Prelude> a
[0,20,40,60,80,100,120,140,160,180,200,220,240,260,280,300]

顺便说一句：无限列表也是可能的：

Prelude> let a=[0,20..]
Prelude> take 20 a
[0,20,40,60,80,100,120,140,160,180,200,220,240,260,280,300,320,340,360,380]

【讨论】：

由于我不了解Haskell，你可以在定义后更改a吗？前任。 a[1] = 15 并保持所有其他值不变，以便下一个 take 20 a 返回 [0, 15, 40, 60, 80, ..] ?
@Ole Jack：好的，八元音看起来很有趣，但我仍然不确定你是如何从“服装结构”到“八元音”的。诚然，我对这个数学分支不太熟悉，但谷歌搜索（我只是对术语感到好奇）“八元服装结构”返回...... this 页面作为第一个点击. ;)
@Stephan：你不能在 Haskell 中重新绑定变量或改变数据结构。
也许 Ole 意味着自定义结构？
我喜欢这个符号。浏览其他答案，它是唯一一个与数学符号足够接近以不言自明的答案。

【解决方案2】：

Excel：

在 A1 中写入 0
在 A2 中写 20
选择 A1:2
向下拖动角

【讨论】：

大声笑，但这不是无限的。你会在某个时候用完行。
这真的是一种编程解决方案吗？我认为它更像是一个静态电子表格解决方案，但 YMMV。
选择整列并从菜单编辑->填充->向下

【解决方案3】：

MatLab：

a = [0:20:300]

【讨论】：

对于复杂的、双重的...等？
@Ole Jack：你能解释一下“双重身份”吗？
MatLab 完全支持复数。我现在没有它在我面前进行测试，但是正如上面的算术序列可以写成：a = [0:15] * 20，一个复数的算术序列可以很容易地产生，例如a = (1 + 3i) + [1:100] * (1 + 2i)

【解决方案4】：

F#：

> let a = [|0..20..300|];;

val a : int [] =
  [|0; 20; 40; 60; 80; 100; 120; 140; 160; 180; 200; 220; 240; 260; 280; 300|]

复数：

let c1   = Complex.Create( 0.0, 0.0)
let c2   = Complex.Create(10.0, 10.0)
let a    = [|c1..c2|]

val a : Complex [] =
 [|0r+0i; 1r+0i; 2r+0i; 3r+0i; 4r+0i; 5r+0i; 6r+0i; 7r+0i; 8r+0i; 9r+0i; 10r+0i|]

如您所见，它只增加实部。

如果步长也是复数，它将增加实部和虚部，直到达到last var实部：

let step = Complex.Create(2.0, 1.0)
let a    = [|c1..step..c2|]

val a: Complex [] =
  [|0r+0i; 2r+1i; 4r+2i; 6r+3i; 8r+4i; 10r+5i|]

请注意，如果此行为不符合您的需求，您仍然可以重载 (..) 和 (.. ..) 运算符。例如。你希望它增加虚部而不是实部：

let (..) (c1:Complex) (c2:Complex) =
  seq {
    for i in 0..int(c2.i-c1.i) do
      yield Complex.Create(c1.r, c1.i + float i)
  }

let a    = [|c1..c2|]
val a : Complex [] =
 [|0r+0i; 0r+1i; 0r+2i; 0r+3i; 0r+4i; 0r+5i; 0r+6i; 0r+7i; 0r+8i; 0r+9i; 0r+10i|]

【讨论】：

我已经编辑了我的答案。请注意，您可以定义这些运算符，以便它们也适用于您的服装结构。

【解决方案5】：

还有 PHP：

$a = range(1,300,20);

【讨论】：

你能用随机数或函数代替20吗？
@Ole Jak，是的，你可以在那里输入任何数字。

【解决方案6】：

等等……

Python：

print range(0, 320, 20)

给予

[0, 20, 40, 60, 80, 100, 120, 140, 160, 180, 200, 220, 240, 260, 280, 300]

给 cmets 的道具（我知道有更简洁的方法：P）

【讨论】：

[y for y in x] 与 x 不同？不必要的列表理解。
@Evan Carroll：当x 是一个生成器表达式而不是一个列表时——当然。列表推导将表达式的计算强制到一个列表中，否则该列表将根据需要进行计算。请注意，这相当于list(x)。
print() 会计算生成器表达式吗？因为对我来说print range(0,320,20) 与print [y for y in range(0, 320, 20)] 相同

【解决方案7】：

斯卡拉：

scala> val a = 0 to 100 by 20
a: scala.collection.immutable.Range = Range(0, 20, 40, 60, 80, 100)

scala> a foreach println
0
20
40
60
80
100

无限列表：

scala> val b = Stream from 1     
b: scala.collection.immutable.Stream[Int] = Stream(1, ?)

scala> b take 5 foreach println
1
2
3
4
5

【讨论】：

【解决方案8】：

在python中你有

a = xrange(start, stop, step)

（或者只是在 python 3 中的范围）这为您提供了一个从开始到停止的迭代器。它可以是无限的，因为它是惰性构建的。

>>> a = xrange(0, 300, 20)
>>> for item in a: print item
...
0
20
40
60
80
100
120
140
160
180
200
220
240
260
280

【讨论】：

OP 也要求提供复数。 AFAIK，xrange 只做整数。
@Timothy：对复数这样做有意义吗？
它是否有意义取决于手头的特定问题。我只是注意到 OP 也专门询问了复数。

【解决方案9】：

还有 C++ [使用 FC++ 库]：

// List is different from STL list
List<int> integers = enumFrom(1); // Lazy list of all numbers starting from 1

// filter and ptr_to_fun definitions provided by FC++
// The idea is to _filter_ prime numbers in this case
// prime is user provided routine that checks if a number is prime
// So the end result is a list of infinite primes :)
List<int> filtered_nums = filter( ptr_to_fun(&prime), integers );

FC++ 惰性列表实现：http://www.cc.gatech.edu/~yannis/fc++/New/new_list_implementation.html

阿潘

【讨论】：

【解决方案10】：

时髦的，

assert [ 1, *3..5, 7, *9..<12 ] == [1,3,4,5,7,9,10,11]

【讨论】：

【解决方案11】：

SWYM 语言似乎不再在线，它可以从几个示例项目推断算术和几何级数并生成适当的列表。

【讨论】：

【解决方案12】：

我相信 perl6 中的语法是start ... *+increment_value, end

【讨论】：

【解决方案13】：

你应该改用数学。

- (int) infiniteList: (int)x 
{
    return (x*20);
}

“智能”数组使用这种格式，因为我严重怀疑 Haskel 是否会让你这样做：

a[1] = 15

在定义a之后。

【讨论】：

Objective-C 但没关系任何语言都可以。
这是objective-c，但原则适用于任何C语言家族，实际上他的示例遗漏了许多所需的样板。
嗯，是的，理想情况下，您可以使用我的示例创建一个完整的“智能数组”类。
Haskell 不允许你做a[1] = 15，这是真的（但原因与你暗示的不同）。但是，您的暗示似乎是这种形式的列表在 haskell 中作为函数实现，而不是存储在内存中。那是错误的。列表[1,3..7] 与列表[1,3,5,7] 一样（懒惰地）存储在内存中。事实上，写[1,3..7] 等同于写[1,3,5,7]。
不知道 Haskell，使用数学计算 [1,3..90] 比存储惰性数组更节省内存。由于 Haskell 不会让您在定义后对其进行更改，因此如果一个简单的数学方程可以表示相同的东西，那么没有理由在内存中存储一个 100 值的不可变数组。

【解决方案14】：

例如，C# 确实实现了 Enumerable.Range(int start, int count)，PHP 提供了函数 range(mixed low, mixed high, number step)，...有编程语言足够“聪明”。

除此之外，无限数组几乎毫无用处 - 它根本不是无限的，而是会消耗所有内存。

你不能简单地用复数进行枚举，因为给定的数字没有直接的后继或前驱。 编辑：这并不意味着您不能比较复数或创建具有指定步骤的数组！

【讨论】：

by infinit 我保证您可以在需要时获得任何物品，例如 [12309987657]。
无限列表一点用处都没有！当然，编程语言应该是惰性的。如果不是，它确实毫无意义g。（顺便说一句：Haskell 很懒）
Enumerable.Range 不是语言功能，而是运行时库 功能。我会让读者决定这是否重要。
复数没有后继，但是当提供步长时，复数范围的任何元素都存在后继。
因为有理数域是可数的，所以很容易看出复数也是可数的（因此是可枚举的）。订购它们只是一个挑战。也许使用upload.wikimedia.org/wikipedia/commons/8/85/…？

【解决方案15】：

我可能误解了这个问题，但是指定您给出的特定示例的编码方式的答案（按 20 计数）并不真正满足数组“缓存”生成数组成员的任意规则的要求。 .似乎几乎任何完整的解决方案都需要一个自定义集合类，该类允许使用委托函数/方法生成成员，特别是因为所有可能的规则可能包括一些需要评估部分/所有现有成员以生成第 n 个成员的规则。

【讨论】：

所以...我能说什么-提供的示例至少对所有初学者都有帮助...同时是构建此类“智能阵列”所需的基础知识类...是的 - 所有可能的规则可能包括一些需要评估一些/所有现有成员以生成第 n 个成员的规则。所以这是一个很难的问题。并且“自然”地做到这一点的语言会很高兴与...一起玩\工作......可能

【解决方案16】：

几乎任何程序语言都可以给你这个序列。问题是你想用什么语法来表达它。例如，在 C# 中，您可以编写：

Enumerable.Range(0, 300).Where(x => (x % 20) == 0)

或

for (int i = 0; i < 300; i += 20) yield return i;

或封装在一个类中：

new ArithmaticSequence(0, 301, 20);

或在静态类的方法中：

Enumerable2.ArithmaticSequence(0, 301, 20);

那么，你的标准是什么？

【讨论】：

【解决方案17】：

组装：假设 edi 包含所需数组的地址：

xor eax, eax
loop_location:
    mov [edi], eax
    add edi, #4
    add eax, #20
    cmp eax, #300
    jl loop_location

【讨论】：

【解决方案18】：

MATLAB 它本身不是一种编程语言，而是一种工具，但您仍然可以像使用编程语言一样使用它。

它是为这样的数学运算而构建的，让数组变得轻而易举:)

a = 0:1:20;

创建一个从 0 到 20 的数组，增量为 1。除了数字 1，您还可以为增量提供任何值/操作

【讨论】：

编程语言与您使用的完全像编程语言但由于某些未指明的原因不是您帐户中的编程语言的东西有什么区别？
Matlab 不是一种编程语言，它是一种实现。 octave 是同一语言的免费实现。但是说Matlab而不是“Matlab使用的编程语言”要方便得多。（类似地，人们可能更喜欢简洁地说“GCC 语言”而不是“C99 语言加上 GCC 特定的扩展”，尽管后者更正确）。

【解决方案19】：

Php 做的事情总是简单得多，有时也简单得危险:)

【讨论】：

【解决方案20】：

嗯……Java 是我曾经认真使用过的唯一一种不能做到这一点的语言（尽管我相信使用 Vector 而不是 Array 可以做到这一点）。

【讨论】：

c 家族（arpan 的聪明才智无法承受）、pascal、/bin/sh 衍生品、/bin/csh 衍生品、fortran 至少在 80 年代……
我并不是说它们不存在（你没有听过我用过的任何严肃的东西），只是那些支持稀疏数组的那些是非常常见的。
Perl 不能用 or 来做到这一点，无论如何使用核心结构perl -E'say for grep $_%20==0, 0..300' 都会很奇怪@你可以自己动手。