Какой язык умен так, чтобы он мог понять variable a = 0 , 20, ..., 300
? таким образом, Вы могли легко создать массивы с ним дающий шаг, запускают var последний var (или, лучше никакая последняя переменная (а-ля бесконечный массив)) и не только для чисел (но и даже комплексные числа и пользовательские структуры как Седенион, который Вы, вероятно, определили бы самостоятельно как класс или безотносительно...),
Точка, найдите язык или алгоритм применимыми на языке, который может поймать закон того, как массив переменных Вы дали (или параметрические усилители этого переменные) изменение. И составьте использование, что закон структура, от которой Вы смогли бы получить любую переменную (переменные).
Всем - примеры, которые Вы обеспечиваете, очень полезны для всех новичков там. И в то же время элементарные знания, требуемые создавать такой 'Умный Массив' класс. Так спасибо, осторожное очень для Вашей восторженной справки.
Поскольку JeffSahol замечен
все возможные правила могли бы включать некоторых, которые требуют, чтобы оценка некоторых/всех существующих участников генерировала энного участника.
Таким образом, это - трудный Вопрос. И я думаю язык, который сделал бы это, 'Естественно' будет большим к play\work с, надо надеяться, не только для математиков.
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]
Что ж ... Java - единственный язык, который я когда-либо серьезно использовал, не мог сделать это (хотя я считаю, что использование вектора вместо массива позволяло это).
Php всегда делает вещи намного проще, а иногда и опасно просто :)
Вместо этого вам следует использовать математику.
- (int) infiniteList: (int)x
{
return (x*20);
}
«Умные» массивы используют этот формат, поскольку я серьезно сомневаюсь, что Haskel может позволить вам это сделать:
a[1] = 15
после определения a
.
Excel:
MATLAB это не сам язык программирования, а инструмент, но все же вы можете использовать его как язык программирования.
Он создан для таких математических операций, чтобы массивы там были проще простого :)
a = 0: 1: 20;
создает массив от 0 до 20 с шагом 1. вместо числа 1 вы также можете указать любое значение / операцию для приращения
Практически любой программный язык может дать вам эту последовательность. Вопрос в том, какой синтаксис вы хотите использовать для его выражения. Например, в 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);
Итак, каковы ваши критерии?
Возможно, я неправильно понимаю вопрос, но ответы, указывающие на способ кодирования конкретного примера, который вы привели (подсчет по 20), на самом деле не соответствуют требованию, чтобы массив "кэшировал" произвольное правило для генерации членов массива... кажется, что почти любое полное решение потребует пользовательского класса коллекции, который позволяет генерировать члены с помощью делегированной функции/метода, тем более что все возможные правила могут включать некоторые, которые требуют оценки некоторых/всех существующих членов для генерации n-го члена.
C #, например, реализует Enumerable.Range (int start, int count)
, PHP предлагает функцию range (смешанный низкий, смешанный высокий, шаг числа)
, ... Есть языков программирования, которые достаточно «умны».
Кроме того, бесконечный массив практически бесполезен - он вовсе не бесконечен, но потребляет всю память.
Вы не можете выполнить это перечисление просто с помощью комплексных чисел, поскольку для данного числа нет прямого преемника или предшественника. Изменить: это не означает, что вы не можете сравнивать комплексные числа или создавать массив с указанным шагом!
Я считаю, что синтаксис Perl6 таков: start ... * + increment_value, end
Язык SWYM , который, похоже, больше не работает в сети, мог вывести арифметические и геометрические прогрессии из нескольких примеров элементов и создать соответствующий список.
И 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
Подробнее: http://www.cc.gatech.edu/~yannis/fc++/
Арпан
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|]
Как видите, увеличивается только действительная часть.
Если шаг также является комплексным числом, он будет увеличивать действительную часть И мнимую часть, пока не будет достигнута последняя переменная
действительная часть:
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|]
Groovy,
assert [ 1, *3..5, 7, *9..<12 ] == [1,3,4,5,7,9,10,11]
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
В 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
Подождите ...
print range(0, 320, 20)
дает
[ 0, 20, 40, 60, 80, 100, 120, 140, 160, 180, 200, 220, 240, 260, 280, 300]
Реквизит к комментариям (я знал там был более лаконичным: P)
Сборка: Предположим, что edi содержит адрес желаемого массива:
xor eax, eax
loop_location:
mov [edi], eax
add edi, #4
add eax, #20
cmp eax, #300
jl loop_location