小编jed*_*rds的帖子

我尝试解决这个问题Flip-coin没有任何争论,并以相同的概率随机返回符号的头部或尾部.这就是我得到的,但我不明白为什么它会给我"不可能"这可以停止吗？

(define flip-coin
    (lambda ( )
        (cond
            [ (= (random 2 ) 1 ) "heads" ]
            [ (= (random 2 ) 0 ) "tails" ]
            [else "impossible" ]
        )
    )
)

我正在寻找一种方法来定义一个"基础"构造函数,它将使用默认值初始化值,然后将该基础扩展为许多专门的构造函数.

我想要的伪代码可能是这样的:

class Foo{
private:
    int val;
    /* ... */

public:
    // Base constructor
    Foo(){ /*...*/ }           // This provides basic initialization of members

    // Named constructors
    static Foo fromString(string s){
        Foo f;                 // Call base constructor
        f.val = s.length();    // Customize base object
        return f;              // Return customized object
    }
    static Foo fromInt(int v){
        Foo f;
        f.val = v;
        return f;
    }
}

起初,我考虑延长临时的生命周期f,但const声明阻止我编辑其成员.所以看来这已经结束了.

然后我尝试了"命名构造函数"方法(如上所示).但是,我必须先修改示例以创建对象,然后修改它,然后返回它.这似乎有效,但我有理由相信它只是一个巧合,因为它f是一个临时的,并且在函数结束时超出了范围.

我也考虑使用像auto_ptrs 这样的东西,但是我正在使用Foo对象以及auto_ptrs到Foo,这使得其余的代码"关心"对象是否通过基础构造函数创建(在这种情况下)它将是一个对象)或通过一个扩展构造函数(在这种情况下它将是一个指针).

如果它有用,在Python中,我会使用这样的东西: …

请考虑以下示例情况:

public abstract class Parent
{
    private ByteBuffer buffer;

    /* Some default method implementations, interacting with buffer */

    public static Parent allocate(int len)
    {
        // I want to provide a default implementation of this -- something like:
        Parent p = new Parent();
        p.buffer = ByteBuffer.allocate(len);
        return p;
    }
}

public class Child extends Parent
{
    /* ... */
}

public class App
{
    public static void main(String[] args)
    {
        // I want to ultimately do something like:
        Child c = …

该线程是先前版本的扩展，可以在此处找到。说，我有一个用于两个目的的代码：1）从整数列表中打印一个最大数；2）新建一个目录。

import argparse
import os

parser = argparse.ArgumentParser()
parser.add_argument('integers', metavar='N', type=int, nargs='+',
                    help='an integer for the accumulator')

parser.add_argument('--sum', dest='accumulate', action='store_const',
                    const=sum, default=sum,
                    help='sum the integers (default: find the max)')

parser.add_argument("--output_dir", type=str, default="data/xx")

def main(args):
    os.makedirs(args.output_dir)
    print args.accumulate(args.integers)

if __name__=='__main__':
    args = parser.parse_args()  # Disable during debugging @ Run through terminal
    # args = argparse.Namespace(integers = 1, output_dir= 'mydata_223ss32')  # Disable when run through terminal: For debugging process
    main(args)

这些语句可以从终端执行

python test_file.py --output_dir data/xxxx 2 2 5 --sum

但是，对于调试过程，我想跳过终端的用法。从 …

我有一个包含一些二进制数据的文本文件.当我使用Python 3读取文件时,在文本模式下,我得到一个UniCodeDecodeError(编解码器不能解码字节...),代码如下:

fo = open('myfile.txt, 'r')
for line in inFile:

如何从文件中删除二进制数据.我有一个在每个二进制数据之前打印的标题(在这种情况下,它显示为数据块).例如,我的文件看起来像我要删除çºí？¼È×"ñdí:

myfile.txt文件:

ABCDEFGH
123456
Data Block 11
çºí?¼Èדñdí
XYZ123

我想要的结果是myfile.txt看起来像这样:

ABCDEFGH
123456
Data Block 11
XYZ123

考虑以下类:

class Coord
{
public:
    double _x, _y;

    Coord(double x, double y)
    {
        _x = x;
        _y = y;
    }
};

class NamedPoint : public Coord
{
public:
    int _id;

    NamedPoint(int id, double x, double y) :
        Coord(x,y),
        _id(id)
    {
    }
};

我想创建NamedPoint的成员函数--coord() - 返回与NamedPoint对应的Coord类型的引用.

例如,我想要像:

const Coord& NamedPoint::coord()
{
    return ((Coord)*this);
}

但我收到关于临时变量的警告,我并不为此感到高兴.

当然,以下工作:

Coord coord()
{
    Coord c = *this;
    return c;
}

但我宁愿返回一个参考.

有没有人知道使用继承类是否可行？

很抱歉没有解释该功能的要点.我为Coord和NamedPoint以不同的方式重载了==运算符.Coord只需检查{x,y},NamedPoint将检查{id,x,y}.如果我忘记在此==测试之前将一个NamedPoint强制转换为Coord,我将使用错误的版本.

所以,虽然我意识到这一点

(Coord)np1 == (Coord)np2 

会给我我想要的东西,我宁愿用类似的东西

np1.coord() == np2.coord()

我认为更清楚的是发生了什么.

学习python,找到了这段代码.它从标准输入读取文本,并在完成时打印"完成".我从来没有见过任何其他语言else的while循环.我发现这个网站上的评论说这是一种类似于finally一段时间循环的pythonic方式.

import sys
while True:
    line = sys.stdin.readline()
    if not line:
        break
else:
    print("Done");

问题是,这是pythonic吗？我工作的地方有一个非常严格的pep-8合规政策,所以我需要知道这是否合适.

关于Java同步,我尝试(从TLF-SOFT-VTC.java.6CFE)的例子,但事实证明错了,为什么没有同步？代码 :

public class InterferenceFix extends Thread {
    String name;
    static boolean isZero = true;
    static int counter = 0;

    public static void main(String arg[]) {
        InterferenceFix one = new InterferenceFix("one");
        InterferenceFix two = new InterferenceFix("two");
        one.start();
        two.start();
    }

    InterferenceFix(String nameString) {
        name = nameString;
    }

    public void run() {
        for (int i = 0; i < 100000; i++) {
            update();
        }
        System.out.println(name + ": " + counter);
    }

    synchronized void update() {
        if (isZero) {
            isZero = false;
            counter++; …

例如，

print(binary_search(7, [1, 5, 10])) # 2 
print(binary_search(42, (-5, 1, 3, 5, 7, 10))) # 6

我的代码：

def binary_search(x, seq):
    if len(seq) == 0
    low = 0
    high = len(seq)
    mid = (low+high)//2
    if x == seq[mid]:
       return mid
    elif x < seq[mid]:
         return binary_search(x,seq[:mid])
    elif x > seq[mid]:
         return mid + 1 + binary_search(x,seq[mid+1:]