Ответ 1

Haskell:

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

btw: возможны и бесконечные списки:

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]

Ответ 2

Excel:

• Напишите 0 в A1
• Напишите 20 в A2
• Выберите A1: 2
• Перетащите угол вниз

Ответ 3

MatLab:

a = [0:20:300]

Ответ 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

Подождите...

Python:

print range(0, 320, 20)

дает

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

Подкрепляет комментарии (я знал, что был более сжатый способ: P)

Ответ 6

И PHP:

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

Ответ 7

Scala:

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

Ответ 9

И С++ тоже [используйте библиотеку FС++]:

// 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 );  

Реализация ленивого списка FС++: http://www.cc.gatech.edu/~yannis/fc++/New/new_list_implementation.html

Подробнее: http://www.cc.gatech.edu/~yannis/fc++/

Арпан

Ответ 10

Groovy,

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

Ответ 11

Язык SWYM, который, как представляется, больше не находится в сети, может вывести арифметические и геометрические прогрессии из нескольких элементов примера и сгенерировать соответствующий список.

Ответ 12

Я считаю, что синтаксис в perl6 равен start ... *+increment_value, end

Ответ 13

С#, например, реализует Enumerable.Range(int start, int count), PHP предлагает функцию range(mixed low, mixed high, number step),... Там есть языки программирования, которые достаточно умны.

Кроме того, бесконечный массив практически бесполезен - он не бесконечен, а всепоглощающий.

Вы не можете сделать это перечислением просто с комплексными числами, поскольку нет прямого преемника или предшественника для данного номера. Изменить: это не означает, что вы не можете сравнивать сложные числа или создавать массив с указанным шагом!

Ответ 14

Вместо этого вы должны использовать математику.

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

"Умные" массивы используют этот формат, так как я серьезно сомневаюсь, что Haskel может позволить вам сделать это:

a[1] = 15

после определения a.

Ответ 15

Возможно, я не понимаю вопрос, но ответы, которые указывают способ кодирования конкретного примера, который вы указали (с 20 по 20), на самом деле не соответствуют требованию, чтобы массив "кешировал" произвольное правило для генерации элементов массива.. Кажется, что почти для любого полного решения потребуется специальный класс коллекции, который позволяет генерировать члены с делегированной функцией/методом, тем более что все возможные правила могут включать в себя некоторые, которые требуют оценки некоторых/всех существующих членов для генерации n-го члена.

Ответ 16

Практически любой язык программы может дать вам эту последовательность. Вопрос в том, какой синтаксис вы хотите использовать для его выражения. Например, в С# вы можете написать:

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 вы также можете указать любое значение/операцию для приращения

Ответ 19

Php всегда делает вещи намного проще, а иногда и опасно просто:)

Ответ 20

Ну... Java - это единственный язык, который я когда-либо всерьез использовал, который не мог этого сделать (хотя я считаю, что использование Vector вместо Array позволило).