Я вот решил в честь 23 февраля почистить игнор лист, и первое, что я увидел, это то, что ты буквально везде ходишь по форуму, и после моих коментов кое-где пишешь, что я отправил тебя в игнор, и на этом основании я шизофреник. Ты серьезно, лилик? Смешной ты…
В честь 24 февраля - верни обратно 
Жалкий ты, в злобе своей…и больной.
нда, насчет тебя я походу погорячился, вали-ка ты обратно, неуч.
А ты - уч.
тут кажется загрузили меня, что я одним глазком тут…
если негде не накосячил то вот
const int bitArraySize = 13; // 100 бит = 13 байтов
byte bitArray[bitArraySize]; // Массив для хранения 100 бит
void setup() {
Serial.begin(9600);
// Инициализация массива нулями
for (int i = 0; i < bitArraySize; i++) { bitArray[i] = 0; }
int number = 30152;// Число для записи (30152 в десятичной системе)
// Запись числа в массив битов
for (int i = 0; i < 16; i++) { // 16 бит для числа 30152
if (number & (1 << i)) {
bitArray[i / 8] |= (1 << (i % 8)); // Устанавливаем соответствующий бит
}
}
// Вывод результата в последовательный порт
Serial.print("Число: ");
Serial.println(number);
Serial.print("Двоичное представление (100 бит): ");
for (int i = 0; i < bitArraySize; i++) {
printBinary(bitArray[i]); // Выводим двоичное представление каждого байта
Serial.print(" "); // Пробел между байтами
}
Serial.println();
}
void loop() {// Основной цикл не используется в этом примере
}
// Функция для вывода двоичного представления байта
void printBinary(byte b) {
for (int i = 7; i >= 0; i--) {
Serial.print((b >> i) & 1); // Сдвигаем и выводим каждый бит
}
}
получается вот так
11001000 01110101 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
и если на число 30152 я тратил 5 символов, то теперь 2…(нули не переписываем а держим в уме)) ) будет больше число, через большее количество операций можно получить все равно 1 символ повторив перегонку чисел из одной системы в другую несколько раз отбросив нули… и обратно восстановить… а то мало байтов в этом бите, дали как украли)))
еще порадовало вот это
я прям себя нео ощущаю))) ложки нет, цифр нет, и можно передать любой почти объем информации, выполнив преобразование и получить текст, а для того что бы вытащить использовать свой байт на 100 бит
только потом это все не вернуть что бы получить исходный текст… или я неправильно понял ?
aa_dav больше всего на эту мысль натолкнуло его сообщение))) всем спс
можно
а вот это фиг
MMM не перевести из 1го байта из 100 бит в 13 байт двоичной системы ? я ошибся где то ? в теории то вроде работает, а за код еще не брался…
ничего удивительного, это число в пределах uint16, что как раз 2 байта
Ты там выше не ответил на фопрос - ты реально такой тупой?
Все что выше - написано всерьез???
так сколько? 1 байта? 100 бит? или 13 байт???
Вопрос попробуй задать четче
это вопрос философский, который отражает ваше отвратительное сугубо личное мнение, и не требует точного ответа)))
записываем число 5 значное, но это тратим 5 символов,(5 байт) переводим в свой байт который состоит не из 8 бит а из 100, записываем полученный ответ в нормальные биты двоичной системы, не переписывая нули, и получаем запись в двоичной системе… которая тратит уже не 5 бит а 8, и суммы цифр нет первой, а есть просто символы…
И ничего не выигрываем.
100бит это и так 13 байт, для этого никакая “свёртка” не нужна.
100 бит все равно занимают 100бит, хоть обзови их “своим” байтом, хоть нет.
это если мы будем еще и 0 писать… а зачем, ведь там нет инфы…
а мы их просто отбросили, и записали лишь 2 нормальных байта, все вновь в двоичной системе… но вот символы там уже будут вместо цифр… но обратно восстановить можно…
но это в теории! может я и неправильно понял))) за код еще не садился…
только это не 13 байт, а 1 который состоит из 100 бит… и сумма для записи больше чем 256… в общем не знаю, к концу недели смогу проверить, может и ошибся…
Ещё раз - для хранения 100 битного числа требуется 100 бит. И никак ты этого не изменишь.
Если ты смог “отбросить нули” - значит число изначально было не 100 битное, а меньше.
Тема ровно такая же, как с вечным двигателем. Как ты не ухитряйся а обмануть закон сохранения не выйдет.
В случае вечного двигателя это закон сохранения энергии, в твоём случае - закон сохранения количества информации.
я бы сказал, 2^100 бит если уж прям для всех вариантов, 100 бит только для одного хватит имхо)
на перевод в такое сжатие, и из такого сжатия тратится очень много энергии, и вряд ли это вечный двигатель))) и это только временный буфер преобразования… тоесть через него гораздо больше цифр проходить будет, 100 символов это только 1 партия… и в итоге для всей записи получится экономия…
@flexprint
поправил
На этом все. Переубеждать изобретателей вечных двигателей - глупо и бессмысленно
ну поцчему, пусть действующий образец покажет и алга…
с ним забиваться надо))
@BABOS vs 7zip, тыщь на пять, может еще на недельку другую сгинет.
Как это нет? А 0?
…Ладно, не мучь уч. Можно в бит писать аппаратно 0,1,Z (схему могу нарисовать, начертить, составить, сложить или просто положить). На этом и сыграй
если нули не переписывать, то как потом их восстанавливать? и вместо нулей на другом числе на их месте могут встречаться единицы - с ними что, тоже отбрасывать?
Прочитайте мой пост выше, а также поймите, как записываются числа в двоичной системе. Например uint16_t это 2 обычных (теперь я так их называю) байта, которые по 8 бит, и нет знака минус (который обычно определяется самым старшим битом), т.е. можно записать числа от 0 до 65535:
bin | dec
0000 0000 0000 0000 | 0
0000 0000 0000 0001 | 1
0000 0000 0000 0010 | 2
0000 0000 0000 0011 | 3
0000 0000 0000 0100 | 4
0000 0000 0000 0101 | 5
0000 0000 0000 0110 | 6
0000 0000 0000 0111 | 7
…
0101 0101 0101 0101 | 21845
…
1010 1010 1010 1010 | 43690
…
1111 1111 1111 1101 | 65533
1111 1111 1111 1110 | 65534
1111 1111 1111 1111 | 65535
В двоичной системе всего две цифры (символа) “0” и “1”, третьего не дано. В каждом разряде числа может быть либо 0 либо 1, всего два варианта - отсюда и название, а также говорят, что у системы счисления основание “2”.
Если вы на запись числа отводите в памяти 1 бит, то вы туда можете записать либо 0 либо 1,
где 1 = 2 ^ 1 - 1 (два в степени один, минус единица).
Если 2 бита, то у вас уже появляются варианты 00, 01, 10, 11, чему соответствуют числа десятичной системы 0, 1, 2, 3,
где 3 = 2 ^ 2 - 1 (два в степени два, минус единица).
Если 3 бита, то 000, 001, 010, 011, 100, 101, 110, 111 чему соответствуют числа десятичной системы 0, 1, 2, 3, 4, 5, 6, 7
где 7 = 2 ^ 3 - 1 (два в степени три, минус единица).
и так далее, для uint16_t у вас 16 бит, то есть числа от 0 до 65535 = 2 ^ 16 - 1 (два в шестнадцатой степени, минус единица).
У вас каждый новый разряд дает увеличение вариантов чисел в количество раз, равное основанию системы счисления. То есть в двоичке - ровно вдвое. При этом ноль тоже считается числом, поэтому мы единицу отнимали из максимально возможного числа в каждом примере.
Но главное! КАЖДЫЙ (!) бит в записи важен, так как каждый бит добавляет вариативность. Если в одном числе там 0, то в каком-либо другом там рано или поздно будет 1. Выкидывая лишние на ваш взгляд разряды из одного числа, и применяя это действие как общее правило, вы автоматически лишаете себя способа записать какое-то другое число.
Когда вы это поймете, то должны осознать, что в вычислительной технике итак уже реализованы механизмы записи чисел некоторой размерности, требующие минимальное необходимое и достаточное для этого количество памяти. Задача программиста лишь выбрать подходящий тип данных для хранения этих чисел, а также обеспечить корректную их конвертацию при необходимости.
Если же речь про хранения очень больших чисел, для которых не подходит даже самый “большой” тип данных, то берут две или более переменных самого большого типа данных, и в них хранят отдельно группы разрядов такого большого числа, но реализация арифметических операций над такими числами ложится на плечи программиста.