思考题：语言是工具？重要是思想？那如何表达思想？（修改版）

OwnWaterloo

互为表里，有辩证的含义。表述思想有很多种方法，语言只是传递思想的工具
一段程序/算法，似乎还没有特定要求只能用某种语言实现的。
mirnshi 发表于 2011-10-26 08:36

不是所有语言都能很好的传递思想。
自然语言中的例子，如汉语，那种细致入微的亲戚关系。 妯娌是什么？ 要怎么翻译为英文？

而编程语言中rc4算法就是这样一个例子： 在一些编程语言中该算法/思想可以很直接的描述， 而在另一些编程语言里就不能。
rc4算法本身并不是重点。需要的资料我也列出了，也不长。 如果感兴趣就去看看吧。

mirnshi

不是所有语言都能很好的传递思想。
自然语言中的例子，如汉语，那种细致入微的亲戚关系。 妯娌是什么？ ...
OwnWaterloo 发表于 2011-10-26 13:41

抬杠不是这么抬的。我回复的帖子里的“语言”上下文都限定于计算机语言。自然语言如果语气或者标点符号不同，表示的意思都会不同的。

某种算法可以在一种语言里直接描述，但不见得在其他语言里就不能描述。如同我上面回复的，C语言描述的，汇编也可以描述，只是复杂度高而已。
如果只抓“直接描述”，那就没有必要讨论了。

nizvoo

KBTiller

任何高级语言描述的，都可以落实到下层的汇编语言吧？
mirnshi 发表于 2011-10-26 08:39

    是的。我这里指的主要是高级语言之间的差别

OwnWaterloo

回复 52# mirnshi

>> 某种算法可以在一种语言里直接描述，但不见得在其他语言里就不能描述。如同我上面回复的，C语言描述的，汇编也可以描述，只是复杂度高而已。
>> 如果只抓“直接描述”，那就没有必要讨论了。

那是否所有算法你都会用汇编实现？ 如果是，我们确实没什么好继续讨论的了。
但显然不会。

同时， C与汇编是有很高相似度的， 很容易对应的翻译。
选择C或者选择汇编还只是复杂度问题而已。


但我举的例子并不是这样。
比如在lua中实现这个算法与在C中实现，表达的就完全不是同一回事， 没有对应关系。
lua与wiki中给出的算法就是一一对应的， 而C做不到。
我觉得举的妯娌的例子很贴切， 只是你体会不到在C中实现这算法其实就是在英文中描述妯娌关系。

PS： 对自然语言，我只是附带举例。 如果引起你不悦了，你可以完全忽略。

OwnWaterloo

回复 52# mirnshi

另外，既然谈论如何表达思想，我觉得就是在谈论"如何更好的表达思想"。
直接是不是更好表达的一个标准？

而"所有算法/思想都可以用汇编实现"这种不证自明而且无意义（你会用汇编去实现所有算法吗？）的话，难道不是在抬杠？

yexiaofan1

作为一个准备入门的新手表示...看你们的讨论搞得都不知道要学什么好了...好多东西都被这个人或那个人贬得一无是处...

mirnshi

回复  mirnshi

>> 某种算法可以在一种语言里直接描述，但不见得在其他语言里就不能描述。如同我上面回复 ...
OwnWaterloo 发表于 2011-10-26 14:16

汇编和C都是计算机语言。Lua语言不懂，所以无法看出具体的语义表述。汇编语言并不是不适合写算法，openssl里就有些汇编（这有些抬杠， ）。

如果仅限于高级语言，那么很多不同语言的数据类型都很难准确翻译了，更不用说算法了，不同的语言体现的是不同层次/层面的计算机，看到或理解的自然不同。很多高级语言从不考虑内存泄漏问题，而C语言就要关注此事。

因此，限定于高级语言，就没必要讨论了。

rover12421

回复 47# OwnWaterloo

1. #include <stdio.h>
   
2. #include <string.h>
   
3. 
   
4. unsigned char* get_S(const unsigned char* key);
   
5. {
   
6.           int i,j;
   
7. 
   
8.           unsigned char* S;
   
9.           S = malloc(256*sizeof(unsigned char));
   
10. 
    
11.           size_t len = strlen(key);
    
12. 
    
13.       for (i=0; i<256; ++i) S[i] = i;
    
14.       for (i=0, j=0; i<256; ++i)
    
15.       {
    
16.             unsigned k;
    
17.             j = (j+key[i%len]+S[i]) % 256;
    
18.             k = S[i]; S[i] = S[j]; S[j] = k;
    
19.       }
    
20. 
    
21.           return S;
    
22. }
    
23. 
    
24. int* rc4(const int* iBuf, int ilen, const unsigned char* S)
    
25. {
    
26.           size_t len = strlen(key);
    
27. 
    
28.           set_S(len);
    
29. 
    
30.       int i,j,c;
    
31.       i = j = 0;
    
32.           int n;
    
33.           int* oBuf;
    
34. 
    
35.           malloc(oBuf, ilen*sizeof(int));
    
36. 
    
37.           for (n=0; n<iLen; ++n)
    
38.       {
    
39.             unsigned k, byte;
    
40.                         c = iBuf[n];
    
41.             i = (i+1) % 256;
    
42.             j = (j+S[i]) % 256;
    
43.             k = S[i]; S[i] = S[j]; S[j] = k;
    
44. 
    
45.             byte = S[ (S[i]+S[j]) % 256 ];
    
46.                         oBuf[n] = c ^ byte;
    
47.       }
    
48. 
    
49.           return oBuf;
    
50. }
    
51. 
    
52. void rc4_file(const char* iFilename, const char* oFilename, const unsigned char* key)
    
53. {
    
54.         unsigned char* S;
    
55.         S = get_S(key);
    
56. 
    
57.         int iBuf[256];
    
58.         int bufLen;
    
59. 
    
60.         FILE* ifile = fopen(iFilename, "rb");
    
61.     FILE* ofile = fopen(oFilename, "wb");
    
62. 
    
63.         int  off = -1;
    
64.         int* oBuf = NULL;
    
65.         do
    
66.         {
    
67.                 off++;
    
68.                 if(off > 256)
    
69.                 {
    
70.                         oBuf = rc4(iBuf, 256, S);
    
71.                         fwrite(oBuf, sizeof(int), 256, ofile);
    
72. 
    
73.                         free(oBuf);
    
74.                         oBuf = NULL;
    
75.                         off  =0;
    
76.                 }
    
77.                
    
78.                 iBuf[off] = getc(ifile);
    
79.         }
    
80.         while (iBuf[off] != EOF);
    
81. 
    
82.         if(off > 0)
    
83.         {
    
84.                 oBuf = rc4(iBuf, off, S);
    
85.                 fwrite(oBuf, sizeof(int), off, ofile);
    
86. 
    
87.                 free(oBuf);
    
88.                 oBuf = NULL;
    
89.         }
    
90. 
    
91.         fclose(ofile);
    
92.         fclose(ifile);
    
93. 
    
94.         free(S);
    
95. }

复制代码

如果这样会不会好些？
不是很明白你们要讨论的问题要旨。我只是按我的理解写，纯属凑热闹~~~

OwnWaterloo

回复 58# mirnshi

wiki中给出的算法伪代码：

1. 
   
2. i := 0
   
3. j := 0
   
4. while GeneratingOutput:
   
5.     i := (i + 1) mod 256
   
6.     j := (j + S[i]) mod 256
   
7.     swap values of S[i] and S[j]
   
8.     K := S[(S[i] + S[j]) mod 256]
   
9.     output K
   
10. endwhile
    

复制代码

如果用Lua（或者python,scheme,C#以及所有支持coroutine的语言），就可以写出这样的实际代码：

1. 
   
2. local i = 0
   
3. local j = 0
   
4. while true do
   
5.     i = math.fmod( (i + 1),256 )
   
6.     j = math.fmod( (j + S[i]),256 )
   
7.     S[i],S[j] = S[j],S[i]
   
8.     local  K = S[math.fmod( (S[i] + S[j]),256 )]
   
9.     coroutine.yield(K)
   
10. end
    

复制代码

这几乎就是与算法/思想一一对应了，而C很难做到这点 —— 关于那段代码，我想说的就是这个。


至于"研究各种表达方式" vs "确信始终可以用汇编表达"， "高级语言" vs "中低级语言"谁才是表达思想， 这类问题我觉得争不出什么结果……