小编גלע*_*רקן的帖子

如果我误用了标题中的大字,请原谅我; 我不太了解他们,但希望他们描述我的问题.我写了一个精心设计的方案来尝试根据这些要求对字符串进行编码.对于长度为10 ^ 4或更高的字符串,我编写的代码非常慢,我想知道 - 因为它一次处理200个块(尽管有时仅向前移动一个字符以获取下一个块),是否可以被修改以更快或更线性地输出结果(例如,立即输出处理的每200个字符的结果).任何有关该或其他明显优化的帮助将不胜感激.

根据电话的建议,我简化了我的例子:

encode xs = encode' xs [] where
  encode' []     result = result
  encode' (z:zs) result
    | null test = encode' zs (result ++ [z])
    | otherwise = encode' (drop numZsProcessed zs) (result ++ processed)
   where test = ..some test
         toProcess = take 200 (z:zs)
         processed = ..do something complicated with toProcess
         numZsProcessed = ..number of z's processed

例如,给定一个值,v和一个函数f,有没有办法让(f v,v)点免费？

我目前正在解决一个数学问题,其中我需要计算减少的适当分数的数量,分子和分母都超过1000000(10 ^ 6).

我有适用于小数字的代码; 给出的示例(值= 8)给出正确的(给定的)答案21.

但是由于我不知道的原因,这个代码似乎对大数字来说非常慢.我在SO上阅读了大量类似的问题,但找不到任何有用的东西.我仔细研究了这个和这个,但这并没有真正帮助我.我的代码以可接受的速度运行,直到1000,然后它变得超级超慢.

import math

def is_prime(n):
    if n == 2:
        return True
    if n % 2 == 0 or n <= 1:
        return False
    sqr = int(math.sqrt(n)) + 1
    for divisor in range(3, sqr, 2):
        if n % divisor == 0:
            return False
    return True

def get_divisors(n):
    liste = [1]
    if n % 2 == 0:
        liste.append(2)
    for divisor in range(3, n+1):
        if n % divisor == 0:
            liste.append(divisor)
    return liste …

我正在开发一个项目,我生成每个可能的井字游戏阵列.作为一个概念证明,我正在研究用9个子数组填充数组的代码.每个子数组将有两个值,第一个为0或1(分别为x和o),第二个为1到9(表示放置时).我希望得到的数组示例如下:

[[0, 0], [1, 1], [0, 2], [1, 3], [0, 4], [1, 5], [0, 6], [1, 7], [0, 8]]

我已经编写了代码,使用9 for循环,每个循环嵌套在上面的一个,这给了我想要的结果(每个可能的数组,每个都是唯一的).但我试图编写代码,使用递归,并避免编写大量的嵌套循环.

当我运行下面的代码时,它只能生成上面的数组,并且无法创建其他组合.我的代码如下:

print("running...")

allGames = []
checkCurrentGame = [5, 5, 5, 5, 5, 5, 5, 5, 5]
stepsDown = 0

def cleanGame(move, currentGame):
    for j in range(9):
        if (currentGame[j][1] >= move):
            currentGame[j] = [5, 0]

def completeMove(moveNumber, currentGame):
    global stepsDown
    stepsDown = stepsDown + 1
    for i in range(9):
        cleanGame(moveNumber, currentGame)
        if (currentGame[i][0] == 5):
            currentGame[i][0] = i % 2 …

我尝试了今年CCC 2019 S5的最后一个问题。

问题陈述：

在平行宇宙中，计算机科学中最重要的数据结构是三角形。大小为M的三角形由M行组成，第i行包含i个元素。此外，这些行必须布置成形成等边三角形的形状。也就是说，每一行都以穿过三角形中间的垂直对称线为中心。例如，下图显示了一个大小为4的三角形：

三角形包含子三角形。例如，上面的三角形包含10个大小为1的子三角形，六个大小为2的子三角形（其中两个是包含（3,1,2）的三角形和包含（4,6,1）的三角形），三个大小为3的子三角形（其中一个包含（2,2,1,1,4,2））。请注意，每个三角形都是其自身的子三角形。

您将获得一个大小为N的三角形，并且必须找到大小为K的每个子三角形的最大元素之和。

输入规格

第一行包含两个以空格分隔的整数N和K（1？K？N？3000）。

接下来是描述三角形的N条线。这些行的第i个包含i个以空格分隔的整数ai，j（0？ai，j？10 ^ 9），代表三角形的第i行。

对于15个可用标记中的4个，N？1000。

输出规格

输出大小为K的每个子三角形的最大元素的整数和。

样本输入

4 2
3
1 2
4 2 1
6 1 4 2

样品输入输出

23

不幸的是，我的解决方案给TLE判决，而且我不知道如何优化它。

这个问题基本上要求找到子三角形的最大元素并将它们加在一起。我的方法很简单，我迭代了大三角形的每个元素，使它们成为子三角形的“根”，然后尝试转到它的每个元素以找到max并将它们添加到结果中。

我需要改进我的解决方案的帮助，是否需要一些数据结构？

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    vector<vector<int>> triangle;

    int n;
    int k;

    cin >> n >> k;

    for (int i = 0; i < n; ++i)
    {
        triangle.push_back(vector<int>(i + 1, 0));

        for (int j = 0; j …

我试图从一系列对象中递归构建一棵树。我目前正在使用该reduce()方法遍历数组中的项目，找出哪些孩子属于特定项目并填充它，然后递归地填充这些孩子的孩子，依此类推。但是，我一直无法取最后一个节点（例如，在这种情况下为波斯和暹罗）并将它们放在数组中（请参见下面的预期和当前输出）

    let categories = [
        { id: 'animals', parent: null },
        { id: 'mammals', parent: 'animals' },
        { id: 'cats', parent: 'mammals' },
        { id: 'dogs', parent: 'mammals' },
        { id: 'chihuahua', parent: 'dogs' },
        { id: 'labrador', parent: 'dogs' },
        { id: 'persian', parent: 'cats' },
        { id: 'siamese', parent: 'cats' }
    ];

   const reduceTree = (categories, parent = null) => 
    categories.reduce(
        (tree, currentItem) => {

            if(currentItem.parent == parent){
               tree[currentItem.id] = reduceTree(categories, currentItem.id);  
            }              

            return tree;
        }, …

我在网站上看到以下内容作为练习。它基本上说不使用递归和不使用向量，堆栈等结构编写以下函数：

void rec(int n) {
        if (n != 0) {
                cout << n << " ";
                rec(n-1);
                rec(n-1);
        }
}

刚开始我以为这会很容易，但是我却很难做到。

为了更好地理解它，我将其定义为数学函数，如下所示：

f（x）= {如果x = 0，则为1，否则为f（x-1）+ f（x-1）}（其中+运算符表示串联，而-是正常减号）

但是，展开此操作会更加困难，而且我被卡住了。有没有直接的方法可以将其编写为循环？而且，更一般而言，是否有一种算法可以解决此类问题？

你如何取一个代表项目列表的数字，并将其划分为块，其中块的数量是 2 的幂，并且每个块也有项目的 2 的幂（大小去最多为 2 的最大幂，所以 1、2、4、8、16、32、32 是最大值）？这甚至可能吗？

因此，例如，8 个项目可以分为 1 个桶（两个桶的幂）和 8 个项目（两个项目的幂）：

[8]

9个项目可能是：

[8, 1]

这是有效的，因为两个数字都是 2 的幂，并且数组的大小是 2（也是 2 的幂）。

让我们试试 11：

[8, 2, 1]

不，那不起作用。因为数组的大小是 3，它不是 2 的幂，即使它加上 11。这个怎么样？

[4, 4, 2, 1]

那个有效！它是 4 个元素，是 2 的幂。

[2, 2, 2, 1, 1, 1, 1, 1]

这也有效，因为有 8 个桶（8 是 2 的幂），每个桶有 1 或 2 个项目（每个是 2 的幂）。但[4, 4, 2, 1]更好，因为它更短。

我想一个更好的（在收到评论后）会是这个，虽然我第一次没有看到它：

[8, 1, 1, 1]

那个很短，也是从最大的数字开始的。

因此，按照这种模式，这里有一些其他数字：

13：

[8, 1, …

我试图解决这个 leetcode 问题https://leetcode.com/problems/find-the-duplicate-number/使用我自己的龟兔算法实现，当给定以下整数数组时导致无限循环：

[3,1,3,4,2]

只有在跟踪我的算法之后，我才能看到慢速和快跑者永远不会同时接受两个重复的值。这是我的伪代码算法：

initialize fast and slow runners to 0

while(true)

   move fast runner two indices forward
   move slow runner one index forward

   if arr[fast] == arr[slow] and fast != slow
      return arr[fast] // this is the duplicate

现在，我确信精通离散数学的人能够直观地知道这种方法不会导致正确的解决方案，而不必像我那样首先跟踪一个例子。

我可以做出哪些推断或观察来让我看到这个算法行不通？我想知道如何通过一系列逻辑陈述直观地识别此逻辑中的缺陷。换句话说，为什么两个跑步者永远不会在这个例子中找到重复的解释是什么？我觉得这可能与计数有关，但我在离散方面没有很强的背景。

澄清一下，我已经查看了正确的实现，所以我知道解决它的正确方法是什么。我只是认为这种方式与将其应用于链表的工作方式过于相似，您可以将快跑者向上移动两个节点，将慢跑者向上移动一个节点。感谢您的帮助。

问题- 您必须找到从初始位置(1,1)到最终位置(N,M) [其中N是行数，M是列数]可以达到的方法数，假设：

1. 您可以向下移动任意数量的步骤。
2. 您可以向右移动任意数量的步骤。

注意：这里的数组索引是 1-indexed

一些条件：

• 你永远不能离开网格。
• 您不能忽略这些条件。
• 第一个单元格 (1,1) 和最后一个单元格 (N,M) 不包含障碍物。
• 一个空闲单元用 表示。障碍物用*表示。

示例测试用例：

>>> 3 3
    . . .
    . * .
    . . .

>>> 8

会有8种方式：

• (1,1),(1,2),(1,3),(2,3),(3,3)
• (1,1),(1,2),(1,3),(3,3)
• (1,1),(1,3),(2,3),(3,3)
• (1,1),(1,3),(3,3)
• (1,1),(2,1),(3,1),(3,2),(3,3)
• (1,1),(3,1),(3,2),(3,3)
• (1,1),(2,1),(3,1),(3,3)
• (1,1),(3,1),(3,3)

我的代码：

def ways(l):
    
   # Don't know how to proceed



Testcases=int(input())
lst=[]
for i in range(Testcases):
    N,M=input().split()
    N,M=int(N),int(M)
    for j in range(N):
        s=input().split(" ",M)
        lst.append(s)
    
    ways(lst)

我不知道如何继续。