Code Bye

打印九九乘法表，要求只能用一个变量

码拜
c语言

c语言要求最多只能用一个变量打印出九九乘法表。
10分
九九乘法表是个不变的，何必用变量。 
int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}
不知道楼主是从哪弄来的题目，我觉得写程序是把问题简单化，不是复杂化，不就是要九九乘法表吗？很容易啊，可是加一个只用一个变量的限制条件      除了使问题复杂化我没看出有什么具体用途
递归？
1楼可以！递归1个变量貌似不够的！
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

顶
表示只会1楼的，一个变量还真不知道如何打印，至少for或者while就一个变量了，
我也表示有点不理解，九九乘法表示应当行列控制，也就是两个变量，除了字符串型那种操作，真想不出其他的了
 
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
	int a;

	for (a = 0x11; a < 0xa0; a++)
	{
		for (a = (a & 0xf0) + 1; (a & 0x0f) <= ((a & 0xf0) >> 4); a++)
		{
			printf("%dx%d=%d\t",
				(a & 0x0f),
				(a & 0xf0) >> 4,
				((a & 0xf0) >> 4) * (a & 0x0f));
		}
		a += 0x10;
		printf("\n");
	}

	return 0;
}

这个应该能满足你的要求…
引用 4 楼 max_min_ 的回复:

1楼可以！递归1个变量貌似不够的！

这个是某个公司的面试题，用字符串打印出来的话人家肯定是不会要的。
10分
问题是：这种题目有意思吗？ 
#include <iostream>
using namespace std;

int main()
{
	for (int i = 0; i < 81; i++)
	{
		printf_s("%d*%d=%2d  ", (i / 9) + 1, (i % 9) + 1, ((i / 9) + 1) * ((i % 9) + 1));
		if (i % 9 == 8)
		{
			printf_s("\n");
		}
	}
	return 0;
}
感觉有点象上世纪八十年代的中学生电脑竞赛题目。哈哈。
谁能不用变量打印九九乘法表？
 
#include <stdio.h>
int main() {
    printf(
        "1×1=1\n"
        "1×2=2 2×2=4\n"
        "1×3=3 2×3=6  3×3=9 \n"
        "1×4=4 2×4=8  3×4=12 4×4=16\n"
        "1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"
        "1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"
        "1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"
        "1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"
        "1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81"
    );
    return 0;
}
引用 8 楼 vrace 的回复: 
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
	int a;

	for (a = 0x11; a < 0xa0; a++)
	{
		for (a = (a & 0xf0) + 1; (a & 0x0f) <= ((a & 0xf0) >> 4); a++)
		{
			printf("%dx%d=%d\t",
				(a & 0x0f),
				(a & 0xf0) >> 4,
				((a & 0xf0) >> 4) * (a & 0x0f));
		}
		a += 0x10;
		printf("\n");
	}

	return 0;
}

这个应该能满足你的要求…

我靠，表示看不懂8楼的代码啊，谁能解答一下，看着挺巧妙的样子
都是常量，没有变量。  
#include <stdio.h>
void mtable_helper(int const n, int const i)
{
   if(i > n)
   {
     printf("\n");
   }
   else
   {
	   printf("%dx%d=%d ", i, n, i *n); 
	   mtable_helper(n,i+1);
   } 
}

void mtable(int const n)
{
  if(0 == n) return;
  mtable(n-1);
  mtable_helper(n,1);
}

int main()
{
  mtable(9);
  return 0;
}
引用 8 楼 vrace 的回复: 
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
	int a;

	for (a = 0x11; a < 0xa0; a++)
	{
		for (a = (a & 0xf0) + 1; (a & 0x0f) <= ((a & 0xf0) >> 4); a++)
		{
			printf("%dx%d=%d\t",
				(a & 0x0f),
				(a & 0xf0) >> 4,
				((a & 0xf0) >> 4) * (a & 0x0f));
		}
		a += 0x10;
		printf("\n");
	}

	return 0;
}

这个应该能满足你的要求…
15楼是递归高手啊！佩服。
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

++++++++++++++++++++++
真的是搞不懂！
很简单啊，把一个变量拆成两半用，例如 unsigned char a,高4位和低4位，就可以了
高4位为 a>>4
代4位为 a &0xf
再设计一个双重循环就可以了

void main{
   unsigned char a;

   for (a=0x10;a<=0x90;a +=x010)
      for (a +=a>>4;a&0xf<=9;a++){
        printf(“%d*%d=%d “,a>>4,a&0xf,(a>>4)*(a&0xf) );
        printf(“\n”);
       }
}
}
void main{
   unsigned char a;

   for (a=0x10;a<=0x90;a +=x010)
      for (a +=a>>4;a&0xf<=9;a++){
        printf(“%d*%d=%d “,a>>4,a&0xf,(a>>4)*(a&0xf) );
        printf(“\n”);
       }
}
}

？？？？？？？？？？？？？、、、、、
#include <stdio.h>
main()
{
    int i;//取一个变量，用变量的十位代表另一变量，注意个位每次要归1
    i=0;
    for(i=11;i<92;i+=10)
   {
       for(;i%10<=i/10;i++)
       {
            printf(“%d*%d=%d “,i/10,i%10,(i/10)*(i%10));
        }
        i=i/10*10+1;
        printf(“\n”);

    }

}
//突然想到一个更简单的
#include <stdio.h>
main()
{
    int i;//取一个变量，用变量的十位代表另一变量，注意个位每次要归1
    i=0;
    for(i=11;i<100;i++)
   {
       if(i%10==0||i%10>i/10)
       {
            printf(“\n”);
            i=i/10*10;
        }
       printf(“%d*%d=%d “,i/10,i%10,(i/10)*(i%10));

    }

}
1~81 做九进制
11~99 拆个位和十位
二进制也能做 

没什么难度
引用 15 楼 mujiok2003 的回复:

都是常量，没有变量。 

#include <stdio.h>
void mtable_helper(int const n, int const i)
{
   if(i > n)
   {
     printf("\n");
   }
   else
   {
	   printf("%dx%d=%d ", i, n, i *n); 
	   mtable_helper(n,i+1);
   } 
}

void mtable(int const n)
{
  if(0 == n) return;
  mtable(n-1);
  mtable_helper(n,1);
}

int main()
{
  mtable(9);
  return 0;
}

不是加 const 就叫做 常量 了
明显不符合题意
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

你这叫耍赖
//测试过的绝对好用
#include “stdafx.h”

void main()
{
int i;
i=0;
for(i=11;i<100;i++)
{
if(i%10==0||i%10>i/10)
       {
            printf(“\n”);
            i=i/10*10+10+1;
        }
       printf(“%d*%d=%d “,i/10,i%10,(i/10)*(i%10));
}

}
引用 25 楼 lin5161678 的回复:
Quote: 引用 15 楼 mujiok2003 的回复:

都是常量，没有变量。 

#include <stdio.h>
void mtable_helper(int const n, int const i)
{
   if(i > n)
   {
     printf("\n");
   }
   else
   {
	   printf("%dx%d=%d ", i, n, i *n); 
	   mtable_helper(n,i+1);
   } 
}

void mtable(int const n)
{
  if(0 == n) return;
  mtable(n-1);
  mtable_helper(n,1);
}

int main()
{
  mtable(9);
  return 0;
}

不是加 const 就叫做 常量 了
明显不符合题意

该叫？
可以只用一个变量 
void main()
{
   for(int i=0;i<10;i++)
   {
      printf("%d x 1 = %d ", i, i); 
      if(i>1)
      {
         printf("%d x 2 = %d ", i, i*2); 
         if(i>2)
         {
            printf("%d x 3 = %d ", i, i*3); 
            if(i>3)
            {
               printf("%d x 4 = %d ", i, i*4); 
               if(i>4)
               {
                  printf("%d x 5 = %d ", i, i*5); 
                  if(i>5)
                  {
                     printf("%d x 6 = %d ", i, i*6); 
                     if(i>6)
                     {
                        printf("%d x 7 = %d ", i, i*7); 
                        if(i>7)
                        {
                           printf("%d x 8 = %d ", i, i*8); 
                           if(i>8)
                           {
                              printf("%d x 9 = %d ", i, i*9); 
                           }
                        }
                     }
                  }
               }
            }
         }
      }
   }
}
引用 30 楼 of123 的回复:

可以只用一个变量

void main()
{
   for(int i=0;i<10;i++)
   {
      printf("%d x 1 = %d ", i, i); 
      if(i>1)
      {
         printf("%d x 2 = %d ", i, i*2); 
         if(i>2)
         {
            printf("%d x 3 = %d ", i, i*3); 
            if(i>3)
            {
               printf("%d x 4 = %d ", i, i*4); 
               if(i>4)
               {
                  printf("%d x 5 = %d ", i, i*5); 
                  if(i>5)
                  {
                     printf("%d x 6 = %d ", i, i*6); 
                     if(i>6)
                     {
                        printf("%d x 7 = %d ", i, i*7); 
                        if(i>7)
                        {
                           printf("%d x 8 = %d ", i, i*8); 
                           if(i>8)
                           {
                              printf("%d x 9 = %d ", i, i*9); 
                           }
                        }
                     }
                  }
               }
            }
         }
      }
   }
}

++
不过这有点像文字游戏，不实用。
20楼的程序重新调试一下，现在可以正常输出了。
int main(){
     unsigned char a;

     for (a=0x10 ; a<=0x90 ; a +=0x10 ) {
        for (a +=(a>>4) ; (a&0xf)<=9 ; a++)
           printf(“%d*%d=%d “,a>>4,a&0xf,(a>>4)*(a&0xf) );

        printf(“\n”);
        a &=0xf0;
     }
   return 0;
}
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

这个必须顶，吊炸天啊。如果我是经理，要的就是你。
引用 29 楼 mujiok2003 的回复:
Quote: 引用 25 楼 lin5161678 的回复:
Quote: 引用 15 楼 mujiok2003 的回复:

都是常量，没有变量。 

#include <stdio.h>
void mtable_helper(int const n, int const i)
{
   if(i > n)
   {
     printf("\n");
   }
   else
   {
	   printf("%dx%d=%d ", i, n, i *n); 
	   mtable_helper(n,i+1);
   } 
}

void mtable(int const n)
{
  if(0 == n) return;
  mtable(n-1);
  mtable_helper(n,1);
}

int main()
{
  mtable(9);
  return 0;
}

不是加 const 就叫做 常量 了
明显不符合题意

该叫？

const是用来限定一个“变量”不允许被改变的修饰符。const正确理解应该是 只读变量。
题目说是最多用一个变量。。。
并没说只用一个变量。
如果是面试碰到，还要思考什么，果断2楼的结果啊。。。
其实，不过你怎么做，
一个变量都不够，
即使你代码里面表面上只有一个变量，
但是当执行的时候还是会用到中间变量，
只是你看不到而已
引用 23 楼 jiyy7758521 的回复:

//突然想到一个更简单的
#include <stdio.h>
main()
{
    int i;//取一个变量，用变量的十位代表另一变量，注意个位每次要归1
    i=0;
    for(i=11;i<100;i++)
   {
       if(i%10==0||i%10>i/10)
       {
            printf(“\n”);
            i=i/10*10;
        }
       printf(“%d*%d=%d “,i/10,i%10,(i/10)*(i%10));

    }

}

这个错的
全部打印：
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=
引用 20 楼 LI_HJ 的回复:

很简单啊，把一个变量拆成两半用，例如 unsigned char a,高4位和低4位，就可以了
高4位为 a>>4
代4位为 a &0xf
再设计一个双重循环就可以了

void main{
   unsigned char a;

   for (a=0x10;a<=0x90;a +=x010)
      for (a +=a>>4;a&0xf<=9;a++){
        printf(“%d*%d=%d “,a>>4,a&0xf,(a>>4)*(a&0xf) );
        printf(“\n”);
       }
}
}

你这个什么都没输出

 
#include <stdio.h>

int main(int argc, char* argv[])
{
	__asm {
		xor eax,eax
		mov esi,1
		mov edi,esi
label1:
		cmp  esi,edi 
		jle  la_next
	}
	printf("\n");
	__asm {
		inc  edi
		mov  esi,1
		cmp  edi,0xA
		je   la_exit
la_next:
		mov  eax,edi
		imul esi
		push eax
		push edi
		push esi
	}
	printf("%dx%d=%-2d ");
	__asm
	{
		add  esp,0x0C
		inc  esi
		jmp  label1
la_exit:
	}
	return 0;
}

我是不是可以说一个变量都没用？
引用 40 楼 jha334201553 的回复:

我是不是可以说一个变量都没用？

别人也可以说你的代码 编译不通过
不是吗

 
#include <stdio.h>
#include <time.h>

int main()
{
	struct tm p;

	for (p.tm_hour=1; p.tm_hour<=9; p.tm_hour++)
	{
		for(p.tm_min=1; p.tm_min<=p.tm_hour; p.tm_min++)
		{
			printf("%dx%d=%-2d ", p.tm_min, p.tm_hour, p.tm_min*p.tm_hour);
		}
		printf("\n");
	}
	return 0;
}

编译器内部有一大堆的全局变量都可以用，还有各种头里面也有很多结构体可以用，一个变量，，哈哈哈哈哈哈，你为难谁
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

绝对的人才，偷懒才是好程序员
引用 40 楼 jha334201553 的回复: 
#include <stdio.h>

int main(int argc, char* argv[])
{
	__asm {
		xor eax,eax
		mov esi,1
		mov edi,esi
label1:
		cmp  esi,edi 
		jle  la_next
	}
	printf("\n");
	__asm {
		inc  edi
		mov  esi,1
		cmp  edi,0xA
		je   la_exit
la_next:
		mov  eax,edi
		imul esi
		push eax
		push edi
		push esi
	}
	printf("%dx%d=%-2d ");
	__asm
	{
		add  esp,0x0C
		inc  esi
		jmp  label1
la_exit:
	}
	return 0;
}

我是不是可以说一个变量都没用？

寄存器 变量？
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

好作品往往是很简单地解决问题。
引用 8 楼 vrace 的回复: 
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
	int a;

	for (a = 0x11; a < 0xa0; a++)
	{
		for (a = (a & 0xf0) + 1; (a & 0x0f) <= ((a & 0xf0) >> 4); a++)
		{
			printf("%dx%d=%d\t",
				(a & 0x0f),
				(a & 0xf0) >> 4,
				((a & 0xf0) >> 4) * (a & 0x0f));
		}
		a += 0x10;
		printf("\n");
	}

	return 0;
}

这个应该能满足你的要求…

感觉这个问题直人很无聊
这是大神级回答啊,>> 的使用一直是我崇拜的.
引用 8 楼 vrace 的回复: 
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
	int a;

	for (a = 0x11; a < 0xa0; a++)
	{
		for (a = (a & 0xf0) + 1; (a & 0x0f) <= ((a & 0xf0) >> 4); a++)
		{
			printf("%dx%d=%d\t",
				(a & 0x0f),
				(a & 0xf0) >> 4,
				((a & 0xf0) >> 4) * (a & 0x0f));
		}
		a += 0x10;
		printf("\n");
	}

	return 0;
}

这个应该能满足你的要求…
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

觉得1楼真的霸气外露的感觉，NICE。
来个 C++ 版的 
#include <stdio.h>
#include <stdlib.h>

template <int x> struct line {
	static void print(int m) {
		line<x-1>::print(m);
		printf("%dx%d=%d\t",x,m,m*x);
	}
};
template <> struct line<1> {
	static void print(int m) {
		printf("1x%d=%d\t",m,m);
	}
};
template <int m,int n> struct table {
	static void print() {
		table<m-1,n-1>::print();
		printf("\n");
		line<n>::print(m);
	}
};
template <> struct table<1,1> {
	static void print() {
		printf("1x1=1\t");
	}
};

int main(void)
{
	table<9,9>::print();
	printf("\n");
	return 0;
}
这公司真无聊。。。。
最简单的办法，把一个int变量的高16位和低16位看成2个变量就搞定了
用一个char变量的高4位和低4为可以不？
见到位操作就晕。这个应该就是考查对位操作的使用吧
楼主，哪里来的题目的？
2楼的不是直接输出而已吗？
引用 55 楼 u011688498 的回复:

楼主，哪里来的题目的？
2楼的不是直接输出而已吗？

某家公司的面试题。要求是只能用一个变量的。
引用 13 楼 zhao4zhong1 的回复: 
#include <stdio.h>
int main() {
    printf(
        "1×1=1\n"
        "1×2=2 2×2=4\n"
        "1×3=3 2×3=6  3×3=9 \n"
        "1×4=4 2×4=8  3×4=12 4×4=16\n"
        "1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"
        "1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"
        "1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"
        "1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"
        "1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81"
    );
    return 0;
}

赵老师很久不见，越来越厉害了
引用 9 楼 z542858367 的回复:
Quote: 引用 4 楼 max_min_ 的回复:

1楼可以！递归1个变量貌似不够的！

这个是某个公司的面试题，用字符串打印出来的话人家肯定是不会要的。

这个有乘数小于被乘数的，貌似是不行吧
引用错了……应该引用10楼来着

#include <iostream>
using namespace std;
 
int main()
{
    for (int i = 0; i < 81; i++)
    {
if((i / 9) <= (i % 9))
printf(“%d*%d=%2d  “, (i / 9) + 1, (i % 9) + 1, ((i / 9) + 1) * ((i % 9) + 1));
        if (i % 9 == 8)
        {
            printf(“\n”);
        }
    }
    return 0;
10L基础上代码加一句判断就行了
15楼不错，高手
我又过来蛋疼了 
#include <stdio.h>

#define MOD_VALUE  15

int main(int argc, char* argv[])
{
	int a;
	for (a=1; a%MOD_VALUE<=9; a++)
	{
		for (a=a%MOD_VALUE+MOD_VALUE; a/MOD_VALUE<=a%MOD_VALUE; a+=MOD_VALUE)
		{
			printf("%d+%d=%-2d ", a/MOD_VALUE, a%MOD_VALUE, (a%MOD_VALUE)*(a/MOD_VALUE) );
		}
		printf("\n");
	}
	return 0;
}

只要MOD_VALUE是大于10的数，这个代码都成立，代码那是何其多啊
引用 61 楼 jha334201553 的回复:

我又过来蛋疼了

#include <stdio.h>

#define MOD_VALUE  15

int main(int argc, char* argv[])
{
	int a;
	for (a=1; a%MOD_VALUE<=9; a++)
	{
		for (a=a%MOD_VALUE+MOD_VALUE; a/MOD_VALUE<=a%MOD_VALUE; a+=MOD_VALUE)
		{
			printf("%d+%d=%-2d ", a/MOD_VALUE, a%MOD_VALUE, (a%MOD_VALUE)*(a/MOD_VALUE) );
		}
		printf("\n");
	}
	return 0;
}

只要MOD_VALUE是大于10的数，这个代码都成立，代码那是何其多啊

上面那个左右啊，右移啊的，什么的，不就是这个MOD_VALUE值等于16的时候的代码意思么。。。。。。。。。

我觉得，面试官不是要你的实用代码，而是看你是否有宽阔的思路，你尽可以给出多种解法。

软件在方案设计的时候，就是要不先入为主，而是列出多种实现供评估和选择。
引用 37 楼 N_sev7 的回复:

其实，不过你怎么做，
一个变量都不够，
即使你代码里面表面上只有一个变量，
但是当执行的时候还是会用到中间变量，
只是你看不到而已

完全同意，中间太多的临时变量了.递归的话更多，15楼的递归参数就是2个变量
引用 28 楼 jiyy7758521 的回复:

//测试过的绝对好用
#include “stdafx.h”

void main()
{
int i;
i=0;
for(i=11;i<100;i++)
{
if(i%10==0||i%10>i/10)
       {
            printf(“\n”);
            i=i/10*10+10+1;
        }
       printf(“%d*%d=%d “,i/10,i%10,(i/10)*(i%10));
}

}

给力  给了很多思路啊.一个变量的高八位 低8位，一个数字的10位个位
int i;

for(i = 11; i < 100; i++) {
if(i % 10 <= i / 10 && i % 10 != 0) {
printf(“%d*%d=%d\t”, i % 10, i / 10, (i / 10) * (i % 10));
}
if(i % 10 == 0) {
printf(“\n”);
i = i / 10 * 10;
}
}
不用变量的猴哥吊炸了，思路果然奇特
如果将一个int型的分为高位和低位两部分来做的话，
为啥不：
typedef struct
{
int i;
int j;
}OneVariate；
在main函数里我就定义一个OneVariate类型的变量  按那种思路也完全符合题意的喽？  也只用一个变量（OneVariate类型）！
这个是每个C语言教本都有的范例啊。
直接按照范例。。。。
8楼，15楼 都是高手啊 膜拜中~~~
好像是酷派手机
小白来学习！不错啊啊啊啊啊啊啊啊啊啊啊阿！
用java写了一个，虽然只用过了一个变量，但是感觉有点违规，因为这样的话如果一个参数不用也可以完成的。 
//打印9*9乘法表，只用一个变量。
	public static void main(String[] args) {
		int i=0;
		for(i=1;i<=3;i++){
			show(i);
		}
	}
	public static void show(int i){
		System.out.println("1*"+i+"="+1*i);
		System.out.println("2*"+i+"="+2*i);
		System.out.println("3*"+i+"="+3*i);
	}
引用 41 楼 lin5161678 的回复:
Quote: 引用 40 楼 jha334201553 的回复:

我是不是可以说一个变量都没用？

别人也可以说你的代码 编译不通过
不是吗

这个和编译器有点相关性，gcc支持__asm__,或者asm,在其他编译器下，这个关键字写法不一致！
引用 46 楼 line_us 的回复:
Quote: 引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

好作品往往是很简单地解决问题。

绝对最佳答案,拒绝过度设计.
引用 13 楼 zhao4zhong1 的回复: 
#include <stdio.h>
int main() {
    printf(
        "1×1=1\n"
        "1×2=2 2×2=4\n"
        "1×3=3 2×3=6  3×3=9 \n"
        "1×4=4 2×4=8  3×4=12 4×4=16\n"
        "1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"
        "1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"
        "1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"
        "1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"
        "1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81"
    );
    return 0;
}

赵老师总是让人迷信
能解决问题的方法就是好方法，1L厉害！
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

牛逼。。。
引用 59 楼 u012352859 的回复:

引用错了……应该引用10楼来着

#include <iostream>
using namespace std;
 
int main()
{
    for (int i = 0; i < 81; i++)
    {
if((i / 9) <= (i % 9))
printf(“%d*%d=%2d  “, (i / 9) + 1, (i % 9) + 1, ((i / 9) + 1) * ((i % 9) + 1));
        if (i % 9 == 8)
        {
            printf(“\n”);
        }
    }
    return 0;
10L基础上代码加一句判断就行了

把if((i / 9) <= (i % 9))改为if((i / 9) >= (i % 9))好看一些啦
思路还是受教了
九九乘法表是个不变的，何必用变量。
哈哈
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

太残暴了
威武啊，呵呵，
一个问题可以有这么多重接法
最好的解决办法，如果不是考察算法的话。
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}
引用 83 楼 u010131960 的回复:
Quote: 引用 59 楼 u012352859 的回复:

引用错了……应该引用10楼来着

#include <iostream>
using namespace std;
 
int main()
{
    for (int i = 0; i < 81; i++)
    {
if((i / 9) <= (i % 9))
printf(“%d*%d=%2d  “, (i / 9) + 1, (i % 9) + 1, ((i / 9) + 1) * ((i % 9) + 1));
        if (i % 9 == 8)
        {
            printf(“\n”);
        }
    }
    return 0;
10L基础上代码加一句判断就行了

把if((i / 9) <= (i % 9))改为if((i / 9) >= (i % 9))好看一些啦
思路还是受教了
乘法表是固定的，何须变量。。。
这才叫设计，不是去显摆技术。
用最简单的方法满足客户需求就是好方案！客户管你用了几个变量
一楼 快准狠 赞一个
引用 56 楼 z542858367 的回复:
Quote: 引用 55 楼 u011688498 的回复:

楼主，哪里来的题目的？
2楼的不是直接输出而已吗？

某家公司的面试题。要求是只能用一个变量的。

原来是这样，那只能设置被乘数是变量了？
这题目没意义吧
课本上有。
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

牛B，确实只用了一个变量···tbl
菜鸟学习了！
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

赞……
   1L给力。
路过学习了。一楼的才是最好的。
引用 42 楼 jha334201553 的回复: 
#include <stdio.h>
#include <time.h>

int main()
{
	struct tm p;

	for (p.tm_hour=1; p.tm_hour<=9; p.tm_hour++)
	{
		for(p.tm_min=1; p.tm_min<=p.tm_hour; p.tm_min++)
		{
			printf("%dx%d=%-2d ", p.tm_min, p.tm_hour, p.tm_min*p.tm_hour);
		}
		printf("\n");
	}
	return 0;
}

编译器内部有一大堆的全局变量都可以用，还有各种头里面也有很多结构体可以用，一个变量，，哈哈哈哈哈哈，你为难谁

好机智，我喜欢
“只能用一个”和“最多只能用一个”不是一回事！
哎~不知道做什么会真正用到这种东西
 
#include <stdio.h>

int main(void)
{
        int i=11;
        while(i<=100){
                while(1){
                        printf("%2d x %2d = %2d ",i/10,i%10,(i/10)*(i%10));
                        if(i%10==9){
                                printf("\n");
                                break;
                        }
                        i++;
                }
                i+=2;
        }
        return 0;
}
 
void print(int i,int j){
    if(i<=9){
    if(j<=9){
	cout<<i*j<<" ";
	print(i,j+1);
    }else{
	cout<<"\n";
	print(i+1,1);
    }
    }
};

int main(){
    print(1,1);
    return 0;
}
这个其实不难
 
void print(int i){
    if((i>>4)<=9){
    if((i&0x0f)<=9){
	cout<<(i>>4)*(i&0x0f)<<" ";
	print(i+0x01);
    }else{
	cout<<"\n";
	print((i&0xf0)+0x11);
    }
    }
};

int main(){
   print(0x11);
    return 0;
}
这有意义吗，这种题目？
其实这是一个找函数的过程：求两个个函数，其变量为x,x取值范围为0-N，N=1+2+3+…+9，
且有：
f1(x):f1(1)=1, [f1(2)=1,f1(3)=2], [f1(4)=1,f1(5)=2,f1(6)=3],…
f2(x):f2(1)=1, [f2(2)=2,f2(3)=2], [f2(4)=3,f2(5)=3,f2(6)=3],…
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

我想说一楼神回复
学习下
8楼和15楼，膜拜
炫耀帖。
省了变量就浪费了代码或堆栈。。。
高人!
 
#include <stdio.h>

#define HALF_BIT_SIZE 4
#define FULL_MASK 255
#define RMASK (FULL_MASK >> HALF_BIT_SIZE)//0000 1111
#define LMASK (FULL_MASK << HALF_BIT_SIZE)//1111 0000
#define LSET(b, n) ((b) = ((b) & RMASK) ^ ((n) << HALF_BIT_SIZE))
#define RSET(b, n) ((b) = ((b) & LMASK) ^ (n))
#define LGET(b) ((b) >> HALF_BIT_SIZE)
#define RGET(b) ((b) & RMASK)
#define GRID 3
#define FULLGRID (GRID * GRID)

int main()
{
	unsigned char s = 0;
	for(LSET(s, 1); LGET(s) <= FULLGRID; LSET(s, LGET(s) + 1))
	{
		for(RSET(s, 1); RGET(s) <= LGET(s); RSET(s, RGET(s) + 1) )
		{
			printf("%d * %d = %d ",LGET(s), RGET(s), LGET(s) * RGET(s));
		}
		putchar(""\n"");
	}
}
把一个字节分成高四位和低四位。
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

神一般的存在
那他要是要输入N*N的乘法表，除N之外再最多只能用一个变量，那应该怎么编呢？
引用 116 楼 longdongshenye 的回复:

那他要是要输入N*N的乘法表，除N之外再最多只能用一个变量，那应该怎么编呢？

输出N*N的乘法表。。。。。
引用 8 楼 vrace 的回复: 
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
	int a;

	for (a = 0x11; a < 0xa0; a++)
	{
		for (a = (a & 0xf0) + 1; (a & 0x0f) <= ((a & 0xf0) >> 4); a++)
		{
			printf("%dx%d=%d\t",
				(a & 0x0f),
				(a & 0xf0) >> 4,
				((a & 0xf0) >> 4) * (a & 0x0f));
		}
		a += 0x10;
		printf("\n");
	}

	return 0;
}

这个应该能满足你的要求…

哈哈。。。直接char不久行了。。。int还浪费字节
引用 8 楼 vrace 的回复: 
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
	int a;

	for (a = 0x11; a < 0xa0; a++)
	{
		for (a = (a & 0xf0) + 1; (a & 0x0f) <= ((a & 0xf0) >> 4); a++)
		{
			printf("%dx%d=%d\t",
				(a & 0x0f),
				(a & 0xf0) >> 4,
				((a & 0xf0) >> 4) * (a & 0x0f));
		}
		a += 0x10;
		printf("\n");
	}

	return 0;
}

这个应该能满足你的要求…

这个a应该算是两个变量，应该不是一个变量
引用 8 楼 vrace 的回复: 
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
	int a;

	for (a = 0x11; a < 0xa0; a++)
	{
		for (a = (a & 0xf0) + 1; (a & 0x0f) <= ((a & 0xf0) >> 4); a++)
		{
			printf("%dx%d=%d\t",
				(a & 0x0f),
				(a & 0xf0) >> 4,
				((a & 0xf0) >> 4) * (a & 0x0f));
		}
		a += 0x10;
		printf("\n");
	}

	return 0;
}

这个应该能满足你的要求…

我觉得8楼这个应该是很不错的.这家公司肯定是在考查空间复杂度之类的… …
引用 105 楼 baso1623 的回复:

这有意义吗，这种题目？

面试题不都这样
delphi 算法
var
  i: Integer;
begin
  for i:= 10 to 99 do
  begin
    if (i div 10) <= (i mod 10) then
    mmo1.Lines.Add(IntToStr(i div 10) + “”*”” + IntToStr(i mod 10) + “”=”” +IntToStr((i div 10) * (i mod 10)));
  end;
end;
C 
int a 
for (a = 99;a>11;a–)
{
  if (a /10) <= (a%10)
{
   printf(“%d*%d=%d\t”,a/10,a%10,(a/10)*(a%10));
}
  if (a%10) = 0
{ 
  printf(“\n”) 
}
}
  
不太明白为啥会用到这个呢啊
引用 124 楼 sywcxx 的回复:

不太明白为啥会用到这个呢啊

面试题都很扯的。
真的不懂一个变量  求解释
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

神一般的2楼
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

+1
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

自古二楼出人才啊

 
        unsigned char a = 0x11;
        for(;(a>>4)<0xa;a = a + 0x10)
        {
                for(a= (a & 0xf0) | 0x01 ;(a&0x0f)<=(a>>4);a++)
                {
                        cout<<(a&0x0f)<<"x"<<(a>>4)<<" ";
                }
                cout<<endl;
        }
该帖都推到首页啦~
package test;

import java.util.Date;

public class testt {

/**
* @param args
*/
public static void main(String[] args) throws Exception{
// TODO Auto-generated method stub

//System.out.println(new Date().getTime());
while(true){
System.out.println((new Date().getTime()/1000L)%10+””);
for(int i=1;i<=(new Date().getTime()/1000L)%10;i++){
System.out.println(” “+(new Date().getTime()/1000L)%10+”X”+i+”=”+(new Date().getTime()/1000L)%10*i);
}
Thread.sleep(999);
if((new Date().getTime()/1000L)>1382093622){break;}

}

}

}

输出是这个：
0
1
1X1=1
2
2X1=2
2X2=4
3
3X1=3
3X2=6
3X3=9
4
4X1=4
4X2=8
4X3=12
4X4=16
5
5X1=5
5X2=10
5X3=15
5X4=20
5X5=25
6
6X1=6
6X2=12
6X3=18
6X4=24
6X5=30
6X6=36
7
7X1=7
7X2=14
7X3=21
7X4=28
7X5=35
7X6=42
7X7=49
8
8X1=8
8X2=16
8X3=24
8X4=32
8X5=40
8X6=48
8X7=56
8X8=64
9
9X1=9
9X2=18
9X3=27
9X4=36
9X5=45
9X6=54
9X7=63
9X8=72
9X9=81
我还是觉得我这个简单
python写的 
def A(n):
    if 0< n <= 9:
        A(n-1)
        for i in range(1,n+1):
            print "%2sx%2s=%2s"%(i,n,i*n),
        print

A(9)

>>> 
 1x 1= 1
 1x 2= 2  2x 2= 4
 1x 3= 3  2x 3= 6  3x 3= 9
 1x 4= 4  2x 4= 8  3x 4=12  4x 4=16
 1x 5= 5  2x 5=10  3x 5=15  4x 5=20  5x 5=25
 1x 6= 6  2x 6=12  3x 6=18  4x 6=24  5x 6=30  6x 6=36
 1x 7= 7  2x 7=14  3x 7=21  4x 7=28  5x 7=35  6x 7=42  7x 7=49
 1x 8= 8  2x 8=16  3x 8=24  4x 8=32  5x 8=40  6x 8=48  7x 8=56  8x 8=64
 1x 9= 9  2x 9=18  3x 9=27  4x 9=36  5x 9=45  6x 9=54  7x 9=63  8x 9=72  9x 9=81
>>> 
引用 8 楼 vrace 的回复: 
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
	int a;

	for (a = 0x11; a < 0xa0; a++)
	{
		for (a = (a & 0xf0) + 1; (a & 0x0f) <= ((a & 0xf0) >> 4); a++)
		{
			printf("%dx%d=%d\t",
				(a & 0x0f),
				(a & 0xf0) >> 4,
				((a & 0xf0) >> 4) * (a & 0x0f));
		}
		a += 0x10;
		printf("\n");
	}

	return 0;
}

这个应该能满足你的要求…

很牛。
引用 8 楼 vrace 的回复: 
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
	int a;

	for (a = 0x11; a < 0xa0; a++)
	{
		for (a = (a & 0xf0) + 1; (a & 0x0f) <= ((a & 0xf0) >> 4); a++)
		{
			printf("%dx%d=%d\t",
				(a & 0x0f),
				(a & 0xf0) >> 4,
				((a & 0xf0) >> 4) * (a & 0x0f));
		}
		a += 0x10;
		printf("\n");
	}

	return 0;
}

这个应该能满足你的要求…

位分段，这个应该是正解吧
表示高手很多，膜拜
引用 68 楼 N_sev7 的回复:

如果将一个int型的分为高位和低位两部分来做的话，
为啥不：
typedef struct
{
int i;
int j;
}OneVariate；
在main函数里我就定义一个OneVariate类型的变量  按那种思路也完全符合题意的喽？  也只用一个变量（OneVariate类型）！

这个思路比较好，变量不是非得按照先入为主的就得是int这种常规变量，自定义一个结构体，完全可以满足题得要求，感觉如果是面试题的，这种答案应该会更符合题意
引用 22 楼 jiyy7758521 的回复:

#include <stdio.h>
main()
{
    int i;//取一个变量，用变量的十位代表另一变量，注意个位每次要归1
    i=0;
    for(i=11;i<92;i+=10)
   {
       for(;i%10<=i/10;i++)
       {
            printf(“%d*%d=%d “,i/10,i%10,(i/10)*(i%10));
        }
        i=i/10*10+1;
        printf(“\n”);

    }

}

mark!
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

膜拜大神
引用 42 楼 jha334201553 的回复: 
#include <stdio.h>
#include <time.h>

int main()
{
	struct tm p;

	for (p.tm_hour=1; p.tm_hour<=9; p.tm_hour++)
	{
		for(p.tm_min=1; p.tm_min<=p.tm_hour; p.tm_min++)
		{
			printf("%dx%d=%-2d ", p.tm_min, p.tm_hour, p.tm_min*p.tm_hour);
		}
		printf("\n");
	}
	return 0;
}

编译器内部有一大堆的全局变量都可以用，还有各种头里面也有很多结构体可以用，一个变量，，哈哈哈哈哈哈，你为难谁

这也行…
引用 40 楼 jha334201553 的回复: 
#include <stdio.h>

int main(int argc, char* argv[])
{
	__asm {
		xor eax,eax
		mov esi,1
		mov edi,esi
label1:
		cmp  esi,edi 
		jle  la_next
	}
	printf("\n");
	__asm {
		inc  edi
		mov  esi,1
		cmp  edi,0xA
		je   la_exit
la_next:
		mov  eax,edi
		imul esi
		push eax
		push edi
		push esi
	}
	printf("%dx%d=%-2d ");
	__asm
	{
		add  esp,0x0C
		inc  esi
		jmp  label1
la_exit:
	}
	return 0;
}

我是不是可以说一个变量都没用？

=.=!
引用 40 楼 jha334201553 的回复: 
#include <stdio.h>

int main(int argc, char* argv[])
{
	__asm {
		xor eax,eax
		mov esi,1
		mov edi,esi
label1:
		cmp  esi,edi 
		jle  la_next
	}
	printf("\n");
	__asm {
		inc  edi
		mov  esi,1
		cmp  edi,0xA
		je   la_exit
la_next:
		mov  eax,edi
		imul esi
		push eax
		push edi
		push esi
	}
	printf("%dx%d=%-2d ");
	__asm
	{
		add  esp,0x0C
		inc  esi
		jmp  label1
la_exit:
	}
	return 0;
}

我是不是可以说一个变量都没用？

看不懂。。。
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

屌炸天
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

顶
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

一个变量也就这个可以了
引用 8 楼 vrace 的回复: 
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
	int a;

	for (a = 0x11; a < 0xa0; a++)
	{
		for (a = (a & 0xf0) + 1; (a & 0x0f) <= ((a & 0xf0) >> 4); a++)
		{
			printf("%dx%d=%d\t",
				(a & 0x0f),
				(a & 0xf0) >> 4,
				((a & 0xf0) >> 4) * (a & 0x0f));
		}
		a += 0x10;
		printf("\n");
	}

	return 0;
}

这个应该能满足你的要求…

这才是标准答案吧，顶。
这样写算是用一个变量嘛 
#include <stdio.h>
#include <stdlib.h>
void print_multitable(int n)
{
	if (!n)
	{
		return;
	}
	int i=0;
	print_multitable(n-1);
	for (i=1;i<=n;i++)
	{
		printf("%dx%d=%-2d ",i,n,i*n);
	}
	printf("\n");
}
void fun()
{
	print_multitable(9);
}
int main(void) 
{    
	fun();
	return 0;
} 
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

赞， 开发软件 越简单粗暴越好

#8楼代码解析：

#include <stdio.h>
void fun1()
{
	//【1】最基本步骤
	int x,y;
	for (x=1;x<10;x++)
	{
		for (y=1;y<=x;y++)
		{
			printf("%dx%d=%-2d ",y,x,x*y);
		}
		printf("\n");
	}
}
void fun2()
{
	//【2】定义一个变量unsigned char a; 0000 0000 分别取高低字节代替x,y
	unsigned char a;//可以取unsigned char因其范围在0-255，满足拆分条件
	//0x10: 0001 0000 --高字节为1
	//0xa0: 1010 0000 --高字节为10
	//a+=0x10 --高字节每次加1
	for (a=0x10;a< 0xa0;a+=0x10)//定义高字节部分
	{
		//低字节赋值1且不破坏高字节部分;低字节部分小于高字节部分;低字节部分++
		for (a=(a & 0xf0)+1;(a & 0x0f)<=((a & 0xf0)>>4);a++)
		{
			printf("%dx%d=%-2d ",
				(a & 0x0f),//低字节部分
				(a & 0xf0)>>4,//高字节部分
				((a & 0xf0)>>4)*(a & 0x0f));
		}
		printf("\n");
	}
}
int main(void)
{     
    fun2();
	return 0; 
} 


#include <stdio.h> 
#include <stdlib.h> 
int main()
{
	int i;     
    for (i = 17; i <160; i++)//17=10001(2),160=10100000(2)
    {
        for (i = (i & 240) + 1; (i & 15) <= ((i & 240)>> 4); i++)//240=11110000(2),15=1111(2)
        {
            printf("%d×%d=%d\t",
                (i & 15),
                (i & 240) >> 4,
                ((i &240) >> 4) * (i & 15));
        }
        i +=16;//16=10000(2)
        printf("\n");
    }     
	system("pause");
	return 0;
}

要求最多只能用一个变量打印出九九乘法表，是因为有两个变量的算法：

#include <stdio.h> 
#include <stdlib.h> 
int main()
{  

	int i=1;
	int j;
	while(i<=9)
	{
        for(j=1;j<=i;j++)
		{
			 printf("%d×%d=%d\t",j,i,i*j);
		} 
		i++;
		printf("\n");
	}   
	system("pause");
	return 0;
}
 
#include <stdio.h> 
#include <stdlib.h> 
int main()
{  
	int i[2];
	for(i[0]=1;i[0]<=9;i[0]++)
	{
		for(i[1]=1;i[1]<=i[0];i[1]++)
		{
			 printf("%d×%d=%d\t",i[1],i[0],i[1]*i[0]);
		} 
		printf("\n");
	}
	system("pause");
	return 0;
}

这也只有一个变量i[2]

 
#include <stdio.h>
#include <stdlib.h>
int main(void) 
{   
	int i;   
    for(i=21;i<108;i+=10)
   {
       for(i=i/11*11+1;i%11<=i/11;i++)
       {
            printf("%d×%d=%d ",i%11,i/11,(i/11)*(i%11));
        }       
        printf("\n");
	}
	system("pause");
    return 0;
} 

这个可以理解了
#include <stdio.h>
void main()
{
    int i = 0;
for(i = 0; i < 81; i++)
{
printf(“%d * %d = %2d  “, (i / 9) + 1, (i % 9) + 1, ((i / 9) + 1)*((i % 9) + 1));
    if ((i + 1) % 9 == 0) printf(“\n”);
}
}
#include <stdio.h>
void main()
{
    int i = 0;
    for(i = 0; i < 81; i++)
    {
        printf(“%d * %d = %2d  “, (i / 9) + 1, (i % 9) + 1, ((i / 9) + 1)*((i % 9) + 1));
        if ((i + 1) % 9 == 0) printf(“\n”);
    }
}
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

高手！
一个变量，又没有说变量类型。定义一个结构体
typdef struct MEM_MULT
{
 int i;
 int j;
}MEM_MULT_S;

程序就是循环。。。此处省略10行代码。

当然还可以改进一下，一个int空间当两个用。9*9足够用
typdef struct MEM_MULT
{
 int i ：4;
 int j ：4;
}MEM_MULT_S;

如果觉得结构体不“厚道”，硬是一个变量。int 高4位一个数，低四位一个数。想想关系也是可以写出来的。

这道题有点像《编程之美》里的中国象棋将帅问题。LZ可以借鉴借鉴
这个可以用位操作来做，将一个变量（如int型）高位看为一个变量，低位看为另一个变量。如果可以用自定义类型就自己定义一个有两个变量的类型就可以了，不过这种方法不一定被承认。
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

必须顶！
引用 8 楼 vrace 的回复: 
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
	int a;

	for (a = 0x11; a < 0xa0; a++)
	{
		for (a = (a & 0xf0) + 1; (a & 0x0f) <= ((a & 0xf0) >> 4); a++)
		{
			printf("%dx%d=%d\t",
				(a & 0x0f),
				(a & 0xf0) >> 4,
				((a & 0xf0) >> 4) * (a & 0x0f));
		}
		a += 0x10;
		printf("\n");
	}

	return 0;
}

这个应该能满足你的要求…

请问这里的const可以不用么？
引用 42 楼 jha334201553 的回复: 
#include <stdio.h>
#include <time.h>

int main()
{
	struct tm p;

	for (p.tm_hour=1; p.tm_hour<=9; p.tm_hour++)
	{
		for(p.tm_min=1; p.tm_min<=p.tm_hour; p.tm_min++)
		{
			printf("%dx%d=%-2d ", p.tm_min, p.tm_hour, p.tm_min*p.tm_hour);
		}
		printf("\n");
	}
	return 0;
}

编译器内部有一大堆的全局变量都可以用，还有各种头里面也有很多结构体可以用，一个变量，，哈哈哈哈哈哈，你为难谁

牛就一个字！
引用 10 楼 amoyman 的回复:

问题是：这种题目有意思吗？

#include <iostream>
using namespace std;

int main()
{
	for (int i = 0; i < 81; i++)
	{
		printf_s("%d*%d=%2d  ", (i / 9) + 1, (i % 9) + 1, ((i / 9) + 1) * ((i % 9) + 1));
		if (i % 9 == 8)
		{
			printf_s("\n");
		}
	}
	return 0;
}

简洁易懂，这个好
引用 68 楼 N_sev7 的回复:

如果将一个int型的分为高位和低位两部分来做的话，
为啥不：
typedef struct
{
int i;
int j;
}OneVariate；
在main函数里我就定义一个OneVariate类型的变量  按那种思路也完全符合题意的喽？  也只用一个变量（OneVariate类型）！

这个也很赞。。
引用 楼主 z542858367 的回复:

c语言要求最多只能用一个变量打印出九九乘法表。

把1个变量拆成2半来用

 
#include <stdio.h>

void main(void)
{
	int i;

	for(i=11; i<100; i++)
	{
		if((i % 10) != 0)
		{
			if((i % 10) <= (i / 10))
			{
				printf("%dx%d=%d   ", i % 10, i / 10, (i % 10) * (i / 10));
			}
		}
		else
		{
			printf("\n");
		}
	}
}
简单，快速，高效，别人看得懂，就是好程序
引用 44 楼 N_sev7 的回复:
Quote: 引用 40 楼 jha334201553 的回复: 
#include <stdio.h>

int main(int argc, char* argv[])
{
	__asm {
		xor eax,eax
		mov esi,1
		mov edi,esi
label1:
		cmp  esi,edi 
		jle  la_next
	}
	printf("\n");
	__asm {
		inc  edi
		mov  esi,1
		cmp  edi,0xA
		je   la_exit
la_next:
		mov  eax,edi
		imul esi
		push eax
		push edi
		push esi
	}
	printf("%dx%d=%-2d ");
	__asm
	{
		add  esp,0x0C
		inc  esi
		jmp  label1
la_exit:
	}
	return 0;
}

我是不是可以说一个变量都没用？

寄存器 变量？

是嵌入了汇编。不是寄存器变量。。
代码真心漂亮
引用 14 楼 stack009 的回复:
Quote: 引用 8 楼 vrace 的回复: 
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
	int a;

	for (a = 0x11; a < 0xa0; a++)
	{
		for (a = (a & 0xf0) + 1; (a & 0x0f) <= ((a & 0xf0) >> 4); a++)
		{
			printf("%dx%d=%d\t",
				(a & 0x0f),
				(a & 0xf0) >> 4,
				((a & 0xf0) >> 4) * (a & 0x0f));
		}
		a += 0x10;
		printf("\n");
	}

	return 0;
}

这个应该能满足你的要求…

我靠，表示看不懂8楼的代码啊，谁能解答一下，看着挺巧妙的样子

 0x11== 0001 0001
 0xa0== 1010 0000
 0xf0== 1111 0000
 0x0f== 0000 1111
把一个int 型变量掰成两半用了。
分成高4位和低4位。
大家思路真多的
有求Remainder和division的方法
有用template的方法
还有直接打印乘法表的方法
还用变量都不用
用向量Vector的方法也可以算一个的了，一个变量的
引用 44 楼 N_sev7 的回复:
Quote: 引用 40 楼 jha334201553 的回复: 
#include <stdio.h>

int main(int argc, char* argv[])
{
	__asm {
		xor eax,eax
		mov esi,1
		mov edi,esi
label1:
		cmp  esi,edi 
		jle  la_next
	}
	printf("\n");
	__asm {
		inc  edi
		mov  esi,1
		cmp  edi,0xA
		je   la_exit
la_next:
		mov  eax,edi
		imul esi
		push eax
		push edi
		push esi
	}
	printf("%dx%d=%-2d ");
	__asm
	{
		add  esp,0x0C
		inc  esi
		jmp  label1
la_exit:
	}
	return 0;
}

我是不是可以说一个变量都没用？

寄存器 变量？

看不懂
真热闹啊， 来个C++版本的 
#include <iostream>
#include <iomanip>
using namespace std;

template <int N , int I>
struct MPRINT : public MPRINT<N, I+1>
{
	MPRINT(){cout<<N-I<<"x"<<N<<"="<<setw(2)<<left<<N*(N-I)<<" ";}
};

template <int N>
struct MPRINT<N,N>
{
};
template <int N>
struct M : public M<N-1>
{
	M(){cout<<endl;}
	MPRINT<N,0> mp;
};

template <>
class M<0>
{
};

int main()
{
	M<9> m;
	return 0;
}
这种题目的意义在哪里？
引用 167 楼 M173475237 的回复:
Quote: 引用 44 楼 N_sev7 的回复:
Quote: 引用 40 楼 jha334201553 的回复: 
#include <stdio.h>

int main(int argc, char* argv[])
{
	__asm {
		xor eax,eax
		mov esi,1
		mov edi,esi
label1:
		cmp  esi,edi 
		jle  la_next
	}
	printf("\n");
	__asm {
		inc  edi
		mov  esi,1
		cmp  edi,0xA
		je   la_exit
la_next:
		mov  eax,edi
		imul esi
		push eax
		push edi
		push esi
	}
	printf("%dx%d=%-2d ");
	__asm
	{
		add  esp,0x0C
		inc  esi
		jmp  label1
la_exit:
	}
	return 0;
}

我是不是可以说一个变量都没用？

寄存器 变量？

是嵌入了汇编。不是寄存器变量。。
代码真心漂亮

哎…
引用 13 楼 zhao4zhong1 的回复: 
#include <stdio.h>
int main() {
    printf(
        "1×1=1\n"
        "1×2=2 2×2=4\n"
        "1×3=3 2×3=6  3×3=9 \n"
        "1×4=4 2×4=8  3×4=12 4×4=16\n"
        "1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"
        "1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"
        "1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"
        "1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"
        "1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81"
    );
    return 0;
}

为何还能这样？printf不是只能有两个引号么？
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

膜拜~~
直接打印，连变量都用不上
引用 29 楼 mujiok2003 的回复:
Quote: 引用 25 楼 lin5161678 的回复:
Quote: 引用 15 楼 mujiok2003 的回复:

都是常量，没有变量。 

#include <stdio.h>
void mtable_helper(int const n, int const i)
{
   if(i > n)
   {
     printf("\n");
   }
   else
   {
	   printf("%dx%d=%d ", i, n, i *n); 
	   mtable_helper(n,i+1);
   } 
}

void mtable(int const n)
{
  if(0 == n) return;
  mtable(n-1);
  mtable_helper(n,1);
}

int main()
{
  mtable(9);
  return 0;
}

不是加 const 就叫做 常量 了
明显不符合题意

该叫？

这确实不能称之为常量了，加了const 也只能称为只读变量。你每次递归初始化的值都不一样，常量的话程序执行期间都是不能改变的。
引用 177 楼 luquan1 的回复:

常量的话程序执行期间都是不能改变的。

这是不存在的.
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

 const限定的量也是一个变量啊  它又不是真正的常量，c语言是不存在真正的常量的
引用 179 楼 hnust_xiehonghao 的回复:
Quote: 引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

 const限定的量也是一个变量啊  它又不是真正的常量，c语言是不存在真正的常量的

C语言可以有三种方法定义一个常量：#define、const和枚举，但只有枚举才是真正的常量，什么是真正的常量？真正的常量是没有存储空间的，是一个右值，这意味着通过任何合法的手段也不会被修改，但被const修饰的对象依然是一个左值，尽管这个对象被const限定，笔者仍然至少可以找到三种合法的手段去修改它，而#define所做的只不过是编译期替换而已，只有枚举常量才能真正做到这一点。const实在不应该被命名为const，这会让人们产生误解，它应该命名为readonly或类似的字眼，意即不能通过被const修饰的对象修改它所指向的对象或者它所代表的对象。但在C的世界里把const称为常量早已是普遍的现象
参考 再再论指针  http://blog.csdn.net/megaboy/article/details/482769  另外枚举变量算得上是真正的变量   我一开始搞错了
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

有才 妈妈再也不用担心我的学习了
呵呵。思路都很开阔。
我猜主考官想要的标准答案大概是这样子的。 
#include <stdio.h>

void print_mtable(int n)
{
int i;

if (n > 1)
  print_mtable(9);
for(i=1; i<=n; i++)
  printf("%d*%d=%d\t", i, n);
printf("\n");
}

int main()
{
print_mtable(9);
return 0;
}
更正第8行一个错误。 
#include <stdio.h>
 
void print_mtable(int n)
{
int i;
 
if (n > 1)
  print_mtable(9);
for(i=1; i<=n; i++)
  printf("%d*%d=%d\t", i, n);
printf("\n");
}
 
int main()
{
print_mtable(9);
return 0;
}
 
#include <stdio.h>
 
void print_mtable(int n)
{
int i;
 
if (n > 1)
  print_mtable(n);
for(i=1; i<=n; i++)
  printf("%d*%d=%d\t", i, n);
printf("\n");
}
 
int main()
{
print_mtable(9);
return 0;
}
高手如云，学习了
2楼是绝世高人，8楼第二个for里面算不算用到第二个变量？
个人觉得184楼思路才是正解，虽然代码有几个小错~~
引用 49 楼 u012208120 的回复:
Quote: 引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

觉得1楼真的霸气外露的感觉，NICE。

跳出约束，满量完成问题，这才是好代码嘛
不用变量的代码应该是 
int main()
{
printf( "1×1=1\n
             1×2=2 2×2=4\n
             1×3=3 2×3=6 3×3=9 \n
             1×4=4 2×4=8 3×4=12 4×4=16\n  
             1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n 
             1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n 
             1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n  
             1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n
             1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81");
  return 0;
}
引用 8 楼 vrace 的回复: 
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
	int a;

	for (a = 0x11; a < 0xa0; a++)
	{
		for (a = (a & 0xf0) + 1; (a & 0x0f) <= ((a & 0xf0) >> 4); a++)
		{
			printf("%dx%d=%d\t",
				(a & 0x0f),
				(a & 0xf0) >> 4,
				((a & 0xf0) >> 4) * (a & 0x0f));
		}
		a += 0x10;
		printf("\n");
	}

	return 0;
}

这个应该能满足你的要求…

这行代码真厉害，虽然不怎么完美。
引用 162 楼 smtctc 的回复:
Quote: 引用 10 楼 amoyman 的回复:

问题是：这种题目有意思吗？

#include <iostream>
using namespace std;

int main()
{
	for (int i = 0; i < 81; i++)
	{
		printf_s("%d*%d=%2d  ", (i / 9) + 1, (i % 9) + 1, ((i / 9) + 1) * ((i % 9) + 1));
		if (i % 9 == 8)
		{
			printf_s("\n");
		}
	}
	return 0;
}

简洁易懂，这个好

这个编译出来的版面很乱。
引用 34 楼 qiminixi 的回复:
Quote: 引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

这个必须顶，吊炸天啊。如果我是经理，要的就是你。

这个的确是吊，必须顶的，符合题目要求，简单易用，一目了然！
发现，看此贴，又涨知识了= =。
全常量就好 不需要变量 
#include<stdio.h>
int main(void)
{
    printf("%s",R"(
            1×1=1
            1×2=2  2×2=4
            1×3=3  2×3=6  3×3=9
            1×4=4  2×4=8  3×4=12  4×4=16
            1×5=5  2×5=10 3×5=15  4×5=20  5×5=25
            1×6=6  2×6=12 3×6=18  4×6=24  5×6=30  6×6=36
            1×7=7  2×7=14 3×7=21  4×7=28  5×7=35  6×7=42  7×7=49
            1×8=8  2×8=16 3×8=24  4×8=32  5×8=40  6×8=48  7×8=56  8×8=64
            1×9=9  2×9=18 3×9=27  4×9=36  5×9=45  6×9=54  7×9=63  8×9=72  9×9=81
            )");
}
引用 1 楼 mujiok2003 的回复:

九九乘法表是个不变的，何必用变量。

int main()
{
char const* const tbl = "1×1=1\n" 
"1×2=2 2×2=4\n" 
"1×3=3 2×3=6 3×3=9 \n" 
"1×4=4 2×4=8 3×4=12 4×4=16\n"  
"1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"  
"1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"  
"1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"  
"1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"  
"1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81";
puts(tbl);
  return 0;
}

只能说：这个吊

 
#include <stdio.h>

int main()
{
	int i;
	for(i=11; i<=100; i++){
		if(i%10 == 0){
			printf("\n");
		}else if(i/10 < i%10){
			printf("\n");
			i = (i/10+1)*10;
		}else{
			printf("%d*%d=%2d  ", i%10, i/10, (i%10)*(i/10));
		}
	}
}

结果:
1*1= 1  
1*2= 2  2*2= 4  
1*3= 3  2*3= 6  3*3= 9  
1*4= 4  2*4= 8  3*4=12  4*4=16  
1*5= 5  2*5=10  3*5=15  4*5=20  5*5=25  
1*6= 6  2*6=12  3*6=18  4*6=24  5*6=30  6*6=36  
1*7= 7  2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49  
1*8= 8  2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64  
1*9= 9  2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81  
十八般武艺全用上了！
引用 13 楼 zhao4zhong1 的回复: 
#include <stdio.h>
int main() {
    printf(
        "1×1=1\n"
        "1×2=2 2×2=4\n"
        "1×3=3 2×3=6  3×3=9 \n"
        "1×4=4 2×4=8  3×4=12 4×4=16\n"
        "1×5=5 2×5=10 3×5=15 4×5=20 5×5=25\n"
        "1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36\n"
        "1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49\n"
        "1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64\n"
        "1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81"
    );
    return 0;
}

好吧。。。居然用字符串常量
引用 134 楼 gaoshou998 的回复:

我还是觉得我这个简单
python写的

def A(n):
    if 0< n <= 9:
        A(n-1)
        for i in range(1,n+1):
            print "%2sx%2s=%2s"%(i,n,i*n),
        print

A(9)

>>> 
 1x 1= 1
 1x 2= 2  2x 2= 4
 1x 3= 3  2x 3= 6  3x 3= 9
 1x 4= 4  2x 4= 8  3x 4=12  4x 4=16
 1x 5= 5  2x 5=10  3x 5=15  4x 5=20  5x 5=25
 1x 6= 6  2x 6=12  3x 6=18  4x 6=24  5x 6=30  6x 6=36
 1x 7= 7  2x 7=14  3x 7=21  4x 7=28  5x 7=35  6x 7=42  7x 7=49
 1x 8= 8  2x 8=16  3x 8=24  4x 8=32  5x 8=40  6x 8=48  7x 8=56  8x 8=64
 1x 9= 9  2x 9=18  3x 9=27  4x 9=36  5x 9=45  6x 9=54  7x 9=63  8x 9=72  9x 9=81
>>> 

n和i2个了。。。
引用 165 楼 KenZhang1031 的回复: 
#include <stdio.h>

void main(void)
{
	int i;

	for(i=11; i<100; i++)
	{
		if((i % 10) != 0)
		{
			if((i % 10) <= (i / 10))
			{
				printf("%dx%d=%d   ", i % 10, i / 10, (i % 10) * (i / 10));
			}
		}
		else
		{
			printf("\n");
		}
	}
}

神一般的存在，用%d省去小数部分，好聪明的想法
1楼相当霸气
九九表无非就是被乘数和乘数均为一位数，我们构造一个两位数的数列x, 则（x/10）得到被乘数，（x%10)得到乘数，跳过乘数为0的不就可以了

for(x=11; x<100; x++)
{
     if(x%10==0)
       continue;
    printf(“% d”, (x/10)*(x%10));
…….
}
格式控制我就不讨论了
引用 8 楼 vrace 的回复: 
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
	int a;

	for (a = 0x11; a < 0xa0; a++)
	{
		for (a = (a & 0xf0) + 1; (a & 0x0f) <= ((a & 0xf0) >> 4); a++)     //这里的a++有啥用？？？倒数第三行的a+=0x10是不是可以放在这里
		{
			printf("%dx%d=%d\t",
				(a & 0x0f),
				(a & 0xf0) >> 4,
				((a & 0xf0) >> 4) * (a & 0x0f));
		}
		a += 0x10;
		printf("\n");
	}

	return 0;
}

这个应该能满足你的要求…
引用 38 楼 qweiu 的回复:
Quote: 引用 23 楼 jiyy7758521 的回复:

//突然想到一个更简单的
#include <stdio.h>
main()
{
    int i;//取一个变量，用变量的十位代表另一变量，注意个位每次要归1
    i=0;
    for(i=11;i<100;i++)
   {
       if(i%10==0||i%10>i/10)
       {
            printf(“\n”);
            i=i/10*10;
        }
       printf(“%d*%d=%d “,i/10,i%10,(i/10)*(i%10));

    }

}

这个错的
全部打印：
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=

这样就对了嘛！
引用 208 楼 u011371360 的回复:
Quote: 引用 38 楼 qweiu 的回复:
Quote: 引用 23 楼 jiyy7758521 的回复:

//突然想到一个更简单的
这个错的
全部打印：
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=1
1*0=0 1*1=

这样就对了嘛！

#include <stdio.h>
main()
{
    int i;//取一个变量，用变量的十位代表另一变量，注意个位每次要归1
    i=0;
    for(i=11;i<100;i++)
   {
       if(i%10==0||i%10>i/10)
       {
            printf(“\n”);
            i=(i/10+1)*10+1;
        }
       printf(“%d*%d=%d “,i/10,i%10,(i/10)*(i%10));

    }
printf(“\n”);

}
引用 16 楼 max_min_ 的回复:
Quote: 引用 8 楼 vrace 的回复: 
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
	int a;

	for (a = 0x11; a < 0xa0; a++)
	{
		for (a = (a & 0xf0) + 1; (a & 0x0f) <= ((a & 0xf0) >> 4); a++)
		{
			printf("%dx%d=%d\t",
				(a & 0x0f),
				(a & 0xf0) >> 4,
				((a & 0xf0) >> 4) * (a & 0x0f));
		}
		a += 0x10;
		printf("\n");
	}

	return 0;
}

这个应该能满足你的要求…

膜拜啊！
std:: cout<<i;

应该是这个也不算什么死循环
横看成林侧成峰！学习！
CodeBye 版权所有丨如未注明 , 均为原创丨本网站采用BY-NC-SA协议进行授权 , 转载请注明打印九九乘法表，要求只能用一个变量！