给定一组16个字母和一个英文字典文件,需要找到一个解决方案,其中这16个字母可以放入4x4网格中,以便可以在每行和每列下读取有效字.
我目前的解决方案
1)获取可以用这些字母(anagram generator)制作的所有可能的4个字母单词的列表,并将它们分配给数组.
2)循环遍历每个单词,在每一行中尝试它,同时检查每个单词的正确数量是否被使用.
3)检查anagram数组中是否存在每列中创建的单词.
逻辑工作,但它已经运行了一个多小时,我在400多个字谜阵列的200字.有什么建议？
namespace GridWords
{
class Program
{
static void Main(string[] args)
{
string[] words = new string[] { "zoon", "zonk", "zone", "zona", "zoea", "zobo", "zero", "zerk", "zeal", "zack", "rore", "roon", "rook", "rood", "rone", "role", "roke", "roed", "rode", "rock", "roch", "robe", "roar", "roan", "road", "rhea", "rend", "redo", "reck", "rear", "rean", "real", "reak", "read", "raze", "rare", "rank", "rand", "rana", "rale", "rake", "rade", "rack", "rach", "race", "raca", "orzo", "orra", "orle", "ordo", "orca", "oral", "orad", "ooze", "oner", "once", …如果我有以下功能:
for(i=0;i<n;i++)
for(j=0;j<i*i;j++)
for(k=0;k<j;k++)
System.out.println(k);
请问big O这个功能是n^5从具有:
n*((n-1)^2)*((n-1)^2)-1？
我刚刚阅读了这篇文章,并想知道我们是否可以得出这样的结论:无论代码在嵌套循环中的代码是什么,小循环中的大循环必须总是比大循环中的小循环运行得更快？举个例子.
int m, n;
m = 1000000;
n = 10;
片段A.
for (int i = 0; i < n; i++)
for (int j=0; j < m; j++)
{
DoSomething();
}
代码片段B.
for (int j = 0; j < m; j++)
for (int i=0; i < n; i++)
{
DoSomething();
}
我们可以这样说,无论DoSomething()实际上做了什么,片段A总是比片段B运行得更快吗？
更新
正如@stackmate所指出的,我想将这个问题扩展为两个
当嵌套循环中的代码是DoSomething()时,这意味着DoSomething()与变量i和j无关.性能差异是什么？
当嵌套循环中的代码是DoSomething(i,j)时,这意味着DoSomething(i,j)与变量i和j具有关联性.性能差异是什么？
我的项目终于完成了,但我唯一的问题是我的老师不接受我们代码中的"中断".有人可以帮我解决这个问题,我已经做了好几天了,我似乎无法让程序在不使用它们的情况下工作.中断位于我的DropYellowDisk和DropRedDisk方法中.除了那个问题,我的连接四个程序是完美无缺的.
private static void DropYellowDisk(String[][] grid) {
int number = 0;
Scanner keyboard = new Scanner (System.in);
System.out.println("Drop a yellow disk at column (1–7): ");
int c = 2*keyboard.nextInt()+1;
for (int i=6;i>=0;i--)
{
if (grid[i][c] == " ")
{
grid[i][c] = "Y";
break;
}}
}
private static void DropRedDisk(String[][] grid) {
Scanner keyboard = new Scanner (System.in);
System.out.print("Drop a red disk at column (1–7): ");
int c = 2*keyboard.nextInt()+1;
for (int i =6;i>=0;i--)
{
if (grid[i][c] == " ")
{ …我正在尝试编写一个程序,以均匀(或尽可能接近)分布关于球体表面的点.我试图通过在单位球体上随机放置N个点,然后运行多个步骤,其中点相互排斥来实现此目的.
问题出在点数组的循环中.下面的代码在每个点上循环,然后在其中循环,再次遍历每个点并计算每个点对之间的排斥力.
for point in points.iter_mut() {
point.movement = Quaternion::identity();
for neighbour in &points {
if neighbour.id == point.id {
continue;
}
let angle = point.pos.angle(&neighbour.pos);
let axis = point.pos.cross(&neighbour.pos);
let force = -(1.0/(angle*angle)) * update_amt;
point.movement = point.movement * Quaternion::angle_axis(angle, axis);
}
}
我收到错误:
src/main.rs:71:27: 71:33 error: cannot borrow `points` as immutable because it is also borrowed as mutable
src/main.rs:71 for neighbour in &points {
和解释
the mutable borrow prevents subsequent moves, borrows, or modification of `points` until the …我有一个对象数组,以及一个特定方法的可接受返回值数组.如何将对象数组减少到只有那些方法在我的可接受值数组中返回值的对象？
现在,我有这个:
my @allowed = grep {
my $object = $_;
my $returned = $object->method;
grep {
my $value = $_;
$value eq $returned;
} @acceptableValues;
} @objects;
问题是这是一个复合循环,我想避免.该程序旨在扩展到任意大小,我想最小化运行的迭代次数.
最好的方法是什么？
我正在尝试编写一个嵌套循环代码来模拟具有 101 行的数据框中的 10 列数据。第一行数据已被指定为起始值。每列应该不同，因为我的矩阵 r 是从随机法线生成的；但是，每列中的结果值完全相同。为循环索引提供一些上下文：
tmax=100; ncol(pop_sims) = 12 (so a total of 10 iterations, 3-12); ncol(r) = 10
for (i in 1:tmax){
for (j in 3:ncol(pop_sims)){
for(k in 1:ncol(r)){
if (pop_sims[i,j]*exp(r[i,k]) <2) {
pop_sims[i+1,j]<- 0}
else {
pop_sims[i+1,j] <- pop_sims[i,j]*exp(r[i,k])}
}}}
任何想法将不胜感激。
更新：我没有使用多个循环，而是省略了矩阵 r 的使用并简化了我的循环。
for (i in 1:tmax){
for (j in 1:10){
if (pop_sims[i,j]*exp(r[i,j]) <2) {
pop_sims[i+1,j]<- 0}
else {
pop_sims[i+1,j] <- pop_sims[i,j]*exp(rnorm(1,mean=0.02, sd=0.1))}
}}
我已经阅读了所有的论点:告诉SQL你想要什么,而不是如何得到它.使用基于集合的方法而不是程序逻辑.不惜一切代价避免使用游标和循环.
不幸的是,我已经绞尽脑汁几周了,我无法弄清楚如何提出一种基于集合的方法来COUNT为按顺序排列的时间顺序数据子集生成迭代.
以下是我正在处理的问题的具体应用.
我使用包含多年播放数据的数据库进行与足球相关的研究,该数据当然按时间顺序按年,游戏和比赛排列.数据库加载到运行MySQL 5.0的Web服务器上.
core表格中包含了我对此特定问题所需的字段.以下是表格相关部分的一些示例数据:
GID | PID | OFF | DEF | QTR | MIN | SEC | PTSO | PTSD
--------------------------------------------------------
121 | 2455 | ARI | CHI | 2 | 4 | 30 | 17 | 10
121 | 2456 | ARI | CHI | 2 | 4 | 15 | 17 | 10
121 | 2457 | ARI | CHI | 2 | 3 | 53 | 17 | 10
121 | …我有一个 csv 文件，其中包含大约 50K 行搜索引擎查询。一些搜索查询是相同的，只是词序不同，例如“查询 A 这是”和“这是查询 A”。
我已经测试过使用 fuzzywuzzy 的 token_sort_ratio 函数来查找匹配的词序查询，效果很好，但是我正在努力解决嵌套循环的运行时问题，并寻找优化技巧。
目前，嵌套 for 循环在我的机器上运行大约需要 60 小时。有谁知道我如何加快速度？
代码如下：
from fuzzywuzzy import fuzz
from fuzzywuzzy import process
import pandas as pd
from tqdm import tqdm
filePath = '/content/queries.csv'
df = pd.read_csv(filePath)
table1 = df['keyword'].to_list()
table2 = df['keyword'].to_list()
data = []
for kw_t1 in tqdm(table1):
for kw_t2 in table2:
score = fuzz.token_sort_ratio(kw_t1,kw_t2)
if score == 100 and kw_t1 != kw_t2:
data +=[[kw_t1, kw_t2, score]]
data_df = pd.DataFrame(data, columns=['query', 'queryComparison', 'score'])
任何意见，将不胜感激。 …