Найти размер наибольшего братства в массиве (оптимизация кода)

@Artem Ka · Регистрация: 25.11.2022

Студворк — интернет-сервис помощи студентам

Задан массив a
состоящий из различных целых положительных чисел.

Назовём подмассив ai,ai+1,…,aj братством только в том случае, если существует целое число m≥2 такое, что aimodm=ai+1modm=…=ajmodm, где xmody это математический остаток от целочисленного деления x на y.

Вам нужно найти размер наибольшего братства в массиве a.

Входные данные
В каждом тесте задано несколько независимых наборов входных данных. В первой строке входных данных указано количество этих наборов t (1≤t≤2⋅104).

В первой строке каждого набора задано целое число n
(1≤n≤2⋅105) – размер массива a.

Во второй строке каждого набора содержится n целых положительных чисел a1,a2,…,an (1≤ai≤1018) – составляющих массив a. Гарантируется, что все числа в a различны.

Гарантируется, что сумма n по всем наборам входных данных меньше 2⋅105.

Выходные данные
Выведите t
строк. В каждой строке должно содержаться единственное целое число — размер наибольшего братства в a
.
Мое решение не проходит по времени, я думаю что он неэффективно перебирает m, подскажите как можно оптимизировать код. Братство это рядом стоящие элементы если что.
Вот мой код

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <bits/stdc++.h>  
using namespace std;  
#define int int64_t  
signed main() {  
    ios::sync_with_stdio(0);   
    cin.tie(0);  
    int t;  
    cin >> t;  
    while (t--) {  
        int n;  
        cin >> n;  
        vector<int> vec(n);  
        for (int i = 0; i < n; ++i) cin >> vec[i];  
        int ans = 0;  
        int m = -1;  
        for (int h = 0; h < n; ++h) {  
            if (vec[h] > m) m = vec[h];   
        } 
 
        for (int i = 0; i < n; ++i) {  
            for (int s = 2; s <= m; ++s) {  
                int l = vec[i] % s;  
                int anss = 1;  
                for (int h = i + 1; h < n; ++h) {  
                    if (vec[h] % s == l) anss++;  
                    else break;  
                }   
                if (anss > ans) ans = anss;  
            }  
        }  
        cout << ans << "\n";  
    }  
    return 0;  
}

Пример
Входные данные

4
5
1 5 2 4 6
4
8 2 5 10
2
2000 1000
8
465 55 3 54 234 12 45 78

Выходные данные

3
3
2
6
Примечание

В первом наборе массив это [1,5,2,4,6]. Наибольшее братство это [2,4,6], поскольку все эти числа имеют остаток 0 по модулю 2, следовательно, m=2.

Во втором наборе массив это [8,2,5,10]. Наибольшее братство это [8,2,5], поскольку все эти числа имеют остаток 2 по модулю 3, следовательно, m=3.

В третьем наборе наибольшее братство это [2000,1000]. Можно привести несколько подходящих значений m.

@lemegeton · 09.05.2024, 19:09

У вас сложность кубическая. Должен быть квадрат.

Есть такое свойство: если два числа имеют одинаковый остаток от деления на m, то их разница делится на m.
Это называется "сравнение по модулю m".

Отсюда вывод, что одинаковый остаток будет у всех делителей модуля разницы. Единичку, естественно, не считаем.
Например, числа 150 и 12. Разница 138. Делители: 2, 3, 6, 23, 46, 69, 138.
Например, числа 12 и 47. Разница 35. Делители: 5, 7, 35
Например, числа 150 и 219. Разница 69. Делители: 3, 23, 69

Если три числа имеют одинаковый остаток от деления на m это означает, что наибольший общий делитель (НОД) их разниц отличается от единицы.
Например, 150, 12, 47. Разницы -- 138, 35. НОД(138, 25) = 1 -- нет такого числа.
Например, 150,219,12. Разницы -- 69,207. НОД(69,207) = 69. Есть такое число. Все числа, дающие в остатке одинаковое число это делители 69 -- 3, 23, 69.

При увеличении количества сравниваемых чисел надо брать НОД от НОД.

Соответственно, алгоритм примерно такой.

Находим разницы всех пар чисел. Получаем массив разностей размером n-1.
Проходимся попарно нодами и записываем НОДы в массив размером n-2. Если все 1, то ответ 2, иначе...
По резульатам проходимся попарно НОДами, записывая в массив размером n-3. Если все 1, то ответ 3, иначе...
и так далее, уменьшая размер нового массива на единицу и увеличивая ответ на единицу. Пока не найдем все 1 или пока не останется 1 элемент. Тогда ответ n.

Добавлено через 43 минуты
Вот как-то так (надо отладить):

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
#include <iostream>
#include <vector>
#include <numeric>
 
/*
template<typename T>
std::ostream &operator<<(std::ostream &out, const std::vector<T> &v) {
    for (auto i = v.begin(), end = v.end(); i != end;) {
        out << *i;
        if (++i != end) {
            out << ',';
        }
    }
    return out;
}
*/
 
template<typename T>
std::istream &operator>>(std::istream &in, std::vector<T> &vector) {
    size_t size;
    in >> size;
    T value;
    while (size--) {
        in >> value;
        vector.push_back(value);
    }
    return in;
}
 
template<typename T>
std::vector<T> operator-(const std::vector<T> &vector) {
    std::vector<T> result{};
    result.reserve(vector.size() - 1);
 
    for (size_t i = 1, size = vector.size(); i < size; ++i) {
        result.push_back(std::abs(std::abs(vector[i - 1]) - std::abs(vector[i])));
    }
    return result;
}
 
template<typename T>
std::pair<bool, std::vector<T>> iterate(const std::vector<T> &v) {
    std::vector<T> result{};
    result.reserve(v.size() - 1);
 
    bool contains = false;
    for (size_t i = 1, size = v.size(); i < size; ++i) {
        auto gcd = std::gcd(v[i - 1], v[i]);
        result.push_back(gcd);
        if (gcd != 1) {
            contains = true;
        }
    }
 
    return {contains, result};
}
 
int main() {
 
    std::size_t count;
    std::cin >> count;
 
 
    while (count--) {
 
        std::vector<std::int64_t> array;
        std::cin >> array;
//        std::cout << "DEBUG: " << array << std::endl;
//        std::cout << "DEBUG: " << -array << std::endl;
 
        size_t answer = 2;
        for (auto next = iterate(-array); next.first && next.second.size() > 1; next = iterate(next.second)) {
            ++answer;
//            std::cout << "DEBUG: " << std::boolalpha << next.first << ": " << next.second << std::endl;
        }
        std::cout << answer << std::endl;
    }
    return 0;
}

@TheCalligrapher · 09.05.2024, 19:20

Сообщение от Artem Ka

1≤t≤2⋅104

Что за странная запись? Почему вместо того, чтобы просто написать 208, написали 2⋅104?

@Royal_X · 09.05.2024, 19:27

Сообщение от Artem Ka

105

10^5 ?

Сообщение от Artem Ka

104

10^4 ?

@TheCalligrapher · 09.05.2024, 21:10

Сообщение от Artem Ka

подскажите как можно оптимизировать код.

Никак, разумеется. Откуда вообще возникла идея делать то, что вы делаете в своем коде?

Сообщение от lemegeton

Соответственно, алгоритм примерно такой.

Мне навскидку пришел в голову вариант с факторизацией каждой разницы соседних (степени факторов значения не имеют, имеет значение лишь спектр уникальных факторов) и поиск наибольшего по длине непрерывного повторения одного и того же фактора. Реализуется несложно, но это, наверное, будет существенно менее эффективно, чем ваш вариант, основанный на НОД.

Что-то вроде

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
#include <cassert>
#include <utility>
#include <vector>
#include <algorithm>
#include <iostream>
 
std::vector<unsigned> unique_factors(unsigned v)
{
  std::vector<unsigned> r;
 
  for (unsigned d = 2; d * d <= v; ++d)
    if (v % d == 0)
    {
      r.push_back(d);
      for (v /= d; v % d == 0; v /= d);
    }
 
  if (v != 1)
    r.push_back(v);
 
  assert(std::is_sorted(r.begin(), r.end()));
  return r;
}
 
int main() 
{ 
  const unsigned MIN = 1, MAX = 100000;
  std::vector<bool> b(MAX - MIN);
 
  unsigned n = 100;
  std::vector<unsigned> a(n);
  for (unsigned &v : a)
  {
    do v = MIN + std::rand() % (MAX - MIN); while (b[v - MIN]);
    b[v - MIN] = true;
  }
 
  std::vector<std::pair<unsigned, unsigned>> curr_factors;
  unsigned n_max_length = 0, i_max_start, max_factor;
 
  for (unsigned i = 1; i < n; ++i)
  {
    unsigned diff = a[i] > a[i - 1] ? a[i] - a[i - 1] : a[i - 1] - a[i];
    auto factors = unique_factors(diff);
 
    auto it_curr = curr_factors.begin();
    auto it_new = factors.begin();
    while (it_curr != curr_factors.end() && it_new != factors.end())
      if (*it_new < it_curr->first)
      { // New run begins
        it_curr = curr_factors.emplace(it_curr, *it_new, i);
        ++it_new;
        ++it_curr;
      }
      else if (*it_new > it_curr->first)
      { // Existing run ends
        unsigned n_length = i - it_curr->second;
        if (n_length > n_max_length)
        {
          n_max_length = n_length;
          i_max_start = it_curr->second;
          max_factor = it_curr->first;
        }
 
        it_curr = curr_factors.erase(it_curr);
      }
      else
      { // Existing run continues
        ++it_new;
        ++it_curr;
      }
 
    // Process remaining tails, if any
 
    if (it_new != factors.end())
    {
      for (; it_new != factors.end(); ++it_new)
        // New run begins
        curr_factors.emplace_back(*it_new, i);
    }
    else
    {
      for (auto it = it_curr; it != curr_factors.end(); ++it)
      { // Existing run ends
        unsigned n_length = i - it->second;
        if (n_length > n_max_length)
        {
          n_max_length = n_length;
          i_max_start = it_curr->second;
          max_factor = it_curr->first;
        }
      }
 
      curr_factors.erase(it_curr, curr_factors.end());
    }
 
    assert(std::is_sorted(curr_factors.begin(), curr_factors.end()));
  }
 
  std::cout << n_max_length + 1 << std::endl;
  std::cout << std::endl;
 
  std::cout << max_factor << std::endl;
  for (unsigned i = i_max_start - 1; i < i_max_start + n_max_length; ++i)
    std::cout << a[i] << " ";
  std::cout << std::endl;
}

@Artem Ka · 10.05.2024, 15:25 **[ТС]**

Спасибо за идею, а вот эта штука как работает

C++
1
return {contains, result};

@Royal_X · 10.05.2024, 16:47

Сообщение от Artem Ka

вот эта штука как работает

работает как std::make_pair

@Artem Ka · 11.05.2024, 16:31 **[ТС]**

Сообщение от lemegeton

Находим разницы всех пар чисел. Получаем массив разностей размером n-1.
Проходимся попарно нодами и записываем НОДы в массив размером n-2. Если все 1, то ответ 2, иначе...
По резульатам проходимся попарно НОДами, записывая в массив размером n-3. Если все 1, то ответ 3, иначе...
и так далее, уменьшая размер нового массива на единицу и увеличивая ответ на единицу. Пока не найдем все 1 или пока не останется 1 элемент. Тогда ответ n.

Написал код по вашей идее, та же ошибка на 3 тесте:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <bits/stdc++.h>
using namespace std;
signed main() {
    ios::sync_with_stdio(0);   
    cin.tie(0);  
    long long n;
    cin >> n;
    for (long long i = 0; i < n; ++i) {
        long long x;
        cin >> x;
        vector<long long> g(x);
        for (long long j = 0; j < x; ++j) cin >> g[j];
        vector<long long> vec;
        for (long long j = 0; j < g.size()-1; ++j) {
            vec.push_back(abs(abs(g[j]) - abs(g[j+1])));
        }
        while (vec.size()!=1) {
            vector<long long> a;
            for (long long j = 0; j < vec.size()-1; ++j) {
                a.push_back(gcd(vec[j], vec[j+1]));
            }
            if (count(a.begin(), a.end(), 1) == a.size()){
                cout << x - a.size() << "\n";
                break;
            } else {
                vec.assign(a.begin(),a.end());
                a.clear();
            }
        }
        if (vec.size() == 1) cout << x << "\n";
    }
    return 0;
}

Может можно как то еще ускорить программу

Добавлено через 41 минуту

Сообщение от lemegeton

Вот как-то так (надо отладить):

Этот код тоже не проходит

@Bleach163 · 11.05.2024, 17:00

Artem Ka, куча перевыделений памяти и лишних копирований.
Во время инициализации разницу можно находу вычислять и записывать в вектор, а не создавать 2 разных вектора:

C++
1
2
3
4
5
6
7
8
size_t n; cin >> n; --n;
vector<int64_t> vec(n);
int64_t prev; cin >> prev;
for (size_t j = 0; j < n; ++j) {
    int64_t curr; cin >> curr;
    vec[j] = abs(curr - prev);
    prev = curr;
}

Вектор a выносите за пределы цикла и резервируете место

C++
1
2
vector<int64_t> a;
a.reserve(vec.size() - 1);

Не нужно копировать второй вектор в первый, нужно просто обменять их содержимое

C++
1
2
3
4
} else {
    vec.swap(a);
    a.clear();
}

@TheCalligrapher · 11.05.2024, 17:04

Сообщение от Bleach163

Не нужно копировать второй вектор в первый, нужно просто обменять их содержимое

Можно было просто сделать перемещающее присваивание, а не какие-то притянутые за уши применения assign или swap.

C++
1
2
vec = std::move(a);
a.clear()

Хотя, конечно, многое может зависеть от реализации...

Сообщение от Artem Ka

Этот код тоже не проходит

"Не проходит" по какой причине???

@Bleach163 · 11.05.2024, 17:23

Сообщение от TheCalligrapher

Можно было просто сделать перемещающее присваивание, а не какие-то притянутые за уши применения assign или swap.

После чего один из буферов умрёт и его придётся заново пересоздавать на следующей итерации.
А при swap+clean у нас остаются те же самые 2 буфера, один из которых можно спокойно заново заполнить.
Хотя я сейчас погуглил, resize тоже не удаляет буфер если новый размер меньше текущего, значит можно даже его использовать вместо clean'а, чтобы push_back не проверял каждый раз переполнение текущего буфера.

@lemegeton · 11.05.2024, 21:59

Можно избавиться от каунта, запихав, как у меня, флаг "все единицы".

Сообщение от Artem Ka

if (count(a.begin(), a.end(), 1) == a.size()){
cout << x - a.size() << "\n";
break;

Может быть постоянная реаллокация так тормозит.

Можно переиспользовать вектор, чтоб не занималась/освобождалась память:

Сообщение от Artem Ka

vector<long long> a;

Размеры всех векторов известны -- воспользуйтесь a.reserve().

Но скорее всего, ожидается алгоритм с меньшей сложностью.
Возможно, стоит обратить внимание на факторизующий алгоритм уважаемого TheCalligrapher.

@Artem Ka · 14.05.2024, 18:00 **[ТС]**

Сообщение от TheCalligrapher

вариант с факторизацией каждой разницы соседних

Написал код под входные данные по вашему.

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
#include <cassert>
#include <utility>
#include <vector>
#include <algorithm>
#include <iostream>
using  namespace std;
std::vector<unsigned> unique_factors(unsigned v)
{
  std::vector<unsigned> r;
 
  for (unsigned d = 2; d * d <= v; ++d)
    if (v % d == 0)
    {
      r.push_back(d);
      for (v /= d; v % d == 0; v /= d);
    }
 
  if (v != 1)
    r.push_back(v);
 
  assert(std::is_sorted(r.begin(), r.end()));
  return r;
}
 
int main() 
{ 
  const unsigned MIN = 1, MAX = 100000;
  std::vector<bool> b(MAX - MIN);
  
  unsigned n;
  cin >>n;
  std::vector<unsigned> a(n);
  for (unsigned &v : a)
  {
      int x ; cin >> x;
    do v = x; while (b[v - MIN]);
    b[v - MIN] = true;
  }
 
  std::vector<std::pair<unsigned, unsigned>> curr_factors;
  unsigned n_max_length = 0, i_max_start, max_factor;
 
  for (unsigned i = 1; i < n; ++i)
  {
    unsigned diff = a[i] > a[i - 1] ? a[i] - a[i - 1] : a[i - 1] - a[i];
    auto factors = unique_factors(diff);
    auto it_curr = curr_factors.begin();
    auto it_new = factors.begin();
    while (it_curr != curr_factors.end() && it_new != factors.end())
      if (*it_new < it_curr->first)
      { // New run begins
        it_curr = curr_factors.emplace(it_curr, *it_new, i);
        ++it_new;
        ++it_curr;
      }
      else if (*it_new > it_curr->first)
      { // Existing run ends
        unsigned n_length = i - it_curr->second;
        if (n_length > n_max_length)
        {
          n_max_length = n_length;
          i_max_start = it_curr->second;
          max_factor = it_curr->first;
        }
 
        it_curr = curr_factors.erase(it_curr);
      }
      else
      { // Existing run continues
        ++it_new;
        ++it_curr;
      }
 
    // Process remaining tails, if any
 
    if (it_new != factors.end())
    {
      for (; it_new != factors.end(); ++it_new)
        // New run begins
        curr_factors.emplace_back(*it_new, i);
    }
    else
    {
      for (auto it = it_curr; it != curr_factors.end(); ++it)
      { // Existing run ends
        unsigned n_length = i - it->second;
        if (n_length > n_max_length)
        {
          n_max_length = n_length;
          i_max_start = it_curr->second;
          max_factor = it_curr->first;
        }
      }
 
      curr_factors.erase(it_curr, curr_factors.end());
    }
 
    assert(std::is_sorted(curr_factors.begin(), curr_factors.end()));
  }
 
  std::cout << n_max_length + 1 << std::endl;
  std::cout << std::endl;
 
  std::cout << max_factor << std::endl;
  for (unsigned i = i_max_start - 1; i < i_max_start + n_max_length; ++i)
    std::cout << a[i] << " ";
  std::cout << std::endl;
}

на входные данные
5
1 5 2 4 6
выдает
2
1 5
подскажите что к чему?что делать с элементами дальше?

@TheCalligrapher · 14.05.2024, 20:37

Сообщение от Artem Ka

подскажите что к чему?

Мой код выдает следующее: длину максимального братства.
Затем через пустую строку дополнительно: делитель, при котором получается одинаковый остаток
Затем само братство.

По приведенному вам выводу видно, что _{как ни трудно в это поверить} мой код содержит грубую ошибку: он забывает обработать братство, простирающееся до конца последовательности. Также, еще одна ошибка: в строках 89-90 должен использоваться it, а не it_curr.

Подправленная версия кода выглядит так

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
#include <cassert>
#include <utility>
#include <vector>
#include <algorithm>
#include <iostream>
 
std::vector<unsigned> unique_factors(unsigned v)
{
  std::vector<unsigned> r;
 
  for (unsigned d = 2; d * d <= v; ++d)
    if (v % d == 0)
    {
      r.push_back(d);
      for (v /= d; v % d == 0; v /= d);
    }
 
  if (v != 1)
    r.push_back(v);
 
  assert(std::is_sorted(r.begin(), r.end()));
  return r;
}
 
int main() 
{ 
  const unsigned MIN = 1, MAX = 100000;
  std::vector<bool> b(MAX - MIN);
 
  unsigned n = 100;
  std::vector<unsigned> a(n);
  for (unsigned &v : a)
  {
    do v = MIN + std::rand() % (MAX - MIN); while (b[v - MIN]);
    b[v - MIN] = true;
  }
 
  std::vector<std::pair<unsigned, unsigned>> curr_factors;
  unsigned n_max_length = 0, i_max_start, max_factor;
 
  for (unsigned i = 1; i < n; ++i)
  {
    unsigned diff = a[i] > a[i - 1] ? a[i] - a[i - 1] : a[i - 1] - a[i];
    auto factors = unique_factors(diff);
 
    auto it_curr = curr_factors.begin();
    auto it_new = factors.begin();
    while (it_curr != curr_factors.end() && it_new != factors.end())
      if (*it_new < it_curr->first)
      { // New run begins
        it_curr = curr_factors.emplace(it_curr, *it_new, i);
        ++it_new;
        ++it_curr;
      }
      else if (*it_new > it_curr->first)
      { // Existing run ends
        unsigned n_length = i - it_curr->second;
        if (n_length > n_max_length)
        {
          n_max_length = n_length;
          i_max_start = it_curr->second;
          max_factor = it_curr->first;
        }
 
        it_curr = curr_factors.erase(it_curr);
      }
      else
      { // Existing run continues
        ++it_new;
        ++it_curr;
      }
 
    // Process remaining tails, if any
 
    if (it_new != factors.end())
    {
      for (; it_new != factors.end(); ++it_new)
        // New run begins
        curr_factors.emplace_back(*it_new, i);
    }
    else
    {
      for (auto it = it_curr; it != curr_factors.end(); ++it)
      { // Existing run ends
        unsigned n_length = i - it->second;
        if (n_length > n_max_length)
        {
          n_max_length = n_length;
          i_max_start = it->second;
          max_factor = it->first;
        }
      }
 
      curr_factors.erase(it_curr, curr_factors.end());
    }
 
    assert(std::is_sorted(curr_factors.begin(), curr_factors.end()));
  }
 
  for (auto it = curr_factors.begin(); it != curr_factors.end(); ++it)
  { // Existing run ends
    unsigned n_length = n - it->second;
    if (n_length > n_max_length)
    {
      n_max_length = n_length;
      i_max_start = it->second;
      max_factor = it->first;
    }
  }
 
  std::cout << n_max_length + 1 << std::endl;
  std::cout << std::endl;
 
  std::cout << max_factor << std::endl;
  for (unsigned i = i_max_start - 1; i < i_max_start + n_max_length; ++i)
    std::cout << a[i] << " ";
  std::cout << std::endl;
}

Вывод для { 1, 5, 2, 4, 6 } выглядит так

В коде, как видите, много повторений, т.е. все это можно реализовать элегантнее/компактнее. Но идею он иллюстрирует.

Новые блоги и статьи Все статьи Все блоги /
Как дизайн сайта влияет на конверсию: 7 решений, которые реально повышают заявки Neotwalker 08.03.2026 Многие до сих пор воспринимают дизайн сайта как “красивую оболочку”. На практике всё иначе: дизайн напрямую влияет на то, оставит человек заявку или уйдёт через несколько секунд. Даже если у вас. . .	Модульная разработка через nuget packages DevAlt 07.03.2026 Сложившийся в . Net-среде способ разработки чаще всего предполагает монорепозиторий в котором находятся все исходники. При создании нового решения, мы просто добавляем нужные проекты и имеем. . .	Модульный подход на примере F# DevAlt 06.03.2026 В блоге дяди Боба наткнулся на такое определение: В этой книге («Подход, основанный на вариантах использования») Ивар утверждает, что архитектура программного обеспечения — это структуры,. . .	Управление камерой с помощью скрипта OrbitControls.js на Three.js: Вращение, зум и панорамирование 8Observer8 05.03.2026 Содержание блога Финальная демка в браузере работает на Desktop и мобильных браузерах. Итоговый код: orbit-controls-threejs-js. zip. Сканируйте QR-код на мобильном. Вращайте камеру одним пальцем,. . .
SDL3 для Web (WebAssembly): Синхронизация спрайтов SDL3 и тел Box2D 8Observer8 04.03.2026 Содержание блога Финальная демка в браузере. Итоговый код: finish-sync-physics-sprites-sdl3-c. zip На первой гифке отладочные линии отключены, а на второй включены:. . .	SDL3 для Web (WebAssembly): Идентификация объектов на Box2D v3 - использование userData и событий коллизий 8Observer8 02.03.2026 Содержание блога Финальная демка в браузере. Итоговый код: finish-collision-events-sdl3-c. zip Сканируйте QR-код на мобильном и вы увидите, что появится джойстик для управления главным героем. . . .	Реалии Hrethgir 01.03.2026 Нет, я не закончил до сих пор симулятор. Эта задача сложнее. Не получилось уйти в плавсостав, но оно и к лучшему, возможно. Точнее получалось - но сварщиком в палубную команду, а это значит, в моём. . .	Ритм жизни kumehtar 27.02.2026 Иногда приходится жить в ритме, где дел становится всё больше, а вовлечения в происходящее — всё меньше. Плотный график не даёт вниманию закрепиться ни на одном событии. Утро начинается с быстрых,. . .