C：不使用循环语句或递归的循环_C_Loops

C：不使用循环语句或递归的循环

c loops

C：不使用循环语句或递归的循环,c,loops,C,Loops,我想写一个C函数，它将在标准输出上每行打印1到N个，其中N是函数的int参数。函数不应使用while、for、do-while循环、goto语句、递归和switch语句。可能吗？首先将所有可能的输出写入字符串，然后在输出应该停止的地方以null终止。这是一个相当肮脏的解决方案，但考虑到局限性，我所能想到的，当然，除了使用汇编程序之外 char a[]="1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n"/*...*/; m

我想写一个C函数，它将在标准输出上每行打印1到N个，其中N是函数的int参数。函数不应使用while、for、do-while循环、goto语句、递归和switch语句。可能吗？

首先将所有可能的输出写入字符串，然后在输出应该停止的地方以null终止。
这是一个相当肮脏的解决方案，但考虑到局限性，我所能想到的，
当然，除了使用汇编程序之外

char a[]="1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n"/*...*/;
main(n,v)char**v;{n=atoi(v[1]);
#define c(x)(n>x?n-x:0)
a[n+c(1)+c(9)+c(99)+c(999)+c(9999)+c(99999)+c(999999)+c(9999999)/*+...*/]=0;
puts(a);}

考虑到流行体系结构上的

MAX_INT==2147483647

，我们只需要升级到

+c（999999999）

。键入初始字符串可能需要一段时间，但是…

您没有禁止

fork（）

N是不固定的，因此无法取消循环。据我所知，C没有迭代器

你应该找到一些模仿循环的东西

或者跳出框框思考：

（例如，N限制为1000，但很容易适应）

如果你知道N的上限，你可以试试这样；）

void func（int N）
{
char*data=“1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n”；
如果（N>0&&N<12）
printf（“%s”，N*3，数据）；
其他的
printf（“数据不足。需要将更多样条线网格化\n”）；
}

撇开玩笑不谈，我真的不明白如果没有递归或你提到的所有指令，你怎么能做到这一点。这让我对解决方案更加好奇

编辑：刚刚注意到我提出了与格罗姆比斯特相同的解决方案：）

这样做：

int main ()
{
printf ("1 to N one per each line\n");
return 0;
}

这里还有一个：

#include <stdlib.h>
#include <stdio.h>

int main (int c, char ** v) {
    char b[100];
    sprintf (b, "perl -e 'map {print \"$_\\n\"} (1..%s)'", v[1]);
    system (b);
    return 0;
}

#包括
#包括
int main（int c，字符**v）{
charb[100]；
sprintf（b，“perl-e'map{print\“$\\\n\”}（1..%s）”，v[1]）；
系统（b）；
返回0；
}

您可以使用setjmp和logjmp函数来执行此操作，如图所示

对于那些想知道为什么有人会有这样的问题的人来说，这是印度招聘应届毕业生的常见问题之一。

你可以通过嵌套宏来实现这一点

int i = 1;

#define PRINT_1(N) if( i < N ) printf("%d\n", i++ );
#define PRINT_2(N) PRINT_1(N) PRINT_1(N)
#define PRINT_3(N) PRINT_2(N) PRINT_2(N)
#define PRINT_4(N) PRINT_3(N) PRINT_3(N)
:
:
#define PRINT_32(N) PRINT_31(N) PRINT_31(N)

我会选择使用

longjmp（）

#包括
#包括
void do_循环（int n）{
int-val；
jmp_buf env；
val=0；
setjmp（环境）；
printf（“%d\n”++val）；
如果（val！=n）
longjmp（env，0）；
}
int main（）{
杜鲁环（7）；
返回0；
}

#包括
int回调（常量无效*a，常量无效*b）{
静态int n=1；
如果（n带有阻塞读取、信号和报警。我认为我必须使用sigaction和SAU重启，但它似乎在没有阻塞的情况下工作得足够好
请注意，setitimer/alarm可能是特定于unix/的
#include <signal.h>
#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

volatile sig_atomic_t counter;
volatile sig_atomic_t stop;

void alarm_handler(int signal)
{
  printf("%d\n", counter++);
  if ( counter > stop )
  {
    exit(0);
  }
}

int main(int argc, char **argv)
{
  struct itimerval v;
  v.it_value.tv_sec = 0;
  v.it_value.tv_usec = 5000;
  v.it_interval.tv_sec = 0;
  v.it_interval.tv_usec = 5000;
  int pipefds[2];
  char b;

  stop = 10;
  counter = 1;

  pipe(pipefds);

  signal(SIGALRM, alarm_handler);

  setitimer(ITIMER_REAL, &v, NULL);

  read(pipefds[0], &b, 1);
}

#包括
#包括
#包括
#包括
#包括
易失性sig_原子计数器；
易挥发的sig_____________________________；
无效报警处理程序（int信号）
{
printf（“%d\n”，计数器++）；
如果（计数器>停止）
{
出口（0）；
}
}
int main（int argc，字符**argv）
{
结构itimerval v；
v、 it_value.tv_sec=0；
v、 it_value.tv_usec=5000；
v、 it_interval.tv_sec=0；
v、 it_interval.tv_usec=5000；
int-pipefds[2]；
字符b；
停止=10；
计数器=1；
管道（pipefds）；
信号（信号机、报警处理器）；
setitimer（ITIMER_实型，&v，NULL）；
读取（管道FDS[0]，&b，1）；
}
我很失望这不起作用。对我来说，短语“函数是在之前注册的函数之后调用的，这些函数在注册时已经被调用了”建议在开始调用atexit处理程序后可以注册它们。也就是说，一个处理程序可以注册另一个处理程序。否则，怎么可能存在一个在注册另一个函数时已被调用的函数？但对我来说，对atexit的调用返回0成功，但实际上没有重新调用又打了一个电话。有人知道为什么吗，我犯了一些愚蠢的错误吗
#include "stdio.h"
#include "stdlib.h"

int count = 0;
int limit = 10;

void handler() {
    printf("%d of %d\n", ++count, limit);
    if (count < limit) atexit(handler);
}

int main(int argc, char **argv) {
    if (argc > 1) limit = atoi(argv[1]);
    atexit(handler);
}

#包括“stdio.h”
#包括“stdlib.h”
整数计数=0；
整数极限=10；
void处理程序（）{
printf（“%d，共%d\n”++计数，限制）；
如果（计数<限制）atexit（处理器）；
}
int main（int argc，字符**argv）{
如果（argc>1）限制=atoi（argv[1]）；
atexit（处理程序）；
}

顺便说一句，不是递归，因为atexit不调用其参数，它将其排队等待以后调用。显然，C运行时包含一个调用atexit处理程序的循环，但无论您是否实际注册任何atexit处理程序，该循环都存在。因此，如果此程序包含一个循环，则每个C程序都会如此；-）
这将从命令行获取整数N，并从1到N打印出来
#include <stdio.h>
#include <stdlib.h>

int total;
int N;

int print16(int n)
{
    printf("%d\n",n+0x01); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x02); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x03); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x04); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x05); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x06); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x07); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x08); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x09); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x0A); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x0B); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x0C); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x0D); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x0E); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x0F); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x10); total++; if (total >= N) exit(0);
}

int print256(int n)
{
    print16(n);
    print16(n+0x10);
    print16(n+0x20);
    print16(n+0x30);
    print16(n+0x40);
    print16(n+0x50);
    print16(n+0x60);
    print16(n+0x70);
    print16(n+0x80);
    print16(n+0x90);
    print16(n+0xA0);
    print16(n+0xB0);
    print16(n+0xC0);
    print16(n+0xD0);
    print16(n+0xE0);
    print16(n+0xF0);
}

int print4096(int n)
{
    print256(n);
    print256(n+0x100);
    print256(n+0x200);
    print256(n+0x300);
    print256(n+0x400);
    print256(n+0x500);
    print256(n+0x600);
    print256(n+0x700);
    print256(n+0x800);
    print256(n+0x900);
    print256(n+0xA00);
    print256(n+0xB00);
    print256(n+0xC00);
    print256(n+0xD00);
    print256(n+0xE00);
    print256(n+0xF00);
}

int print65536(int n)
{
    print4096(n);
    print4096(n+0x1000);
    print4096(n+0x2000);
    print4096(n+0x3000);
    print4096(n+0x4000);
    print4096(n+0x5000);
    print4096(n+0x6000);
    print4096(n+0x7000);
    print4096(n+0x8000);
    print4096(n+0x9000);
    print4096(n+0xA000);
    print4096(n+0xB000);
    print4096(n+0xC000);
    print4096(n+0xD000);
    print4096(n+0xE000);
    print4096(n+0xF000);
}

int print1048576(int n)
{
    print65536(n);
    print65536(n+0x10000);
    print65536(n+0x20000);
    print65536(n+0x30000);
    print65536(n+0x40000);
    print65536(n+0x50000);
    print65536(n+0x60000);
    print65536(n+0x70000);
    print65536(n+0x80000);
    print65536(n+0x90000);
    print65536(n+0xA0000);
    print65536(n+0xB0000);
    print65536(n+0xC0000);
    print65536(n+0xD0000);
    print65536(n+0xE0000);
    print65536(n+0xF0000);
}

int print16777216(int n)
{
    print1048576(n);
    print1048576(n+0x100000);
    print1048576(n+0x200000);
    print1048576(n+0x300000);
    print1048576(n+0x400000);
    print1048576(n+0x500000);
    print1048576(n+0x600000);
    print1048576(n+0x700000);
    print1048576(n+0x800000);
    print1048576(n+0x900000);
    print1048576(n+0xA00000);
    print1048576(n+0xB00000);
    print1048576(n+0xC00000);
    print1048576(n+0xD00000);
    print1048576(n+0xE00000);
    print1048576(n+0xF00000);
}

int print268435456(int n)
{
    print16777216(n);
    print16777216(n+0x1000000);
    print16777216(n+0x2000000);
    print16777216(n+0x3000000);
    print16777216(n+0x4000000);
    print16777216(n+0x5000000);
    print16777216(n+0x6000000);
    print16777216(n+0x7000000);
    print16777216(n+0x8000000);
    print16777216(n+0x9000000);
    print16777216(n+0xA000000);
    print16777216(n+0xB000000);
    print16777216(n+0xC000000);
    print16777216(n+0xD000000);
    print16777216(n+0xE000000);
    print16777216(n+0xF000000);
}

int print2147483648(int n)
{
   /*
    * Only goes up to n+0x70000000 since we
    * deal only with postive 32 bit integers
    */
   print268435456(n);
   print268435456(n+0x10000000);
   print268435456(n+0x20000000);
   print268435456(n+0x30000000);
   print268435456(n+0x40000000);
   print268435456(n+0x50000000);
   print268435456(n+0x60000000);
   print268435456(n+0x70000000);
}


int main(int argc, char *argv[])
{
   int i;

   if (argc > 1) {
      N = strtol(argv[1], NULL, 0);
   }

   if (N >=1) {
      printf("listing 1 to %d\n",N);
      print2147483648(0);
   }
   else {
      printf("Must enter a postive integer N\n");
   }
}

#包括
#包括
整数合计；
int N；
int print16（int n）
{
printf（“%d\n”，n+0x01）；总计++；如果（总计>=n）退出（0）；
printf（“%d\n”，n+0x02）；总计++；如果（总计>=n）退出（0）；
printf（“%d\n”，n+0x03）；总计++；如果（总计>=n）退出（0）；
printf（“%d\n”，n+0x04）；总计++；如果（总计>=n）退出（0）；
printf（“%d\n”，n+0x05）；总计++；如果（总计>=n）退出（0）；
printf（“%d\n”，n+0x06）；总计++；如果（总计>=n）退出（0）；
printf（“%d\n”，n+0x07）；总计++；如果（总计>=n）退出（0）；
printf（“%d\n”，n+0x08）；总计++；如果（总计>=n）退出（0）；
printf（“%d\n”，n+0x09）；总计++；如果（总计>=n）退出（0）；
printf（“%d\n”，n+0x0A）；总计++；如果（总计>=n）退出（0）；
printf（“%d\n”，n+0x0B）；总计++；如果（总计>=n）退出（0）；
printf（“%d\n”，n+0x0C）；总计++；如果（总计>=n）退出（0）；
printf（“%d\n”，n+0x0D）；总计++；如果（总计>=n）退出（0）；
printf（“%d\n”，n+0x0E）；总计++；如果（总计>=n）退出（0）；
printf（“%d\n”，n+0x0F）；总计++；如果（总计>=n）退出（0）；
printf（“%d\n”，n+0x10）；总计++；如果（总计>=n）退出（0）；
}
int print256（int n）
{
第16（n）条；
print16（n+0x10）；
print16（n+0x20）；
print16（n+0x30）；
print16（n+0x40）；
print16（n+0x50）；
print16（n+0x60）；
print16（n+0x70）；
print16（n+0x80）；
print16（n+0x90）；
print16（n+0xA0）；
print16（n+0xB0）；
打印16（n+0xC0）；
print16（n+0xD0）；
print16（n+0xE0）；
print16（n+0xF0）；
}
int print4096（int n）
{
打印256（n）；
打印256（n+0x100）；
#include <stdio.h>
#include <setjmp.h>

void do_loop(int n) {
  int val;
  jmp_buf env;

  val = 0;

  setjmp(env);

  printf("%d\n", ++val);

  if (val != n)
    longjmp(env, 0);  
}

int main() {
  do_loop(7);
  return 0;
}

#include <stdlib.h>

int callback(const void *a, const void *b) {
    static int n = 1;

    if (n <= N)
        printf("%d\n", n++);

    return 0;
}

int main(int argc, char *argv) {
    char *buf;
    /* get N value here */

    buf = malloc(N);  // could be less than N, but N is definitely sufficient
    qsort(buf, N, 1, callback);
}

#include <signal.h>
#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

volatile sig_atomic_t counter;
volatile sig_atomic_t stop;

void alarm_handler(int signal)
{
  printf("%d\n", counter++);
  if ( counter > stop )
  {
    exit(0);
  }
}

int main(int argc, char **argv)
{
  struct itimerval v;
  v.it_value.tv_sec = 0;
  v.it_value.tv_usec = 5000;
  v.it_interval.tv_sec = 0;
  v.it_interval.tv_usec = 5000;
  int pipefds[2];
  char b;

  stop = 10;
  counter = 1;

  pipe(pipefds);

  signal(SIGALRM, alarm_handler);

  setitimer(ITIMER_REAL, &v, NULL);

  read(pipefds[0], &b, 1);
}

#include "stdio.h"
#include "stdlib.h"

int count = 0;
int limit = 10;

void handler() {
    printf("%d of %d\n", ++count, limit);
    if (count < limit) atexit(handler);
}

int main(int argc, char **argv) {
    if (argc > 1) limit = atoi(argv[1]);
    atexit(handler);
}

#include <stdio.h>
#include <stdlib.h>

int total;
int N;

int print16(int n)
{
    printf("%d\n",n+0x01); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x02); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x03); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x04); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x05); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x06); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x07); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x08); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x09); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x0A); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x0B); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x0C); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x0D); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x0E); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x0F); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x10); total++; if (total >= N) exit(0);
}

int print256(int n)
{
    print16(n);
    print16(n+0x10);
    print16(n+0x20);
    print16(n+0x30);
    print16(n+0x40);
    print16(n+0x50);
    print16(n+0x60);
    print16(n+0x70);
    print16(n+0x80);
    print16(n+0x90);
    print16(n+0xA0);
    print16(n+0xB0);
    print16(n+0xC0);
    print16(n+0xD0);
    print16(n+0xE0);
    print16(n+0xF0);
}

int print4096(int n)
{
    print256(n);
    print256(n+0x100);
    print256(n+0x200);
    print256(n+0x300);
    print256(n+0x400);
    print256(n+0x500);
    print256(n+0x600);
    print256(n+0x700);
    print256(n+0x800);
    print256(n+0x900);
    print256(n+0xA00);
    print256(n+0xB00);
    print256(n+0xC00);
    print256(n+0xD00);
    print256(n+0xE00);
    print256(n+0xF00);
}

int print65536(int n)
{
    print4096(n);
    print4096(n+0x1000);
    print4096(n+0x2000);
    print4096(n+0x3000);
    print4096(n+0x4000);
    print4096(n+0x5000);
    print4096(n+0x6000);
    print4096(n+0x7000);
    print4096(n+0x8000);
    print4096(n+0x9000);
    print4096(n+0xA000);
    print4096(n+0xB000);
    print4096(n+0xC000);
    print4096(n+0xD000);
    print4096(n+0xE000);
    print4096(n+0xF000);
}

int print1048576(int n)
{
    print65536(n);
    print65536(n+0x10000);
    print65536(n+0x20000);
    print65536(n+0x30000);
    print65536(n+0x40000);
    print65536(n+0x50000);
    print65536(n+0x60000);
    print65536(n+0x70000);
    print65536(n+0x80000);
    print65536(n+0x90000);
    print65536(n+0xA0000);
    print65536(n+0xB0000);
    print65536(n+0xC0000);
    print65536(n+0xD0000);
    print65536(n+0xE0000);
    print65536(n+0xF0000);
}

int print16777216(int n)
{
    print1048576(n);
    print1048576(n+0x100000);
    print1048576(n+0x200000);
    print1048576(n+0x300000);
    print1048576(n+0x400000);
    print1048576(n+0x500000);
    print1048576(n+0x600000);
    print1048576(n+0x700000);
    print1048576(n+0x800000);
    print1048576(n+0x900000);
    print1048576(n+0xA00000);
    print1048576(n+0xB00000);
    print1048576(n+0xC00000);
    print1048576(n+0xD00000);
    print1048576(n+0xE00000);
    print1048576(n+0xF00000);
}

int print268435456(int n)
{
    print16777216(n);
    print16777216(n+0x1000000);
    print16777216(n+0x2000000);
    print16777216(n+0x3000000);
    print16777216(n+0x4000000);
    print16777216(n+0x5000000);
    print16777216(n+0x6000000);
    print16777216(n+0x7000000);
    print16777216(n+0x8000000);
    print16777216(n+0x9000000);
    print16777216(n+0xA000000);
    print16777216(n+0xB000000);
    print16777216(n+0xC000000);
    print16777216(n+0xD000000);
    print16777216(n+0xE000000);
    print16777216(n+0xF000000);
}

int print2147483648(int n)
{
   /*
    * Only goes up to n+0x70000000 since we
    * deal only with postive 32 bit integers
    */
   print268435456(n);
   print268435456(n+0x10000000);
   print268435456(n+0x20000000);
   print268435456(n+0x30000000);
   print268435456(n+0x40000000);
   print268435456(n+0x50000000);
   print268435456(n+0x60000000);
   print268435456(n+0x70000000);
}


int main(int argc, char *argv[])
{
   int i;

   if (argc > 1) {
      N = strtol(argv[1], NULL, 0);
   }

   if (N >=1) {
      printf("listing 1 to %d\n",N);
      print2147483648(0);
   }
   else {
      printf("Must enter a postive integer N\n");
   }
}

int main() {
    return system("seq 7");
}

    /// <summary>
    /// Print one to Hundred without using any loop/condition.
    /// </summary>
    int count = 100;
    public void PrintOneToHundred()
    {
        try
        {
            int[] hey = new int[count];
            Console.WriteLine(hey.Length);
            count--;
            PrintOneToHundred();
        }
        catch
        {
            Console.WriteLine("Done Printing");
        }
    }

int x=1;

void PRINT_2(int);

void PRINT_1(int n)
{ if(x>n)
    return;
  printf("%d\n",x++);
  PRINT_2(n);  
}

void PRINT_2(int n)
{ if(x>n)
    return;
  printf("%d\n",x++);
  PRINT_1(n);  
}

int main() 
{   int n;
    scanf("%d",&n);
    if(n>0)
      PRINT_1(n);
    system("pause");
}

 #include "stdio.h"

 #include "stdlib.h"

 #include "signal.h"

 int g_num;

 int iterator;

 void signal_print()

 {

        if(iterator>g_num-1)

                exit(0);

        printf("%d\n",++iterator);

 }

 void myprintf(int n)

 {

     g_num=n;

        int *p=NULL;

     int x= *(p); // the instruction is reexecuted after handling the signal

 }

 int main()

 {

        signal(SIGSEGV,signal_print);

        int n;

        scanf("%d",&n);

        myprintf(n);

        return 0;

 }