标签: packing

我正在绊倒Gtk +教程和参考,试图了解如何完成一个体面的布局.文档说你应该使用GtkGrid而不是弃用的Box/HBox/VBox,但我无法GtkGrid扩展到完整的窗口大小.使用gtk_widget_set_hexpand对根本没有影响GtkGrid.

这个答案建议 "查看expand属性"但我无法找到有关这些属性实际是什么以及如何设置它们的信息(我只是假设每个属性总是有一个getter/setter对,但在这种情况下没有gtk_widget_set_expand功能).

我错过了什么？

更新:

设置展开属性仍然不起作用 - 按钮"粘贴"在窗口的左上角.这是代码:

static void initializeGui() {
    GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(window), "Blabla");
    gtk_window_set_default_size(GTK_WINDOW(window), 800, 500);
    gtk_window_set_hide_titlebar_when_maximized(GTK_WINDOW(window), TRUE);
    gtk_container_set_border_width(GTK_CONTAINER(window), 10);
    g_signal_connect(window, "delete-event", G_CALLBACK(onWindowDelete), NULL);
    g_signal_connect(window, "destroy", G_CALLBACK(onWindowDestroy), NULL);

    GtkWidget *mainbox = gtk_grid_new();
    g_object_set(G_OBJECT(mainbox), "expand", TRUE, NULL);
        GtkWidget *button = gtk_button_new_with_label("Short button");
        g_signal_connect(button, "clicked", G_CALLBACK(onButtonClick), NULL);
        gtk_grid_attach(GTK_GRID(mainbox), button, 0, 0, 1, 1);

        button = gtk_button_new_with_label("Very very long …

给定一组具有值的项目,确定要包括在集合中的每个项目的数量,使得总值小于或等于给定限制,并且总值尽可能大.

例:

Product A = 4
Product B = 3
Product C = 2
Product D = 5

If Total Capacity = 10.5 , then the combination of B,C,D will be selected.
If Total Capacity = 12.5 , then the combination of A,B,D will be selected.
If Total Capacity = 17 , then the combination of A,B,C,D will be selected.

我正在寻找一种算法(如背包或垃圾箱包装)来确定组合.任何帮助赞赏.

我正在开发一款游戏,我发现了一个问题,我必须解决这个问题来处理一个类似于包装问题的组件布局.

总结一下我需要做的事情,假设我有一个类似于下面的空间:

+------------+---------+------------+
| 0          | 1       | 2          |
|            |         |            |
|            |         |            |
|            |         |            |
+------------+---------+------------+
| 3          | 4       | 5          |
|            |         |            |
|            |         |            |
+------------+---------+------------+
| 6          | 7       | 8          |
|            |         |            |
|            |         |            |
|            |         |            |
+------------+---------+------------+

其中每个角单元为4x4,而中心单元为3x3(因此其余角单元为3x4和4x3).然后我有一组元素放在这些块中,可以从1x1到3x3不等(我认为还不需要任何4x4,但它不应该改变任何东西).当然,这些元素不能跨越线条,必须完全位于一个块内.

哪个可能是分配它们的最佳方式？如果没有必要,我宁愿不让它们全部粘在一起(例如,如果周围有足够的空间将它们分开,则不要将两个元素放在一起).我正在寻找一个简单的算法,也因为情况非常有限..

奖金问题:假设除了这9个(可能是其他3-4个)之外的其他区块我怎么能比新的区块优先考虑这些区块？(我的意思是在达到填充阈值之前不使用附加块)

当然我正在寻找一般的想法,没有实现:)

我对Tk和包装概念都很陌生,所以请耐心等待.这是我的代码:

from Tkinter import *

class frm_main:

    def __init__(self, parent):
        self.frame = Frame(parent, bg="green") #green for testing
        self.frame.pack(fill="both")

        self.canvas = Canvas(self.frame, bg="black", width=1000, height=700)
        self.canvas.pack(fill="both")

root = Tk()
main_frm = frm_main(root)
root.mainloop()

我已经尝试了几种不同的选项和测试,看起来框架和画布都是在x方向上锚定和扩展,但是在y方向上调整大小会留下一堆空白空间.

如何让Frame锚定到窗口的所有边,然后将画布锚定到我框架的所有边？我应该使用Frame吗？

由于打包,我想计算/总结一个目标文件的开销(理想情况下,让gcc最小化它).

例如,考虑以下结构(32位x86,gcc):

struct a { 
    uint8_t a_char;
    uint32_t an_integer
    uint8_t another_letter;
};

虽然实际数据只占用6个字节,但该结构在内存中占用12个字节,因为两个字符后跟3个填充字节.通过重新排序结构如下:

struct b { 
    uint32_t an_integer
    uint8_t a_char;
    uint8_t another_letter;
};

该结构只有sizeof(struct b)== 8(仍然是4字节的开销).

(1)理想情况下,我想gcc的重新排列struct a,以struct b救我的空间,但我的版本(4.2)似乎并没有任何优化级别做到这一点.

(2)或者,给定struct a,我想(自动)获得数量6(总开销量)或4(最小量的开销,如果成员被"理想地"订购).这样做的目的是确定手动重新排序结构是否值得花时间(可能不是).

有没有办法让gcc做(1),是否有一个工具可以执行(2)？我能想到的最接近的事情是(1)#pragma pack(1),但是(我猜)通过使大部分/全部内存访问不对齐,它会产生严重的性能影响.对于(2),我认为解析调试符号的Perl脚本可能能够做到这一点,但我对DWARF不太熟悉,无法确切知道.

我有一个数组,其中包含不同大小的材料列表:{4,3,4,1,7,8}.但是,垃圾箱可以容纳最大尺寸为10的材料.我需要找出包装阵列中所有元素所需的最小数量的垃圾箱.

对于上述阵列中,可以在3个箱包装和将它们划分如下:{4,4,1},{3,7},{8}.还有其他可能的安排也适合三个库存管道,但它不能用更少的

我试图通过递归来解决这个问题,以便更好地理解它.

我正在使用这个 DP配方(pdf文件的第20页)

考虑输入(n1; :::; nk),其中n =Σnj项
确定可以打包到单个bin中的k元组(输入的子集)的集合
即所有元组(q1; :::; qk)其中OPT(q1; :::; qk)= 1
用Q表示这个集合对于每个k元组q,我们有OPT(q)= 1
通过使用递归计算剩余值:OPT(i1; :: :; ik)= 1 + minOPT(i1 - q1; :::; ik - qk)

我已经制作了代码,它适用于小型数据集.但是如果将我的数组的大小增加到超过6个元素,它变得非常慢 - 解决包含8个元素的数组需要大约25秒你能告诉我算法是否有问题？我不需要替代解决方案--- 只需要知道为什么这么慢,以及如何改进它

这是我用C++编写的代码:

void recCutStock(Vector<int> & requests,  int numStocks)
{
 if (requests.size() == 0)
 {

     if(numStocks <= minSize)
    {
        minSize = numStocks;

    }
//   cout<<"GOT A RESULT : "<<numStocks<<endl;
        return ;
 }
 else
 {
    if(numStocks+1 < minSize) …

这是背包算法还是装箱算法？我找不到确切的解决方案，但基本上我有一个固定的矩形区域，我想用完美的正方形填充它，这些正方形代表我的物品，其中每个物品都有不同的重量，这会影响它们相对于其他物品的大小。

它们将从左上到右下从大到小排序。

另外，即使我需要完美的正方形，最终也允许一些非均匀缩放填充整个空间，只要它们仍然保留其相对面积，并且非均匀缩放是用尽可能少的量完成的。

我可以使用什么算法来实现这一目标？

我想将 3 个有符号的 4 位整数（4 位数据，1 位符号位）打包成一个 16 位整数，但我不知道该怎么做或从哪里开始:(

我需要用尽可能少的数据来表示 3D 网格中的位置（由于网格尺寸较大，它确实加起来了）。如果有帮助，我正在使用 GLM（OpenGL 数学库，因此我可以访问诸如glm::sign()）

如果可能的话，请给我的代码打包和解压。

谢谢

我需要为我正在处理的Ruby on Rails项目生成格式化的文本打包单.我正在考虑使用Ruport或者只是将自己格式化为字符串并将其输出到文本中.唯一的挑战是适当地证明所有输出.它需要看起来像这样,总是正确对齐.有什么建议？

Company Name
(T) 1-800-123-1234
(E) info@company.com

BILL TO: CUSTOMER NAME                   SHIP TO: CUSTOMER NAME
123 Some Street                          321 Some Street
Address etc.                             Address etc.

Date: 2010-03-12 16:30
Payment Number: 1234-123456

LN  NAME             SKU           DESCRIPTION             QTY    PRICE      TOTAL
----------------------------------------------------------------------------------
001 Product name     GUDB 012 HGQ  product description     2      52.99     105.98
         - Color

假设我有两个结构：object和widget：

struct object {
    int field;
    void *pointer;
};

struct widget {
    int field;
    void *pointer;
};

还有一个函数：

void consume(struct object *obj)
{
    printf("(%i, %p)\n", obj->field, obj->pointer);
}

我知道如果我尝试这样做：

struct widget wgt = {3, NULL};
consume(&wgt);

我会违反严格的别名规则，从而产生未定义的行为。

据我了解，未定义的行为是由于编译器可能以不同的方式对齐结构字段的事实造成的：也就是说，填充字段以与地址边界对齐（但永远不会更改字段顺序，因为保证遵守该顺序）标准）。

但是如果这两个结构被打包怎么办？它们具有相同的内存布局吗？或者，换句话说，上面的代码是否consume()仍然具有未定义的行为（尽管存在持久的编译器警告）？

注意：我用于struct __attribute__((__packed__)) object { ... };打包（GCC）。