全部问题

您需要按以下顺序找到数字的总和： 2, 22, 222, 2222, ..., 2(n), - 其中，n 是最后一个数字的位数

例如，n = 5，最后一个数字是 22222，序列中数字的总和是 24690。

n = 5  # кол-во разрядов
last_num = 0  # итоговое число
i = 1  # счетчик разрядов
sum = 0  # 2 + 22 + 222 + 2222 + 22222 => 24690

while n > 0:
    last_num += 2 * i
    i *= 10
    n -= 1
print(last_num)
while last_num != 0:
    sum += last_num // 10
    last_num //= 10
print(sum)

我知道代码是一条曲线，因为我刚开始学习 Python。请告诉我如何找到数字的总和，因为条件 sum += last_num // 10 “切断”了前两个，因此，总和是从数字 2222 + 222 + 22 + 2 = 2468 中获得的, 而不是 22222 + 2222 + 222 + 22 + 2 = 24690。

大学里的小家伙得到了任务 - 编写一个编译程序，可以这么说，在该程序中应该尽可能多地使用相同的标识符。但只是不同，所以有些嵌套

namespace a { namespace a { namespace a { 

与单个命名空间相比，它没有提供任何新的东西。

既然小号已经作曲发了

namespace a
{
    struct a
    {
        int a;
    };
    int a()
    {
        struct a a {0};
        return a.a;
    }
}

int main()
{
    int a = a::a();
    std::cout << a;
}

我认为自己有权将这个问题作为一个问题提出——谁能取得更多成就？:)

我坐下来思考如何摆脱重复的代码。

2048你知道这个游戏，我正在编写我自己的实现版本。有一个瓷砖数组，每个瓷砖是

const cell = {
  row : 1,
  col : 1,
  value : 32,
  merged : false,
  node : <HTMLElement>
}

从逻辑上讲，有一个 4x4 瓷砖的运动场。

任务：当玩家移动时，你需要穿过整个场地，并沿着正确的方向移动瓷砖，将具有相同价值的瓷砖合并。

这段代码有效，但看起来很糟糕。它仅使用一组瓦片来实现移动和合并瓦片的逻辑。从技术上讲，DOM 是用另一种方法更新的，瓦片的实际合并也发生在后面，这里只在瓦片上放了一个标签，它将被合并。要删除的图块只需设置为 0。

const size = 4;

function move(direction) {
  let moved = false;
  if (direction === 'left') {
    for (let col = 1; col < size; col++) {
      for (let row = 0; row < size; row++) {
        const cell = getCell(row, col);
        if (cell && !cell.merged) {
          let targetCol;
          for (targetCol = col - 1; targetCol >= 0; targetCol--) {
            const targetCell = getCell(row, targetCol);
            if (!targetCell)
              continue;
            if (targetCell.value == cell.value && !targetCell.merged) {
              cell.value = 0;
              targetCell.merged = true;
            }
            break;
          }
          if (cell.value != 0)
            targetCol++;
          if (col != targetCol) {
            moveCol(cell, targetCol);
            moved = true;
          }
        }
      }
    }
  }
  if (direction === 'right') {
    for (let col = size - 2; col >= 0; col--) {
      for (let row = 0; row < size; row++) {
        const cell = getCell(row, col);
        if (cell && !cell.merged) {
          let targetCol;
          for (targetCol = col + 1; targetCol < size; targetCol++) {
            const targetCell = getCell(row, targetCol);
            if (!targetCell)
              continue;
            if (targetCell.value == cell.value && !targetCell.merged) {
              cell.value = 0;
              targetCell.merged = true;
            }
            break;
          }
          if (cell.value != 0)
            targetCol--;
          if (col != targetCol) {
            moveCol(cell, targetCol);
            moved = true;
          }
        }
      }
    }
  }
  if (direction === 'up') {
    for (let row = 1; row < size; row++) {
      for (let col = 0; col < size; col++) {
        const cell = getCell(row, col);
        if (cell && !cell.merged) {
          let targetRow;
          for (targetRow = row - 1; targetRow >= 0; targetRow--) {
            const targetCell = getCell(targetRow, col);
            if (!targetCell)
              continue;
            if (targetCell.value == cell.value && !targetCell.merged) {
              cell.value = 0;
              targetCell.merged = true;
            }
            break;
          }
          if (cell.value != 0)
            targetRow++;
          if (row != targetRow) {
            moveRow(cell, targetRow);
            moved = true;
          }
        }
      }
    }
  }
  if (direction === 'down') {
    for (let row = size - 2; row >= 0; row--) {
      for (let col = 0; col < size; col++) {
        const cell = getCell(row, col);
        if (cell && !cell.merged) {
          let targetRow;
          for (targetRow = row + 1; targetRow < size; targetRow++) {
            const targetCell = getCell(targetRow, col);
            if (!targetCell)
              continue;
            if (targetCell.value == cell.value && !targetCell.merged) {
              cell.value = 0;
              targetCell.merged = true;
            }
            break;
          }
          if (cell.value != 0)
            targetRow--;
          if (row != targetRow) {
            moveRow(cell, targetRow);
            moved = true;
          }
        }
      }
    }
  }
  return moved;
}

我找不到优化额头的方法。也许你需要改变算法，帮我弄清楚。

算法，例如，用于向左（左）移动：

• 我从0开始逐列查看，也就是从左到右
• 如果我找到一个瓷砖，我会检查左边是否有瓷砖
• 如果有，检查它的值
• 如果它匹配并且瓷砖之前没有被冻结，那么我合并
• 我按照上面的条件移动瓦片，也就是要么往合并，要么往左边最远的空闲单元格移动，如果有的话
• 继续下一行

上面代码中调用的方法，供参考

const cells = [];
const cellSize = 100 / size;

function moveRow(cell, row) {
  cell.row = row;
  cell.node.style.top = (row * cellSize) + '%';  
}

function moveCol(cell, col) {
  cell.col = col;
  cell.node.style.left = (col * cellSize) + '%';
}

function getCell(row, col) {
  for (let i = 0; i < cells.length; i++) {
    const cell = cells[i];
    if (cell.row == row && cell.col == col && cell.value != 0)
      return cell;
  }
}

受到这个问题的启发。

我的决定

#include <vector>
#include <string>
#include <algorithm>
#include <iostream>
#include <iomanip>

using namespace std;

int main(int argc, char * argv[])
{
    vector<int> v(36000000);
    int k = 0;
    for(int i = 1;    i <= 6000; ++i)
        for(int j = 6001; j <= 12000; ++j)
            v[k++] = i*j;
    sort(v.begin(),v.end());
    long long s = 0;
    for(int i = 0; i < 36000000; ++i) s += v[i];
    cout << s;
}

工作原理与 Python 中最好的差不多，但速度稍慢。在我的机器上，这一切都计为大约 2.04±0.01 秒。好吧，这不可能是 C ++ 不如 Python :) - 我开始尝试以各种方式加速这段代码。

无法优化，一切都依赖于sort. 带着悲伤，我把它换成了stable_sort——看看会发生什么，然后——你瞧！— 时间下降到 1.30±0.03 秒。

似乎一直有人说，在一般情况下，由于更大的复杂性stable_sort（不仅是算法，它等于O(N·log(N) ²）），它的效果更差sort。但是，事实证明，至少并非总是如此？我知道常数可能会有很大的不同:)，但是它什么时候小于常数sort？

在 G++ 下进行了检查-差异略有不同，但通常相同：1和2。

没有人对此进行深入研究，无法发表评论，如果两种功能都适合您，什么时候应用更有效？

视觉 C++ 2019，Windows 10

我想从 gif 重复所有动画

为了做到这一点，我画了这条蛇，甚至把这条蛇弄得歪歪扭扭的，但我不明白需要做什么才能在动画的一开始就没有侧柱，以及如何制作类似的光晕

这是我的尝试

<svg width="400" viewBox="0 0 609.38 279.68" xmlns="http://www.w3.org/2000/svg">
 <g transform="translate(198.07 -4.5882)">
  <path d="m-70.02 279.95c-29.907-1.6357-56.417-11.813-78.052-29.964-6.0632-5.0869-13.525-13.006-18.604-19.744-15.537-20.613-24.346-44.903-26.818-73.951-0.42004-4.9366-0.41761-18.147 4e-3 -22.754 2.9007-31.687 15.735-59.855 37.48-82.258 23.29-23.995 53.139-38.262 87.048-41.607 4.5623-0.45002 18.788-0.45559 23.548-0.0092 37.496 3.5162 69.373 19.864 109.93 56.378 7.109 6.3997 16.018 14.968 28.148 27.073 10.478 10.456 13.338 13.172 13.87 13.172 0.53239 0 3.5209-2.8317 14.451-13.692 14.073-13.984 18.174-17.925 25.76-24.753 38.255-34.437 72.993-52.945 108.54-57.829 7.1174-0.97794 10.82-1.2078 19.182-1.1908 16.348 0.03321 30.326 2.3376 46.302 7.6335 20.105 6.6647 35.662 16.185 49.347 30.2 14.997 15.358 25.492 34.841 31.98 59.368 7.5177 28.42 6.5109 57.404-2.9061 83.663-8.6577 24.141-24.084 45.291-44.788 61.403-11.428 8.8942-25.715 16.572-39.736 21.355-34.463 11.756-71.614 9.3193-106.08-6.9576-14.867-7.0208-30.596-17.476-47.511-31.581-11.513-9.6-20.607-18.075-38.634-36.001-12.885-12.813-15.351-15.152-15.98-15.152-0.61733 0-1.5987 0.87823-5.7977 5.1886-11.24 11.538-29.556 29.087-39.192 37.551-23.435 20.585-44.235 34.237-65.082 42.716-14.704 5.9806-31.066 9.9048-47.493 11.391-3.2145 0.29075-15.782 0.52676-18.918 0.35525zm15.25-55.132c14.91-0.78415 27.848-4.3352 42.561-11.682 15.648-7.8134 30.032-18.303 49.609-36.178 5.8064-5.3016 31.796-31.355 32.037-32.116 0.14007-0.4413-0.27758-0.98323-2.1736-2.8205-1.2909-1.2508-8.7169-8.4734-16.502-16.05-17.427-16.96-21.976-21.222-29.501-27.639-19.76-16.851-37.606-26.987-55.329-31.426-8.7162-2.1831-14.464-2.8146-23.773-2.6117-10.632 0.23171-18.69 1.8413-28.054 5.6036-23.755 9.544-41.568 30.062-47.896 55.172-2.9576 11.735-3.2389 22.754-0.9017 35.322 2.5757 13.85 7.5166 25.444 15.278 35.851 2.9692 3.9811 9.5786 10.586 13.592 13.583 12.056 9.0014 26.49 14.144 42.02 14.972 2.11 0.11251 3.896 0.2215 3.9688 0.24221 0.0728 0.0207 2.3515-0.0791 5.0639-0.22172zm333.23-0.37342c18.216-2.3838 33.623-9.7698 46.372-22.231 6.7217-6.5698 11.946-13.698 15.886-21.675 7.9596-16.116 10.391-33.23 7.2779-51.235-3.7747-21.833-14.531-39.765-30.789-51.329-8.6978-6.1865-19.627-10.702-30.434-12.574-9.8125-1.7001-21.425-1.5954-31.709 0.28582-25.286 4.6255-49.591 18.828-79.414 46.406-9.8671 9.1243-32.017 31.525-32.017 32.379 0 0.40409 1.2235 1.7441 4.0302 4.414 2.2166 2.1086 9.0925 8.7826 15.28 14.831 17.681 17.285 24.951 23.946 34.533 31.637 17.242 13.841 33.981 22.91 49.742 26.951 5.1841 1.329 8.4804 1.8731 15.875 2.6202 2.1412 0.21635 12.524-0.108 15.367-0.48005z" />
   
  <path d="m81.643 116.42c-11.805-11.887-23.24-24.264-36.286-34.774-13.007-10.479-26.503-20.775-41.577-27.97-15.465-7.382-32.054-13.762-49.137-15.119-18.011-1.431-36.691 1.3912-53.673 7.5595-14.787 5.3711-29.333 13.443-40.065 24.946-12.842 13.764-21.634 31.697-26.458 49.893-4.1997 15.839-4.9784 33.121-1.5119 49.137 3.6236 16.742 11.206 33.393 22.679 46.113 11.753 13.031 27.976 22.352 44.601 27.97 20.856 7.0486 43.992 9.285 65.768 6.0476 21.8-3.241 42.778-12.897 61.232-24.946 19.397-12.665 33.829-31.689 49.893-48.381 11.507-11.957 33.262-37.042 33.262-37.042s34.826-40.602 55.94-56.696c17.226-13.131 36.341-24.346 56.696-31.75 22.897-8.3287 47.721-17.221 71.815-13.607 20.845 3.1267 40.692 14.93 55.94 29.482 10.786 10.294 17.607 24.533 22.679 38.554 5.2987 14.647 7.997 30.543 7.5595 46.113-0.3915 13.934-2.6636 28.443-9.0714 40.821-6.7246 12.991-17.618 23.949-29.482 32.506-15.19 10.955-32.846 20.166-51.405 22.679-23.978 3.2468-49.084-2.2907-71.815-10.583-18.92-6.9022-35.611-19.254-51.405-31.75-12.576-9.95-22.839-22.52-34.018-34.018-17.644-18.148-34.324-37.225-52.161-55.185z" fill="none" stroke="#fff" stroke-width="40" id="line" stroke-dasharray="400 1496">
    <animate attributeName="stroke-dashoffset" 
             dur="3s"
             begin="0s"
             values="-400; -1396"
             repeatCount="indefinite"/>
  </path>
 </g>
</svg>