全部问题(coding)

我能够CEdit使用函数中下面显示的代码在控件内显示几个字符OnInitDialog()，但我无法在函数主体内突出显示相同的文本OnInitDialog()。我只是不知道该怎么做。在我的CReplaceCharacterDlg课程中，我使用向导添加了一个CEdit ReplaceCharsCtrl变量，并使用资源编辑器创建了CEdit控件。我尝试在函数中执行以下行OnInitDialog()，如下所示，但出现调试断言失败错误。有人可以给我提示一下可以这样做吗？

// CReplaceCharacter dialog

class CReplaceCharacterDlg : public CDialogEx
{
    DECLARE_DYNAMIC(CReplaceCharacterDlg)

public:
    CReplaceCharacterDlg(CWnd* pParent = nullptr);   // standard constructor
    CReplaceCharacterDlg(CWnd* pPar, CStringW replaceStrW);
    virtual ~CReplaceCharacterDlg();

// Dialog Data
#ifdef AFX_DESIGN_TIME
    enum { IDD = IDD_REPLACE_CHAR };
#endif

protected:
    virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
    virtual BOOL OnInitDialog();

    DECLARE_MESSAGE_MAP()
public:
    CEdit ReplaceCharsCtrl;
    CStringW ReplacementCharacterStr;
    afx_msg void OnBnClickedOk();
};

// Implementation
BOOL CReplaceCharacterDlg::OnInitDialog()
{
    GetDlgItem(IDC_EDIT1)->SetWindowTextW(ReplacementCharacterStr);
        ReplaceCharsCtrl.SetHighlight(0, 2);  <---- GIVES ASSERT ERROR  ReplaceCharsCtrl hWnd = NULL
    return TRUE;
}

请参阅帖子正文。

可以在不同的协程之间共享相同的协程上下文吗？我测试过了，似乎运行正常。

val context = Dispatchers.IO + myThreadLocal.asContextElement() + myThreadContextElement
val deferredResultOne = async(context) { /* some work */ }
val deferredResultTwo = async(context) { /* some work */ }
val resultOne = deferredResultOne.await()
val resultTwo = deferredResultTwo.await()

假设我有一个值数组

values = np.array([0.0, 1.0, 2.0, 3.0, 4.0])

和一个索引数组

indices = np.array([0,1,0,2,2])

有没有一种矢量化的方法来对每个唯一索引的值求和？我的意思是获取此代码片段中的indices矢量化版本：sums

sums = np.zeros(np.max(indices)+1)
for index, value in zip(indices, values):
    sums[index] += value

如果解决方案允许values（并且因此sums）是多维的，则可获得加分。

编辑：我对发布的解决方案进行了基准测试：

import numpy as np
import time
import pandas as pd


values = np.arange(1_000_000, dtype=float)
rng = np.random.default_rng(0)
indices = rng.integers(0, 1000, size=1_000_000)


N = 100


now = time.time_ns()
for _ in range(N):
    sums = np.bincount(indices, weights=values, minlength=1000)
print(f"np.bincount: {(time.time_ns() - now) * 1e-6 / N:.3f} ms")


now = time.time_ns()
for _ in range(N):
    sums = np.zeros(1 + np.amax(indices), dtype=values.dtype)
    np.add.at(sums, indices, values)
print(f"np.add.at: {(time.time_ns() - now) * 1e-6 / N:.3f} ms")


now = time.time_ns()
for _ in range(N):
    pd.Series(values).groupby(indices).sum().values
print(f"pd.groupby: {(time.time_ns() - now) * 1e-6 / N:.3f} ms")


now = time.time_ns()
for _ in range(N):
    sums = np.zeros(np.max(indices)+1)
    for index, value in zip(indices, values):
        sums[index] += value
print(f"Loop: {(time.time_ns() - now) * 1e-6 / N:.3f} ms")

结果：

np.bincount: 1.129 ms
np.add.at: 0.763 ms
pd.groupby: 5.215 ms
Loop: 196.633 ms

基本上，我试图将存储在变量中的节点的节点名称写入文件。我的问题是，当我通过 select 属性分配变量的值时，它会起作用，而通过内容分配时则不起作用。不过我确实需要让后者工作，因为我希望该内容是有条件的（下面的示例中不是这样）。

有人能帮我解决这个问题吗？谢谢！

我的环境是一个专有软件平台，用于发布可变数据，使用 Altova 的某个东西（引擎这个词正确吗？）来处理 xslt。我在 xslt 2.0 模式下使用此引擎。

这一切都发生在这个命名模板中：

<xsl:template name="setValidatedEmail">
  <xsl:param name="docType"/>
  <xsl:variable name="break" select="'&#13;&#10;'"/>
  <xsl:variable name="contEm1" select="."/>
  <xsl:variable name="contEm2">
    <xsl:copy-of select="."/>
  </xsl:variable>
  <validatedEmail>
    <xsl:result-document ...">
      <xsl:value-of select="local-name-from-QName(node-name($contEm1))"/>
      <xsl:value-of select="$break"/>
      <xsl:value-of select="local-name-from-QName(node-name($contEm2))"/>
    </xsl:result-document>
  </validatedEmail>
</xsl:template>

其调用方式如下：

<xsl:template match="email">
  <xsl:call-template name="setValidatedEmail">
    <xsl:with-param name="docType">Stockbooks</xsl:with-param>
  </xsl:call-template>
</xsl:template>

local-name-from-QName(node-name($contEm1))返回字符串email（如预期的那样），但local-name-from-QName(node-name($contEm2))意外地不返回任何内容。

在使用自定义输入组件时，我遇到了一些奇怪的行为。

首先，我建立了一个简单的抽象类，它具有组件的主要“功能”和方法，然后是具有很少代码的输入组件：

// Abstract class

export abstract class BaseFormInput<T> implements ControlValueAccessor, Validator, AfterViewInit, OnDestroy {
    @Input() label: string
    @Output() onChange: EventEmitter<T> = new EventEmitter<T>()

    private changeInternal: (obj: T) => void
    private changeSub: Subscription
    private disabled$ = new BehaviorSubject(false)
    private required$ = new BehaviorSubject(false)

    public input = new FormControl(null)

    ngOnDestroy() {
        this.changeSub.unsubscribe()
    }

    ngAfterViewInit() {
        this.changeSub = this.input.valueChanges.subscribe(v => {
            if (!this.disabled$.getValue()) {
                this.onChange.emit(v)
                this.changeInternal(v)
            }
        })
    }

    writeValue = (obj: T) => this.input.setValue(obj)

    registerOnChange = (fn: (obj: T) => void) => this.changeInternal = fn

    registerOnTouched = (_fn: (obj: any) => void) => {}

    setDisabledState = (isDisabled: boolean) => this.disabled$.next(isDisabled)

    validate(control: AbstractControl): ValidationErrors {
        this.required$.next(control.hasValidator(Validators.required))

        // THIS LINE HAS WEIRD BEHAVIOR
        console.log(control, control.errors)

        return null
    }

    public get isDisabled$(){
        return this.disabled$.asObservable()
    }

    public get isRequired$(){
        return this.required$.asObservable()
    }
}

输入组件简单设计如下：

@Component({
    selector: "ec-input-text",
    template: `<div class="form-control">
            <label *ngIf="label">
                {{ label }}
                <span *ngIf="isRequired$ | async">*</span>
            </label>
            <input *ngIf="type !== 'textarea'" [type]="type" [formControl]="input" [attr.disabled]="isDisabled$ | async" />
            <textarea *ngIf="type === 'textarea'" [formControl]="input" [attr.disabled]="isDisabled$ | async"></textarea>
            <ng-template></ng-template>
        </div>`,
    changeDetection: ChangeDetectionStrategy.OnPush,
    providers: [
        { provide: NG_VALUE_ACCESSOR, useExisting: forwardRef(() => InputTextComponent), multi: true },
        { provide: NG_VALIDATORS, useExisting: forwardRef(() => InputTextComponent), multi: true }
    ]
})
export class InputTextComponent extends BaseFormInput<string> {
    @Input() type: "text" | "password" | "email" | "textarea" = "text"
    @Input() maxLength: number
}

最后，我创建了一个使用输入的注册组件。

HTML：

<form [formGroup]="form">
    <ec-input-text label="First name" formControlName="firstName" />
    <ec-input-text label="Last name" formControlName="lastName" />
    <ec-input-text label="E-mail" formControlName="email" type="email" />
    <ec-input-text label="Password" formControlName="password" type="password" />
</form>

注册组件的 TS 具有如下公共属性：

public form = new FormGroup({
        firstName: new FormControl(null, [Validators.required, Validators.maxLength(50)]),
        lastName: new FormControl(null, [Validators.required, Validators.maxLength(50)]),
        email: new FormControl(null, [Validators.required, Validators.maxLength(100)]),
        password: new FormControl(null, Validators.required)
    })

现在，问题如下：在抽象类的validate方法中（我在其中添加了注释），我尝试记录控制错误，但出现了奇怪的行为：记录formControl时，我可以在控制台中看到属性errors为空，但如果我记录control.errors，则会记录：

{ required: true }

即使控件有效，并且我输入了值（实际上，control.value有一个值并且结果有效）。因此，如果我这样做：

console.log(control)

我将其扩展，错误为空（预期行为，正确！）

但如果我这么做：

console.log(control.errors)

它被重视了（不正确，控制是有效的！）

我该如何解决这个问题？提前致谢！

我需要找到大小为 L 的最小子数组，A[0:L]，B[0:L]，使得 A 中有 M 个不同元素大于 B 中有 M 个不同元素。例如 A[i] > B[j] 算数，但我不能再使用 A[i] 或 B[j]。此外，子数组必须从数组的开头开始。

作业是关于 AVLTrees 和 Heap 的，所以我猜解决方案会涉及其中之一（对于下面的示例，我使用了 stl 中的 priority_queue，但实际上我不允许使用任何库中的任何容器，所以我已经有了 min-heap 实现，但为了易于理解，我使用了 stl 等效项）。此外，我还希望使用 AVL Tree 或 Heap 来解决问题。

附言：我发现数组可以包含重复元素。

A和B的大小相同，即：N。

我需要找到一个时间复杂度为 O(N * logN * logM) 的解决方案

#include <iostream>
#include <queue>
#include <span>

int minLenOfSubarrays(std::span<int> aArr, std::span<int> bArr, int M)
{
    const int N = aArr.size();
    int count = 0;
    int L = 0;

    int left = M;
    int right = N;
    while(left <= right){ //log N
        //Heap a; //min-heap
        //Heap b; //min-heap
        int mid = left+(right-left)/2;
        std::priority_queue<int,std::vector<int>,std::greater<int>> a;
        std::priority_queue<int,std::vector<int>,std::greater<int>> b;
        count = 0;
        for(int j = 0; j < mid; j++){ //N log N
            a.push(aArr[j]);
            b.push(bArr[j]);
        }
        while(!a.empty()){ // N log N
            if(a.top() > b.top()){
                count++;
                a.pop();
                b.pop();
            }
            else{
                a.pop();
            }
        }
        if(count >= M){
            L = mid;
            right = mid-1;
        }
        else{
            left = mid+1;
        }
    }
    return L;
}

int main(int argc, char* argv[]){

    int aArr[] = {2,4,10,6,1,11};
    int bArr[] = {3,5,8,9,7,12};
    int M = 3;
    
    std::cout << minLenOfSubbarays(aArr, bArr, M) << '\n';
}

我尝试过使用最小堆和二分搜索的解决方案，但我能达到的复杂度最大为 O(N*logN*logN)。

我有一个 pandas 数据框，其中的值有时会变为 NA。我想用与另一列长度相同的字符串列表填充此列：

import pandas as pd
import numpy as np

df = pd.DataFrame({"a": ["one", "two"],
                   "b": ["three", "four"],
                   "c": [[1, 2], [3, 4]],
                   "d": [[5, 6], np.nan]})

我希望这成为

我试过

df["d"] = np.where(df.d.isna(),
                   ['no_value' for element in df.c],
                   df.d)

和

df["d"] = np.where(df.d.isna(),
                   ['no_value'] * len(df.c),
                   df.d)

但两者都不起作用。有人有主意吗？

解决方案：我稍微调整了 PaulS 的回答：

df[‘d‘] = np.where(df.d.isna(), 
                   pd.Series([['no_value'] * len(lst) for lst in df.c]), 
                   df.d))

我有一个函数定义，它以函数指针作为参数：

void ReadLogFile(void (*msgHandler)(String msg) = NULL)
{
  ...
  if (msgHandler) msgHandler(msg);
  ...
}

我尝试通过 lambda 来调用它：

logger.ReadLogFile([](String s) 
  {
    MQTT_SendLogEntry(telemetry_topic, s, s);
  });

事实证明，这不起作用，因为telemetry_topic它位于 lambda 外部，并且无法访问外部变量。因此，我更改了 lambda 以捕获所有外部变量：

logger.ReadLogFile([&](String s) 
  {
    MQTT_SendLogEntry(telemetry_topic, s);
  });

这次我收到一个编译错误：

不存在从“lambda [](String s)->void”到“void (*)(String msg)”的合适转换函数

我不知道如何改变声明logger.ReadLogFile()来接受这样的 lambda 函数，然后如何从那里调用它。

我尝试使用 HTML 和 JavaScript 创建一个列表，当单击按钮时该列表会转换到视图中，其中包括一个可滚动的内部容器，并使用父 DIV 上的最大高度转换。

但是，虽然父 div 过渡平滑，但过渡完成后内容会立即出现。这似乎是在内部 div 溢出时发生的。

我知道删除内部 div、删除其溢出属性或将其高度限制为父级将阻止症状的发生，但我想保持内部 div 可滚动，但我不确定为什么我不能这样做。

这是我一直在尝试的一个例子。

let visible = false;

function showHideList() {
  const listContainerRef = document.getElementById('list-id');
  if (!listContainerRef?.style?.maxHeight) 
    return;
    
  listContainerRef.style.maxHeight = visible ? 0 + 'px' : 200 + 'px';
  visible = !visible;
}

<button onclick="showHideList()" style="padding: 1rem; background: #2aabd2">Show / Hide</button>
<div id="list-id" style="transition: max-height 2s linear; overflow: hidden; max-height: 0;">
  <div style="overflow: auto; max-height: 200px">
    <div style="background-color: green">
      <span style="display: block; background-color: red; padding: 0.5rem 0.75rem">Item 1</span>
      <span style="display: block; background-color: red; padding: 0.5rem 0.75rem">Item 2</span>
      <span style="display: block; background-color: red; padding: 0.5rem 0.75rem">Item 3</span>
      <span style="display: block; background-color: red; padding: 0.5rem 0.75rem">Item 4</span>
      <span style="display: block; background-color: red; padding: 0.5rem 0.75rem">Item 5</span>
      <span style="display: block; background-color: red; padding: 0.5rem 0.75rem">Item 6</span>
    </div>
  </div>
</div>

下面是另一个示例：

#list-container {
    max-height: 0;
    transition: max-height 2s ease-out;
    overflow: hidden;
}
#list-container.visible {
    max-height: 300px;
}
#list-content {
    max-height: 200px;
    overflow: auto;
}
li {
    background-color: red;
    padding: 0.5rem 0.75rem;
}
button {
    padding: 1rem;
    background: #2aabd2;
}

<button onclick="document.getElementById('list-container').classList.toggle('visible')">Show / Hide</button>
  <div id="list-container">
      <div id="list-content">
    <ul>
        <li>item</li>
        <li>item</li>
        <li>item</li>
        <li>item</li>
        <li>item</li>
        <li>item</li>
    </ul>
      </div>
</div>

我有一个数据框：

df = pd.DataFrame({"ID": ["ID1", "ID2", "ID3",
                                "ID4", "ID5"],
                   "Item": ["Item1", "Item2", "Item3",
                                    "Item4","Item5"],
                   "Catalog1": ["cat1", "1Cat12", "Cat35",
                                    "1cat3","Cat5"],
                   "Catalog2": ["Cat11", "Cat12", "Cat35",
                                    "1Cat1","2cat5"],
                   "Catalog3": ["cat6", "Ccat2", "1Cat9",
                                    "1cat3","Cat7"],
                   "Price": ["716", "599", "4400",
                                    "150","139"]})

我需要找到所有在名称以 Catalog 开头的列中包含字符串“cat1”或“Cat1”的行（这些列的数量可能有所不同，因此我不能只列出它们）。

我试过：

filter_col = [col for col in df if col.startswith('Catalog')]

df_res = df.loc[(filter_col.str.contains('(?i)cat1'))]

但我犯了错误：

AttributeError：'list' 对象没有属性 'str'