小编Kha*_*d.K的帖子

我正在尝试在Django 1.2中使用local_setting ,但它对我不起作用.目前我只是将local_settings.py添加到我的项目中.

settings.py

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql', # Add 'postgresql_psycopg2', 'postgresql', 'mysql', 'sqlite3' or 'oracle'.
        'NAME': 'banco1',                      # Or path to database file if using sqlite3.
        'USER': 'root',                      # Not used with sqlite3.
        'PASSWORD': '123',                  # Not used with sqlite3.
        'HOST': 'localhost',                      # Set to empty string for localhost. Not used with sqlite3.
        'PORT': '',                      # Set to empty string for default. Not used with sqlite3.
    }
}

local_settings.py

DATABASES = { …

我编写了一个用于测试目的的小型Java应用程序,它可以在ubuntu 12.04上从混音器中捕获声音.

代码工作正常,我可以从所有应用程序捕获声音,除了在Wine下运行的任何东西.

每当我启动我的程序时,在启动Wine之后,呼叫targetDataLine.read()将永远阻止

当Wine没有在后台运行时,它会0在没有输入时正确输出,或者如果有输入则读取字节数,如预期的那样.

如果我在启动Wine之前启动我的程序,那么声音驱动程序将无法在wine中使用.

我尝试过使用Alsa提供的混音器以及默认设备,结果相同.

我可以想象葡萄酒会以某种方式锁定Alsa(无论出于何种原因),但为什么一个简单的调用会TargetDataLine.read()导致Wine中的声音失败？ mixerInfo[0]在我的系统btw上是默认的,并且应用程序当然总是使用oracle的最新JRE(7)在Wine之外运行.

private void readSound ()
{
    byte tempBuffer[] = new byte[10000];
    int cnt = 0;
    Mixer.Info[] mixerInfo = AudioSystem.getMixerInfo();

    System.out.println("Available mixers:");
    for (int p = 0; p < mixerInfo.length; p++)
        System.out.println(mixerInfo[p].getName());

    format = getAudioFormat();
    DataLine.Info dataLineInfo = new DataLine.Info(TargetDataLine.class, format);
    Mixer mixer = AudioSystem.getMixer(mixerInfo[0]);

    try
    {
         targetDataLine = (TargetDataLine) mixer.getLine(dataLineInfo);
         targetDataLine.open(format);
    }
    catch(Exception e)
    {
        e.printStackTrace();
    }
    targetDataLine.start();

    while (true)
    {
        i++;
        cnt = targetDataLine.read(tempBuffer, …

我正在寻找一种方法,从节点和度数的所有强连接有向图(没有自循环)的空间均匀地采样.nk=(k_1,...,k_n), 1 <= k_i <= n-1

输入

• n,节点数量
• k = (k_1,...,k_n),其中k_i =进入节点的有向边数i(度数)

产量

• 具有n给定度数的节点(没有自循环)的强连接有向图,k_1,...,k_n其中每个可能的这样的图以相同的概率返回.

我特别感兴趣的n是大而k_i小的情况,因此简单地创建图形并检查强连通性是不可行的,因为概率基本上为零.

我浏览了各种各样的论文和方法,但找不到任何可以解决这个问题的方法.

我有一组具有订单关系的元素(可能很大):

[a,b,c,d,e,f] 

和一组带有id的频繁模式(可能很大):

[a]:1,[b]:2,[c]:3,[a,b]:4,[b,c]:5,[a,b,c]:6

我有一系列有序集:

[a,b], [e], [c], [e,f], [a,b,c]

我想将序列中的每个集合与相应模式的ID匹配:

[a,b]:{1,2,4}, [e]:{}, [c]:{3}, [a,b,c]:{1,2,3,4,5,6}

我的目标是限制序列上的传递次数,因此我想构建一个我可以在扫描期间使用的数据结构.我在想一个前缀树:

??null
   ???a : 1
   |  |
   |  ???b : 4
   |     |
   |     ???c : { 5, 6 }
   |
   ???b : 2
   |  |
   |  ???c : 5
   |
   ???c : 3

我扫描序列中的一个集合,并通过递归多次传递它(set,set.tail,set.tail.tail ...),每当我到达一个节点时,我将相应的id添加到数组中.

我是否会错过我的推理中的任何特殊情况(只是意识到depth>2如果我不想错过[a,c]如果[a,b,c]存在于集合中,我必须为节点添加多个id )？我可以使用更复杂的数据结构来改善处理时间吗？

编辑:事实上在深度n,我需要2^(n-2)用我的方法的id(考虑到我的树是密集的).我不确定这是一个有效的方法......

Edit2:另一种合并序列中每个元素的位图以构建每个模式的方法(如SPADE算法中所使用的).

a  : [1,0,0,0,1]
b  : [0,1,0,0,1]
ab : [0,0,0,0,1]

通过一些数组操作,我应该能够将它与我的初始数组的元素相匹配.

我试图找出谷歌趋势背后的系统设计(或任何其他像Twitter这样的大规模趋势功能).

挑战:

• 需要处理大量数据来计算趋势.

• 过滤支持 - 按时间,地区,类别等

• 需要一种存储进行存档/离线处理的方法.过滤支持可能需要多维存储.

这就是我的假设(我对MapReduce/NoSQL技术没有实际经验)

来自用户的每个搜索项将维护将被存储并最终处理的一组属性.

以及按时间戳,搜索区域,类别等维护搜索列表.

例:

搜索Kurt Cobain术语:

Kurt-> (Time stamp, Region of search origin, category ,etc.)

Cobain-> (Time stamp, Region of search origin, category ,etc.)

题:

• 他们如何有效地计算搜索词的频率？

• 换句话说,给定一个大型数据集,他们如何以分布式可扩展方式找到前10个频繁项目？

我建立了一个/parent/project由Mercurial管理的PyCharm项目/parent/project/.hg.独立于此项目,/parent由Git at管理/parent/.git.

不幸的是,这导致PyCharm抱怨:"检测到未注册的Git root:目录/父目录在Git下,但未在设置中注册."

什么是干净的解决方案？理想情况下,我希望PyCharm简单地忽略项目目录本身上方目录中的任何存储库.

我有一个由直线段定义的形状.

我想简化用直线构造的形状,但只有一组有限的斜率.

我想尽量减少使用的段数,并尽量减少区域与前后形状的差异.

我想用用户定义的重量同时最小化这两件事,强调最小化另一个.

minimize { J = w1(number of segments/length) + w2(difference area/length) }

当w1和w2均为重量和长度是新段的长度.我想要一个算法来做到这一点.有任何想法吗？

下面我展示一些我可能希望它如何工作的图片.文献中是否有任何可能有助于编写算法的内容.谢谢!

请考虑以下代码段:

if (foo != null
 && foo.bar != null
 && foo.bar.boo != null
 && foo.bar.boo.far != null)
{
    doSomething (foo.bar.boo.far);
}

我的问题很简单:是否有更简单\更短的方法来做到这一点？

详细说明:有没有更简单的方法来验证链的每个部分,我想像这样的..

if (validate("foo.bar.boo.far"))
{
    doSomething (foo.bar.boo.far);
}

给定一个整数的数组arr [],找出任何两个元素之间的差异,使得较大的元素出现在arr []中较小的数字之后.

Max Difference = Max { arr[x] - arr[y] | x > y }

例子:

• 如果[2, 3, 10, 6, 4, 8, 1, 7]返回数组,则值应为8(10和2之间的差值).

• 如果[ 7, 9, 5, 6, 3, 2 ]返回数组,则值应为2(7到9之间的差异)

我的算法:

我想过使用D&C算法.说明

2, 3, 10, 6, 4, 8, 1, 7

then

2,3,10,6      and     4,8,1,7

then

2,3  and 10,6  and  4,8 and 1,7

then

2 and 3   10 and 6   4 and 8    1 and 7

在这里,因为这些元素将保持相同的顺序,我将得到最大的差异,这里是6.

现在我将回到merege这些数组并再次找到第一个块的最小值和第二个块的最大值之间的差异,并继续这样做直到结束.

我无法在我的代码中实现这一点.任何人都可以为此提供伪代码吗？

我们正在尝试解决处理大量 Http POST 请求的问题，而在使用 Netty Server 时，我只能处理~50K requests/sec太低的请求。

我的问题是如何调整此服务器以确保处理> 1.5 million requests/second？

Netty4 服务器

// Configure the server.
EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
        ServerBootstrap b = new ServerBootstrap();
        b.option(ChannelOption.SO_BACKLOG, 1024);

        b.group(bossGroup, workerGroup)
         .channel(NioServerSocketChannel.class)
         .handler(new LoggingHandler(LogLevel.INFO))
         .childHandler(new HttpServerInitializer(sslCtx));

        Channel ch = b.bind(PORT).sync().channel();

        System.err.println("Open your web browser and navigate to " +
                (SSL? "https" : "http") + "://127.0.0.1:" + PORT + '/');

        ch.closeFuture().sync();
    } finally {
        bossGroup.shutdownGracefully();
        workerGroup.shutdownGracefully();
    }

初始化程序

    public …

我很困惑解决这个时间复杂性问题.

T(n) = T(n-1)

我知道快速排序最糟糕的情况 T(n) = T(n-1) + T(1) + n

评估为(n-1) + (n-2) + (n-3) + ... + 1&此几何序列等于O(n^2)

然而.我看到stackoverflow上的答案T(n) = T(n-1) + c = O(n).

当这也等于时(n-1) + (n-2) + (n-3) + ... + 1,这怎么可能呢？O(n^2)

有人可以解释一下.

描述:
给定两个排序的数组(非下降),在T = O(lg(m + n))中找到Kth min元素,m和n分别是两个数组的长度.

问题:
不了解下面的算法大约有三点:

• 当A [aPartitionIndex] <B [bPartitionIndex]时,为什么我们可以直接丢弃A的左边部分？
• 为什么不能同时丢弃A的左侧部分和B的右侧部分？
• 一些"资源"说这个算法可以应用于在N个排序数组中找到Kth min,怎么样？将k分成N个部分？

代码: Java.解决方案:二进制搜索.

    // k is based on 1, not 0.
    public int findKthMin(int[] A, int as, int ae, 
                           int[] B, int bs, int be, int k) {

        int aLen = ae - as + 1;
        int bLen = be - bs + 1;

        // Guarantee the first array's size is smaller than the second one,
        // which is convenient to remaining part …