全部问题(coding)

我有一个 Polars DataFrame，其中包含一列，其中的字符串表示“稀疏”部门风险敞口，如下所示：

pl.DataFrame(
    [
        pl.Series("sector_exposure", [
            'Technology=0.207;Financials=0.090;Health Care=0.084;Consumer Discretionary=0.069', 
            'Financials=0.250;Health Care=0.200;Consumer Staples=0.150;Industrials=0.400'
            ], dtype=pl.String),
    ]
)

我想将此字符串“解压”到每个部门（例如，技术、金融、医疗保健）的新列中，并具有相关值或以部门名称作为字段和曝光值的极坐标结构。

我正在寻找一种仅使用极坐标表达式的更有效的解决方案，而不求助于 Python 循环（或 python 映射函数）。任何人都可以提供如何实现这一目标的指导吗？

这是我到目前为止所想出的——它可以生成所需的结构，但有点慢。

(
    df["sector_exposure"]
    .str
    .split(";")
    .map_elements(lambda x: {entry.split('=')[0]: float(entry.split('=')[1]) for entry in x},
                  skip_nulls=True,
                  )
)

谢谢！

我想比较两个图像并找到第二个图像中模板的位置，所以第一个图像是这样的：

这是我们的模板图像，应与下图进行比较：

但是当我运行代码时，我得到以下结果：

我怎样才能改善结果？

import cv2
import numpy as np
from imutils.object_detection import non_max_suppression
import matplotlib.pyplot as plt
template =cv2.imread("euro.jpg",cv2.IMREAD_COLOR)
template =cv2.resize(template,(99,99))
img =cv2.imread("euro_2024.jpg",cv2.IMREAD_COLOR)
img2 = img.copy()
# image =cv2.resize(image,(700,700))
h,w =template.shape[:2]

# All the 6 methods for comparison in a list
methods = ['cv2.TM_CCOEFF', 'cv2.TM_CCOEFF_NORMED', 'cv2.TM_CCORR',
            'cv2.TM_CCORR_NORMED', 'cv2.TM_SQDIFF', 'cv2.TM_SQDIFF_NORMED']

for meth in methods:
    img = img2.copy()
    method = eval(meth)

    # Apply template Matching
    res = cv2.matchTemplate(img,template,method)
    min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)

    # If the method is TM_SQDIFF or TM_SQDIFF_NORMED, take minimum
    if method in [cv2.TM_SQDIFF, cv2.TM_SQDIFF_NORMED]:
        top_left = min_loc
    else:
        top_left = max_loc
    bottom_right = (top_left[0] + w, top_left[1] + h)

    cv2.rectangle(img,top_left, bottom_right, 255, 2)

    plt.subplot(121),plt.imshow(res,cmap = 'gray')
    plt.title('Matching Result'), plt.xticks([]), plt.yticks([])
    plt.subplot(122),plt.imshow(img,cmap = 'gray')
    plt.title('Detected Point'), plt.xticks([]), plt.yticks([])
    plt.suptitle(meth)

    plt.show()

-1为什么使用 编译时会产生以下代码g++ -O1？我的gcc版本是13.2.1。

#include <iostream>
#include <cmath>
#include <cfenv>

using namespace std;

int main() {
    fesetround(FE_DOWNWARD);
    cout << rint(-1.6) << endl;
    return 0;
}

Polars noob，给定一个m x nPolars 数据帧df和一个1 x n标量的 Polars 数据帧，我想将每一列除以df另一帧中相应的标量。

import numpy as np
import polars as pl

cols = list('abc')
df = pl.DataFrame(np.linspace(1, 9, 9).reshape(3, 3),
                  schema=cols)
scalars = pl.DataFrame(np.linspace(1, 3, 3)[:, None],
                       schema=cols)

In [13]: df
Out[13]: 
shape: (3, 3)
┌─────┬─────┬─────┐
│ a   ┆ b   ┆ c   │
│ --- ┆ --- ┆ --- │
│ f64 ┆ f64 ┆ f64 │
╞═════╪═════╪═════╡
│ 1.0 ┆ 2.0 ┆ 3.0 │
│ 4.0 ┆ 5.0 ┆ 6.0 │
│ 7.0 ┆ 8.0 ┆ 9.0 │
└─────┴─────┴─────┘

In [14]: scalars
Out[14]: 
shape: (1, 3)
┌─────┬─────┬─────┐
│ a   ┆ b   ┆ c   │
│ --- ┆ --- ┆ --- │
│ f64 ┆ f64 ┆ f64 │
╞═════╪═════╪═════╡
│ 1.0 ┆ 2.0 ┆ 3.0 │
└─────┴─────┴─────┘

我可以在 Pandas 中轻松完成此任务，如下所示，通过委托 NumPy 广播，但我想知道最好的方法是什么，而无需在 Polars / Pandas 表示之间来回切换。

In [16]: df.to_pandas() / scalars.to_numpy()
Out[16]: 
     a    b    c
0  1.0  1.0  1.0
1  4.0  2.5  2.0
2  7.0  4.0  3.0

我发现了这个类似的问题，其中标量常量已经是原始帧中的一行，但不知道如何利用另一个帧中的行。

到目前为止我能想到的最好的办法就是组合框架并做一些......看起来很讨厌的事情：D

In [31]: (pl.concat([df, scalars])
    ...:    .with_columns(pl.all() / pl.all().tail(1))
    ...:    .head(-1))
Out[31]: 
shape: (3, 3)
┌─────┬─────┬─────┐
│ a   ┆ b   ┆ c   │
│ --- ┆ --- ┆ --- │
│ f64 ┆ f64 ┆ f64 │
╞═════╪═════╪═════╡
│ 1.0 ┆ 1.0 ┆ 1.0 │
│ 4.0 ┆ 2.5 ┆ 2.0 │
│ 7.0 ┆ 4.0 ┆ 3.0 │
└─────┴─────┴─────┘

我尝试了以下 2 种方法来设置 JavaFX 中 AnchorPane 的 minHeight 和 minWidth（使其在 1280x720 下无法调整大小）：

从控制器类（从 login-view.fxml 中的按钮调用，该按钮具有相同的高度和宽度的最小值和最大值，但仅在本地，并且不会将任何内容传输到 admin-view.fxml）。

root、stage、scene在LoginController中声明，但它们不是

root = FXMLLoader.load(getClass().getResource("admin-view.fxml"));
stage = (Stage) ((Node) event.getSource()).getScene().getWindow();


scene = new Scene(root);
stage.setScene(scene);
stage.setMinHeight(scene.getRoot().minHeight(-1));
stage.setMinWidth(scene.getRoot().minWidth(-1));

和

stage.setMinHeight(720);
stage.setMinWidth(1280);

并在 admin-view.fxml 中

<VBox maxHeight="720.0" maxWidth="1280.0" minHeight="720.0" minWidth="1280.0" ...>
    <children>
    <VBox VBox.vgrow="ALWAYS" />
        <AnchorPane maxHeight="720.0" maxWidth="1280.0" minHeight="720.0" minWidth="1280.0">
    ... my code here ...
    <VBox VBox.vgrow="ALWAYS" />
    </children>
<VBox>

（我选择了相同的最小值和最大值，因为我在教程中看到这应该可行）。

但我的问题是窗口的大小以 1280x720 加载，但它的大小可以调整为 ~1260x690。

我有一张地图Map<MetricResult, Long> metricResultToComputationTime。

MetricResult有一个方法MetricResult::getEndTime。

我想要一个每个人都有独特的结束时间的List<MetricResult>地方。MetricResult如果结束时间匹配，我想使用地图中计算时间较长的那个。我该如何巧妙地做到这一点？

我知道有一些简单而冗长的方法可以做到这一点，但我正在寻找一些优雅的方法。

我尝试了一些这样的东西：

List<MetricResult> metricResults =
    metricResultToComputationTime.entrySet().stream()
        .collect(
            groupingBy(
                MetricResult::getEndTime,
                collectingAndThen(maxBy(Map.Entry.comparingByValue()), Optional::get)))
        .values();

但它不能编译

错误：

没有找到适合的方法collect(java.util.stream.Collector<MetricResult&java.util.Map.Entry<java.lang.Object,V>,capture#1 of ?,java.util.Map<Timestamp,java.lang. Object>>) 方法 java.util.stream.Stream.collect(java.util.function.Supplier,java.util.function.BiConsumer<R,? super java.util.Map.Entry<MetricResult,Timestamp>>,java .util.function.BiConsumer<R,R>) 不适用（推理变量 T 具有不兼容的边界上限：MetricResult,java.util.Map.Entry<K,V>,T,T 下限：MetricResult,Timestamp> ）

考虑 的定义compare_and_exchange_strong_explicit：

_Bool atomic_compare_exchange_strong_explicit( volatile A* obj,
                                               C* expected, C desired,
                                               memory_order succ,
                                               memory_order fail );

我对 的用例感到困惑memory_order fail。考虑到 x86，很明显可能lock cmpxchg会失败，但也明确定义了（强调我的）

读取或写入不能用 I/O 指令、锁定 指令或序列化指令重新排序

这使得这种memory_order fail无关紧要，因为lock在任何情况下都能保证顺序一致性。

例子：

#include <stdatomic.h>

void fail_seqcst(volatile int *p, int *expected, int *desirable){
    atomic_compare_exchange_strong_explicit(p, expected, desirable, memory_order_release, memory_order_seq_cst);
}

void fail_relaxed(volatile int *p, int *expected, int *desirable){
    atomic_compare_exchange_strong_explicit(p, expected, desirable, memory_order_release, memory_order_relaxed);
}

编译为：

fail_relaxed:
        mov       ecx, edx                                      
        mov       eax, DWORD PTR [rsi]                          
        lock      
        cmpxchg   DWORD PTR [rdi], ecx                          
        mov       DWORD PTR [rsi], eax                          
        sete      al                                            
        movzx     eax, al                                       
        ret 

fail_seqcst:
        mov       ecx, edx                                      
        mov       eax, DWORD PTR [rsi]                          
        lock      
        cmpxchg   DWORD PTR [rdi], ecx                          
        mov       DWORD PTR [rsi], eax                          
        sete      al                                            
        movzx     eax, al                                       
        ret                                                     

神箭

memory_order_relaxed编译器是否可以进行任何优化来区分和memory_order_seq_cst在这种情况下的代码x86？或者也许有一种架构可以使这种差异变得显着？

我有两列：serial_number和inv_number包含列表。如果有一个inv_number用于多个serial_number，我需要使 's 列表的大小inv_number与 's 相同serial_number。

    serial_number                                       inv_number
28  [С029768, С029775]                                  [101040031171, 101040031172]
29  [090020960190402011, 090020960190402009]            [210134002523, 210134002524]
31  [1094]                                              [410124000215]
32  [01]                                                [101040022094]
33  [F161B5, F17D86, F17D8D, F1825C, F1825A, F1825D]    [101040026976]

在索引 33 处，我们有 6 个序列号，但有 1 个库存号，因此应更改为

[101040026976, 101040026976, 101040026976, 101040026976, 101040026976, 101040026976]

我尝试通过“乘以”值来制作列表（例如[value] * N）：

si.loc[si['inv_number'].apply(len)==1, 'inv_number'].apply
    (lambda x: [str(x[0])] * si['serial_number'].apply(len).values)

但它给了我一个错误：

UFuncTypeError: ufunc 'multiply' 不包含签名匹配类型的循环 (dtype('<U12'), dtype('int64')) -> None

我怎么解决这个问题？

抱歉，我对编码有点陌生，但我被要求将一个整数作为第 n 项的输入并打印出此模式中的值，并且我已经编写了一些有效的东西，但我觉得好像我我把事情严重复杂化了。这是有问题的系列：

y = -(1)-(1+2)+(1+2+3)+(1+2+3+4)-(1+2+3+4+5) .... (1+2 +3+4...+n)

这是代码：

import java.util.Scanner;
public class wontwork {
  public static void main(String[] args) {
   Scanner np = new Scanner(System.in);
   
    System.out.println("Enter n");
    int n = np.nextInt();
    int count = 1;
    int sum = 0;
    int y = 0;
    
    for(int i = 1; i<=n ; i+=2) {
      
      if(count%2==0) {
        sum+=i;
        y+=sum;
        sum+=i+1;
        y+=sum;
      }
      else {
        sum+=i;
        y-=sum; 
        sum+=i+1;
        y-=sum;
      }
      count++;
    }
    
    if(n%2!=0) {
      
      if (count%2==0) {
        System.out.print(y+sum);
      }
      else {
        System.out.print(y-sum);
      }

  }
    else {
      System.out.print(y);
  }
  np.close();
}
}

当输入 4 时，样本输出应给出 12；当输入 5 时，样本输出应给出 -3。

据我了解，它是减去两次并加上两倍的值之和。我所做的是创建一个 for 循环并采用一个计数变量来检查是否首先添加或减去，具体取决于它是奇数还是偶数，然后采用 sum 变量来计算括号之间每次迭代的值并添加或将其减去 y。

但每次循环运行时，这个过程都会发生两次。因此，当计数为奇数时，y 在第一个循环中添加 -(1) 和 -(1+2)，然后在下一个循环中，当计数为奇数时，y 添加 (1+2+3) 和 (1+2+3+4)甚至。我这样做是因为如果我单独添加 (1+2+3) 计数为偶数，我还必须添加 (1+2+3+4) 并增加计数，但是，这使它成为奇数，并且它是对于使用它进行加法或减法不再有用。如果我错过了一些明显的东西，我会很讨厌，但我一生都无法弄清楚如何才能知道它何时增加两次，然后使其为正值或负值。

出于这个原因，如果不是最后的 if else 语句，程序只会为每个 2n 输出正确的值，并修复我获取最后存储的总和值并检查 count 是奇数还是偶数，然后添加或再次减去 y it 即可找到 n 的中间值。由于这是我在这里发表的第一篇文章，如果我没有错误地编写或格式化任何内容，请道歉，但请让我知道我还能做什么。我将不胜感激任何帮助。

renderHanoi() 方法应该移动磁盘，方法是从 VBox 中清除磁盘，然后在每次移动后以新顺序再次添加它们，但似乎没有显示任何内容，除非它是最后一个移动，这使得一切都毫无意义。

我尝试了不同的创建延迟的方法，如 Thread.sleep、Platform.runLater 等。它们似乎都不起作用。我该如何解决这个问题？

import java.util.Arrays;
import java.util.Random;
import javafx.animation.AnimationTimer;
import javafx.application.Application;
import javafx.application.Platform;
import javafx.scene.Scene;
import javafx.scene.layout.HBox;
import javafx.scene.layout.VBox;
import javafx.scene.paint.Color;
import javafx.scene.shape.Rectangle;
import javafx.stage.Stage;

public class App extends Application {

    @Override
    public void start(Stage stage) {
        HBox platform = new HBox();
        VBox[] towerBoxes = new VBox[] { new VBox(), new VBox(), new VBox()};
        platform.getChildren().addAll(Arrays.asList(towerBoxes));
        Hanoi testing = new Hanoi(10);
        testing.towerBoxes = towerBoxes;
        var scene = new Scene(platform, 640, 480);
        stage.setScene(scene);
        stage.show();
        testing.solve();
    }

    public static void main(String[] args) {
        launch();
    }
}

class Tower {
    private int sp = 0;
    private Rectangle[] disks;
    
    Tower(int n) {
        disks = new Rectangle[n];
    }
    
    public void push(Rectangle entry) {
        if (sp < disks.length)
            disks[sp++] = entry;
        else
            System.err.println(this + ".push(" + entry + ") failed, stack is full");
    }
    
    public Rectangle pop() {
        if (sp > 0)
            return disks[--sp];
        else {
            System.err.println(this + ".pop() failed, stack is empty");
            return null;
        }
    }
    
    public boolean hasEntry() {
        return sp > 0;
    }
    
    @Override
    public Tower clone() {
        Tower copy = new Tower(disks.length);
        copy.sp = this.sp;
        copy.disks = this.disks.clone();
        return copy;
    }
}

class Hanoi {
    Tower src;
    Tower aux;
    Tower dest;
    int n;
    
    public VBox[] towerBoxes;
    
    public Hanoi(int n) {
        src = new Tower(n);
        aux = new Tower(n);
        dest = new Tower(n);
        
        this.n = n;
        
        for (int i = 0; i < n; i++) {
            Rectangle disk = new Rectangle(30 + 20 * i, 10);
            Color diskColor = generateRandomColor();
            disk.setFill(diskColor);
            disk.setStroke(diskColor);
            src.push(disk);
        }
    }
    
    private static Color generateRandomColor() {
        Random random = new Random();
        double red = random.nextDouble();
        double green = random.nextDouble();
        double blue = random.nextDouble();
        
        return new Color(red, green, blue, 1.0);
    }
    
    private void solve(int n, Tower src, Tower aux, Tower dest) {
        if (n < 1) {
            return;
        }
        solve(n-1, src, dest, aux);
        dest.push(src.pop());
        System.out.println(n);
        solve(n-1, aux, src, dest);
    }
    
    public void solve() {
        renderHanoi();
        timer.start();
        solve(n, src, aux, dest);
    }
    
    AnimationTimer timer = new AnimationTimer() {
        @Override
        public void handle(long now) {
          renderHanoi(); // Update UI after each frame
        }
    };

    
    private void renderHanoi() {
        for (VBox towerBox:towerBoxes)
            towerBox.getChildren().clear();
        Tower[] towersCopy = new Tower[]{src.clone(), aux.clone(), dest.clone()};
        for (int i = 0; i < 3; i++)
            while (towersCopy[i].hasEntry())
                towerBoxes[i].getChildren().add(towersCopy[i].pop());
    }
}