Линейное возрастание. Всё сложно

Что ты этим хотел сказать?

def f(k: int, dataset: list = None):
    return map(lambda x: k*x, dataset or [])

if __name__ == '__main__':
    y = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    print(list(f(k=1, dataset=y)))
    print(list(f(k=2, dataset=y)))

out:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Язабан афтора за неуважение к читателям. Зачем эти простыни одноколоночного текста, в строку записать не судьба?

Выглядит так, будто тебе надо просто задать коэффициенты в формуле ax + by + c = 0.

все это решается вложенностью циклов

проще рекурсией цикла

Ой, Вам наверное арифметическая прогрессия нужна? Так вики про неё знает!

Без монад и хаскеля тут никуда…

import math


def f(k: int, dataset: list = None):
    return map(lambda x: math.ceil(k*x), dataset or [])

Частично, грубо, коэффициенты сам подставь:

print(list(f(k=0.5, dataset=y)))
[1, 1, 2, 2, 3, 3, 4, 4, 5, 5]

print(list(f(k=0.75, dataset=y)))
[1, 2, 3, 3, 4, 5, 6, 6, 7, 8]

print(list(f(k=0.65, dataset=y)))
[1, 2, 2, 3, 4, 4, 5, 6, 6, 7]

print(list(f(k=0.32, dataset=y)))
[1, 1, 1, 2, 2, 2, 3, 3, 3, 4]

это похоже на разности суммы вида

1 1 1 1 1 1 1 1

1 2 3 4 5 6 7 8 9

1 3 6 10 15 ....

на ютупчике был видосик который рассказал про койкакое открытие

(где в отличии от вышеприведённого (уголок едениц) где по классике натуральный,треугольные и так далее )

в 40-50ых 20го - что типо если чутка поправить вкраплениями в еденицы других чисел - получаться другие и тоже хорошие ряды

собственно тебе генерация каких выходов то нужна а дорогоуй?

не ну если у него заранее не известно число параметров - то можно одной функцией которая делает по циклу_длины функция от текущего параметра_ свой вызов с меньшим числом параметров

А вот это = None, dataset or None какой то сакральный смысл имеет? Просто dataset = [] нельзя? Я правда не знаю, интересно.

Это уже замыкание и декораторы. А монады это про другое емнип.

чётче покажи наборы выходов от наборов входов -

не вполне понятна текущая нумерация наборов - напоминает чем-то список Борхеса

В Python не следует указывать в аргументах по умолчанию изменяемые типы, т.к. приводит не к тому, что ожидаешь.

Просто dataset = [] нельзя?

Можно но не нужно, потому что это не создаст новый объект, как может показаться.

Что ты этим хотел сказать?

То, что не стыдно что-то не знать, но формулировать так, чтобы тебя поняли и оформить это, чтобы можно было читать - ты обязан.

Выглядит как ужасно плохо сформулированный вопрос.

def f(k: int, dataset: list = None):

print(list(f(k=0.5, dataset=y)))`

k=0.5

Ну что поделать - копипаста предыдущего комментария )

ТС взрослый мальчик, думаю, такие детали исправит.

В примере о котором я спросил это явно избыточно, но в целом, как защита от дурака, подход отличный.

Это одна из стандартных сложноотлавливаемых ошибок в питоне, я просто всегда делал копию объекта (если была опасность его изменения). Но тут вариант конечно изящней.

А, всё довольно просто. Тебе нужно написать распределённую функцию map-reduce на Erlang.

Тебе нужно написать распределённую функцию map-reduce на Erlang

А в чём челленж?

Не совсем нормально оно работает

import math


def f(k: int, dataset: list = None):
    return map(lambda x: math.ceil(k*x), dataset or [])


if __name__ == '__main__':
    y = [1, 2, 3, 4, 5, 6, 7, 9, 10]
    step = 0.1
    for x in range(0, 21):
        print(list(f(k=step, dataset=y)))
        step += 0.1

out:

[1, 1, 1, 1, 1, 1, 1, 1, 1]
[1, 1, 1, 1, 1, 2, 2, 2, 2]
[1, 1, 1, 2, 2, 2, 3, 3, 4]
[1, 1, 2, 2, 2, 3, 3, 4, 4]
[1, 1, 2, 2, 3, 3, 4, 5, 5]
[1, 2, 2, 3, 3, 4, 5, 6, 6]
[1, 2, 3, 3, 4, 5, 5, 7, 7]
[1, 2, 3, 4, 4, 5, 6, 8, 8]
[1, 2, 3, 4, 5, 6, 7, 9, 9]
[1, 2, 3, 4, 5, 6, 7, 9, 10]
[2, 3, 4, 5, 6, 7, 8, 10, 11]
[2, 3, 4, 5, 6, 8, 9, 11, 12]
[2, 3, 4, 6, 7, 8, 10, 12, 13]
[2, 3, 5, 6, 8, 9, 10, 13, 15]
[2, 4, 5, 7, 8, 10, 11, 14, 16]
[2, 4, 5, 7, 9, 10, 12, 15, 17]
[2, 4, 6, 7, 9, 11, 12, 16, 18]
[2, 4, 6, 8, 10, 11, 13, 17, 19]
[2, 4, 6, 8, 10, 12, 14, 18, 20]
[3, 5, 7, 9, 11, 13, 15, 19, 21]
[3, 5, 7, 9, 11, 13, 15, 19, 22]

Я делал так:

def gen(dataset, m, start=0, end=20):
    temp = [dataset[0]]
    count = 0
    for x in range(start, end):
        try:
            count = 0 if count >= len(m)-1 else count
            if not x == 0:
                temp.append(temp[-1] + m[count])
            count += 1
        except Exception as e:
            print(e)

    print(temp)

if __name__ == '__main__':
    y = [1]
    m0 = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
    m1 = [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
    gen(dataset=y, m=m0)
    gen(dataset=y, m=m1)

out:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
[1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10]

Тут дело в том, что эта реализация может быть тонко настраиваемой т.е можно поставить какие-то элементы отрицательными, тем самым «замедлить» рост. Вопрос в том, как бы это сделать как у тебя т.е параметром, но чтобы можно было замедлять и с отрицательным ростом

Так это будет просто абстракция в виде вложенных массивов если так можно выразится, если развернуть то всё всё всё равно будет линейно.

Если типа чтобы обходить массив не 1 2 3 4 за одну итерацию, а 1 2 3 2 3 4 3 4 4 то просто при обходе линейного массива доходить до N-1 его размера и снова начинать с I+1 его начала. Или вложенные циклы использовать.

Сами массивы смысла не имеют имеют смысл данные. Никто не мешает сделать типа такого

[1] = {[2] = {}, [3] = {} }
[2] = {[3] = {}, [4] = {} }
[3] = {[4] = {}, [5] = {} }

Где индексы это просто ключи в виде чиселок. Ну и обходить такие данные в соответствии с их структурой.

Без отрыва от задачи ничего нипанятна =)

Так ты нам практическую реализацию. Мы же тут все джуны :)

Мы же тут все джуны :)

А я чё нет? :D

практическую реализацию

На lua или C выбирай хехехе. Но на самом деле я сольюсь сейчас потому что ниасилю ведь я анскильная лалка некогда =)

А задать функцию у от х нужного вида и применить её к последовательности иксов (например, в цикле) не пробовал?

Тут еще не до оптимизации кода

import numpy as np

def lin(lst, rows, lsargs, ty="cs", *_):
    a = np.array([lst] * rows)
    ls = np.linspace(*lsargs, False).astype(int)
    ls = ls.cumsum() if ty=="cs" else ls
    ls_vec = np.expand_dims(ls, 0).T
    r = a + ls_vec
    r = np.repeat(r, range(1,len(r)+1),0) if ty == "re" else r
    return r.tolist()
    
params = [
    ([1,1],    3, (0,3,3), '  ',  "Скорость возрастания с шагом 2"),
    ([1,1,1],  3, (0,3,3), '  ',  "Скорость возрастания с шагом 3"),
    ([1,2],    3, (0,3,3), '  ',  "Нелинейная скорость возрастания #1"),
    ([1,2,3],  5, (0,6,5), 'cs',  "Нелинейная скорость возрастания #2"),
    ([1,2,3],  6, (0,3,6), '  ',  "Нелинейная скорость возрастания #3"),
    ([1,2,3],  3, (0,3,3), 're',  "Нелинейная скорость возрастания #4"),
    ([1,2,3],  3, (0,9,3), '  ',  "Ещё какая-то скорость возрастания"),
]

for p in params:
    print(p[-1], '\n   ', lin(*p), '\n')

$ python lin.py
Скорость возрастания с шагом 2 
    [[1, 1], [2, 2], [3, 3]] 

Скорость возрастания с шагом 3 
    [[1, 1, 1], [2, 2, 2], [3, 3, 3]] 

Нелинейная скорость возрастания #1 
    [[1, 2], [2, 3], [3, 4]] 

Нелинейная скорость возрастания #2 
    [[1, 2, 3], [2, 3, 4], [4, 5, 6], [7, 8, 9], [11, 12, 13]] 

Нелинейная скорость возрастания #3 
    [[1, 2, 3], [1, 2, 3], [2, 3, 4], [2, 3, 4], [3, 4, 5], [3, 4, 5]] 

Нелинейная скорость возрастания #4 
    [[1, 2, 3], [2, 3, 4], [2, 3, 4], [3, 4, 5], [3, 4, 5], [3, 4, 5]] 

Ещё какая-то скорость возрастания 
    [[1, 2, 3], [4, 5, 6], [7, 8, 9]] 

нелинейная скорость возрастания #2 … # [1] [2] [3] [2] [3] [4] [4] [5] [6] … [8] [9] [10]

Тут либо мне не хватило ICQ, чтобы распарсить закономерность, либо автору топика.

эта ошибка буквально признак _игнорирование питона в питоне_

когда исходят из модели понимания что

все команды связывающие имена включая def class и т.д. выполняются в ходе интерпретации объемлющего блока

то «изменяемое в аргументах по умолчанию» логично создаётся однократно вместе с самим именем из (def,class и т.д.)

ваще примечательно как шоубиз усложняет обучение

в «истинных доках» питона пример с кортежным присвоением идёт сразу после(вместе) с ознакомлением что есть кортежи и ваще (straite)составные как то tuple,list,str а затем «перемешанные» dict (И позже прикрученные set)

в «развлекательном ЖИ обучение»

a,b=b,a+b

подаётся как отдельно стОящая магия

ровно в оппозицию к максиме - знание малого количества принципов замещает знание большого количества (сырых) фактов

это прекрасно на что только ни идут «лишбы» замедлить наступление коммунизма

Рекомендую к просмотру

https://youtu.be/uCusYRgEjlU

Тут еще не до оптимизации кода

Я имею в виду что-то такое

(ns fns)

(defn slow-ascending-fn
  "y = floor(1/2 * x)"
  [x]
  (int (* 1/2 x)))

(defn fast-ascending-fn
  "y = floor(x^2)"
  [x]
  (int (* x x)))

(defn combined-fn
  "y = floor(floor(1/2 * x)^2)"
  [x]
  ((comp fast-ascending-fn slow-ascending-fn) x))

(def naturals (iterate inc 0))
(def slow (map slow-ascending-fn naturals))
(def fast (map fast-ascending-fn naturals))
(def combined (map combined-fn naturals))

(take 10 naturals) ;; => (0 1 2 3 4 5 6 7 8 9)
(take 10 slow) ;; => (0 0 1 1 2 2 3 3 4 4)
(take 10 fast) ;; => (0 1 4 9 16 25 36 49 64 81)
(take 10 combined) ;; => (0 0 1 1 4 4 9 9 16 16)

Все нужные параметры входят в определение конкретной функции; функций можно наделать сколько угодно.

http://ru.wikipedia.org/wiki/Гипергеометрическая_функция

тебе осталось малое:

выбрать параметры

Тут еще не до оптимизации кода

Какая еще оптимизация? Ты даже еще не дошел до хоть какой-то реализации функции генерации необходимых тебе последовательностей.

По-моему, вы гуманитарий.

Попрошу, синьор гуманитарий.

Править нами будет значит.

import math


def f(k: int, dataset: list = None):
    return map(lambda x: math.ceil(k*x), dataset or [])


if __name__ == '__main__':
    y = [10]
    step = 0.1
    for x in range(0, 21):
        print(list(f(k=step, dataset=y)))
        step += 0.1

./sample.py
[1]
[2]
[4]
[4]
[5]
[6]
[7]
[8]
[9]
[10]
[11]
[12]
[13]
[15]
[16]
[17]
[18]
[19]
[20]
[21]
[22]

Вообще хотелось бы генерить это всё изменяя стартовое значение, а не просто с единицы

На произвольных параметрах оно ломается. Допустим, с 30-40 возрастание

Хорошо, а как бы это описать в виде коофициента?

m0 = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
m1 = [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1]

Т.е чтобы я задавал какой-то коофициент и на выходе мне генерилась определенная матрица вида [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1]

Т.е, чтобы я в функцию мог передавать не матрицу, а m=x.xx

PS: потому что всё то, что выкладывали - или некорректное или ломается на параметрах

Покажи как ты вызываешь функцию и в каком месте ломается.

Хорошо, ([1, 2, 3], 9, (0, 5, 5), ' ', "Скорость возрастания с шагом 2"), –> (0, 5, 5) эти параметры как влияют на возрастание?

def lin(lst, lsargs, ty=None, *_):
    a = np.array([lst] * lsargs[-1])
    ls = np.linspace(*lsargs, False).astype(int)
    ls = ls.cumsum() if ty=="cs" else ls
    ls_vec = np.expand_dims(ls, 0).T
    r = a + ls_vec
    r = np.repeat(r, range(1,len(r)+1),0) if ty == "re" else r
    return r.tolist()

Так как размерности a и ls_vec должны совпадать, то второй аргумент функции, в принципе, лишний. Здесь я его убрал, чтобы он тебя не смущал. Если хочешь по-старому, то значения второго аргумента функции и последнего элемента третьего аргумента должны совпадать.

эти параметры как влияют на возрастание?

# изменяемая Последовательность
arr = [1,2,3]
# начальная точка линейного приращения
start = 0
# конечная точка линейного приращения
stop = 10
# количество точек от start до stop
# и количество изменённых Последовательностей arr
count = 5

print(lin(arr, (start,stop,count)))

# линейное приращение может быть приведено к его совокупной сумме
# (cumulative sum), для этого надо передать дополнительный аргумент
print(lin(arr, (start,stop,count), 'cs'))

# или каждая новая Последовательность arr может быть повторена i раз,
# где i - номер Новой Последовательности, начиная с 1
print(lin(arr, (start,stop,count), 're'))

[[1, 2, 3], [3, 4, 5], [5, 6, 7], [7, 8, 9], [9, 10, 11]]
[[1, 2, 3], [3, 4, 5], [7, 8, 9], [13, 14, 15], [21, 22, 23]]
[[1, 2, 3], [3, 4, 5], [3, 4, 5], [5, 6, 7], [5, 6, 7], [5, 6, 7], [7, 8, 9], [7, 8, 9], [7, 8, 9], [7, 8, 9], [9, 10, 11], [9, 10, 11], [9, 10, 11], [9, 10, 11], [9, 10, 11]]

Спасибо!

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