小编Lir*_*una的帖子

挑战

按字符排序的最短代码从给定的数字卡列表中输出最佳案例的二十一点手.

输入是由空格分隔的1到10(含)之间的数字列表.

输出将是从该卡片列表中形成的最佳二十一点手 - 最接近的可用组合,通过所有卡值的总和达到21而不超过它.卡可以删除但不能添加.

如果需要移除两张或多张卡以支持一张卡以获得相同结果(移除5或4,1以获得21),则移除最少的卡.如果要移除相同数量的卡(移除1,4或3,2),将删除具有最小值的组(在前面的示例中,1,4将被移除为min(min(3,2), min(1,4))属于该对).在重复卡的情况下,应该删除第一次遭遇.

输出将形成为钻石卡,输入顺序保留:

 __________  __________ 
|          ||          |
|          || /\       |
|          || \/       |
|    /\    ||          |
|    \/    ||          |
|          ||       /\ |
|          ||       \/ |
|__________||__________|
 __________  __________ 
|          ||          |
| /\       || /\    /\ |
| \/       || \/    \/ |
|    /\    ||          |
|    \/    ||          |
|       /\ || /\    /\ |
|       \/ || \/    \/ |
|__________||__________|
 __________ …

挑战

最短的代码按字符计数来解决输入灯输出板.

灯光输出板是一个不同大小的2d方形网格,由两个字符组成 - .用于关闭*的灯光和打开的灯光.

要解决电路板,必须关闭所有"灯".切换灯(即打开时关闭,关闭时打开)一次点亮5个灯 - 选择灯并且灯以+(加号)形状包围."选择"中间灯会解决问题:

.*.
***
.*.

自熄灯!解决方案顺序无关紧要,输出将是一个新的电路板,在选择的灯泡上有标记.上面板的解决方案是

...
.X.
...

关闭没有侧灯关闭的角落的灯不会溢出:

...
..*
.**

在这种情况下,选择右下灯泡只会关闭3个灯泡.

测试用例

Input:
    **.**
    *.*.*
    .***.
    *.*.*
    **.**
Output:
    X...X
    .....
    ..X..
    .....
    X...X

Input:
    .*.*.
    **.**
    .*.*.
    *.*.*
    *.*.*
Output:
    .....
    .X.X.
    .....
    .....
    X.X.X

Input:
    *...*
    **.**
    ..*..
    *.*..
    *.**.
Output:
    X.X.X
    ..X.. 
    .....
    .....
    X.X..

代码计数包括输入/​​输出(即完整程序).

挑战

按字符计算的最短代码根据输入输出钻石图案.

输入由3个正数组成,表示菱形的大小和网格的大小.

钻石由ASCII字符/和\空格组成.1号钻石是:

/\
\/

网格的大小由钻石数量的宽度和高度组成.

测试用例

Input:
    1 6 2
Output:
    /\/\/\/\/\/\
    \/\/\/\/\/\/
    /\/\/\/\/\/\
    \/\/\/\/\/\/

Input: 
    2 2 2
Output:
     /\  /\ 
    /  \/  \
    \  /\  /
     \/  \/ 
     /\  /\ 
    /  \/  \
    \  /\  /
     \/  \/ 

Input 
    4 3 1
Output:
       /\      /\      /\   
      /  \    /  \    /  \
     /    \  /    \  /    \
    /      \/      \/      \
    \      /\      /\      /
     \    /  \    /  \    / …

using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            var a = new Derived();
            int x = 123;
            a.Foo(x);
        }
    }

    public class Base
    {
        public virtual void Foo(int x)
        {
            Console.WriteLine("Base::Foo");
        }
    }

    public class Derived : Base
    {
        public override void Foo(int x)
        {
            Console.WriteLine("Derived::Foo(int x)");
        }

        public void Foo(object o)
        {
            Console.WriteLine("Derived::Foo(object o)");
        }
    }
}

结果:"Derived :: Foo(object o)"

为什么？？？

我正在寻找最便携的汇编程序库,如asmjit或jitasm.

当我说'最便携'时,我的意思是,它对大量架构的支持最多.语言并不重要,但C++将是最好的解决方案,尤其是与GCC结合使用时.

对我来说重要的架构是x86/64,PowerPC和ARM.

我的公司拥有大约30个网站,它们共享相同的代码库并重复使用许多相同的图像.现在,所有站点的图像都托管在一个域上,然后每个其他站点都必须链接到这些图像.

即www.example.com/images/hello.jpg

在www.example2.com上我们有类似的东西: <img src="http://www.example.com/images/hello.jpg" />

最近有人告诉我,我应该将所有这些共享/静态图像放在子域上,但我没有看到它的优点.我听说可能会有轻微的速度提升,但我也听说它会让事情复杂化.有人可以详细说明吗？

我试图找出类型的自引用如何与python3的类型注释一起工作 - 文档没有指定任何关于此的内容.

举个例子:

from typing import TypeVar, Optional, Generic

T = TypeVar('T')
class Node(Generic[T]):
    left = None
    right = None
    value = None

    def __init__(
        self, value: Optional[T],
        left: Optional[Node[T]]=None,
        right: Optional[Node[T]]=None,
    ) -> None:
        self.value = value
        self.left = left
        self.right = right

此代码生成错误:

Traceback (most recent call last):
  File "node.py", line 4, in <module>
    class Node(Generic[T]):
  File "node.py", line 12, in Node
    right: Optional[Node[T]]=None,
NameError: name 'Node' is not defined

这是使用Python 3.5.1

想象一下以下数据库:

表'公司'有字段ID,名称和flagship_product_id.表'产品'包含字段id,name和company_id.

公司必须拥有旗舰产品(1:1关系),所有产品都有一家公司(1:N关系).

当使用MyISM等存储引擎时,上述情况应该没有任何问题,但是当使用InnoDB之类的引擎时,在插入新数据时会出现问题.

除了允许初始INSERT的NULL关系外,有什么好的解决方案？

总而言之,A公司必须拥有一个旗舰产品.

我正在尝试编写一个简单的粒子系统,利用CUDA来更新粒子位置.现在我定义一个粒子有一个对象,其位置定义有三个浮点值,一个速度也定义了三个浮点值.更新粒子时,我在速度的Y分量上添加一个常数值来模拟重力,然后将速度加到当前位置以得出新位置.在内存管理方面,最好是维护两个独立的浮点数组来存储数据或以面向对象的方式构造.像这样的东西:

struct Vector
{
    float x, y, z;
};

struct Particle
{
    Vector position;
    Vector velocity;
};

看起来两种方法的数据大小相同(每个浮点数4个字节,每个向量3个浮点数,每个粒子2个向量,总计24个字节)似乎OO方法可以在CPU和CPU之间实现更高效的数据传输. GPU,因为我可以使用单个Memory复制语句而不是2(并且从长远来看更多,因为有一些关于将变得相关的粒子的其他信息,如年龄,寿命,重量/质量,温度等)然后还有代码的简单可读性和易于处理它也使我倾向于OO方法.但我见过的例子并没有使用结构化数据,因此我想知道是否有理由.

所以问题是哪个更好:单个数据数组或结构化对象？

我正在寻找一种便携式方式来接收(方便)$_SERVER['PATH_INFO']变量.

看了一会儿后,结果发现PATH_INFO是CGI/1.1,而且并不总是出现在所有配置中.

获得该变量的最佳方式(主要是安全方式)是什么 - 除了手动提取它(安全问题).