+ -
当前位置:首页 → 问答吧 → [转帖]老手是这样教新手编程的

[转帖]老手是这样教新手编程的

时间:2010-06-25

来源:互联网

本帖最后由 anyc 于 2010-06-25 15:36 编辑

comp.lang.c全球最大的C语言新闻组,其Google的链接是:http://groups.google.com/group/comp.lang.c/ 可惜被GFW了。在comp.lang.c新闻组,有一个日本网友发了个贴子,说他正在学习一个在线的C语言课程,要完成一个作业,用程序输出如下的结果,而他的老师在美国,因为时差问题,他无法和他联系,所以只有上这里来寻求帮助。
  1.     *
  2.    ***
  3.   *****
  4. *******
  5. *********
  6. *********
  7. *******
  8.   *****
  9.    ***
  10.     *
复制代码
很明显,在comp.lang.c上发这种贴子是一定会被拍的很惨的,这样的事,以前在SUN的论坛上也发生过,详情请看这里。还有一个去软件官网上要一个盗版序列号的。果不然后,我看到了这样的一个回贴。提供这样的一段代码:
  1. #define      M 002354l  
  2. #define     A   000644l  
  3. #define    G     000132l  
  4. #define     I   000322l  
  5. #define      C 000374l  
  6. #define                a ;  
  7. #define               b for  
  8. #define              c    ++  
  9. #define             d       %  
  10. #define            e       int  
  11. #define           f           ,  
  12. #define          g             -  
  13. #define         h             011  
  14. #define        i                 =  
  15. #define       j                   {  
  16. #define      k                     )  
  17. #define     l                    '\n'  
  18. #define    m                      main  
  19. #define    n                         <  
  20. #define     o                       }  
  21. #define      p                     >  
  22. #define       q                  &&  
  23. #define        r                 (  
  24. #define         s              ||  
  25. #define          t             ?  
  26. #define           u     putchar  
  27. #define            v      void  
  28. #define             w     '*'  
  29. #define              x     :  
  30. #define               y ' '  
  31. #define                _ /  
  32. #define           C_O_O_L return  
  33.                    e u r e k a  
  34.                         e  
  35.                        m r  
  36.                       v k j  
  37.                      j j j j  
  38.                     j j j j j  
  39.                    j j j j j j  
  40.                   j j j j j j j  
  41.                  j e z a b r z i  
  42.                 M _ A _ G _ I _ C  
  43.                a z n G a u r z d h  
  44.               + z _ h p M _ A q z d  
  45.              h + z _ h n M _ G q z _  
  46.             h n z d h + M _ I q z _ h  
  47.            p z d h g M _ C t w x y k f  
  48.           z d h g h + 1 s u r l k f z c  
  49.          k a u r l k a j j j j j j j j j  
  50.         j j C_O_O_L M _ A _ G _ I _ C a o  
  51.        o o o o o o o o o o o o o o o o o o  
  52.                      o o o o  
  53.                      o o o o  
  54.                      o o o o  
  55.                      o o o o
复制代码
这段程序是可以编译通过的,没有任何问题,而且还是可以得到正确的结果的。关于这样的程序,你可以参考本站的这篇文章《6个变态的C语言Hello World程序》,而另一篇文章教你如何搞乱你的C代码。呵呵。当然,你并不需要把在你的VC或是GCC下编译这段代码,现在什么都有在线了,编译器当然也在线了,这里是一篇关于在线编译器的文章,甚至一个在线的IDE(连这个网站的CTO都在本站留言了),上去编译一下你就可以看到结果了。

最后,不恶搞了,在comp.lang.c的这个贴子中看到了很多不错的“如何教新手编程”的观点,下面罗列一些:

1)你把你自认为最好程序贴出来,我会帮你看的,但我是不会帮你写的。

2)要解决这个问题,你需要先观察输出,然后找到其规律,算法总是去描述一些有规律的事情。关于你的这个程序,很明显,你可以分成两个部分,一个正三角,一个倒三角,每一行的星号都是连续的奇数,1,3,5,7,9,而前面的空格又是顺序的自然数:4,3,2,1,你看这样的规律用程序来干不是正合适吗?

从这两个例子,我们可以看到,老手应该如何去教新手,那就是,a)让其独立思考,b)步步为营的引导,c)教一种方法而不是直接给答案。希望与大家共勉。

作者: anyc   发布时间: 2010-06-25

不知道为什么那菱形会那样?重新编辑也不行,凑合看吧

作者: anyc   发布时间: 2010-06-25

用gcc -E破解之:
  1. $ gcc -E tree.c | indent
  2. # 1 "tree.c"
  3. # 1 "<built-in>"
  4. # 1 "<command-line>"
  5. # 1 "tree.c"
  6. # 33 "tree.c"
  7. int putchar (int);
  8. int
  9. main (void)
  10. {
  11.   {
  12.     {
  13.       {
  14.         {
  15.           {
  16.             {
  17.               {
  18.                 {
  19.                   {
  20.                     {
  21.                       {
  22.                         {
  23.                           {
  24.                             {
  25.                               {
  26.                                 {
  27.                                   {
  28.                                     {
  29.                                       {
  30.                                         {
  31.                                           {
  32.                                             {
  33.                                               {
  34.                                                 int z;
  35.                                                 for (z =
  36.                                                      002354l / 000644l /
  37.                                                      000132l / 000322l /
  38.                                                      000374l; z < 000132l;
  39.                                                      putchar (z % 011 +
  40.                                                               z / 011 >
  41.                                                               002354l /
  42.                                                               000644l
  43.                                                               && z % 011 +
  44.                                                               z / 011 <
  45.                                                               002354l /
  46.                                                               000132l
  47.                                                               && z / 011 <
  48.                                                               z % 011 +
  49.                                                               002354l /
  50.                                                               000322l
  51.                                                               && z / 011 >
  52.                                                               z % 011 -
  53.                                                               002354l /
  54.                                                               000374l ? '*' :
  55.                                                               ' '),
  56.                                                      z % 011 - 011 + 1
  57.                                                      || putchar ('\n'), z++);
  58.                                                 putchar ('\n');
  59.                                                 {
  60.                                                   {
  61.                                                     {
  62.                                                       {
  63.                                                         {
  64.                                                           {
  65.                                                             {
  66.                                                               {
  67.                                                                 {
  68.                                                                   {
  69.                                                                     {
  70.                                                                       return
  71.                                                                         002354l
  72.                                                                         /
  73.                                                                         000644l
  74.                                                                         /
  75.                                                                         000132l
  76.                                                                         /
  77.                                                                         000322l
  78.                                                                         /
  79.                                                                         000374l;
  80.                                                                     }
  81.                                                                   }
  82.                                                                 }
  83.                                                               }
  84.                                                             }
  85.                                                           }
  86.                                                         }
  87.                                                       }
  88.                                                     }
  89.                                                   }
  90.                                                 }
  91.                                               }
  92.                                             }
  93.                                           }
  94.                                         }
  95.                                       }
  96.                                     }
  97.                                   }
  98.                                 }
  99.                               }
  100.                             }
  101.                           }
  102.                         }
  103.                       }
  104.                     }
  105.                   }
  106.                 }
  107.               }
  108.             }
  109.           }
  110.         }
  111.       }
  112.     }
  113.   }
  114. }
  115. $
复制代码

作者: 没本   发布时间: 2010-06-25

呵呵,很艺术

作者: ydfgic   发布时间: 2010-06-25

让我想起了“中++ 6.0”。

作者: fender0107401   发布时间: 2010-06-25

如果手工破解的话应该很困难吧,

所以想手工写这么一个也应该比较困难,

那原作者是怎么写的呢?

应该有相应的工具吧。

作者: fender0107401   发布时间: 2010-06-25

我在这里读到了一些讽刺的感觉...

作者: ling0088   发布时间: 2010-06-25

那个叫做“丙正正”……

作者: starwing83   发布时间: 2010-06-25