81

(9 відповідей, залишених у C++)

Потрібно знайти кількість рішень того, як можна розмістити n ферзів на шаховій дошці n x n так, щоб вони не били одне одного.

Ось що в мене вийшло:

using namespace std;

class Solution {

    bool is_not_under_attack(vector<vector<int>>& board, int& row, int& col)
    {
        bool answer { true };
        if (board.at(row).at(col) != 0) {
            answer = false;
        }
        return answer;
    }

    void place_queen(vector<vector<int>>& board, const int& n, int row, int col)
    {
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                if (board.at(i).at(j) == 0 && (i == row || j == col || (i - row == j - col) || (i + j == col + row))) {
                    board.at(i).at(j) = 1;
                }
            }
        }
    }

    void remove_queen(vector<vector<int>>& board, const int& n, int row, int col)
    {
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                if (board.at(i).at(j) != 0 && (i == row || j == col || (i - row == j - col) || (i + j == col + row))) {
                    board.at(i).at(j) = 0;
                }
            }
        }
    }

    int backtrack_nqueens(vector<vector<int>>& board, const int& n, int row, int count)
    {
        for (int col = 0; col < n; ++col) {
            if (is_not_under_attack(board, row, col)) {
                place_queen(board, n, row, col);
                if (row + 1 == n) {
                    ++count;
                } else {
                    count = backtrack_nqueens(board, n, row + 1, count);
                }
                remove_queen(board, n, row, col);
            }
        }
        return count;
    }

public:
    int totalNQueens(int n)
    {
        vector<vector<int>> board(n, vector<int>(n, 0));
        int answer = backtrack_nqueens(board, n, 0, 0);
        return answer;
    }
};
int main()
{

    int n { 4 };

    Solution obj;
    int answer = obj.totalNQueens(n);
    cout << answer << endl;

    return 0;
}

Але десь там помилка і я не знаю, де саме.
Забагато рішень нараховує.

Тоді чи варто уникати рекурсії? Якщо ні, то в яких випадках вона буде бажана, а в яких ні?

Тобто, як я розумію, для пошуку в глибину (depth first search) краще обирати рекурсію, за потреби з мемоізацією.
А для пошуку в ширину (breadth first search) перевага віддається ітеративному методу, наприклад, з чергою.
Бо якщо навпаки робити, вийде доволі апокаліптичне кодло, як от для пошуку в глибину зі стеком.

Мені цікаво як перевірити чи бінарне дерево збалансоване ітеративним способом.
Рекурсією виходить ось так:

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
    int dfs_height(TreeNode* root)
    {
        if (root == nullptr)
            return 0;

        int left_height = dfs_height(root->left);
        

        if (left_height == -1)
            return -1;

        int right_height = dfs_height(root->right);
        

        if (right_height == -1)
            return -1;

        if (abs(left_height - right_height) > 1)
            return -1;

        return max(left_height, right_height) + 1;
    }

public:
    bool isBalanced(TreeNode* root)
    {
        return dfs_height(root) != -1;
    }
};

Пробував просто замінити циклами рекурсію — не виходить.

85

(12 відповідей, залишених у C++)

lucas-kane написав:
Teg Miles написав:

Ось так зробив, але все одно десь помилка є, проходжу лише два тести[

Можливо я чогось не розумію, але:

Teg Miles написав:
    int new_mat_row = height + 2 * (kernel_row / 2);
    int new_mat_col = width + 2 * (kernel_col / 2);

Який сенс множити на 2 та ділити на 2 ???!
А від стилю коду просто  :! хочеться. Читається важко, просто  *WALL*! Автор про коментарі хоч щось чув?!
Ну от, наприклад взяти функцію padding, котра, напевно за задумом автора, має повернути нове зображення, враховуючи розміри зображення на вході та розміри ядра. Тобто, ця функція створює нове зображення з новими розмірами, тоді так і називай функцію - newImageWithPadding, чи якось подібно, щоб було зрозуміло із найменування функції, що вона має виконувати.
Додавай коментарі до коду! Взяти хоча б шматок коду із купою if-else. Бля-я-я! Туди навіть заглядати не хочеться! Можна було б, хоча якось так:

Прихований текст
std::vector<u8> newImageWithPadding(const std::vector<u8> &inputImage, const int &imageHeight, const int &imageWidth, const int &kernelRows, const int &kernelColumns)
{
  // Ррозрахунок нового розміру зображення
  int heigthNewImage = ...;
  int widthNewImage = ... ;

  // Нове зображення
  std::vector<u8> outputImage(heigthNewImage * widthNewImage);

  // Заповнення відступів
  for (int i = 0; i < heigthNewImage; ++i)  {
    for (int j = 0; j < widthNewImage; ++j)    {
     // Лівий верхній кут
      if (i >= 0 && i <= kernelRows / 2 && j >= 0 && j <= kernelColumns / 2) {
        outputImage.at(i *widthNewImage + j) = inputImage.front();
      }

      // Правий верхній кут
      else if (i >= 0 && i <= kernelRows / 2 && j >= widthNewImage - kernelColumns / 2 - 1) {
        outputImage.at(i *widthNewImage + j) = inputImage.at(imageWidth - 1);
      }

      // Лівий нижній кут
      else if (i >= heigthNewImage - kernelRows / 2 - 1 && j >= 0 && j <= kernelColumns / 2) {
        outputImage.at(i *widthNewImage + j) = inputImage.at((imageHeight - 1) *imageWidth);
      }

      // Правий нижній кут
      else if (i >= heigthNewImage - kernelRows / 2 - 1 && j >= widthNewImage - kernelColumns / 2 - 1) {
        outputImage.at(i *widthNewImage + j) = inputImage.back();
      }

      // Лівий край
      else if (i > kernelRows / 2 && i < heigthNewImage - kernelRows / 2 - 1 && j >= 0 && j < kernelColumns / 2) {
        outputImage.at(i *widthNewImage + j) = inputImage.at((i - kernelRows / 2) *imageWidth);
      }

      // Верхній край
      else if (i >= 0 && i < kernelRows / 2 && j > kernelColumns / 2 && j < widthNewImage - kernelColumns / 2) {
        outputImage.at(i *widthNewImage + j) = inputImage.at(j - kernelColumns / 2);
      }

      // Правий край
      else if (i > kernelRows / 2 && i < heigthNewImage - kernelRows / 2 - 1 && j >= widthNewImage - kernelColumns / 2) {
        outputImage.at(i *widthNewImage + j) = inputImage.at((i - kernelRows / 2) *imageWidth + imageWidth - 1);
      }

      // Нижній край
      else if (i > heigthNewImage - kernelRows / 2 - 1 && j > kernelColumns / 2 && j < widthNewImage - kernelColumns / 2) {
        outputImage.at(i *widthNewImage + j) = inputImage.at((imageHeight - 1) *imageWidth + (j - kernelColumns / 2));
      }
    }
  }

  return outputImage;
}

Там цілі числа, тому 3/2 = 1, 1*2 = 2. А без двійок було б 3.
Стиль коду поганий, бо я лише навчаюся.
Код був невеликий, тому вирішив не коментувати. Хоча, може, й потрібно було.

86

(12 відповідей, залишених у C++)

Ось так зробив, але все одно десь помилка є, проходжу лише два тести:

#include <vector>
#include <algorithm>
#include <cmath>
typedef unsigned char u8;


std::vector<std::vector<int>> get_coords_mat(const int& row, const int& col)
{
    std::vector<std::vector<int>> coords(row * col, std::vector<int>(2));
    int j { 0 };
    for (int i = 0; i < row * col; ++i) {
        coords.at(i) = { i % row - row / 2, row / 2 - j / row };
        ++j;
    }
    
    return coords;
}



u8 find_sum(const int& i, const int& j, const int& width,
    const std::vector<u8>& img, std::vector<std::vector<float>>& weights)
{
    float cur_sum { 0.0 };

    std::vector<std::vector<int>> coords = get_coords_mat(weights.size(), weights.at(0).size());
    for (auto& coord : coords) {

        int row_coord { i + coord.at(0) },
            col_coord { j + coord.at(1) };
        int row_weights = weights.size() / 2 + coord.at(0);
        int col_weights = weights.at(0).size() / 2 + coord.at(1);
        
        cur_sum += img.at(row_coord * width + col_coord) * weights.at(row_weights).at(col_weights);
        
    }
    return std::clamp(int(std::round(cur_sum)), 0, 255);
}

std::vector<u8> padding(const std::vector<u8>& original, int& height,
    int& width, const int& kernel_row, const int& kernel_col)
{
    int new_mat_row = height + 2 * (kernel_row / 2);
    int new_mat_col = width + 2 * (kernel_col / 2);
    std::vector<u8> new_mat(new_mat_row * new_mat_col);
    for (int i = kernel_row / 2; i < new_mat_row - kernel_row / 2; ++i) {
        for (int j = kernel_col / 2; j < new_mat_col - kernel_col / 2; ++j) {
            new_mat.at(i * new_mat_col + j) = original.at((i - kernel_row / 2) * width + (j - kernel_col / 2));
        }
    }

    for (int i = 0; i < new_mat_row; ++i) {
        for (int j = 0; j < new_mat_col; ++j) {
            if (i >= 0 && i <= kernel_row / 2 && j >= 0 && j <= kernel_col / 2) {
                new_mat.at(i * new_mat_col + j) = original.front();
            } else if (i >= new_mat_row - kernel_row / 2 - 1 && j >= new_mat_col - kernel_col / 2 - 1) {
                new_mat.at(i * new_mat_col + j) = original.back();
            } else if (i >= 0 && i <= kernel_row / 2 && j >= new_mat_col - kernel_col / 2 - 1) {
                new_mat.at(i * new_mat_col + j) = original.at(width - 1);
            } else if (i >= new_mat_row - kernel_row / 2 - 1 && j >= 0 && j <= kernel_col / 2) {
                new_mat.at(i * new_mat_col + j) = original.at((height - 1) * width);
            } else if (i > kernel_row / 2 && i < new_mat_row - kernel_row / 2 - 1 && j >= 0 && j < kernel_col / 2) {
                new_mat.at(i * new_mat_col + j) = original.at((i - kernel_row / 2) * width);
            } else if (i >= 0 && i < kernel_row / 2 && j > kernel_col / 2 && j < new_mat_col - kernel_col / 2) {
                new_mat.at(i * new_mat_col + j) = original.at(j - kernel_col / 2);
            } else if (i > kernel_row / 2 && i < new_mat_row - kernel_row / 2 - 1 && j >= new_mat_col - kernel_col / 2) {
                new_mat.at(i * new_mat_col + j) = original.at((i - kernel_row / 2) * width + width - 1);
            } else if (i > new_mat_row - kernel_row / 2 - 1 && j > kernel_col / 2 && j < new_mat_col - kernel_col / 2) {
                new_mat.at(i * new_mat_col + j) = original.at((height - 1) * width + (j - kernel_col / 2));
            }
        }
    }

    
    return new_mat;
}

std::vector<u8> processImage(const std::vector<u8>& imageData, int height,
    int width, std::vector<std::vector<float>> weights)
{
    std::vector<u8> answer(3*imageData.size(), 0);
    const int& kernel_row = weights.size();
    const int& kernel_col = weights.at(0).size();
    
    std::vector<u8> padded = padding(imageData, height, width, kernel_row, kernel_col);
    
    int padded_col = width + (kernel_col / 2) * 2;
  
    for (int i = 0; i < height; ++i) {
        for (int j = 0; j < width; ++j) {
          for (int color=0; color<3; ++color){
            answer.at(3*(i * width + j)+color) = find_sum(i + kernel_row / 2, j + kernel_col / 2, padded_col, padded, weights);
          }
            
            
        }
    }

    

    return answer;
}

87

(12 відповідей, залишених у C++)

koala написав:
Teg Miles написав:

У дужках — це координати пікселя, але нащо множити на три й додавати змінну color?

Бо піксель складається з 3 байтів, по одному на колір. Ви краще скажіть - ви як у своєму коді кольори розрізняєте? Константи 3 я у вас там не бачу, як і назв кольорів. Де саме відбувається відокремлення кольорів, щоб їх сумувати?

Ніде, поки що. Я ще не розібрався, як саме в моєму коді це реалізувати.

88

(12 відповідей, залишених у C++)

koala написав:

А що робить std::clamp, як гадаєте?

Зрозумів, замість створення доповнення навколо матриці,
clamp дає змогу просто стиснути координати до найближчого пікселя.

Ще не зовсім зрозуміли ось цей рядок:

int coord = 3*(y*width+x)+color;

У дужках — це координати пікселя, але нащо множити на три й додавати змінну color?
Розумію, що обробка кольору, але що дають такі дії?

89

(12 відповідей, залишених у C++)

koala написав:

До речі, а чому ваша функція find_sum повертає int, а не u8?

Бо був неуважний. Остача була лише тимчасовим рішенням, думав такий підхід
впливатиме лише на колір, а все решта більш менш працюватиме.
До речі, з кольором незрозуміло. І у вашому коді я не розумію де там доповнення по найближчому пікселю.

90

(12 відповідей, залишених у C++)

koala написав:
звісно, треба було суму в окрему функцію винести, а ще краще - створити клас і методи, але мені ліньки
#include <vector>
#include <algorithm>
#include <cmath>

typedef unsigned char u8;

std::vector<u8> processImage (const std::vector <u8> &imageData, int height, int width, std::vector <std::vector <float>> weights) {
    std::vector<u8> result;
    int n = weights.size();
    for(int row=0; row<height; ++row) {
        for(int col=0; col<width; ++col) {
            for(int color=0; color<3; ++color) {
                float sum = 0.0;
                for(int dy=-n/2; dy<=n/2; ++dy) {
                    for(int dx=-n/2; dx<=n/2; ++dx) {
                        int x = std::clamp(col+dx, 0, width-1);
                        int y = std::clamp(row+dy, 0, height-1);
                        int coord = 3*(y*width+x)+color;
                        sum += imageData[coord] * weights[n/2+dy][n/2+dx];
                    }
                }
                result.push_back(std::clamp(int(round(sum)),0,255));
            }
        }
    }
    return result;
}

Що ж до вашої проблеми, то ви в курсі, що це за операція взагалі?

return cur_sum%256;

Мені потрібно було отримати числа в межах 0-255, тому використав остачу від ділення.

91

(12 відповідей, залишених у C++)

Є зображення, подане одновимірним масивом unsigned char,
і фільтр, поданий двовимірним масивом float.
Щоб обробити зображення потрібно помножити фільтр на зображення,
так щоб середина фільтру збігалася з елементом зображення,
а решта з навколишніми елементами зображення (треба доповнити найближчими пікселями, де потрібно).
Тобто елементи фільтру множаться на елементи зображення, а їхня сума — це вже елемент обробленого зображення.
Повна умова тут: https://www.codewars.com/kata/5239078120eeabe18f0000da
Ось моє рішення цього завдання.

#include <vector>

typedef unsigned char u8;

std::vector<std::vector<int>> get_coords_mat(const int& row, const int& col)
{
    std::vector<std::vector<int>> coords(row * col, std::vector<int>(2));
    int j { 0 };
    for (int i = 0; i < row * col; ++i) {
        coords.at(i) = { i % row - row / 2, row / 2 - j / row };
        ++j;
    }
    
    return coords;
}



int find_sum(const int& i, const int& j, const int& height, const int& width,
    const std::vector<u8>& img, std::vector<std::vector<float>>& weights)
{
    int cur_sum { 0 };

    std::vector<std::vector<int>> coords = get_coords_mat(weights.size(), weights.at(0).size());
    for (auto& coord : coords) {
        int row_coord { i + coord.at(0) },
            col_coord { j + coord.at(1) };
        int row_weights = weights.size() / 2 + coord.at(0);
        int col_weights = weights.at(0).size() / 2 + coord.at(1);
        
        cur_sum += img.at(row_coord * width + col_coord) * weights.at(row_weights).at(col_weights);
        
    }
    return cur_sum%256;
}

std::vector<u8> padding(const std::vector<u8>& original, int& height,
    int& width, const int& kernel_row, const int& kernel_col)
{
    int new_mat_row = height + 2 * (kernel_row / 2);
    int new_mat_col = width + 2 * (kernel_col / 2);
    std::vector<u8> new_mat(new_mat_row * new_mat_col);
    for (int i = kernel_row / 2; i < new_mat_row - kernel_row / 2; ++i) {
        for (int j = kernel_col / 2; j < new_mat_col - kernel_col / 2; ++j) {
            new_mat.at(i * new_mat_col + j) = original.at((i - kernel_row / 2) * width + (j - kernel_col / 2));
        }
    }

    for (int i = 0; i < new_mat_row; ++i) {
        for (int j = 0; j < new_mat_col; ++j) {
            if (i >= 0 && i <= kernel_row / 2 && j >= 0 && j <= kernel_col / 2) {
                new_mat.at(i * new_mat_col + j) = original.front();
            } else if (i >= new_mat_row - kernel_row / 2 - 1 && j >= new_mat_col - kernel_col / 2 - 1) {
                new_mat.at(i * new_mat_col + j) = original.back();
            } else if (i >= 0 && i <= kernel_row / 2 && j >= new_mat_col - kernel_col / 2 - 1) {
                new_mat.at(i * new_mat_col + j) = original.at(width - 1);
            } else if (i >= new_mat_row - kernel_row / 2 - 1 && j >= 0 && j <= kernel_col / 2) {
                new_mat.at(i * new_mat_col + j) = original.at((height - 1) * width);
            } else if (i > kernel_row / 2 && i < new_mat_row - kernel_row / 2 - 1 && j >= 0 && j < kernel_col / 2) {
                new_mat.at(i * new_mat_col + j) = original.at((i - kernel_row / 2) * width);
            } else if (i >= 0 && i < kernel_row / 2 && j > kernel_col / 2 && j < new_mat_col - kernel_col / 2) {
                new_mat.at(i * new_mat_col + j) = original.at(j - kernel_col / 2);
            } else if (i > kernel_row / 2 && i < new_mat_row - kernel_row / 2 - 1 && j >= new_mat_col - kernel_col / 2) {
                new_mat.at(i * new_mat_col + j) = original.at((i - kernel_row / 2) * width + width - 1);
            } else if (i > new_mat_row - kernel_row / 2 - 1 && j > kernel_col / 2 && j < new_mat_col - kernel_col / 2) {
                new_mat.at(i * new_mat_col + j) = original.at((height - 1) * width + (j - kernel_col / 2));
            }
        }
    }

    
    return new_mat;
}

std::vector<u8> processImage(const std::vector<u8>& imageData, int height,
    int width, std::vector<std::vector<float>> weights)
{
    std::vector<u8> answer(imageData.size(), 0);
    const int& kernel_row = weights.size();
    const int& kernel_col = weights.at(0).size();
    
    std::vector<u8> padded = padding(imageData, height, width, kernel_row, kernel_col);
    int padded_row = height + (kernel_row / 2) * 2;
    int padded_col = width + (kernel_col / 2) * 2;
    for (int i = 0; i < height; ++i) {
        for (int j = 0; j < width; ++j) {
            answer.at(i * width + j) = find_sum(i + kernel_row / 2, j + kernel_col / 2, padded_row, padded_col, padded, weights);
            
        }
    }

    

    return answer;
}

Але щось я зробив не так, бо зображення повертається кашею.
Підозрюю, що це якось пов'язано з множенням unsigned char на float, але не бачу, де саме помилився.

92

(3 відповідей, залишених у C++)

Порада щодо перегляду доступних тем оформлення.
Наберіть наступну команду без квадратних дужок:

:colorscheme[пробіл][Ctrl+d]

Отримаєте перелік наявних тем оформлення і запрошення обрати якусь(:colorscheme [назва обраної теми]).
Аби щоразу не набирати все наново можна зробити ось таку прив'язку до клавіші клавіатури:
nmap <F9> :colorscheme <c-D>
imap <F9> <Esc> :colorscheme <c-D>

93

(6 відповідей, залишених у C++)

koala написав:

А взагалі жахливий спосіб написати

for (unsigned long i = 0; i < bits.size(); i += 3)
    fix_text.push_back(bits[i]==bits[i+1] ? bits[i] : bits[i+2]);

Я ще не звик до таких жахливих способів:), окрім того не розумію чому порівнюються лише суміжні біти.

94

(6 відповідей, залишених у C++)

koala написав:

А який другий аргумент метода substr?

Дійсно, переплутав із ітераторами, а в substr інший підхід.

95

(6 відповідей, залишених у C++)

Потрібно отримати й обробити субрядок заданої довжини.
Роблю ось так:

    std::string fix_text { "" };
    for (unsigned long i = 0; i < bits.size(); i += 3) {
        std::string triple = bits.substr(i, i + 3);
        std::cout << triple << std::endl;
        if (std::count(triple.begin(), triple.end(), '1') > std::count(triple.begin(), triple.end(), '0')) {
            fix_text.push_back('1');
        } else {
            fix_text.push_back('0');
        }
    }

Але в змінній triple чомусь замість лише трійки символів ось таке:
000
111111
111000111
000111000000
111000000000000
000000000000111111
000000000111111000000
000000111111000000111000
000111111000000111000111000
111111000000111000111000111111
111000000111000111000111111111111
000000111000111000111111111111000000
000111000111000111111111111000000111
111000111000111111111111000000111
000111000111111111111000000111
111000111111111111000000111
000111111111111000000111
111111111111000000111
111111111000000111
111111000000111
111000000111
000000111
000111
111

Чому значення накопичуються, я ж кожного разу оголошую наново цю змінну?

96

(4 відповідей, залишених у C++)

Ось це завдання https://www.codewars.com/kata/5959ec605595565f5c00002b
Але я неправильно зрозумів умову, треба не нулі й одиниці міняти, а в зворотному порядку прочитати бінарну форму.

    std::string new_bits = std::bitset<sizeof(unsigned int) * CHAR_BIT>(n).to_string();
    new_bits.erase(0, new_bits.find_first_not_of('0'));
    std::reverse(new_bits.begin(), new_bits.end());
    std::bitset<64> boom(new_bits);
    return (unsigned int)(boom.to_ulong());

97

(4 відповідей, залишених у C++)

Потрібно замінити біти на протилежні в unsigned int, а тоді вивести нове unsigned int.
Робив ось так:

unsigned int reverse_bits(unsigned int n)
{
    std::bitset<sizeof(unsigned int) * CHAR_BIT> n_bits(n);
    std::cout << (unsigned int)(n_bits.flip().to_ulong()) << std::endl;
    std::cout << (~n) << std::endl;
    std::string new_bits = std::bitset<sizeof(unsigned int) * CHAR_BIT>(n).to_string();
    new_bits.erase(0, new_bits.find_first_not_of('0'));
    std::bitset<sizeof(char) * CHAR_BIT> second_bits(new_bits);
    std::cout << (unsigned int)(second_bits.flip().to_ulong()) << std::endl;


    return 0;
}

Але в результаті виходить завелике число, бо всі попередні нулі перетворюються в одиниці.
Пробував обрізати за допомогою string, усе одно виходить хибна відповідь.

98

(9 відповідей, залишених у C++)

koala написав:
Teg Miles написав:

Я мав на увазі бінарний запис одиницями та нулями.

Вони записані в пам'яті одиницями і нулями, тому ваше "пояснення" не допомагає. Вам потрібен зручний доступ до конкретних бітів, і ви вважаєте, що b[idx] принципово зручніше за (b>>idx)&1? Чи щось інше? От які саме дії з бінарними числами вам потрібні? Бо наразі єдина дія, яку ви виконуєте - це перетворення "бінарного" bitset на число. А це з числами значно простіше робити :)

Мені потрібно порівнювати одиниці й нулі на певних місцях та змінювати їхнє значення на обернене (1 на 0 чи 0 на 1).

99

(9 відповідей, залишених у C++)

wander написав:

Не розумію питання, що означає:

Як краще перетворювати ціле число в бінарне

?
Якщо мова про цілі числа типів int, short, char тощо, то вони і так є бінарними..
Ви б краще пояснили, що ви хочете зробити.

Я мав на увазі бінарний запис одиницями та нулями.

100

(9 відповідей, залишених у C++)

А як краще перетворювати ціле число в бінарне?
Ось два методи, які я знайшов:

    std::bitset<8> a_bits(a);
    std::bitset<sizeof(long) * CHAR_BIT> b_bits(b);

Не розумію яка користь з другого. Там початкових нулів забагато.