标签: optimization

Python noob在这里,我只是想知道是否有人可以帮助我减少这个脚本.

我试过了:

if letter == 'A' or 'B' or 'C' 但它似乎没有用.

因此,如果字母是A,B或C打印"Hello"
或者如果字母是D,E或F打印再见.

任何帮助都会很棒.

干杯

if letter == 'A':
    print "Hello"
if letter == 'B':
    print "Hello"
if letter == 'C':
    print "Hello"              
if letter == 'D':
    print "GoodBye"
if letter == 'E':
    print "GoodBye"       
if letter == 'F':
    print "GoodBye"

我是一名新手程序员,我正在用Java编写我的第一个游戏,我刚刚实现了一个目标AI,现在每当我运行它时,总是滞后于开始,我想解释为什么请或者某种方法这个更好,谢谢你提前.

代码:(对于最可能造成滞后的因素)

public class Handler {
//Use Linked Lists
private Animator a;
private boolean renderMini;
private int x, y;
public LinkedList<GameObject> object = new LinkedList<GameObject>();
public LinkedList<EntityObject> entity = new LinkedList<EntityObject>();
public LinkedList<Faction> faction = new LinkedList<Faction>();

public Handler(){
    a = new Animator();
    this.renderMini = false;
}

public void render(Graphics g){
    ///if(GameMain.numFrames > 5){
        if(renderMini){
            a.AnimateMini(g, x, y, 32, 32);
        }
        for(int i = 0; i < entity.size(); i++){
            EntityObject tempObject = entity.get(i);

            tempObject.render(g);
        }

        for(int i = 0; i …

当我对某些查询执行explain analyze时,我已经从一些低值到一些更高的值获得了正常的成本.但是当我试图通过将enable_seqscan切换为false来强制使用表上的索引时,查询成本会跳转到疯狂的值,如:

Merge Join  (cost=10064648609.460..10088218360.810 rows=564249 width=21) (actual time=341699.323..370702.969 rows=3875328 loops=1)
    Merge Cond: ((foxtrot.two = ((five_hotel.two)::numeric)) AND (foxtrot.alpha_two07 = ((five_hotel.alpha_two07)::numeric)))
  ->  Merge Append  (cost=10000000000.580..10023064799.260 rows=23522481 width=24) (actual time=0.049..19455.320 rows=23522755 loops=1)
          Sort Key: foxtrot.two, foxtrot.alpha_two07
        ->  Sort  (cost=10000000000.010..10000000000.010 rows=1 width=76) (actual time=0.005..0.005 rows=0 loops=1)
                Sort Key: foxtrot.two, foxtrot.alpha_two07
                Sort Method: quicksort  Memory: 25kB
              ->  Seq Scan on foxtrot  (cost=10000000000.000..10000000000.000 rows=1 width=76) (actual time=0.001..0.001 rows=0 loops=1)
                      Filter: (kilo_sierra_oscar = 'oscar'::date)
        ->  Index Scan using alpha_five on five_uniform  (cost=0.560..22770768.220 rows=23522480 width=24) (actual time=0.043..17454.619 …

我正在使用GCC 4.8.1.我试图通过将其放入嵌套循环来对某些代码的速度进行基准测试,如下例所示.每当我这样做时,它会在最短的时间内(如.02秒)执行,使用-03或不进行任何优化,无论有多少次迭代.有什么理由吗？我确信它工作正常,因为值总是正确的,如果我printf在循环中使用,那么它会按预期运行.

int main()
{
    int i,j,k;
    int var;
    int big_num = 1000000;
    int x[1];

    for (i = 0;i<big_num;++i){
        for (j = 0;j<big_num;++j){
            for (k = 0;k<big_num;++k){
               // any short code fragment such as:
               var = i - j + k; 
               x[0] = var;
            }
        }
    }
    return 0;
}

我编写了一个C++例程来查找排序数组中最近的double元素.有没有办法加快？

reversed如果reversed按降序排序,则有两个基于boolean值的分支.

 void findNearestNeighbourIndex_new(real_T value, real_T* x, int_T x_size, int_T& l_idx)
{
    l_idx = -1;

    bool reversed= (x[1] - x[0] < 0);

    if ((!reversed&& value <= x[0]) 
                  || (reversed&& value >= x[0])){ 
        // Value is before first position in x
        l_idx = 0;
    }
    else if ((!reversed&& value >= x[x_size - 1]) 
                    || (reversed&& value <= x[x_size - 1])){ 
        // Value is after last position in x
        l_idx = x_size - 2;
    }
    else // All other …

我在http://droid.ly的网站加载非常慢!我该怎么办才能修复它？非常感谢任何和所有的帮助.

谢谢!

我的问题很简单.我有一个像这样的python简单代码:

for i in range(1,1193616,1) :
        print i

因此,将打印范围1中的所有数字,直到1193616,这个循环进度需要很长时间..如何使其快速？

编辑:

实际上,我尝试为图像数据(Raster)制作一个A-star寻路程序.到目前为止,这是我的A-star函数脚本:

def A_star(h,c,dx,dy,u,s_id,e_id,Op,Cl,Prt,CC,o,ht,w):
    Op.append(s_id) 
    while e_id not in Op : 
        if Op == [ ] :
            break
        candidate = { }
        for i in Op :
            d = {i : CC[i]}
            candidate.update(d)
        o = min(candidate, key=candidate.get)
        Cl.append(o)
        Op.remove(o)
        adjacent_list = adjacent_cell(o,dx,dy )
        for p in adjacent_list :
            if p in Cl:       
                adjacent_list = filter(lambda i: i != p, adjacent_list)    
            elif p not in Op :   
                Op.append(p)
                d = {p : …

假设我使用方法X跟随A类.我可以通过以下两种方式重载方法.

A{
  void X(foo p, bar q);
  void X(foo p, baq q);
}

A{
  void X(foo p, bar q);
  void X(baq q, foo p);
}

第二个实现是否应该首选,因为它需要更少的时间来解决并找到正确的功能？

如果需要进一步澄清,请与我们联系.

有没有办法缩短这段代码？它运作良好,但必须有一种方法,使它看起来更好.

#d=69+12*log(2)*(f/440)
#d is midi, f is frequency
import math
f=raw_input("Type the frequency to be converted to midi: ")
d=69+(12*math.log(float(f)/440))/(math.log(2))
d=round(d)

上部是转换器,下部区域是需要缩短的区域......

if d==127:
    print("G")
elif d==126:
    print("F#")
elif d==125:
    print("F")
elif d==124:
    print("E")
elif d==123:
    print("D#")
elif d==122:
    print("D")
elif d==121:
    print("C#")
elif d==120:
    print("C")
elif d==119:
    print("B")
elif d==118:
    print("A#")
elif d==117:
    print("A")
elif d==116:
    print("G#")
elif d==115:
    print("G")
elif d==114:
    print("F#")
elif d==113:
    print("F")
elif d==112:
    print("E")
elif d==111:
    print("D#")
elif d==110:
    print("D")
elif d==109:
    print("C#")
elif …

我正在研究Deep Neural Networks并且想知道以下问题:

为了获得最佳准确度,每层最佳层数和神经元数量是多少？

根据这张图片:

最佳数字是否等于要素大小,以便考虑每个要素对另一组要素的影响？

此外,如果我们寻求最佳的准确性和效率,答案会有所不同吗？

谢谢,任何见解表示赞赏!

编辑:

这些答案内容丰富.我仍然觉得他们没有特别提到我问题的第一部分.澄清:是否有最大量的神经元和层在应用时对数据同样精细,因此添加更多神经元或层将是多余的？我假设3个特征数据集的无限层在某些时候变得不必要.再次感谢所有阅读和回复!