A_Hatake's questions

任务是：

命令行将仅包含以下字符：∙ 拉丁字母（大小）和数字、∙ 空格 (ASCII 32)、∙ 双引号 (ASCII 34)。

参数按顺序写入命令行。在每两个相邻参数之间插入一个或多个空格以将它们彼此分开。该参数可以完全用双引号括起来。如果参数内有空格，则必须用双引号括起来。参数本身没有双引号字符 - 它们只能围绕参数。所有参数都是非空的。

要解析的命令行位于输入文件的一行。其长度不超过 100 个字符。请注意，此命令行缺少可执行文件的名称。将需要的命令行参数输出到输出文件，每行一个参数。每个参数必须用方括号括起来。不需要输出特殊的空参数（命令行本身）。

以下是我的代码。似乎工作正常，但是当你输入多个空格时，输出是某种难以理解的混乱，我不明白是什么原因：

#include <stdio.h>
#include <conio.h>
#include <string.h>

int main()
{
    char c;
    do
    {
        scanf("%c", &c);
        switch (c) {
        case '"':
            printf("[");
            scanf("%c", &c);

            while (c != '"')
            {
                printf("%c", c);
                scanf("%c", &c);
            }
            //printf("]\n");
        case ' ':
            if (c != '\n')
            {
                scanf("%c", &c);
            }
        default:
            while (c != ' ' && c != '\n')
            {
                printf("[%c", c);
                scanf("%c", &c);
            }
            printf("]\n");
    
            getch();
        }
    } while ( c!= '\n');

    return 0;
}

输入/输出示例：

输入文件的前四个字节包含数字 𝑁 — 序列中数字的数量 (1 <= 𝑁 <=10000)。接下来，给出序列的整数：𝑁 个，每个 4 个字节。所有数字的绝对值不超过 10^5。需要找到序列的 𝑁 个数之和，并将其输出为 4 字节整数。 这个问题中的所有输入和输出都是二进制的。在每个特定测试中，所有数字都以相同的字节顺序写入：它可以是 big-endian 或 little-endian。但是，字节顺序在不同的测试中可能会有所不同。需要以与给定输入数据相同的字节顺序输出一个数字作为响应。

这是我的示例，但根本没有显示任何内容...怎么了，请告诉我

#include<stdio.h>
#include <math.h>
int main() {
    FILE* input;
    fopen_s(&input, "input.bin", "rb");
    FILE* output;
    fopen_s(&output, "output.bin", "wb");

    int N;
    scanf("%d", &N);
    fread(&N, sizeof(int), 1, input);
    fread(&S, sizeof(int), 1, input);

for(int i=0; i<N; i++){
int S = (int)(((double)S));

fwrite(&S, sizeof(int), 1, output);


return 0;
}

在这个问题中，需要计算参数的正弦，并且禁止使用 sin 函数，即我们使用泰勒级数。签名：第一行包含一个整数 N - 您要为其计算正弦的参数数量 (1<=N<=10^5)。然后有 N 行，每行一个实数 X。每个数字都是要计算其正弦的数字。所有 X 数字的绝对值不超过 1（以弧度表示）。您需要输出 N 行，每行一个实数，它等于输入数据中相应参数的 sin X。建议以“%0.15lf”格式输出数字，以便显示小数点后 15 位。每个答案的误差不应超过 10^12。这是我的程序，但无论更改多少，它都无法通过测试系统。

#include<stdio.h>
int main(){
    int N;
    double k;
    double s;
    int n;
    n=1;
    k=x;
    s=0;
    scanf("%d", &N);
    for(int i=0; i<N; i++){
        scanf("%d\n", &k);
        while(fabs(k)>eps){
         s+=k;
         n++;
         k*=-x*x/(2.*n-1.0)/(2.0*n-2.0); 
         printf("%0.15lf", s);
        }
    }
   
}

upd：这是我的程序的新版本，但现在它只是零，每个参数 N 次......

#include<stdio.h>
#include<math.h>
#define eps  0.000001
double Sin(double x){
    double d, s;
    int n;
    s=d=x;
    n=1;
    while(fabs(d)>eps){
        d *= n*n;
        d *= x*x;
        +n;
        d /= n;
        ++n;
        d /= n;
        s+=d;
    }
    return s;
}

int main(){
    int N;
    double x, h;
    scanf("%d", &N);
    for(int i=0; i<N; i++){
         scanf("%d\n", &x);
         printf("%0.15lf\n", Sin(x));
        }
}

upd 2.0：我真诚地尝试，但我的程序不理解它:) 现在我的类型在主要部分和函数中不匹配。总的来说，直觉表明系统不会接受这样的程序。有没有接近真相的地方？

#include<stdio.h>
#include<math.h>
#define eps  0.000000000001
double Sin(double x, N){
    double d, s;
    int n;
    s=d=x;
    if(fabs(d)>eps){
         for(n=1; n<=N; n++){
             s+=d;
             d *= (-1)*x*x/(2*n)/(2*n+1);
         }
    }
    return s;
}

int main(){
    int N;
    double x;
    scanf("%d", &N);
    for(int i=0; i<N; i++){
         scanf("%d\n", &x);
         printf("%0.15lf\n", Sin(x, N));
        }
}

upd 3.0：另一个更新 :) 再一次，不是很成功。所有警告和错误消息都消失了，但现在输入的每个参数都有一个不正确的响应。虽然公式是正确的。也许循环中有错误？

#include<stdio.h>
#include<math.h>
#define eps  0.000000000001
double Sin(double x){
    double d, s;
    int n, N;
    scanf("%d", &N);
    s=d=x;
    if(fabs(d)>eps){
         for(n=1; n<=N; n++){
             s+=d;
             d *= (-1)*x*x/(2*n)/(2*n+1);
         }
    }
    return s;
}

int main(){
    int N;
    double x;
    for(int i=0; i<N; i++){
         scanf("%lf\n", &x);
         printf("%0.15lf\n", Sin(x));
        }
}

给定一个包含 𝑛 整数的数组 𝐴。您需要遍历此数组中的所有数字对𝐴𝑖和𝐴𝑗，为每一对找到最小最小值（𝐴𝑖，𝐴𝑗）并将所有这些最小值相加。输入数据格式：第一行包含一个整数𝑛——数组中有多少个数字（1 <= 𝑁 <= 300 000）。其余的 𝑛 行包含这些数字本身，它们按照它们在数组 𝐴 中出现的顺序排列。所有模数不超过 10^9。输出数据格式：您需要输出一个整数 - 所需的最小值之和 𝑆。𝑆 的总和可能非常大。估计 𝑆 的最大可能值并选择适当的整数类型。需要及时解决问题𝑂(𝑁)。 到目前为止有这样的尝试，但距离 O(N) 还很远：

#include<stdio.h>
int main(){
    int A[300001];
    int N;
    int S; 
    S = 0;
    scanf("%d\n", &N);
    for(int i=1; i<N; i++){
        scanf("%d\n", &A[i]);
    }
    for(int i=1; i<N; i++){
        for(int j=i+1; j!=i; j++){
            if(A[i,j]<=A[i,j+1])
                S=S+A[i,j];
            else
                S=S+A[i,j+1];
        }
    }
    printf("%d", S);
}

前 n 个元素的子列表，从零开始。数字 n 作为第一个参数传递，原始列表作为第二个参数传递。空列表返回任何数字的空列表。提供元素数小于 n 值的情况。以任何合理的方式解决它。该列表可能无穷无尽。 我得到了函数本身，但我不能在那里插入一个条件，如果 n 大于列表中的元素数会发生什么。问题是不能使用卷积函数。如何解决这种情况？

length' :: [a] -> Int
length' [] = 0
length' (x:xs) = length' xs + 1 
take' :: Int -> [a] -> [a]
take' n _ | n <= 0 = []
          | (n > (length' xs)) = error "error!!!"
take' _ [] =  []
take' n (x:xs) =  x : take' (n-1) xs

需要对已排序数组中具有给定值的元素进行二进制搜索。第一行包含一个整数 𝑁 — 排序数组的大小 (1 <= 𝑁 <= 10^5)。接下来，写入数组𝐴𝑖（整数的𝑁，|𝐴𝑖| <= 10^9）的元素。然后写入一个整数 𝑄 — 需要处理的请求数 (1 <= 𝑄 <= 10^5)。剩下的 𝑄 行包含定义搜索查询的整数 𝑋𝑗。每个请求必须按如下方式处理。首先，您需要将前面查询的答案𝑅𝑗−1 添加到文件中写入的数字𝑋𝑗，得到𝑌𝑗 = 𝑋𝑗 + 𝑅𝑗−1。然后你需要在数组𝐴中找到一个等于𝑌𝑗的元素：它的索引将是这个查询的答案𝑅𝑗。如果有很多这样的元素，那么应该选择最大的索引作为答案𝑅𝑗。如果没有这样的元素，那么答案𝑅𝑗是-1。数组元素的索引从 0 到𝑁 − 1。第一个查询没有先前的答案，所以我们把 𝑌0 = 𝑋0。 告诉我如何改进程序：

#include <stdio.h>
#include <malloc.h>
#include <conio.h>

int binarysearch(int a, int mass[], int n);
void InsertionSort(int n, int mass[]);

int main()
{
    int N, a;
    printf("Input N: ");
    scanf_s("%d", &N);
    int* mass;
    mass = (int *)malloc(N * sizeof(int));
    printf("Input the array elements:\n");
    for (int i = 0; i < N; i++)
        scanf_s("%d", &mass[i]);
    InsertionSort(N, mass);
    printf("Sorted array:\n");
    for (int i = 0; i < N; i++)
        printf("%d ", mass[i]);
    printf("\n");
    printf("Input variable 'a' for search: ");
    scanf_s("%d", &a);
    int k;
    k = binarysearch(a, mass, N);
    if (k != -1)
    {
        printf("The index of the element is %d\n", k);
    }
    else
        printf("The element isn't found!\n");
    free(mass);
    _getch();
    return 0;
}

int binarysearch(int a, int mass[], int n)
{
    int low, high, middle;
    low = 0;
    high = n - 1;
    while (low <= high)
    {
        middle = (low + high) / 2;
        if (a < mass[middle])
            high = middle - 1;
        else if (a > mass[middle])
            low = middle + 1;
        else 
            return middle;
    }
    return -1;
}

 
void InsertionSort(int n, int mass[])
{
    int newElement, location;

    for (int i = 1; i < n; i++)
    {
        newElement = mass[i];
        location = i - 1;
        while (location >= 0 && mass[location] > newElement)
        {
            mass[location + 1] = mass[location];
            location = location - 1;
        }
        mass[location + 1] = newElement;
    }
}

UPD： 我能够搞砸一些事情，但测试系统说程序没有通过所有测试。怎么了？？？

#include<stdio.h>
int a[1000000];
int main()
{
int N,Q,c;
scanf("%d",&N);
if (N!=0){
int x,y=0,z=0;
for(int i=0;i<N;i++)
{
scanf("%d",&c);
a[c]=i;
}
scanf("%d",&Q);
for(int i=0;i<Q;i++)
{
scanf("%d",&x);
y+=x;
int j=0;
int flag=0;
z=a[y];
if (z!=0)
{
flag=1;
}
y=z;
if (flag==0)
y=-1;
printf("%d\n",y);
j++;
}
return(0);
}
}

您需要计算数字 N 的阶乘，其中 1<=N<=1000。您还需要在响应中提供最多 3000 个字符。我写了一个程序，它在编译器中运行良好：

#include <stdio.h>
#include <gmp.h>

static void
factorial (long n, mpz_t r)
{ 
  mpz_init_set_si (r, 1);
  for (; n > 1; n--) {
    mpz_mul_si (r, r, n);
  }
}

int
main (void)
{
  int n;
  mpz_t r;
  while (scanf ("%d", &n) == 1) {
    factorial (n, r);
    gmp_printf ("%Zd\n", r);
  }
  return 0;
}

但是测试系统不接受代码，因为 不知道 GMP 库。告诉我如何解决这个问题？

需要实现一个函数来确定一个字符串中有多少个大写字母、小写字母和数字。该函数必须具有签名： int calcLetters ( char * iStr , int * oLowerCnt , int * oUpperCnt , int * oDigitsCnt ); 这里 iStr 是一个指向以空字符结尾的字符串开头的指针。oLowerCnt、oUpperCnt 和 oDigitsCnt 参数被输出：调用者将一个指向某些局部变量的指针传递给它们以在其中得到相应的结果。函数返回iStr字符串的长度，*oLowerCnt变量必须填写小写字母的个数，*oUpperCnt填写大写字母的个数，*oDigitsCnt填写数字个数。 作为一项测试任务，您需要读取文件的所有行并打印每一行的统计信息。

文件行可以包含任何可打印的 ASCII 字符，包括空格（包括代码 32 到 126）。因此，推荐使用gets来读取字符串。任意字符串的长度不超过 100，字符串可以为空。请注意，文件的最后一行也以换行符结尾。

对于输入文件的每一行，以与示例输出完全相同的格式输出统计信息：

Line 1 has 30 chars: 24 are letters (23 lower, 1 upper), 0 are digits.
Line 2 has 32 chars: 22 are letters (22 lower, 0 upper), 0 are digits.
Line 3 has 26 chars: 18 are letters (17 lower, 1 upper), 0 are digits.
Line 4 has 12 chars: 7 are letters (7 lower, 0 upper), 0 are digits.
Line 5 has 31 chars: 21 are letters (20 lower, 1 upper), 0 are digits.
Line 6 has 13 chars: 6 are letters (6 lower, 0 upper), 1 are digits.
Line 7 has 30 chars: 19 are letters (19 lower, 0 upper), 1 are digits.
Line 8 has 1 chars: 0 are letters (0 lower, 0 upper), 0 are digits.

**我已经挠头一天了，它只是发生了：**

#include <stdio.h>
main() {
    char str[255];
    int i,let_b, let_s, digit;
    gets(str);
    let_s = 0;
    let_b = 0;
    digit = 0;
    for (i=0; str[i]!='\0'; i++)
        if (str[i] >= 'a' && str[i] <= 'z') let_s += 1;
        else if (str[i] >= 'A' && str[i] <= 'Z') let_b += 1;
        else if (str[i]>='0'&&str[i]<='9') digit++;
        printf("%d %d %d", let_s, let_b, digit);
}```

как сюда впихнуть войд? и что делать, если строк несколько? буду благодарна за ваши ответы

给定两个整数数组 𝐴 和 𝐵。需要找到数组𝐴的所有元素的值，这些值不在数组𝐵的元素中。第一行包含一个整数 𝑁 (1 <= 𝑁 <= 10^5) — 数组 𝐴 中的元素数。第二行包含 𝑁 空格分隔的非负整数，每个整数不超过 10^5 — 数组 𝐴 的元素。接下来的两行以类似的格式包含数组 𝐵 的元素。 在第一行打印一个整数——满足所述条件的值的数量。在第二行按升序打印所有这些值。 这是我的代码，但它输出的结果与它应该输出的完全相反。告诉我可以在这里做什么或更正，我请求：

#include<stdio.h>
int main(){
    int N1, N2, i, j, k;
    k=0;
    int A[100000];
    int B[100000];
    scanf("%d", &N1);
    for(i=0; i<N1; i++){
        scanf("%d", &A[i]);
    }
    scanf("%d", &N2);
    for(j=0; j<N2; j++){
        scanf("%d", &B[i]);
    }
    for(i=0; i<N1; i++){
        for(j=0; j<N2; j++){
            if (A[i]!=B[j]){
              k++;
              printf("%d\n", A[j]);
            }
        }
    }
    printf("%d", k);
}

给定一组 𝑁 数字 𝑎0, 𝑎1, . . ., 𝑎𝑁−1。构建数组元素值的直方图：对于每个值，计算它在数组中出现的次数。第一行包含一个整数 𝑁 (1 <= 𝑁 <= 10^5)。第二行包含 𝑁 空格分隔的整数 𝑎𝑖 (1 <= 𝑎𝑖 <= 10^4)。 对于数组中至少出现一次的每个值，以“值：数字”格式打印它在数组元素中出现的次数。 值必须按升序显示。输出两个用冒号和空格隔开的整数，用 printf 函数，格式字符串如下： printf ("%d: %d", value , count ); 我做了几天的程序；在输出中，所有元素都重复：

#include<stdio.h>
int main(){
    int N, kol;
    kol=1;
    int a[100000];
    scanf("%d\n", &N);
    for(int i=0; i<N; i++){
        scanf("%d", &a[i]);
    }
    for(int i=1; i<N; i++){
        if (a[i]==a[i-1]){
            kol++;
        }
    printf("%d: %d\n", a[i], kol);
    }
    return 0;
}

请让我知道在这里可以做什么/更正。

给定一组 𝑁 数字 𝑎1, 𝑎2, . . ., 𝑎𝑁 . 需要输出 𝑁 个数 𝑡𝑘 (𝑘 = 1, . . ., 𝑁)，其中𝑡𝑘 是步长为𝑘的数组元素之和：即 𝑡1 等于所有数组元素的和，𝑡2 等于数组中每个第二个元素的和，𝑡3 等于每个第三个元素的和，以此类推。第一行包含一个整数 𝑁 (1 <= 𝑁 <= 10^5)。第二行包含 𝑁 空格分隔的整数 𝑎𝑖 (1 <= 𝑎𝑖 <= 10^4)。 打印 𝑁 行：在第 𝑘 行打印值 𝑡𝑘。 我的代码原则上几乎是正确的，但我无法弄清楚为什么它错误地计算了 t1 和 tk 之间的值：

#include<stdio.h>
int main(){
    int N, k, t, sigma;
    scanf("%d", &N);
    int a[10000];
    for (int i=0; i<N; i++){
        scanf("%d", &a[i]);
    }
    for(int i=0; i<N; i++){
        for(k=0; k<N; k++){
            sigma+=a[i+k];
        }
    printf("%d\n", sigma);
    sigma=0;
    }
}

请告诉我要解决的问题:)（示例：N=6 输入 4 3 5 1 2 9，输出应为 24 13 14 1 2 9（在一列中））

给定一个 𝑁 数字数组：𝑏1, 𝑏2, . . ., 𝑏𝑁 . 数组 𝑏𝑖 的每个元素都需要计算右侧 (𝑖 < 𝑗) 但小于它 (𝑏𝑖 > 𝑏𝑗 ) 的元素 𝑏𝑗 的数量。 第一行包含一个整数 𝑁 (1 <= 𝑁 <= 100)。第二行包含以空格分隔的 𝑁 正整数——数组元素的值。保证元素的值不超过100。 打印𝑁空格分隔的整数：按顺序，对于输入数组的每个元素，打印满足上述条件的元素个数。我的代码似乎可以工作，但它输出了一些奇怪的值。例如，N=3，输入 3 2 1，输出应该是 2 1 0，但我一般有 1 2 3。请指教可以做什么/更正，拜托:)

#include<stdio.h>
int main(){
    int N, i, j, n;
    n=0;
    scanf("%d", &N);
    int b[10000];
    for(i=0; i<N; i++){
        scanf("%d", &b[i]);
    }
    for(i=0; i<N; i++){
        for(j=0; j<N; j++){
            if((i<j)&&(b[i]>b[j])){
                n++;
                printf("%d", n);
            }
        }
    }
    return 0;
}

该文件包含三个整数𝐿、𝑅和𝐾。需要 找到在 𝐿 到 𝑅 范围内恰好具有 𝐾 元素的递增等差数列数。 在这个问题中，我们只需要考虑所有元素都是整数的级数。人们相信算术级数有第一个元素，但没有最后一个元素：它是无限的。如果两个进程以不同的元素开始，那么它们必须被认为是不同的。我一直在为代码苦苦挣扎，但结果证明是某种废话......请建议可以做什么/更正：)

#include<stdio.h>
#include<math.h>
int main(){
    int L, R, K, N, i, a, b;
    N=0;
    scanf("%d %d %d", &L, &R, &K);
    if(K==1){
        N=R-L;
    }
    else if (K>1){
        b=ceil((R-L)/(K-1));
        for(i=0; i<=(R-L); i+=b){
            if((i>=L)&&((i+(K-1)*b)<L))
                N++;
        }
        
        
    }
    printf("%d", N);
}

给定一个 𝑁 位序列，每个位的值是 0 或 1。您需要将此序列划分为字节，每个字节 8 位（最后一个字节可以有更少的位）。之后，需要以人们熟悉的十进制系统打印所有接收到的字节的值。 字节内的位以现代计算机熟悉的小端顺序写入：首先是低位，然后是高位。 输入文件的第一行包含一个整数 𝑁 — 序列中的位数。第二行正好包含𝑁字符0或1：序列中位的值。 在文件的第二行之后，可能会出现换行符，也可能不会出现。 我的代码如下所示。不管我和他打多少架——错误的答案就是输出。告诉一个愚蠢的新手可以做什么/纠正什么？

#include<stdio.h>
#include<math.h>
int main(){
    int N, i, v;
    scanf("%d", &N);
    int p[N-1];
    for (i=0; i<=N-1; i+=8){
        v=((p[i]*(pow(2,i)))+(p[i+1]*(pow(2,(i+1))))+(p[i+2]*(pow(2,(i+2))))+(p[i+3]*(pow(2,(i+3))))+(p[i+4]*(pow(2,(i+4))))+(p[i+5]*(pow(2,(i+5))))+(p[i+6]*(pow(2,(i+6))))+(p[i+7]*(pow(2,(i+7)))));
        printf("%d", v);
    }
}

给定三个矩形 A、B 和 C，由它们的边长给出。需要确定是否可以将它们排列在一个平面上，以便满足两个条件：

1. 矩形的所有边相互平行/垂直；2.rectangle A 内部包含矩形 B 和 C（允许侧面触摸）； 允许旋转矩形。 第一行包含六个用空格分隔的正整数：𝑎1、𝑎2、𝑏1、𝑏2、𝑐1、𝑐2。矩形 A 的边长是𝑎1 和𝑎2，矩形B 是𝑏1 和𝑏2，矩形C 是𝑐1 和𝑐2。所有数字不超过100。如果可以按照要求的方式排列矩形，则输出单词YES，否则输出NO。程序有问题。请建议可以做/纠正的事情:)我开始学习C

#include<stdio.h>
int main(){
    int a1, a2, b1, b2, c1, c2;
    scanf("%d %d %d %d %d %d", &a1, &a2, &b1, &b2, &c1, &c2);
    if ((b1<a1)&&(b2<a2)){
     if((c1<(a1-b1))&&(c2<(a2-b2))){
         printf("YES");
     } 
     if((c1<(a2-b2))&&(c2<(a1-b1))){
         printf("YES");
     }
     else{
         printf("NO");
     }
    }
    if ((b1<a2)&&(b2<a1)){
        if((c1<(a2-b1))&&(c2<(a1-b2))){
            printf("YES");
        }
        if((c1<(a1-b2))&&(c2<(a2-b1))){
            printf("YES");
        }
        else{
            printf("NO");
        }
    }
    else{
        printf("NO");
    }
}

更正代码时，发生了这样的事情（剧透：当你输入一些数据时，程序仍然没有产生任何东西）

 #include<stdio.h>
int main(){
    int a1, a2, b1, b2, c1, c2;
    scanf("%d %d %d %d %d %d", &a1, &a2, &b1, &b2, &c1, &c2);
    if ((b1<=a1)&&(b2<=a2)){
     if(((c1<=(a1-b1))&&(c2<=(a2-b2))) || ((c1<=(a2-b2))&&(c2<=(a1-b1)))){
         printf("YES");
     } 
    }
    else if ((b1<=a2)&&(b2<=a1)){
        if(((c1<=(a2-b1))&&(c2<=(a1-b2))) || ((c1<=(a1-b2))&&(c2<=(a2-b1)))){
            printf("YES");
        }
    }
    else{
        printf("NO");
    }
}

经过一夜的折磨和痛苦，这个程序成功地通过了所有测试，并给出了正确的答案：

#include <stdio.h>
int inside(int a1, int a2, int b1, int b2)
{
    if(a1>=b1 && a2>=b2)
    {
        return 1;
    }
    return 0;
}

int inside_r(int a1, int a2, int b1, int b2)
{
    return inside(a1, a2, b1, b2) || inside(a1, a2, b2, b1);
}

int inside_2(int a1, int a2, int b1, int b2, int c1, int c2)
{
    int d1, d2;
    d1=a1-b1;
    d2=a2-b2;
    int result=0;
    result=result || inside_r(d1, a2, c1, c2) && inside (a1, a2, b1, b2);
    result=result || inside_r(a1, d2, c1, c2) && inside (a1, a2, b1, b2);
    return result;
}
int inside_2_r(int a1, int a2, int b1, int b2, int c1, int c2)
{
    return inside_2(a1, a2, b2, b1, c1, c2) || inside_2(a1, a2, b1, b2, c1, c2);
}



int main()
{
    int a1, a2, b2, b1, c1, c2;
    scanf ("%d %d %d %d %d %d", &a1, &a2, &b2, &b1, &c1, &c2);
    if (inside_2_r(a1, a2, b2, b1, c1, c2))
    {
         printf("YES");
    }
    else
    {
    printf("NO");
    }
    return 0;
}

第一行包含一个整数 𝑁 — 序列中元素的数量。第二行包含 𝑁 空格分隔的整数——序列本身。序列中所有元素的绝对值不超过100 输出数据格式：输出三个实数。第一个显示了负数的比例。第二个是数字的百分比为零。最后 - 正数的比例是多少。每个输出数字必须与其正确值相差不超过 10^-5。这是我的程序。请告诉我该怎么做/修复。我还在学习如何做简单的谜题:)

#include<stdio.h>
int main(){
    int i, N, a, b, c, A, B, C, k;
    a=b=c=0;
    scanf("%d", &N);
    for (i=0; i<=N; i++){
        scanf("%d", &k);
        if (k==0){
            b++;
        }
        if(k>0){
            c++;
        }
        if(k<0){
            a++;
        }
    }
    A=a/(double)N;
    B=b/(double)N;
    C=c/(double)N;
    printf("%0.5lf %0.5lf %0.5lf", A, B, C);
}

第一行包含一个整数𝑁。您需要打印从 1 到 𝑁 范围内的所有素数，每行一个数字。

这是我的代码，程序不显示任何内容并及时挂起。
请告知该怎么做/修复。
PS我刚刚开始学习C，所以请原谅我的愚蠢:)

#include<stdio.h>
int main(){
    int i, N, t, k;
    t=0;
    i=2;
    scanf("%d", &N);
    for (k=2; k<=N; k++){
        while(i<N){
            if (k%i==0){
                t++;
                i++;
            }
        if(t==0){
            printf("%d", k);
        }
        }
    }
}

文件的单行包含三个表示英文星期几的字母。需要显示一周中这一天的编号。文件中没有空格。第一个字母是大写，另外两个是小写。保证英文中星期几的名称以三个书面字母开头。这是我自己的代码，程序不输出任何东西。你会建议做什么/修复？

#include<stdio.h>
int main(){
    char c, d, e;
    scanf("%d %d %d", &c, &d, &e);
    
    if((c=='M')&&(d=='o')&&(e=='n'))
                printf("1");
              
    if((c=='T')&&(d=='u')&&(e=='e'))
                printf("2");
               
    if((c=='W')&&(d=='e')&&(e=='d'))
                printf("3");
               
    if((c=='T')&&(d=='h')&&(e=='u'))
                printf("4");
               
    if((c=='F')&&(d=='r')&&(e=='i'))
                printf("5");
               
    if((c=='S')&&(d=='a')&&(e=='t'))
                printf("6");
               
    if((c=='S')&&(d=='u')&&(e=='n'))
                printf("7");
}