хотя можно опустить самые старшие буквы 'a

нельзя, поток тогда будет не выровнен

хм. А ваще можно действительно сделать прямо потоком

не, я про окончание потока

не, я про окончание потока

❓

я даже привел на С код, который это реализует

Какой из твоих кодов по 14 бит преобразует?

все 8)

Проблему с окончанием потока можно решить записав в начале длинну бинарного потока в байтах.

точнее он преобразовывает инт в трехбуквенную запись

тогда это не поток

начиная с младших разрядов

а можно сделать поток

по 64 бита = 0,5833333333333333

тоже не очень...

ну ок))))

по 14 бит, думаю, самое то )

47 бит хорошо

или по 47

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

ну да, нужен какой-то признак окончания потока

Либо в конце потока будем говорить, где именно он закончился.

26^10/2^47 = 1.00305254345

я чтото не то считаю?

Либо в конце потока будем говорить, где именно он закончился.

я буду выравнивать исходные данные

эффективность ниже, зато никакого гемора с паддингом

ща сделаю для потока

поток кончается EOF

ну, для 47 бит получается 5 лишних байт в крайнем случае

можно не заморачиваться

ща буду соображать как на питоне битовые сдвиги делать ))))

эээ

так же, как у всех нормальных людей

xor

» «

>> и <<

давно я этого не делал )

xor ecx, 2

ну, для 47 бит получается 5 лишних байт в крайнем случае

Хмм... Что-то не понял как ты выравнивать их собираешься. Вот нужно тебе записать 64 бита, первыми десятью буквыми ты записал 47, а как ты запишешь оставшиеся 17 бит?

допишешь впереди еще 30 нулей и запишешь

ну да, надо знать длину получается

Хмм... Что-то не понял как ты выравнивать их собираешься. Вот нужно тебе записать 64 бита, первыми десятью буквыми ты записал 47, а как ты запишешь оставшиеся 17 бит?

добить нулями слева

для 47 бит получается очень плохо

надо по 14 таки делать

добить нулями слева

Допустим тебе осталось записать 1 бит. Если ты добьёшь его нулями, то как отличишь 00...01 от 1?

гхм...

c 14 та же ботва на самом деле

полную длину знать нужно, или какой-то явный признак окончания всего ваапще

либо добивать исходные данные так, чтобы они были кратны по длинне

что я собственно и собираюсь сделать, по этому 14 бит лучше

47 бит это почти 48, то есть 6 байт

вы можете добавить заголовок из 2 символов, в котором напишете, сколько бит в последнем чанке значащие

могу

Может тогда суффикс, где бы описывалось сколько значащих бит в предпоследнем чанке? Тогда можно передавать потоком

а как отличить суффикс от потока?

о, можно сделать ваще красиво

Поток же закрывается, не?

47 бит помещаются в 10 букв, но не покрывают все возможные комбинации

можно сделать особую комбинацию, которая означает окончание потока

можно и на кадры поток разделить

так-то

zzzzzzzzzz например будет означать окончание потока - оно не помещается в 47 бит

потом придете к какому-нибудь HDLC over Enigma

Какие редакторы вы используете?

емакс с ивил модом

поигрался, понял, что запутался с битиками и надо по-нормальному с тестами писать

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

ERROR: S client not available

2^47 25 23 24 13 07 24 23 07 12 20 то есть максимальное значение из 47 бит в виде букв это zxynhyxhmu

точнее zxynhuxhmt

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

Какие редакторы вы используете?

PyCharm, Sublime, vim

Rodeo

vim\

atom with vim-mode ?

заморочился ))))

def b26encode(input): """Encode the bytes-like object input using Base26 and return a string. """ if not isinstance(input, bytes): raise TypeError('input must be bytes') #pading leftover = len(input) % 7 if leftover: input = input + bytes(7 - leftover) # Don't use += ! # conv = BaseConverter(_b26alphabet).from_decimal encoded = '' for i in range(0, len(input), 7): c = int.from_bytes(input[i: i + 7], 'big') e = int2base(c >> 42) # bits 1 - 14 if len(e) < 3: e += _b26alphabet[0]; encoded += e e = int2base((c >> 28) & 0x3fff) # bits 14 - 28 if len(e) < 3: e += _b26alphabet[0]; encoded += e e = int2base((c >> 14) & 0x3fff) # bits 28 - 42 if len(e) < 3: e += _b26alphabet[0]; encoded += e e = int2base(c & 0x3fff) # bits 42 - 56 if len(e) < 3: e += _b26alphabet[0]; encoded += e return encoded

кто подскажет? есть такая последовательность A A[0] = 9 A[1] = 3 A[2] = 9 A[3] = 3 A[4] = 9 A[5] = 7 A[6] = 9 надо найти число которое встречается только один раз, т.е. в данном случае 7 вопрос как правильнее это сделать? элементы всегда нечетные числа

я делал в лоб эту задачу

можно использовать хеш

def solution(A): s = set() for n, a in enumerate(A): if a not in A[n+1:] and a not in s: return a else: s.add(a)

но гы сложность выходит O(N**2)

если можно использовать O(N) по памяти, то за O(N) по времени можно сделать, используя нечетность

еще подскажку кинь что почитать?

подумай, как ты можешь использовать нечетность

идеи?

хз, только если умножать на 2? или складывать, получатся же четные числа

кто подскажет? есть такая последовательность A A[0] = 9 A[1] = 3 A[2] = 9 A[3] = 3 A[4] = 9 A[5] = 7 A[6] = 9 надо найти число которое встречается только один раз, т.е. в данном случае 7 вопрос как правильнее это сделать? элементы всегда нечетные числа

dict ?

O(N)

можно и дикт, тогда и нечетность не используется

Выглядит так, как будто задачку неправильно запомнили

можно и дикт, тогда и нечетность не используется

Я думаю можно извратиться и найти решение за O(1) по памяти

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

я думаю 100% можно)) дайте наводку или кусок кода, чтобы понять

нипаксорить

повторяются всегда четное количество раз

во

а, лол

ну тогда все проще

почитай про битовые операции