主页 / coding / 问题

全部问题(coding)

Martin Hope
Loaf
Asked: 2024-11-14 21:35:12 +0800 CST
  • 8

我有一个文件夹，里面有很多子文件夹，每个子文件夹都包含一个 .cpp 文件和多个不重要的文件。我想运行一个命令，进入每个子文件夹并删除文件夹本身和 .cpp 文件以外的所有内容。

我尝试过这个命令但它只是删除了文件夹本身：

gci -Path $path | ? {!($_.Name -ilike "*.cpp")} | % { Remove-Item -Path $_.FullName }

先感谢您！

powershell
Martin Hope
user p
Asked: 2024-11-14 20:50:44 +0800 CST
  • 8

我目前正在尝试为我的应用程序创建一个卡片组件，以用于学习目的。我的目标是获得一个通用的可重复使用的卡片组件。当我不使用 card-footer 指令时，我不希望加载带有 class-footer 类的 div

卡片.组件.ts

import { Component, Directive } from '@angular/core';

@Directive({
  selector: 'card-header',
  host: {
    'class': 'card-header',
  },
})
export class CardHeaderDirective {}

@Directive({
  selector: 'card-content',
  host: {
    'class': 'card-content',
  },
})
export class CardContentDirective {}

@Directive({
  selector: 'card-footer',
  host: {
    'class': 'card-footer',
  },
})
export class CardFooterDirective {}

@Component({
  selector: 'app-card',
  standalone: true,
  imports: [],
  templateUrl: './card.component.html',
  styleUrl: './card.component.scss',
})
export class CardComponent {
}

卡片.组件.html

<div class="card">
  <div class="card-header">
    <ng-content select="[card-header]"></ng-content>
  </div>
  <div class="card-content">
    <ng-content select="[card-content]"></ng-content>
  </div>
  <div class="card-footer">
    <ng-content select="[card-footer]"></ng-content>
  </div>
</div>

下面是我如何使用它的一个例子：

<app-card>
  <div card-header>
    <span>Header</span>
  </div>
  <div card-content>
    <span>Some content</span>
  </div>
  <div card-footer>
    <span>Sometimes I'm using this and sometimes not</span>
  </div>
</app-card>

问题在于 card-footer 类出于 UI 原因具有 border-top。有时我想使用此组件但不想使用 card-footer。我不想看到 border-top，但由于 div，它现在当然一直在那里。

到目前为止，我尝试使用@if，并在 AfterContentInit 中使用 ViewChild 的 ContentChildren 检查内容时选择性地加载 div card-footer，但没有成功

angular
Martin Hope
Andi
Asked: 2024-11-14 17:11:39 +0800 CST
  • 8
df = pl. DataFrame({"col1": [1, 2, 3], "col2": [4, 5, 6]})

print(df)

shape: (3, 2)
┌──────┬──────┐
│ col1 ┆ col2 │
│ ---  ┆ ---  │
│ i64  ┆ i64  │
╞══════╪══════╡
│ 1    ┆ 4    │
│ 2    ┆ 5    │
│ 3    ┆ 6    │
└──────┴──────┘

我正在寻找polars相当于 的东西numpy.tile。
类似于df.tile(2)或 的东西df.select(pl.all().tile(2))。

预期结果应如下所示：

shape: (6, 2)
┌──────┬──────┐
│ col1 ┆ col2 │
│ ---  ┆ ---  │
│ i64  ┆ i64  │
╞══════╪══════╡
│ 1    ┆ 4    │
│ 2    ┆ 5    │
│ 3    ┆ 6    │
│ 1    ┆ 4    │
│ 2    ┆ 5    │
│ 3    ┆ 6    │
└──────┴──────┘
python
Martin Hope
Rimso
Asked: 2024-11-13 20:02:41 +0800 CST
  • 8

C++ 中的连接原理是什么std::string？它在内存分配中如何工作？

我在探索 leetcode 卡片时发现，在 Java 中：
“连接的工作方式是首先为新字符串分配足够的空间，从旧字符串复制内容并附加到新字符串”。
与 Java 不同，“在 C++ 中，这不会对性能产生明显影响”。

我认为在 C++ 中也是一样，因为动态数组的工作方式。我记得如果你想增加动态数组的容量，程序首先创建一个新的空间，其大小等于所需的大小，然后将旧数组的所有元素复制到新数组中。

c++
Martin Hope
StrayByteIncarnate
Asked: 2024-11-13 03:34:22 +0800 CST
  • 8

我有一个数字字母对的列表，例如：

all_edges_array = [
                   [1,'a'],[1,'b'],[1,'c'],
                   [2,'c'],[2,'d'],
                   [3,'b'],[3,'c']
                  ]

请注意，输入对不是所用字母和数字的叉积 - 例如[2, 'a']缺失。

我想要有效地找到一定数量的对的组合，使得在一个组内，没有两对使用相同的数字或相同的字母。

对于上述输入，总共应该有 5 个结果：[([1, 'a'], [2, 'c'], [3, 'b']), ([1, 'a'], [2, 'd'], [3, 'b']), ([1, 'a'], [2, 'd'], [3, 'c']), ([1, 'b'], [2, 'd'], [3, 'c']), ([1, 'c'], [2, 'd'], [3, 'b'])]。

其他组合无效：例如，([1, 'a'], [1, 'b'], [3, 'c'])包含两对使用相同的数字 (1)，以及([1, 'b'], [2, 'c'], [3, 'b'])包含两对使用相同的字母 (b)。

itertools.combinations我有代码，可以通过使用然后过滤结果来强制执行此操作：

from itertools import combinations

number_letter_dict = {1:['a','b','c'], 2:['c','d'], 3:['b','c']}

# create the edges based on the connections in the number_letter_dict
all_edges_array = []
for key in number_letter_dict.keys():
    for item in number_letter_dict[key]:
        all_edges_array.append([key, item])

# get the number of connections relative to the number of keys in dict
number_of_connections = len(number_letter_dict.keys())

# Find all 35 combinations
all_combinations_array = list(combinations(all_edges_array, number_of_connections))

# cut down the list of combinations to what I actually need
all_good_combinations = []
for collection in all_combinations_array:
    duplicated_item = False
    seen_indices = []
    for item in collection:
        if item[0] in seen_indices:
            duplicated_item = True
            break
        if item[1] in seen_indices:
            duplicated_item = True
            break
        seen_indices.append(item[0])
        seen_indices.append(item[1])
    # all clear--add the collection! :)
    if not duplicated_item:
        all_good_combinations.append(collection)

这可行，但效率低下——对于我的实际输入，它需要花费令人无法接受的长时间才能运行。生成的组合比有效组合多得多，而且边和连接越多，情况就越糟。

我该如何改进这个算法？我假设它首先涉及不生成无效组合，但我看不出有办法实现这一点。

我找到了之前的问答Python: 如何生成元组列表的所有组合而不重复元组的内容，但它没有回答我的问题。那里的答案假设输入包含所有可能的对（并且组合中的对数应等于更受约束的对元素的可能性数量）。

编辑：我替换了一些最小化的代码，因为它造成的混乱比它节省的还多：哎呀？此外，此代码确实有效。如果有足够的时间，它将可靠地给出正确答案。话虽如此，花五天时间处理一张图片对我来说还不够快。

python
Martin Hope
Newbyte
Asked: 2024-11-13 01:50:09 +0800 CST
  • 8

我一直在开发一个用 C 编写的应用程序，它使用 GLib 并且专门针对 Linux。通常我的经验是 GLib 的实用程序很有用，并且与仅使用 C 标准库相比，通常可以使编写 C 更容易。然后我注意到g_strdup存在。阅读一些文档strdup，我没有注意到任何明显的区别，除了g_strdup指定你可以传递 NULL 而strdup没有提到它在这种情况下的行为方式。

有了这些信息，我有什么理由使用g_strdup吗strdup？

c
Martin Hope
Hydro
Asked: 2024-11-12 23:20:31 +0800 CST
  • 8

我有一个数据集，我想zero用递增值替换每个值：第一个零变为 0.001，第二个零变为 0.002，第三个零变为 0.003，依此类推。每次出现零时，它都应比上一次替换增加 0.001。

set.seed(123)
DF <- data.frame(Year = 1981:2000, Value = sample(0:5, 20, replace = T))
Martin Hope
Dark Angel
Asked: 2024-11-12 22:52:59 +0800 CST
  • 8

我有以下数组作为输入

String[] input = new String[] {
       "This is a sample string",
       " string ",                   // additional spaces here cause issues while splitting
       "Another sample string",
       "This is not    a sample string"
};

我需要计算单个单词的频率。所需的输出是：

{a=2, not=1, string=4, This=2, is=2, sample=3, Another=1}

到目前为止，我得到了一些可行的代码：

// 1. Convert String[] into a single " " delimited String 
String joined = String.join(" ", input);

// 2. Split on " " and then calculate count using Collectors.groupingBy
Map <String, Long> output = 
        Arrays
            .stream(joined.split(" "))
            .filter(s -> !s.equals(""))    // To Deal with Empty Strings
            .collect(
                Collectors.groupingBy(
                    Function.identity(),
                    Collectors.counting()
                )
            );

System.out.println(output);

这对我来说看起来很粗糙，请建议一种使用 Streams API 来实现此目的的更好方法。

java
Martin Hope
Giampaolo Levorato
Asked: 2024-11-12 03:39:46 +0800 CST
  • 8

我创建了以下熊猫数据框：

import pandas as pd

ds = {'col1' : ['A','A','B','C','C','D'],
      'col2' : ['A','B','C','D','D','A']}

df = pd.DataFrame(data=ds)

数据框如下所示：

print(df)

  col1 col2
0    A    A
1    A    B
2    B    C
3    C    D
4    C    D
5    D    A

col1和中的可能值col2有A、B和C。D

我需要创建 4 个新列，称为：

  • countA：计算A每行/记录中有多少个
  • countB：计算B每行/记录中有多少个
  • countC：计算C每行/记录中有多少个
  • countD：计算D每行/记录中有多少个

因此，从上面的例子来看，生成的数据框将如下所示：

在此处输入图片描述

有人能帮帮我吗？

python
Martin Hope
engineerdavut
Asked: 2024-11-12 00:49:15 +0800 CST
  • 8

我使用遗传算法 (nest.js) 编写了类调度。我的程序有 Geneticalgorithm.ts、data.ts、population.ts、scheduleservice.ts 和 Schedulemodule.ts。我在 Geneticalgorithmclass 中使用的方法中调用了 Population。作为构造函数。我需要将 Population.getSchedules().length 作为数字传递给构造函数。但我收到了这个错误。Geneticalgorithm.ts Population.ts 和 Schedulemodule.ts 如下。

错误定义；

[Nest] 63732  - 11/11/2024, 6:51:23 PM     LOG [NestFactory] Starting Nest application...
[Nest] 63732  - 11/11/2024, 6:51:23 PM     LOG [InstanceLoader] AppModule dependencies initialized +54ms
[Nest] 63732  - 11/11/2024, 6:51:23 PM     LOG [Instance Loader] Type Orm Module dependencies initialized +0ms
[Nest] 63732  - 11/11/2024, 6:51:23 PM     LOG [Instance Loader] Number dependencies initialized +1ms

[Nest] 63732  - 11/11/2024, 6:51:23 PM   ERROR [Exception Handler] Nest can't resolve dependencies of the Population (?, Data). Please make sure that the argument Number at index [0] is available in the ScheduleModule context.

Potential solutions:
- Is ScheduleModule a valid NestJS module?
- If Number is a provider, is it part of the current ScheduleModule?
- If Number is exported from a separate @Module, is that module imported within ScheduleModule?
  @Module({
    imports: [ /* the Module containing Number */ ]
  })


    import { Injectable } from '@nestjs/common';
    import { Data } from './data';
    import { Population } from './population';
    import { Schedule } from './schedule';
    import { Driver } from './driver';
    
    @Injectable()
    export class GeneticAlgorithm {
      private data: Data;
    
      constructor(data: Data) {
        this.data = data;
      }
    
      public evolve(population: Population): Population {
        return this.mutatePopulation(this.crossoverPopulation(population));
      }
    
      private crossoverPopulation(population: Population): Population {
        const crossoverPopulation = new Population(population.getSchedules().length, this.data);
        for (let i = 0; i < Driver.NUMB_OF_ELITE_SCHEDULES; i++) {
          crossoverPopulation.getSchedules()[i] = population.getSchedules()[i];
        }
        for (let i = Driver.NUMB_OF_ELITE_SCHEDULES; i < population.getSchedules().length; i++) {
          if (Driver.CROSSOVER_RATE > Math.random()) {
            const schedule1 = this.selectTournamentPopulation(population).sortByFitness().getSchedules()[0];
            const schedule2 = this.selectTournamentPopulation(population).sortByFitness().getSchedules()[0];
            crossoverPopulation.getSchedules()[i] = this.crossoverSchedule(schedule1, schedule2);
          } else {
            crossoverPopulation.getSchedules()[i] = population.getSchedules()[i];
          }
        }
        return crossoverPopulation;
      }
    
      private crossoverSchedule(schedule1: Schedule, schedule2: Schedule): Schedule {
        const crossoverSchedule = new Schedule(this.data).initialize();
        for (let i = 0; i < crossoverSchedule.getClasses().length; i++) {
          if (Math.random() > 0.5) {
            crossoverSchedule.getClasses()[i] = schedule1.getClasses()[i];
          } else {
            crossoverSchedule.getClasses()[i] = schedule2.getClasses()[i];
          }
        }
        return crossoverSchedule;
      }
    
      private mutatePopulation(population: Population): Population {
        const mutatePopulation = new Population(population.getSchedules().length, this.data);
        const schedules = mutatePopulation.getSchedules();
        for (let i = 0; i < Driver.NUMB_OF_ELITE_SCHEDULES; i++) {
          schedules[i] = population.getSchedules()[i];
        }
        for (let i = Driver.NUMB_OF_ELITE_SCHEDULES; i < population.getSchedules().length; i++) {
          schedules[i] = this.mutateSchedule(population.getSchedules()[i]);
        }
        return mutatePopulation;
      }
    
      private mutateSchedule(schedule: Schedule): Schedule {
        const mutateSchedule = new Schedule(this.data).initialize();
        for (let i = 0; i < schedule.getClasses().length; i++) {
          if (Driver.MUTATION_RATE > Math.random()) {
            schedule.getClasses()[i] = mutateSchedule.getClasses()[i];
          }
        }
        return schedule;
      }
    
      private selectTournamentPopulation(population: Population): Population {
        const tournamentPopulation = new Population(Driver.TOURNAMENT_SELECTION_SIZE, this.data);
        for (let i = 0; i < Driver.TOURNAMENT_SELECTION_SIZE; i++) {
          tournamentPopulation.getSchedules()[i] = population.getSchedules()[Math.floor(Math.random() * population.getSchedules().length)];
        }
        return tournamentPopulation;
      }
    }



    import { Injectable } from '@nestjs/common';
    import { Data } from './data';
    import { Schedule } from './schedule';
    
    @Injectable()
    export class Population {
      private schedules: Schedule[];
    
      constructor(size: number, data: Data) {
        this.schedules = new Array<Schedule>(size);
        for (let i = 0; i < size; i++) {
          this.schedules[i] = new Schedule(data).initialize();
        }
      }
    
      public getSchedules(): Schedule[] {
        return this.schedules;
      }
    
      public sortByFitness(): Population {
        this.schedules.sort((schedule1, schedule2) => {
          let returnValue = 0;
          if (schedule1.getFitness() > schedule2.getFitness()) returnValue = -1;
          else if (schedule1.getFitness() < schedule2.getFitness()) returnValue = 1;
          return returnValue;
        });
        return this;
      }
    }



    import { Module } from '@nestjs/common';
    import { TypeOrmModule } from '@nestjs/typeorm';
    import { Schedule } from './schedule.entity';
    import { ScheduleService } from './schedule.service';
    import { ScheduleController } from './schedule.controller';
    import { ScheduleRepository } from './schedule.repository';
    import { Data } from './data';
    import { GeneticAlgorithm } from './genetic-algorithm';
    import { Population } from './population';
    import { Class } from './class.entity';
    import { CourseModule } from '../course/course.module';
    import { DepartmentModule } from '../department/department.module';
    import { InstructorModule } from '../instructor/instructor.module';
    import { MeetingTimeModule } from '../meeting-time/meeting-time.module';
    import { RoomModule } from '../room/room.module';
    
    @Module({
      imports: [
        TypeOrmModule.forFeature([Schedule, Class]),
        CourseModule,
        DepartmentModule,
        InstructorModule,
        MeetingTimeModule,
        RoomModule,
      ],
      providers: [ScheduleService, ScheduleRepository, Data, GeneticAlgorithm, Population],
        
    
      controllers: [ScheduleController],
    })
    export class ScheduleModule {}
javascript
上一页
下一页