C:循环而不使用循环语句或递归

Question

我想编写一个C函数,它将在stdout上每行打印1到N一个,其中N是函数的int参数.该函数不应使用while,for,do-while循环,goto语句,递归和switch语句.可能吗？

Answer 1

#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);
}

我认为它不算递归.

Answer 2

N不固定,因此您无法解除循环.据我所知,C没有迭代器.

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

或者在盒子外面思考:

(例如N限制为1000,但很容易适应)

int f(int N) {
    if (N >= 900) f100(100);
    if (N >= 800) f100(100);
    if (N >= 700) f100(100);
    ...

    f100(n % 100);
}

int f100(int N) {
    if (N >= 90) f10(10);
    if (N >= 80) f10(10);
    if (N >= 70) f10(10);
    ...

    f(n % 10);
}

int f10(int N) {
    if (N >= 9) func();
    if (N >= 8) func();
    if (N >= 7) func();
    ...
}

Answer 3

具有阻塞读取,信号和报警功能.我以为我必须使用sigaction和SA_RESTART,但似乎没有使用它.

请注意,setitimer/alarm可能是unix/-like特定的.

#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);
}

Answer 4

我会去使用 longjmp()

#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;
}

Answer 5

您可以通过嵌套宏来完成此操作.

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)

总共将有32个宏.假设大小int为4个字节.现在PRINT_32(N)从任何函数调用.

编辑: 为清晰起见添加示例.

void Foo( int n )
{
    i = 1;

    PRINT_32( n );
}


void main()
{
    Foo( 5 );
    Foo( 55 );
    Foo( 555 );
    Foo( 5555 );
}

Answer 6

您可以使用setjmp和logjmp函数执行此操作,如此C FAQ中所示

对于那些对某人有这样的问题感到好奇的人来说,这是印度招聘新鲜毕业生的常见问题之一.

Answer 7

首先将所有可能的输出写入字符串,并在输出停止的位置将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).输入那个初始字符串可能需要一段时间,但是......

Answer 8

这样做:

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;
}