или с классом

да да

Так

ты покажи, в общем, где у тебя id влезает.

но зачем вообще это писать руками? Set Mo, филды формы можно автоматом выводить.

Если не приписывать это слово то не работает

может, человеку секса не хватает.

я тоже поначалу руками писал.

Что бы тег менять

Если не приписывать это слово то не работает

давай скриншоты, что ты делаешь. И зачем тебе менять теги формы, если само всё неплохо работает.

обо мне

И такая же строка

Как имя

проще скриншотами.

ок

но сайт через жопу

учусь

Пока

?

у всех поначалу через жопу.

В вк сидите

там у нас группа

В переписке

Есть ?

тут удобнее.

дааа

но если что, да, есть я там.

Надо друга как нибудь сюда

ну как буду около ноута

сразу скину

И ссылку свою от профиля скину

Всем привет! помогите нубу: в общем , есть список списков, нужно, чтобы на выходе в подсписках нулевой элемент был 1, следующий равен предыдущему +1 Если в исходном подсписке последующий == предыдущему, то на выходе следующий равен предыдущему тоже

т.е. удалить первые элементы подсписков?

не, чтобы всегда с единицы начинались, длины подсписков на выходе должны равняться исходным длинам подсписков

map(range(map(len, l)))

Спасибо, Zart, попробую

а, не, это с нуля даст

[list(range(1, len(i)+1)) for i in list_of_lists] примерно так, компрехеншеном

Спасибо, сейчас посмотрю, что выйдет)

По идее правильно

Если они в беспорядочном

то надо добавить сорт

отсортировал перед этим)

а ну тогда все должно сработать

)

че то не выходит) или я не то делаю?:)

не понятно как то ответы

В конце строки

там 8 у тебя 5

Меня окружают смутные сомнения

По идее там в подсписке 2 должно быть на выходе 1, 1, 2, 3, 4

точнее 1, 1, 2, 3, 4, 4

он не правильную формулу дал

У него нет условных операторов иф

вот как-то надо условие задать, что если последующий равнялся предыдущему, то следующий элемент равен предудущему +0, если нет, то плюс 1

последующий/предыдущий кто

[[3, 3, 3], [4, 4, 4, 4], [7, 7, 7, 7, 7, 7, 7]] -> [[1, 2, 3], [1, 1, 2, 3], [1, 1, 1, 2, 3, 4, 5]] ?

[[3, 3, 3], [4, 4, 4, 4], [7, 7, 7, 7, 7, 7, 7]] -> [[1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1]]

эм

внятные условия задачи нужны

[[1, 2, 3], [2, 2, 5, 9], [1, 3, 5, 5, 7, 9, 9]] -> [[1, 2, 3], [1, 1, 2, 3], [1, 2, 3, 3, 4, 5, 5]]

вот примерно так((

Сорри, парни, путаю всех только)

я ничего не понял.

ага, дошло

»> renum = lambda e:reduce((lambda (o, i, p), c:(lambda n:(o+[n], n, c))(i if c==p else i+1)), e, ([], 0, 1))[0] »> s = [[1, 2, 3], [2, 2, 5, 9], [1, 3, 5, 5, 7, 9, 9]] »> map(renum, s) [[1, 2, 3], [2, 2, 3, 4], [1, 2, 3, 3, 4, 5, 5]]

скажем так,конкретно эта магия немного выше уровня начинающих 8)))

жесть)))

скажем так,конкретно эта магия немного выше уровня начинающих 8)))

Перепиши на обычные циклы, легче будет.

попробую разобраться, спасибо большое:)

ну тут жестокое издевательство над reduce()

поправил там 1 на 0, чтобы исправить случай когда подсписок стартует с одинаковых

def renum(l): output = [] counter = 0 prev = 0 for curr in l: if curr != prev: counter += 1 prev = curr output.append(counter) return output »> map(renum, [[1, 2, 3], [2, 2, 5, 9], [1, 3, 5, 5, 7, 9, 9]]) [[1, 2, 3], [1, 1, 2, 3], [1, 2, 3, 3, 4, 5, 5]] »> map(renum, [[3, 3, 3], [4, 4, 4, 4], [7, 7, 7, 7, 7, 7, 7]]) [[1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1]]

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

т.е. в prev мы храним предыдущее значение списка и проходя по списку мы его обновляем и при сравнении определяем увеличивать ли счетчик

Zart, круто , спасибо большое) очень)

а если сделать xx = [1], for j, k in enumerate(i[1:], 1), то от строк 7 -8 можно избавиться сразу

вообще в задаче ничего не сказано про поведение когда длины подсписков меньше двух

ну и ты аппендишь j, а надо по идее xx[-1] или xx[-1]+1

с одним элементом в подсписке код Zarta тоже пашет)

тот код неявно считает что перед списком стоит нолик

а теперь как микеланджело берем и отсекаем лишнее: lists = [1, 2, 3], [2, 2, 5, 9], [1, 3, 5, 5, 7, 9, 9] newLists = [] for i in lists: xx = [1] for j, k in enumerate(i[1:], 1): xx.append(xx[j-1] + int(i[j-1] != i[j])) newLists.append(xx) »> newLists [[1, 2, 3], [1, 1, 2, 3], [1, 2, 3, 3, 4, 5, 5]]

я уже вижу вариант короче 8))

я уже вижу вариант короче 8))

ещё пара итераций - и вы вернётесь к варианту с трёхуровневым reduce().