//注册编程控件js
//C语言命名空间
Namespace.register("U.CD.CL");

//此二维数组包含了7门语言，数据量庞大，下面是数组中代码的含义,从头到尾依次排序

//一维中排序为：1、C语言   2、PHP语言  3、Net语言  4、Python语言  5、Nodejs语言 6、Ruby  7、Perl 8、Lisp 。。。。。

//二维排序为：
//1、输出语句 2、整形变量定义 3、浮点型变量定义 4、单个字符变量定义 5、判断结构  6、多条件判断 7、自加运算符 8、取模运算符 9、字符串函数 
//10、循环结构 11、while循环 12、do while循环 13、一维数组 14、数组和循环的对应关系 15、二维数组 16、循环与二维数组 17、函数 18、99乘法表 
//19、冒泡排序方法 20、Gcc迷宫 21、结构体定义和使用 22、递归函数，求1加到10的结果 23、汉诺塔程序 24、二分查找方法 25、输入语句
U.CD.CL.LangArr = [
    [
        "#include <stdio.h>\nvoid main(){\n    //printf即为输出语句，可以输出你敲入的字符，把hellow world改为其他字符试一试？\n    printf(\"hello world\\n\");\n}",
        "#include <stdio.h>\nvoid main(){\n    //定义整形变量，int表示整形，i表示整形变量，可以给i赋值。由于是变量(变化的量),所以先给他赋予10，再赋予20，结果就是最后一次赋值的结果。\n    int i;\n    i=10;\n    i=20;\n    //输出整形变量,猜猜输出多少？输出整形变量用%d表示\n    printf(\"%d\\n\",i);\n}",
        "#include <stdio.h>\nvoid main(){\n    //定义浮点型变量，float表示可以有小数位，i表示浮点型变量，可以给i赋值。由于是变量(变化的量),所以先给他赋予10.0002，再赋予20.1114，结果就是最后一次赋值的结果。\n    float i;\n    i=10.0002;\n    i=20.11114;\n    //输出浮点型变量,猜猜输出多少？输出浮点型变量用%f表示，哈，浮点数不精确哦，下面的双精度浮点型就是精确的。对比一下2个结果\n    printf(\"下面为单精度浮点型\\n\");\n    printf(\"%f\\n\",i);\n    //双精度浮点型，双精度浮点型用double标示符。\n    double j;\n    j=10.0002;\n    j=20.11114;\n    // \\n表示回车换行哦，为了区别开2个输出，在前面加了2个回车。\n    printf(\"\\n\\n下面为双精度浮点型\\n\");\n    printf(\"%lf\",j);\n}",
        "#include <stdio.h>\nvoid main(){\n    //定义字符型变量，char表示单个字符，例如'a','b'等，i表示字符型变量，可以给i赋值。由于是变量(变化的量),所以先给他赋予'a'，再赋予'b'，结果就是最后一次赋值的结果。\n    char i;\n    i='a';\n    i='b';\n    //输出字符型变量,猜猜输出多少？输出字符型变量用%c表示，哈，不能输出多个字符哦，比如'aabb'，要输出多个怎么办？可以用多个printf输出，也可以看后续关于数组的章节\n    printf(\"下面为单个字符\\n\");\n    printf(\"%c\\n\",i);\n}",
        "#include <stdio.h>\nvoid main(){\n    int i=10;\n    //if 是判断的标示符，即你输入if，计算机能识别出这是判断，做很多语言中，=是赋值，比如给i赋值10的写法是 int i=10\n    //那么数学中的等号怎么表示呢？用2个等号==。。。下面这个if判断是判断变量i是否等于10，如果是10，输出第一句，否则，输出第二句。\n    //判断语句的标准写法是  if {}  else {}    如果满足条件则做什么，不满足条件，执行else里面的语句\n    if(i==10){\n        printf(\"变量i等于10\\n\");\n    }\n    else{\n        printf(\"变量i不等于10\\n\");\n    }\n}",
        "#include <stdio.h>\nvoid main(){\n    //修改以下整形变量的值，得出成绩的优良中差。\n    int i=75;\n    //switch 是多条件判断的标示符。case是分支语句，满足不同条件，转向不同分支执行。\n    //j=i/10表示变量j等于变量i除以10.\n    int j=i/10;\n    switch(j){\n        case 6:printf(\"及格\\n\");break;\n        case 7:printf(\"良好\\n\");break;\n        case 8:printf(\"良好\\n\");break;\n        case 9:printf(\"优秀\\n\");break;\n        default:printf(\"不及格\\n\");break;\n    }    \n}",
        "#include <stdio.h>\nvoid main(){\n    //定义整形变量i等于5。\n    int i=5;\n    printf(\"第一次i等于：%d\\n\",i);\n    i=i+1;\n    printf(\"运行i=i+1后i等于：%d\\n\",i);\n    i++;\n    printf(\"运行i++后i等于：%d\\n\",i);\n    //得出结论：i++其实是i自己加1.\n}",
        "#include <stdio.h>\nvoid main(){\n    //定义整形变量i等于5。\n    int i=5;\n    //取模标示符为%，实质是取余数。比如5/4 余数是1\n    int j=i%4;\n    printf(\"%d\\n\",j);\n    int z=i%6;//5除以6，余数是5.商0\n    printf(\"%d\\n\",z);\n}",
        "#include <stdio.h>\n//C语言中只能处理单个字符。比如\'a\',\'b\'。要处理多个字符，需要使用字符串函数，使用字符串函数，必须引用下面的头文件\n#include <string.h>\nvoid main(){\n    //在C语言中如何表达姓名、地址等复杂字符呢，用数组可以表达，参加后续章节，数组。\n    char A[10]=\"张三\";\n    printf(\"%s\\n\",A);    //如何再次给A赋值呢、A=\"李四\";。这样会错，用strcpy\n    strcpy(A,\"李四\");\n    printf(\"%s\\n\",A);\n    //j=i/10表示变量j等于变量i除以10.\n}",
        "#include <stdio.h>\nvoid main(){\n    //printf即为输出语句，可以输出你敲入的字符，把hellow world改为其他字符试一试？\n    int i;\n    //for为循环标识，i=0;i<10;i++ 分别是三条语句。i的初值为0 每次加1，i大于等于10退出循环\n    //下面是循环输出10条Hellow world的语句。\n    for(i=0;i<10;i++){\n        printf(\"hello world\\n\");\n    }\n}",
        "#include <stdio.h>\nvoid main(){\n    //printf即为输出语句，可以输出你敲入的字符，把hellow world改为其他字符试一试？\n    int i=0;\n    //while为循环标识，i<10 为判断语句，满足条件执行 while中的内容。\n    //下面是使用while循环输出10条Hellow world的语句。\n    while(i<10){\n        printf(\"hello world\\n\");\n        i++;\n    }\n}",
        "#include <stdio.h>\nvoid main(){\n    //do whild循环，没执行do大括号中的语句一次，就和while中的条件匹配一次，知道不满足条件，退出循环。\n    int i=0;\n    do{\n        printf(\"hello world\\n\");\n        i++;\n    }while(i<10);\n}",
        "#include <stdio.h>\nvoid main(){\n    //数组定义，变量带中括号，中括弧中输入数组的大小，=表示赋值，大括号中是数组的值。\n    int i[10]={1,1,1,1,0,1,1,1,1,1};\n    //输出数组的第一位，哈，数组从0开始的哦\n    printf(\"%d\\n\",i[0]);\n    //输出数组的第二位\n    printf(\"%d\\n\",i[1]);\n    //输出数组的第五位，第五位是0哦。但第五位标号是4哦。\n    printf(\"%d\\n\",i[4]);    \n}",
        "#include <stdio.h>\nvoid main(){\n    //数组定义，变量带中括号，中括弧中输入数组的大小，=表示赋值，大括号中是数组的值。\n    int i[10]={1,9,8,10,2,3,4,5,6,7};\n    //数组大小为10，刚好用循环可以输出数组的值，可以看出，数组和循环经常会结合在一起使用。\n    int j;\n    for(j=0;j<10;j++){\n        printf(\"%d\\n\",i[j]);\n    }\n}",
        "#include <stdio.h>\nvoid main(){\n    //二维数组定义方法，其实是在一维数组中加入了另外一个中括号，以表示二维。\n    int A[10][10]={\n        {1,0,1,1,1,1,1,1,1,1},\n        {1,0,1,1,1,1,1,1,1,1},\n        {1,0,0,0,0,0,0,0,1,1},\n        {1,1,1,1,1,1,1,0,1,1},\n        {1,1,1,1,1,1,1,0,1,1},\n        {1,1,1,1,1,1,1,0,1,1},\n        {1,1,1,1,1,1,1,0,1,1},\n        {1,1,1,1,1,1,1,0,1,1},\n        {1,1,1,1,1,1,1,0,0,0},\n        {1,1,1,1,1,1,1,1,1,1}\n    };\n    //二维数组输出方法,输出第一排第一个\n    printf(\"%d\\n\",A[0][0]);\n    //输出第一排第二个\n    printf(\"%d\\n\",A[0][1]);\n    //输出第二排第3个\n    printf(\"%d\\n\",A[1][2]);\n}",
        "#include <stdio.h>\nvoid main(){\n    //二维数组定义方法，其实是在一维数组中加入了另外一个中括号，以表示二维。\n    int A[10][10]={\n        {1,0,1,1,1,1,1,1,1,1},\n        {1,0,1,1,1,1,1,1,1,1},\n        {1,0,0,0,0,0,0,0,1,1},\n        {1,1,1,1,1,1,1,0,1,1},\n        {1,1,1,1,1,1,1,0,1,1},\n        {1,1,1,1,1,1,1,0,1,1},\n        {1,1,1,1,1,1,1,0,1,1},\n        {1,1,1,1,1,1,1,0,1,1},\n        {1,1,1,1,1,1,1,0,0,0},\n        {1,1,1,1,1,1,1,1,1,1}\n    };\n    //二维数组需要用2个循环来输出全部内容。这就是二维数组和循环的关系\n    int i,j;\n    for(i=0;i<10;i++){\n        for(j=0;j<10;j++){\n            printf(\"%d\\t\",A[i][j]);\n        }\n        printf(\"\\n\");\n    }\n}",
        "#include <stdio.h>\n//下面定义了一个求最大值的函数\nint max(int x,int y){\n    //如果x>y，返回x，否则，返回y。\n    if(x>y) return x;\n    else return y;\n}\nvoid main(){\n    //连续定义2个整形变量i,j。并赋予初始值。\n    int i=10,j=20;\n    //调用函数max，求得最大值。。\n    int z=max(10,20);\n    //输出最大值。\n    printf(\"最大值为：%d\\n\",z);\n}",
        "#include <stdio.h>\nvoid main(){\n    int i,j;\n    for(i=1;i<10;i++)\n    {\n        for(j=1;j<10;j++)\n        {\n            printf(\"%dX%d=%2d  \",i,j,i*j);\n        }\n        printf(\"\\n\");\n    }    \n}\n",
        "#include <stdio.h>\n//下面定义了一个求最大值的函数\nint* maopao(int A[],int n){\n    //如果x>y，返回x，否则，返回y。\n    int i,j,temp;\n    for(i=0;i<n;i++) {\n        for(j=0;j<n-1;j++){\n            //交换位置方法。\n            if(A[j]>A[j+1]){\n                temp=A[j];\n                A[j]=A[j+1];\n                A[j+1]=temp;\n            }\n        }\n    }\n    return A;\n}\nvoid main(){\n    //连续定义2个整形变量i,j。并赋予初始值。\n    int A[10]={1,6,3,9,10,2,7,8,4,5};\n    //定义指针变量B，获取返回结果，函数无法返回数组，有更优解法请留言。\n    int* B;\n    B=maopao(A,10);\n    printf(\"冒泡排序结果为：\");\n    int i;\n    for(i=0;i<10;i++)\n        printf(\"%d\\t\",B[i]);\n}",
        "#include <stdio.h>\nvoid main(){\n    //定义迷宫数组，用二维数组表达迷宫，1为墙，0为路\n    int A[10][20]={\n        {1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},\n        {1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},\n        {1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1},\n        {1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1},\n        {1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,0,1,1,1},\n        {1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,0,0,0,1},\n        {1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,1,1,0,1},\n        {1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,1,1,0,1},\n        {1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,0,1},\n        {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1}\n    };\n    int i,j;\n    for(i=1;i<10;i++)\n    {\n        for(j=1;j<20;j++)\n        {\n            if(A[i][j]==0) printf(\"□\");\n            else printf(\"▉\");\n        }\n        printf(\"\\n\");\n    }    \n}",
        "#include <stdio.h>\n//包含字符串函数头文件，这样就可以使用strcpy函数给字符串变量赋值了\n#include <string.h>\n//定义一个学生的结构体，包含了姓名，年龄，学号。定义在主函数之外，是全局变量\nstruct student{\n    char name[10];\n    int age;\n    int number;\n};\n//主函数\nvoid main(){\n    struct student stu;  //根据新类型student，生成一个学生变量。\n    strcpy(stu.name,\"张三\");//给学生赋予姓名\n    stu.age=15;//给学生赋予年龄\n    stu.number=1001;//给学生赋予学号。\n    //打印学生信息，打印字符串用%s，\t代表空4格。\n    printf(\"%s\\t%d\\t%d\\n\",stu.name,stu.age,stu.number);\n}",
        "#include<stdio.h> \n//定义了一个递归函数，递归函数的特征是函数调用函数本身。\nint dg(int x,int z) { \n    if(x<=10){\n        z=z+x;\n        x++;\n        dg(x,z);\n    }\n    else {\n        return z;\n    }\n} \nmain() { \n    //本题是用递归函数求1一直加到10的结果。\n    //用递归实现循环。递归的作用是函数调用函数本身，速度比循环慢。但可以解决很多问题。\n    int n=dg(1,0);\n    printf(\"递归的结果：%d\\n\",n); \n} ",
        "#include<stdio.h> \nvoid move(int n,char a,char b,char c) { \n    if(n==1) \n        printf(\"\\t%c->%c\\n\",a,c);    //当n只有1个的时候直接从a移动到c \n    else\n    { \n        move(n-1,a,c,b);            //第n-1个要从a通过c移动到b \n        printf(\"\\t%c->%c\\n\",a,c); \n        move(n-1,b,a,c);            //n-1个移动过来之后b变开始盘，b通过a移动到c，这边很难理解 \n    } \n} \nmain() { \n    //定义汉诺塔个数。\n    int n=10; \n    move(n,'a','b','c'); \n} \n",
        "#include <stdio.h>\n//二分查找函数定义\nint erfen(int* a, int key){\n     int low = 0,high = 14, mid;\n     while (low <= high)\n     {\n          mid = (low + high) / 2;\n          if (key == a[mid])\n               return mid;//找到结果\n          else if (key < a[mid])\n               high = mid - 1;//从高位找\n          else\n              low = mid + 1;//从低位找\n     }\n     return 0;//未找到，返回0\n}\nvoid main(){\n    //二分查找一定是做排好序的序列里面查找\n    int A[10]={1,2,3,4,5,6,7,8,9,10};\n    //调用二分查找函数，查找值为7的元素做数组中位于第六位。\n    int i=erfen(A,7);\n    printf(\"二分查找值为7的元素的索引为：%d\\n\",i);\n}",
        "//!!!!!!!!!!!!!!!!!!提示，本平台暂时不支持输入语句，求高手提供解决方案\n#include <stdio.h>\n//演示输入语句的用法\nvoid main(){\n    printf(\"hello world\");\n    int i;\n    scanf(\"%d\",&i);\n    printf(\"%d\",i);\n}"
    ],
    [
        "<?php \n    //PHP输出语句，输出一串欢迎文字,最开始一句是php开始标记，最后一句是php结束标记\n    echo(\"欢迎您来到PHP环境!\");\n?>",
        "<?php\n    //定义整形变量，int表示整形，i表示整形变量，可以给i赋值。由于是变量(变化的量),所以先给他赋予10，再赋予20，结果就是最后一次赋值的结果。\n    $i=10;\n    $i=20;\n    //输出整形变量,猜猜输出多少？输出整形变量用%d表示\n    echo $i;\n?>",
        "<?php\n    //定义浮点型变量，表示可以有小数位，可以给i赋值,PHP能根据值自动推断出变量类型。先给他赋予10.0002，再赋予20.1114，结果就是最后一次赋值的结果。\n    $i=10.0002;\n    $i=20.11114;\n    //  在输出时加了2个回车。\n    echo(\"下面为双精度浮点型\");\n    echo($i);\n?>",
        "<?php\n    //定义字符型变量，由于是变量(变化的量),所以先给他赋予'a'，再赋予'b'，结果就是最后一次赋值的结果。\n    $i='a';\n    $i='b';\n    //输出字符型变量,猜猜输出多少？\n    echo(\"下面为单个字符\");\n    echo($i);\n?>",
        "<?php\n    $i=10;\n    //if 是判断的标示符，即你输入if，计算机能识别出这是判断，做很多语言中，=是赋值，比如给i赋值10的写法是 int i=10\n    //那么数学中的等号怎么表示呢？用2个等号==。。。下面这个if判断是判断变量i是否等于10，如果是10，输出第一句，否则，输出第二句。\n    //判断语句的标准写法是  if {}  else {}    如果满足条件则做什么，不满足条件，执行else里面的语句\n    if($i==10){\n        echo(\"变量i等于10\");\n    }\n    else{\n        echo(\"变量i不等于10\");\n    }\n?>",
        "<?php\n    //修改以下整形变量的值，得出成绩的优良中差。\n    $i=75;\n    //switch 是多条件判断的标示符。case是分支语句，满足不同条件，转向不同分支执行。\n    //j=i/10表示变量j等于变量i除以10.在PHP中，除号会有小数位，所以必须用函数取整。\n    $j=$i/10;\n    //PHP取整函数\n    $j=floor($j);\n    switch($j){\n        case 6:echo(\"及格\");break;\n        case 7:echo(\"良好\");break;\n        case 8:echo(\"良好\");break;\n        case 9:echo(\"优秀\");break;\n        default:echo(\"不及格\");break;\n    }    \n?>",
        "<?php\n    //定义整形变量i等于5。\n    $i=5;\n    //php换行使用.chr(10)。比较特殊哈！\n    echo(\"第一次i等于：$i\".chr(10));\n    $i=$i+1;\n    echo(\"运行i=i+1后$i等于: $i\".chr(10));\n    $i++;\n    echo(\"运行i++后i等于：$i\".chr(10));\n    //得出结论：i++其实是i自己加1.\n?>",
        "<?php\n    //取余数方法在游戏编程中应用非常广泛。\n    //定义整形变量i等于5。\n    $i=5;\n    //取模标示符为%，实质是取余数。比如5/4 余数是1\n    $j=$i%4;\n    echo(\"5模4的结果为：$j\".chr(10));\n    $z=$i%6;\n    //5除以6，余数是5.商0\n    echo(\"5模6的结果是：$z\".chr(10));\n?>",
        "<?php\n    //在PHP中，字符串处理比C语言方便很多，直接就可以赋值。\n    $i=\"张三\";\n    echo($i.chr(10));    \n    //再次给变量赋值\n    $i=\"李四\";\n    echo($i);\n?>",
        "<?php\n    //for为循环标识，i=0;i<10;i++ 分别是三条语句。i的初值为0 每次加1，i大于等于10退出循环\n    //下面是循环输出10条Hellow world的语句。\n    for($i=0;$i<10;$i++){\n        echo(\"hello world\".chr(10));\n    }\n?>",
        "<?php\n    $i=0;\n    //while为循环标识，i<10 为判断语句，满足条件执行 while中的内容。\n    //下面是使用while循环输出10条Hellow world的语句。\n    while($i<10){\n        echo(\"hello world\".chr(10));\n        $i++;\n    }\n?>",
        "<?php\n    //do whild循环，没执行do大括号中的语句一次，就和while中的条件匹配一次，知道不满足条件，退出循环。\n    $i=0;\n    do{\n        echo(\"hello world\".chr(10));\n        $i++;\n    }while($i<10);\n?>",
        "<?php\n    //数组定义，变量带中括号，中括弧中输入数组的大小，=表示赋值，大括号中是数组的值。\n    $i=array(1,1,1,1,0,1,1,1,1,1);\n    //PHP一样可以用printf哦。。下面看看不一样的输出\n    //输出数组的第一位，哈，数组从0开始的哦\n    printf(\"数组第1个位置等于：%d \\n\",$i[0]);\n    //输出数组的第二位\n    printf(\"数组第2个位置等于：%d \\n\",$i[1]);\n    //输出数组的第五位，第五位是0哦。但第五位标号是4哦。\n    printf(\"数组第5个位置等于：%d \\n\",$i[4]);    \n?>",
        "<?php\n    //数组定义，使用array定义数组，小括号中是数组的值。\n    $arr=array(1,9,8,10,2,3,4,5,6,7);\n    //数组大小为10，刚好用循环可以输出数组的值，可以看出，数组和循环经常会结合在一起使用。\n    for($j=0;$j<10;$j++){\n        printf(\" %d \",$arr[$j]);\n    }\n?>",
        "<?php\n    //二维数组定义方法，其实是在一维数组中加入了另外一个中括号，以表示二维。\n    //PHP二维数组直接赋值显得有些累赘\n    $A=array(\n        array(1,0,1,1,1,1,1,1,1,1),\n        array(1,0,1,1,1,1,1,1,1,1),\n        array(1,0,0,0,0,0,0,0,1,1),\n        array(1,1,1,1,1,1,1,0,1,1),\n        array(1,1,1,1,1,1,1,0,1,1),\n        array(1,1,1,1,1,1,1,0,1,1),\n        array(1,1,1,1,1,1,1,0,1,1),\n        array(1,1,1,1,1,1,1,0,1,1),\n        array(1,1,1,1,1,1,1,0,0,0),\n        array(1,1,1,1,1,1,1,1,1,1)\n    );\n    //二维数组输出方法,输出第一排第一个\n    printf(\" %d \\n\",$A[0][0]);\n    //输出第一排第二个\n    printf(\" %d \\n\",$A[0][1]);\n    //输出第二排第3个\n    printf(\" %d \\n\",$A[1][2]);\n?>",
        "<?php\n    //二维数组定义方法，其实是在一维数组中加入了另外一个中括号，以表示二维。\n    $A=array(\n        array(1,0,1,1,1,1,1,1,1,1),\n        array(1,0,1,1,1,1,1,1,1,1),\n        array(1,0,0,0,0,0,0,0,1,1),\n        array(1,1,1,1,1,1,1,0,1,1),\n        array(1,1,1,1,1,1,1,0,1,1),\n        array(1,1,1,1,1,1,1,0,1,1),\n        array(1,1,1,1,1,1,1,0,1,1),\n        array(1,1,1,1,1,1,1,0,1,1),\n        array(1,1,1,1,1,1,1,0,0,0),\n        array(1,1,1,1,1,1,1,1,1,1)\n    );\n    //二维数组需要用2个循环来输出全部内容。这就是二维数组和循环的关系\n    for($i=0;$i<10;$i++){\n        for($j=0;$j<10;$j++){\n            printf(\"%d\\t\",$A[$i][$j]);\n        }\n        printf(\"\\n\");\n    }\n?>",
        "<?php\n    //下面定义了一个求最大值的函数,和js一样，PHP函数用function作为标识。\n    function mymax($x,$y){\n        //如果x>y，返回x，否则，返回y。\n        if($x>$y) return $x;\n        else return $y;\n    }\n    //连续定义2个整形变量i,j。并赋予初始值。\n    $i=10;$j=20;\n    //调用函数max，求得最大值。。\n    $z=mymax(10,20);\n    //输出最大值。\n    printf(\"最大值为：%d\\n\",$z);\n?>",
        "<?php\n    //哈哈，PHP构建乘法表和C差不多哦。\n    for($i=1;$i<10;$i++)\n    {\n        for($j=1;$j<10;$j++)\n        {\n            printf(\"%dX%d=%2d  \",$i,$j,$i*$j);\n        }\n        printf(\"\\n\");\n    }    \n?>",
        "<?php\n    //下面定义了冒泡排序函数\n    function maopao($A,$n){\n        //如果x>y，返回x，否则，返回y。\n        for($i=0;$i<$n;$i++) {\n            for($j=0;$j<$n-1;$j++){\n                //交换位置方法。\n                if($A[$j]>$A[$j+1]){\n                    $temp=$A[$j];\n                    $A[$j]=$A[$j+1];\n                    $A[$j+1]=$temp;\n                }\n            }\n        }\n        return $A;\n    }\n    //连续定义2个整形变量i,j。并赋予初始值。\n    $A=array(1,6,3,9,15,2,7,8,4,5);\n    printf(\"排序前的结果为：\");\n    for($i=0;$i<10;$i++) printf(\"%d\\t\",$A[$i]);\n    //定义指针变量B，获取返回结果，函数无法返回数组，有更优解法请留言。\n    $B=maopao($A,10);\n    printf(\"\\n冒泡排序的结果为：\");\n    for($i=0;$i<10;$i++)\n        printf(\"%d\\t\",$B[$i]);\n?>",
        "<?php\n    //定义迷宫数组，用二维数组表达迷宫，1为墙，0为路\n    $A=array(\n        array(1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1),\n        array(1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1),\n        array(1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1),\n        array(1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1),\n        array(1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,0,1,1,1),\n        array(1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,0,0,0,1),\n        array(1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,1,1,0,1),\n        array(1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,1,1,0,1),\n        array(1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,0,1),\n        array(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1)\n    );\n    //使用循环输出二维数迷宫。\n    for($i=1;$i<10;$i++){\n        for($j=1;$j<20;$j++){\n            if($A[$i][$j]==0) printf(\"□\");\n            else printf(\"▉\");\n        }\n        printf(\"\\n\");\n    }    \n?>",
        "<?php\n    //PHP是弱类型，定义结构体可以定义为一个类。\n    //定义一个学生的类，包含了姓名，年龄，学号。\n    class student{\n        var $name;\n        var $age;\n        var $number;\n    };\n    $stu=new student();  //根据新类型student，生成一个学生变量。\n    $stu->name=\"张三\";//给学生赋予姓名\n    $stu->age=15;//给学生赋予年龄\n    $stu->number=1001;//给学生赋予学号。\n    //打印学生信息，打印字符串用%s， 代表空4格。\n    printf(\"%s\\t%d\\t%d\\n\",$stu->name,$stu->age,$stu->number);\n?>",
        "<?php\n    //定义了一个递归函数，递归函数的特征是函数调用函数本身。\n    function dg($x,$z) { \n        if($x<=10){\n            $z=$z+$x;\n            $x++;\n            //PHP递归函数返回值必须在函数前面加return，很奇怪的一个问题？？\n            return dg($x,$z);\n        }\n        else {\n            return $z;\n        }\n    }     \n    //本题是用递归函数求1一直加到10的结果。\n    //用递归实现循环。递归的作用是函数调用函数本身，速度比循环慢。但可以解决很多问题。\n    $a=dg(1,0);\n    printf(\"递归的结果：%d\\n\",$a); \n?>",
        "<?php\n    //定义汉诺塔的递归函数\n    function move($n,$a,$b,$c) { \n        if($n==1) \n            printf(\"\\t%s->%s\\n\",$a,$c);    //当n只有1个的时候直接从a移动到c \n        else\n        { \n            move($n-1,a,$c,$b);            //第n-1个要从a通过c移动到b \n            printf(\"\\t%s->%s\\n\",$a,$c); \n            move($n-1,b,$a,$c);            //n-1个移动过来之后b变开始盘，b通过a移动到c，这边很难理解 \n        } \n    } \n    //定义汉诺塔个数。\n    $n=10; \n    move($n,'a','b','c'); \n?>",
        "<?php\n    //二分函数写法\n    function erfen($a, $key){\n         //PHP变量不能用逗号连续定义，奇怪\n         $low = 0; $high = 14; $mid;\n         while ($low <= $high)\n         {\n              $mid = ($low + $high) / 2;\n              if ($key == $a[$mid])\n                   return $mid;//找到结果\n              else if ($key < $a[$mid])\n                   $high = $mid - 1;//从高位找\n              else\n                  $low = $mid + 1;//从低位找\n         }\n         return 0;//未找到，返回0\n    }\n    //二分查找一定是做排好序的序列里面查找\n    $A=array(1,2,3,4,5,6,7,8,9,10);\n    //调用二分查找函数，查找值为7的元素做数组中位于第六位。\n    $i=erfen($A,7);\n    printf(\"二分查找值为7的元素的索引为：%d\\n\",$i);\n?>",
        "//!!!!!!!!!!!!!!!!!!提示，本平台暂时不支持输入语句，求高手提供解决方案\n//演示输入语句的用法\n<?php\n    printf(\"hello world\");\n    scanf(\"%d\",$i);\n    printf(\"%d\\n\",$i);\n?>"
    ],
    [
        "//必须包含的系统命令，类似C语言的#include。\nusing System;\n//Net 或者 Mono 必须定义一个类才能运行\nclass main\n{\n    //主函数\n    static void Main()\n    {\n        //输出语句\n        Console.Write(\"欢迎来到开源Mono和Net的世界！！\");\n    }\n}\n",
        "//必须包含的系统命令，类似C语言的#include。\nusing System;\n//Net 或者 Mono 必须定义一个类才能运行\nclass main\n{\n    //主函数\n    static void Main()\n    {\n        //定义整形变量i，并给i赋值\n        int i=10;\n        //修改i的值\n        i=20;\n        Console.Write(\"变量i的值为：\"+i);\n    }\n}",
        "using System;\nclass main\n{\n    //主函数\n    static void Main()\n    {\n        //定义浮点型变量i，并给i赋值，记得浮点型后面必须跟f！！,浮点型不能长于6位。可以尝试把小数位加大会出错。\n        float i=10.11112f;\n        //Console.WriteLine输出时会换行。\n        Console.WriteLine(\"浮点型变量i的值为：\"+i);\n        double j=22.22222222222222222222;\n        Console.Write(\"双精度浮点型变量j的值为：\"+j);\n    }\n}",
        "using System;\nclass main\n{\n    //主函数\n    static void Main()\n    {\n        //Net和Mono中的字符定义非常简单，已经封装好了现成的函数\n        string i=\"张三\";\n        //输出语句,使用了字符串相加的方法，把张三放在中间\n        Console.Write(\"欢迎\"+i+\"来到开源Mono和Net的世界！！\");\n    }\n}",
        "using System;\nclass program{\n    static void Main(){\n        int i=10;\n        //if 是判断的标示符，即你输入if，计算机能识别出这是判断，做很多语言中，=是赋值，比如给i赋值10的写法是 int i=10\n        //那么数学中的等号怎么表示呢？用2个等号==。。。下面这个if判断是判断变量i是否等于10，如果是10，输出第一句，否则，输出第二句。\n        //判断语句的标准写法是  if {}  else {}    如果满足条件则做什么，不满足条件，执行else里面的语句\n        if(i==10){\n            Console.Write(\"变量i等于10\\n\");\n        }\n        else{\n            Console.Write(\"变量i不等于10\\n\");\n        }\n    }\n}",
        "using System;\nclass main{\n    static void Main(){\n        //修改以下整形变量的值，得出成绩的优良中差。\n        int i=75;\n        //switch 是多条件判断的标示符。case是分支语句，满足不同条件，转向不同分支执行。\n        //j=i/10表示变量j等于变量i除以10.\n        int j=i/10;\n        switch(j){\n            case 6:Console.Write(\"及格\\n\");break;\n            case 7:Console.Write(\"良好\\n\");break;\n            case 8:Console.Write(\"良好\\n\");break;\n            case 9:Console.Write(\"优秀\\n\");break;\n            default:Console.Write(\"不及格\\n\");break;\n        }    \n    }\n}",
        "using System;\nclass main{\n    static void Main(){\n         //定义整形变量i等于5。\n        int i=5;\n        Console.WriteLine(\"第一次i等于：\"+i);\n        i=i+1;\n        Console.WriteLine(\"运行i=i+1后i等于：\"+i);\n        i++;\n        Console.WriteLine(\"运行i++后i等于：\"+i);\n        //得出结论：i++其实是i自己加1.\n    }\n}",
        "using System;\nclass main{\n    static void Main(){\n        //定义整形变量i等于5。\n        int i=5;\n        //取模标示符为%，实质是取余数。比如5/4 余数是1\n        int j=i%4;\n        Console.WriteLine(\"5模4的结果为：\"+j);\n        int z=i%6;//5除以6，余数是5.商0\n        Console.Write(\"5模6的结果为：\"+z);\n    }\n}",
        "using System;\nclass main\n{\n    //主函数\n    static void Main()\n    {\n        //Net和Mono中的字符定义非常简单，已经封装好了现成的函数\n        string i=\"张三\";\n        //输出语句,使用了字符串相加的方法，把张三放在中间\n        Console.Write(\"欢迎\"+i+\"来到开源Mono和Net的世界！！\");\n    }\n}",
        "using System;\nclass main{\n    static void Main(){\n        int i;\n        //for为循环标识，i=0;i<10;i++ 分别是三条语句。i的初值为0 每次加1，i大于等于10退出循环\n        //下面是循环输出10条Hellow world的语句。\n        for(i=0;i<10;i++){\n            Console.Write(\"hello world\");\n        }\n    }\n}",
        "using System;\nclass main{\n    static void Main(){\n        int i=0;\n        //while为循环标识，i<10 为判断语句，满足条件执行 while中的内容。\n        //下面是使用while循环输出10条Hellow world的语句。\n        while(i<10){\n            Console.WriteLine(\"hello world\");\n            i++;\n        }\n    }\n}",
        "using System;\nclass main{\n    static void Main(){\n        //do whild循环，没执行do大括号中的语句一次，就和while中的条件匹配一次，知道不满足条件，退出循环。\n        int i=0;\n        do{\n            Console.WriteLine(\"hello world\");\n            i++;\n        }while(i<10);\n    }\n}",
        "using System;\nclass main{\n    static void Main(){\n       //数组定义，变量带中括号，中括弧中输入数组的大小，=表示赋值，大括号中是数组的值。\n        int[] i={1,1,1,1,0,1,1,1,1,1};\n        //输出数组的第一位，哈，数组从0开始的哦\n        Console.WriteLine(\"数组的第一位的值为：\"+i[0]);\n        Console.WriteLine(\"数组的第二位的值为：\"+i[1]);\n        Console.WriteLine(\"数组的第五位的值为：\"+i[4]);    \n    }\n}",
        "using System;\nclass main{\n    static void Main(){\n        //数组定义，变量带中括号，中括弧中输入数组的大小，=表示赋值，大括号中是数组的值。\n        int[] i={1,9,8,10,2,3,4,5,6,7};\n        //数组大小为10，刚好用循环可以输出数组的值，可以看出，数组和循环经常会结合在一起使用。\n        int j;\n        for(j=0;j<10;j++){\n            Console.WriteLine(i[j]);\n        }\n    }\n}",
        "using System;\nclass main{\n    static void Main(){\n        //二维数组定义方法，其实是在一维数组中加入了另外一个中括号，以表示二维。\n        int[][] A={\n            new []{1,0,1,1,1,1,1,1,1,1},\n            new []{1,0,1,1,1,1,1,1,1,1},\n            new []{1,0,0,0,0,0,0,0,1,1},\n            new []{1,1,1,1,1,1,1,0,1,1},\n            new []{1,1,1,1,1,1,1,0,1,1},\n            new []{1,1,1,1,1,1,1,0,1,1},\n            new []{1,1,1,1,1,1,1,0,1,1},\n            new []{1,1,1,1,1,1,1,0,1,1},\n            new []{1,1,1,1,1,1,1,0,0,0},\n            new []{1,1,1,1,1,1,1,1,1,1}\n        };\n        //二维数组输出方法,输出第一排第一个\n        Console.WriteLine(\"第一排第一个值为：\"+A[0][0]);\n        //输出第一排第二个\n        Console.WriteLine(\"第一排第二个值为：\"+A[0][1]);\n        //输出第二排第3个\n        Console.WriteLine(\"第二排第3个值为：\"+A[1][2]);\n    }\n}",
        "using System;\nclass main{\n    static void Main(){\n        //二维数组定义方法，其实是在一维数组中加入了另外一个中括号，以表示二维。\n        int[][] A={\n            new []{1,0,1,1,1,1,1,1,1,1},\n            new []{1,0,1,1,1,1,1,1,1,1},\n            new []{1,0,0,0,0,0,0,0,1,1},\n            new []{1,1,1,1,1,1,1,0,1,1},\n            new []{1,1,1,1,1,1,1,0,1,1},\n            new []{1,1,1,1,1,1,1,0,1,1},\n            new []{1,1,1,1,1,1,1,0,1,1},\n            new []{1,1,1,1,1,1,1,0,1,1},\n            new []{1,1,1,1,1,1,1,0,0,0},\n            new []{1,1,1,1,1,1,1,1,1,1}\n        };\n        //二维数组需要用2个循环来输出全部内容。这就是二维数组和循环的关系\n        int i,j;\n        for(i=0;i<10;i++){\n            for(j=0;j<10;j++){\n                Console.Write(A[i][j]+\"\\t\");\n            }\n            Console.WriteLine();\n        }\n    }\n}",
        "using System;\nclass main{\n    //下面定义了一个求最大值的函数,方法必须定义为静态的才能给Main调用\n    static int max(int x,int y){\n        //如果x>y，返回x，否则，返回y。\n        if(x>y) return x;\n        else return y;\n    }\n    static void Main(){\n        //连续定义2个整形变量i,j。并赋予初始值。\n        int i=10,j=20;\n        //调用函数max，求得最大值。。\n        int z=max(i,j);\n        //输出最大值。\n        Console.Write(\"最大值为：\"+z);\n    }\n}",
        "using System;\nclass main{\n    static void Main(){\n        //Mono和C#实现99乘法表的方法，除了输出语句不一样，其他和C一样\n        int i,j;\n        for(i=1;i<10;i++)\n        {\n            for(j=1;j<10;j++)\n            {\n                Console.Write(i+\"*\"+j+\"=\"+i*j+\"  \");\n            }\n            Console.WriteLine();\n        }    \n    }\n}",
        "using System;\nclass main{\n    //下面定义了一个冒泡排序的函数\n    static int[] maopao(int[] A,int n){\n        //如果x>y，返回x，否则，返回y。\n        int i,j,temp;\n        for(i=0;i<n;i++) {\n            for(j=0;j<n-1;j++){\n                //交换位置方法。\n                if(A[j]>A[j+1]){\n                    temp=A[j];\n                    A[j]=A[j+1];\n                    A[j+1]=temp;\n                }\n            }\n        }\n        return A;\n    }\n    static void Main(){\n        //连续定义2个整形变量i,j。并赋予初始值。\n        int[] A={1,6,3,9,10,2,7,8,4,5};\n        //定义指针变量B，获取返回结果，函数无法返回数组，有更优解法请留言。\n        int[] B;\n        B=maopao(A,10);\n        Console.WriteLine(\"冒泡排序结果为：\");\n        int i;\n        for(i=0;i<10;i++)\n            Console.Write(B[i]+\"\\t\");\n     }\n}",
        "using System;\nclass main{\n    static void Main(){\n        //定义迷宫数组，用二维数组表达迷宫，1为墙，0为路\n        int[][] A={\n            new []{1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},\n            new []{1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},\n            new []{1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1},\n            new []{1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1},\n            new []{1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,0,1,1,1},\n            new []{1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,0,0,0,1},\n            new []{1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,1,1,0,1},\n            new []{1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,1,1,0,1},\n            new []{1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,0,1},\n            new []{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1}\n        };\n        //循环输出上面用二维数组定义的迷宫\n        int i,j;\n        for(i=1;i<10;i++)\n        {\n            for(j=1;j<20;j++)\n            {\n                if(A[i][j]==0) Console.Write(\"□\");\n                else Console.Write(\"▉\");\n            }\n            Console.WriteLine();\n        }    \n    }\n}",
        "using System;\nclass main{\n    //定义一个学生的结构体，包含了姓名，年龄，学号。定义在主函数之外，是全局变量\n    public struct student{\n        public string name;\n        public int age;\n        public int number;\n    };\n    static void Main(){\n        student stu;  //根据新类型student，生成一个学生变量。\n        stu.name=\"张三\";//给学生赋予姓名\n        stu.age=15;//给学生赋予年龄\n        stu.number=1001;//给学生赋予学号。\n        //打印学生信息，打印字符串用%s， 代表空4格。\n        Console.Write(\"姓名：\"+stu.name+\"  年龄：\"+stu.age+\"  学号：\"+stu.number);\n     }\n}",
        "using System;\nclass main{\n    //定义了一个递归函数，递归函数的特征是函数调用函数本身。\n    static int dg(int x,int z) { \n        if(x<=10){\n            z=z+x;\n            x++;\n            return dg(x,z);\n        }\n        else {\n            return z;\n        }\n    } \n    static void Main(){\n        //本题是用递归函数求1一直加到10的结果。\n        //用递归实现循环。递归的作用是函数调用函数本身，速度比循环慢。但可以解决很多问题。\n        int n=dg(1,0);\n        Console.Write(\"递归的结果：\"+n); \n    }\n}",
        "using System;\nclass main{\n    //汉诺塔递归函数\n    static void move(int n,char a,char b,char c) { \n        if(n==1) \n            Console.Write(\"\\t\"+a+\"->\"+c+\"\\n\");    //当n只有1个的时候直接从a移动到c \n        else\n        { \n            move(n-1,a,c,b);            //第n-1个要从a通过c移动到b \n            Console.Write(\"\\t\"+a+\"->\"+c+\"\\n\"); \n            move(n-1,b,a,c);            //n-1个移动过来之后b变开始盘，b通过a移动到c，这边很难理解 \n        } \n    } \n    static void Main(){\n        //定义汉诺塔个数。\n        int n=10; \n        move(n,'a','b','c'); \n     }\n}",
        "using System;\nclass main{\n    //二分查找函数定义\n    static int erfen(int[] a, int key){\n         int low = 0,high = 14, mid;\n         while (low <= high)\n         {\n              mid = (low + high) / 2;\n              if (key == a[mid])\n                   return mid;//找到结果\n              else if (key < a[mid])\n                   high = mid - 1;//从高位找\n              else\n                  low = mid + 1;//从低位找\n         }\n         return 0;//未找到，返回0\n    }\n    static void Main(){\n        //二分查找一定是做排好序的序列里面查找\n        int[] A={1,2,3,4,5,6,7,8,9,10};\n        //调用二分查找函数，查找值为7的元素做数组中位于第六位。\n        int i=erfen(A,7);\n        Console.Write(\"二分查找值为7的元素的索引为：\"+i);\n    }\n}",
        "//!!!!!!!!!!!!!!!!!!提示，本平台暂时不支持输入语句，求高手提供解决方案\n#include <stdio.h>\n//演示输入语句的用法\nvoid main(){\n    printf(\"hello world\");\n    int i;\n    scanf(\"%d\",&i);\n    printf(\"%d\",i);\n}"
    ],
    [
        "#coding=utf-8\n#第一行是设置中文编码，如果不设置，不能输入中文,#号是Python的注释\n#下一行是Python的输出语句\nprint(\"欢迎来到Python的世界！\")",
        "#coding=utf-8\n#一切数据是对象，一切命名是引用”\n#Python中变量无需定义，定义了反而会出错,但是必须声明以及初始化该变量\ni=123;\n#输出变量i的值\nprint i;",
        "#coding=utf-8\n#Python确定一个变量的类型是在给它赋值的时候。\ni=123.123;\n#输出浮点型变量i的值\nprint i;",
        "#coding=utf-8\n#Python确定一个变量的类型是在给它赋值的时候。\ni='A';\n#输出字符型变量i的值\nprint i;",
        "#coding=utf-8\n#Python语言是一款对缩进非常敏感的语言，tab和空格的混用会导致错误，或者缩进不对，而这是用肉眼无法分别的。\n#错误标识是expected an indented block，切记切记\n#冒号的下一行往往要缩进，该缩进的地方就要缩进，不缩进反而会出错\ni=123;\nif i==123:\n    print('变量i等于A');\nelse:\n    print('变量i不等于A');",
        "#coding=utf-8\n#Python语言没有switch case语句，用多个if else 替代。\ni=75;\n#除十取商数，\nj=i/10;\nif j==6:     print('及格');\nif j==7:     print('良好');\nif j==8:     print('良好');\nif j>9:      print('优秀');\nif j<6:      print('不及格');",
        "#coding=utf-8\ni=5;\n#Python中在输出语句中使用变量的方式如下。\nprint \"第一次i等于：%d\\n\" %i;\ni=i+1;\nprint '运行i=i+1后i等于：%d' %i;\n#Python没有i++这种语法，如果要实现此效果，必须用上面的方式替代。\n",
        "#coding=utf-8\ni=5;\n#取模标示符为%，实质是取余数。比如5/4 余数是1\nj=i%4;\nprint '%d'  %j;\nz=i%6;#5除以6，余数是5.商0\nprint '%d'  %z;\n",
        "#coding=utf-8\nA='张三';\nprint '%s' %A;    #如何再次给A赋值呢\nA='李四';\nprint '%s' %A;\n",
        "#coding=utf-8\ni=0;\n#for为循环标识，i为变化的量，range为循环范围。\n#下面是循环输出10条Hellow world的语句。\nfor i in range(0,10):\n    print 'hello world';\n",
        "#coding=utf-8\ni=0;\n#while为循环标识，i<10 为判断语句，满足条件执行 while中的内容。\n#下面是使用while循环输出10条Hellow world的语句。\nwhile i<10:\n    print 'hello world\\n';\n    i=i+1;\n",
        "#coding=utf-8\n#do whild循环，没执行do大括号中的语句一次，就和while中的条件匹配一次，知道不满足条件，退出循环。\nprint 'Python语言没有do while语句！！';",
        "#coding=utf-8\n#数组定义，变量带中括号，中括弧中输入数组的大小，=表示赋值，大括号中是数组的值。\ni=[1,1,1,1,0,1,1,1,1,1];\n#输出数组的第一位，哈，数组从0开始的哦\nprint \"数组第一位：%d\\n\" %i[0];\n#输出数组的第二位\nprint \"数组第二位：%d\\n\" %i[1];\n#输出数组的第五位，第五位是0哦。但第五位标号是4哦。\nprint \"数组第五位：%d\\n\" %i[4];    ",
        "#coding=utf-8\n#数组定义，变量带中括号，中括弧中输入数组的大小，=表示赋值，大括号中是数组的值。 \ni=[1,9,8,10,2,3,4,5,6,7];\n#数组大小为10，刚好用循环可以输出数组的值，可以看出，数组和循环经常会结合在一起使用。\nfor j in range(0,10):\n    print '%d\\n' %i[j];\n",
        "#coding=utf-8\n#数组定义，变量带中括号，中括弧中输入数组的大小，=表示赋值，大括号中是数组的值。\n#二维数组定义方法，其实是在一维数组中加入了另外一个中括号，以表示二维。\nA=[\n        [1,0,1,1,1,1,1,1,1,1],\n        [1,0,1,1,1,1,1,1,1,1],\n        [1,0,0,0,0,0,0,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,0,0],\n        [1,1,1,1,1,1,1,1,1,1]\n   ];\n#二维数组输出方法,输出第一排第一个\nprint '数组第一排第一个：%d' %A[0][0];\n#输出第一排第二个\nprint '数组第一排第二个：%d' %A[0][1];\n#输出第二排第3个\nprint '数组第二排第三个：%d' %A[1][2];\n",
        "#coding=utf-8\nA=[\n        [1,0,1,1,1,1,1,1,1,1],\n        [1,0,1,1,1,1,1,1,1,1],\n        [1,0,0,0,0,0,0,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,0,0],\n        [1,1,1,1,1,1,1,1,1,1]\n   ];\n#Python实现双重循环，print为换行  print 后面加逗号为不换行。\nfor i in range(0,10):\n   for j in range(0,10):\n      print '%d\t' %A[i][j],\n   print\n",
        "#coding=utf-8\n#下面定义了一个求最大值的函数\ndef max(x,y):\n    #如果x>y，返回x，否则，返回y。\n    if x>y: return x;\n    else: return y;\n#连续定义2个整形变量i,j。并赋予初始值。\ni=10\nj=20\n#调用函数max，求得最大值。。\nz=max(10,20);\n#输出最大值。\nprint '最大值为：%d' %z;\n",
        "#coding=utf-8\n#嗯，Python做99乘法表好像代码很少啊。\nfor i in range(1,10):\n    for j in range (1,10):\n        print '%dX%d=%2d  ' %(i, j, i*j),\n    print;\n",
        "#coding=utf-8\n#下面定义了一个求最大值的函数\ndef maopao(A,n):\n    #如果x>y，返回x，否则，返回y。\n    for i in range(0,n):\n        for j in range(0,n-1):\n            #交换位置方法。\n            if A[j]>A[j+1]:\n                temp=A[j];\n                A[j]=A[j+1];\n                A[j+1]=temp;\n    return A\n#连续定义2个整形变量i,j。并赋予初始值。\nA=[1,6,31,9,10,2,7,8,4,5]\n#定义指针变量B，获取返回结果，函数无法返回数组，有更优解法请留言。\nB=maopao(A,10);\nprint '冒泡排序结果为：'\nfor i in range(0,10):\n    print '%d\t' %B[i],\n",
        "#coding=utf-8\n#include <stdio.h>\n#定义迷宫数组，用二维数组表达迷宫，1为墙，0为路\nA=[\n    [1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\n    [1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\n    [1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1],\n    [1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1],\n    [1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,0,1,1,1],\n    [1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,0,0,0,1],\n    [1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,1,1,0,1],\n    [1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,1,1,0,1],\n    [1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,0,1],\n    [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1]\n ];\nfor i in range(1,10):\n    for j in range(1,10):\n        if A[i][j]==0: \n            print '□',\n        else: \n            print '▉',\n    print;\n",
        "#coding=utf-8\n#定义一个学生的结构体，包含了姓名，年龄，学号。定义在主函数之外，是全局变量\nclass student(object):\n    \"这是一个学生类\"\n    name='学生';\n    age=0;\n    number=0;\nstu=student();  #根据新类型student，生成一个学生变量。\nstu.name='张三';#给学生赋予姓名\nstu.age=15;#给学生赋予年龄\nstu.number=1001;#给学生赋予学号。\n#打印学生信息，打印字符串用%s， 代表空4格。\nprint '%s\t%d\t%d' %(stu.name,stu.age,stu.number)\n",
        "#coding=utf-8\n#定义了一个递归函数，递归函数的特征是函数调用函数本身。\ndef dg(x,z):\n    if x<=10:\n        z=z+x;\n        x=x+1;\n        #PHP递归函数返回值必须在函数前面加return，很奇怪的一个问题？？\n        return dg(x,z);\n    else:\n        return z;\n#本题是用递归函数求1一直加到10的结果。\n#用递归实现循环。递归的作用是函数调用函数本身，速度比循环慢。但可以解决很多问题。\na=dg(1,0)\nprint '递归的结果：%d' %a ",
        "#coding=utf-8\n#定义汉诺塔的递归函数\ndef move(n,a,b,c): \n    if n==1: \n        print '\\t%s->%s' %(a,c)     #当n只有1个的时候直接从a移动到c \n    else:\n        move(n-1,a,c,b);            #第n-1个要从a通过c移动到b \n        print '\\t%s->%s' %(a,c) \n        move(n-1,b,a,c);            #n-1个移动过来之后b变开始盘，b通过a移动到c，这边很难理解 \n#定义汉诺塔个数。\nn=10; \nmove(n,'a','b','c'); ",
        "#coding=utf-8\n#二分函数写法\ndef erfen(a, key):\n     #PHP变量不能用逗号连续定义，奇怪\n     low = 0\n     high = 10\n     while low <= high:\n          mid = (low + high) / 2;\n          if key == a[mid]:\n               return mid;   #找到结果\n          elif key < a[mid]:\n               high = mid - 1;#从高位找\n          else:\n              low = mid + 1;  #从低位找\n     return 0; #未找到，返回0\n#二分查找一定是做排好序的序列里面查找\nA=[1,2,3,4,5,6,7,8,9,10];\n#调用二分查找函数，查找值为7的元素做数组中位于第六位。\ni=erfen(A,7)\nprint '二分查找值为7的元素的索引为：%d' %i",
        "#coding=utf-8\n#!!!!!!!!!!!!!!!!!!本平台暂时不支持输入语句，寻求高手支持！！！！！！！！！！！！\nprintf(\"hello world\");\nscanf(\"%d\",$i);\nprintf(\"%d\\n\",$i);"
    ],
    [
        "//nodejs的输出很简洁，即符合传统语言，又简单\nconsole.log(\"欢迎您来到nodejs的世界。\");",
        "//定义变量i，并赋值为10，再修改为20，然后输出\nvar i=10;\ni=20;\nconsole.log(i);",
        "//定义变量i，并赋值为小数，再修改为精度很高的小数，然后输出\nvar i=10.12345;\nconsole.log(i);\ni=20.222222222222222222222222;\nconsole.log(i);",
        "//定义变量i，并赋值为张三，再修改为李四，然后输出\nvar i='张三';\nconsole.log(i);\ni='李四';\nconsole.log(i);",
        "//定义变量i，并赋值为张三\n//使用判断结构，判断变量i是否等于张三\nvar i='张三';\nif(i=='张三')\n    console.log('变量i等于张三');\nelse\n    console.log('变量i不等于张三');",
        "//修改以下整形变量的值，得出成绩的优良中差。 \nvar i=75;\n//switch 是多条件判断的标示符。case是分支语句，满足不同条件，转向不同分支执行。\n//j=i/10表示变量j等于变量i除以10.nodejs会得出小数，需用Math.floor函数取整数\nvar j= Math.floor(i/10);\nswitch(j){\n    case 6:console.log('及格');break;\n    case 7:console.log('良好');break;\n    case 8:console.log('良好');break;\n    case 9:console.log('优秀');break;\n    default:console.log('不及格');break;\n}  ",
        "//定义整形变量i等于5。\nvar i=5;\nconsole.log('第一次i等于：'+i);\ni=i+1;\nconsole.log('运行i=i+1后i等于：'+i);\ni++;\nconsole.log('运行i++后i等于：'+i);\n//得出结论：i++其实是i自己加1.\n",
        "//定义整形变量i等于5。\nvar i=5;\n//取模标示符为%，实质是取余数。比如5/4 余数是1\nvar j=i%4;\nconsole.log('5模4的结果为：'+j);\nvar z=i%6;//5除以6，余数是5.商0\nconsole.log('5模6的结果为：'+z);",
        "//在C语言中如何表达姓名、地址等复杂字符呢，用数组可以表达，参加后续章节，数组。\nvar A='张三';\nconsole.log(A);    //如何再次给A赋值呢、A='李四';\nA='李四';\nconsole.log(A);\n",
        "var i;\n//for为循环标识，i=0;i<10;i++ 分别是三条语句。i的初值为0 每次加1，i大于等于10退出循环\n//下面是循环输出10条Hellow world的语句。\nfor(i=0;i<10;i++){\n    console.log('hello world');\n}",
        "var i=0;\n//while为循环标识，i<10 为判断语句，满足条件执行 while中的内容。\n//下面是使用while循环输出10条Hellow world的语句。\nwhile(i<10){\n    console.log('hello world');\n    i++;\n}",
        "//do whild循环，没执行do大括号中的语句一次，就和while中的条件匹配一次，知道不满足条件，退出循环。\nvar i=0;\ndo{\n    console.log('hello world');\n    i++;\n}while(i<10);",
        "//数组定义，变量带中括号，中括弧中输入数组的大小，=表示赋值，大括号中是数组的值。\nvar i=[1,1,1,1,0,1,1,1,1,1];\n//输出数组的第一位，哈，数组从0开始的哦\nconsole.log('数组第一位是：'+i[0]);\n//输出数组的第二位\nconsole.log('数组第二位是：'+i[1]);\n//输出数组的第五位，第五位是0哦。但第五位标号是4哦。\nconsole.log('数组第五位是：'+i[4]);    ",
        "//数组定义，变量带中括号，中括弧中输入数组的大小，=表示赋值，大括号中是数组的值。\nvar i=[1,9,8,10,2,3,4,5,6,7];\n//数组大小为10，刚好用循环可以输出数组的值，可以看出，数组和循环经常会结合在一起使用。\nvar j;\nfor(j=0;j<10;j++){\n    console.log(i[j]);\n}",
        "//二维数组定义方法，其实是在一维数组中加入了另外一个中括号，以表示二维。\nvar A=[\n        [1,0,1,1,1,1,1,1,1,1],\n        [1,0,1,1,1,1,1,1,1,1],\n        [1,0,0,0,0,0,0,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,0,0],\n        [1,1,1,1,1,1,1,1,1,1]\n    ];\n//二维数组输出方法,输出第一排第一个\nconsole.log('第一排第一个:'+A[0][0]);\n//输出第一排第二个\nconsole.log('第一排第二个:'+A[0][1]);\n//输出第二排第3个\nconsole.log('第二排第三个:'+A[1][2]);",
        "var A=[\n        [1,0,1,1,1,1,1,1,1,1],\n        [1,0,1,1,1,1,1,1,1,1],\n        [1,0,0,0,0,0,0,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,0,0],\n        [1,1,1,1,1,1,1,1,1,1]\n    ];\n//二维数组需要用2个循环来输出全部内容。这就是二维数组和循环的关系\nvar i,j;\nfor(i=0;i<10;i++){\n    for(j=0;j<10;j++){\n        //console.log会换行，用process.stdout.write可以不换行\n        process.stdout.write(A[i][j]+'\t');\n    }\n    console.log();\n}",
        "//下面定义了一个求最大值的函数\nfunction max(x,y){\n    //如果x>y，返回x，否则，返回y。\n    if(x>y) return x;\n    else return y;\n}\n//连续定义2个整形变量i,j。并赋予初始值。\nvar i=10,j=20;\n//调用函数max，求得最大值。。\nvar z=max(10,20);\n//输出最大值。\nconsole.log('最大值为:'+z);\n",
        "//nodejs实现99乘法表\nvar i,j;\nfor(i=1;i<10;i++)\n{\n    for(j=1;j<10;j++)\n    {\n        process.stdout.write(i+'X'+j+'='+i*j+'  ');\n    }\n    console.log();\n}   ",
        "//nodejs冒泡排序函数\nfunction maopao(A,n){\n    //如果x>y，返回x，否则，返回y。\n    var i,j,temp;\n    for(i=0;i<n;i++) {\n        for(j=0;j<n-1;j++){\n            //交换位置方法。\n            if(A[j]>A[j+1]){\n                temp=A[j];\n                A[j]=A[j+1];\n                A[j+1]=temp;\n            }\n        }\n    }\n    return A;\n}\nvar A=[1,6,3,9,10,2,7,8,4,5];\n//定义变量B，获取返回结果。\nvar B=maopao(A,10);\nconsole.log('冒泡排序结果为：');\nvar i;\nfor(i=0;i<10;i++)\n    process.stdout.write(B[i]+'\t');\n",
        "//nodejs定义迷宫数组，用二维数组表达迷宫，1为墙，0为路\nvar A=[\n        [1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\n        [1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\n        [1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1],\n        [1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1],\n        [1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,0,1,1,1],\n        [1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,0,0,0,1],\n        [1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,1,1,0,1],\n        [1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,1,1,0,1],\n        [1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,0,1],\n        [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1]\n    ];\nvar i,j;\n//循环输出迷宫\nfor(i=1;i<10;i++){\n    for(j=1;j<20;j++){\n        if(A[i][j]==0) process.stdout.write('□');\n        else process.stdout.write('▉');\n    }\n    console.log();\n} ",
        "//定义一个学生的结构体，包含了姓名，年龄，学号。\nfunction student(){\n    var name;\n    var age;\n    var number;\n}\nstu=new student();  //根据新类型student，生成一个学生变量。\nstu.name='张三';//给学生赋予姓名\nstu.age=15;//给学生赋予年龄\nstu.number=1001;//给学生赋予学号。\n//打印学生信息，打印字符串用%s， 代表空4格。\nconsole.log(stu.name+'  '+stu.age+'  '+stu.number);\n",
        "//定义了一个递归函数，递归函数的特征是函数调用函数本身。\nfunction dg(x,z) { \n    if(x<=10){\n        z=z+x;\n        x++;\n        return dg(x,z);\n    }\n    else {\n        return z;\n    }\n} \n//本题是用递归函数求1一直加到10的结果。\n//用递归实现循环。递归的作用是函数调用函数本身，速度比循环慢。但可以解决很多问题。\nvar n=dg(1,0);\nconsole.log('递归的结果：',n); \n",
        "//nodejs实现汉诺塔函数\nfunction move(n,a,b,c) { \n    if(n==1) \n        console.log('\t'+a+'->'+c);    //当n只有1个的时候直接从a移动到c \n    else\n    { \n        move(n-1,a,c,b);            //第n-1个要从a通过c移动到b \n        console.log('\t'+a+'->'+c); \n        move(n-1,b,a,c);            //n-1个移动过来之后b变开始盘，b通过a移动到c，这边很难理解 \n    } \n} \n//定义汉诺塔个数。\nvar n=10; \nmove(n,'a','b','c'); \n",
        "//二分查找函数定义\nfunction erfen(a, key){\n     var low = 0,high = 14, mid;\n     while (low <= high)\n     {\n          mid = (low + high) / 2;\n          if (key == a[mid])\n               return mid;//找到结果\n          else if (key < a[mid])\n               high = mid - 1;//从高位找\n          else\n              low = mid + 1;//从低位找\n     }\n     return 0;//未找到，返回0\n}\n//二分查找一定是做排好序的序列里面查找\nvar A=[1,2,3,4,5,6,7,8,9,10];\n//调用二分查找函数，查找值为7的元素做数组中位于第六位。\nvar i=erfen(A,7);\nconsole.log('二分查找值为7的元素的索引为：'+i);\n",
        "//nodejs输入语句。。。。\n//!!!!!!!!!!!!!!!!!!本平台暂时不支持输入语句，寻求高手支持！！！！！！！！！！！！\nprintf(\"hello world\");\nscanf(\"%d\",$i);\nprintf(\"%d\\n\",$i);"
    ],
    [
        "#ruby 输出方法,和Python一样，用#做为注释的标志。\n#Ruby语言中，以对象为基本单位，所有的元素都是对象,和Python一样。\nputs('欢迎来到Ruby的世界!');",
        "#定义变量i，赋值为10，再赋值为20，输出i\ni=10;\ni=20;\nputs(i);",
        "#定义浮点型变量i，并赋值，再赋值为很多小数位，输出i\ni=10.6666;\nputs(i);\ni=20.22222222222222222222222;\nputs(i);",
        "#定义字符型变量i，并赋值为张三，再赋值为李四，输出i\ni='张三';\nputs(i);\ni='李四';\nputs(i);",
        "#可以看出，Ruby条件语句比较啰嗦\ni='张三';\nif i=='张三' then\n    puts('变量i等于张三');\nelse\n    puts('变量i不等于张三');\nend",
        "#修改以下整形变量的值，得出成绩的优良中差。\ni=45;\n#ruby中 switch case写法比较特别，用Case做关键字，满足不同条件，转向不同分支执行。\n#j=i/10表示变量j等于变量i除以10.\nj=i/10;\ncase j\n    when 6:puts('及格');\n    when 7:puts('良好');\n    when 8:puts('良好');\n    when 9:puts('优秀');\n    when 1..5:puts('不及格'); #范围表达用1..5.   \nend",
        "#Rbuy语言自加的方法\ni=0;\ni=i+1;\nputs(i);\n#Ruby不支持i++的语法，和Python一样\n#i++;\n",
        "#Rbuy语言取模的方法，取模就是求余数，小学的课程。\ni=5;\nj=i%4;\nputs(j);#余数为1\nj=i%6;\nputs(j);#余数为5\n",
        "#定义字符型变量i，并赋值为张三，再赋值为李四，输出i\ni='张三';\nputs(i);\ni='李四';\nputs(i);",
        "#for为循环标识，i为循环变量.1..10为循环次数\n#下面是循环输出10条Hellow world的语句。\nfor i in 1..10\n    puts('hello world');\nend\n",
        "#while为循环标识，i为循环变量.i<=10为循环次数\n#下面是循环输出10条Hellow world的语句。\ni=1;\nwhile i<=10 do\n    puts('hello world');\n    i=i+1;\nend\n",
        "#Ruby和Python一样，已经不存在do while循环了，只能变通的去实现",
        "#数组定义，变量带中括号，中括弧中输入数组的大小，=表示赋值，大括号中是数组的值。\ni=[1,1,1,1,0,1,1,1,1,1];\n#输出数组的第一位，哈，数组从0开始的哦\nputs('数组第一位：',i[0]);\n#输出数组的第二位\nputs('数组第二位：',i[1]);\n#输出数组的第五位，第五位是0哦。但第五位标号是4哦。\nputs('数组第五位：',i[4]);  ",
        "i=[1,9,8,10,2,3,4,5,6,7];\n#数组大小为10，刚好用循环可以输出数组的值，可以看出，数组和循环经常会结合在一起使用。\nfor j in 1..10\n    puts(i[j]);\nend",
        "#数组定义，变量带中括号，中括弧中输入数组的大小，=表示赋值，大括号中是数组的值。\n#二维数组定义方法，其实是在一维数组中加入了另外一个中括号，以表示二维。\nA=[\n        [1,0,1,1,1,1,1,1,1,1],\n        [1,0,1,1,1,1,1,1,1,1],\n        [1,0,0,0,0,0,0,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,0,0],\n        [1,1,1,1,1,1,1,1,1,1]\n   ];\n#二维数组输出方法,输出第一排第一个\nputs('数组第一排第一个：', A[0][0]);\n#输出第一排第二个\nputs('数组第一排第二个：', A[0][1]);\n#输出第二排第3个\nputs('数组第二排第三个：', A[1][2]);",
        "#定义二维数组\nA=[\n        [1,0,1,1,1,1,1,1,1,1],\n        [1,0,1,1,1,1,1,1,1,1],\n        [1,0,0,0,0,0,0,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,1,1],\n        [1,1,1,1,1,1,1,0,0,0],\n        [1,1,1,1,1,1,1,1,1,1]\n   ];\n#Ruby实现双重循环，print为换行  print 后面加逗号为不换行。\n#ruby循环是0到9  不是0到10，需要注意！！！！！！！！！\nfor i in 0..9\n    for j in 0..9\n        #Ruby字符串相加是用逗号，需要注意\n        print(A[i][j],' ');\n    end\n    puts();\nend",
        "#下面定义了一个求最大值的函数\ndef max(x,y)\n    #如果x>y，返回x，否则，返回y。\n    if x>y then return x;\n    else return y;\n    end\nend\n#连续定义2个整形变量i,j。并赋予初始值。\ni=10\nj=30\n#调用函数max，求得最大值。。\nz=max(i,j);\n#输出最大值。\nprint '最大值为：%d' %z;\n",
        "#嗯，Ruby实现99乘法表。\n#Ruby的数组坑特别多，小心使用\nfor i in 1..9\n    for j in 1..9\n        print(i,'X',j,'=',i*j,'  ')\n    end\n    puts() ;\nend",
        "#Ruby数组和其他语言有很大出入，比较复杂，难用！！！\n#Ruby数组变量名不能用大写！！！！！！！不知道这些奇怪的规定是要干啥\n#下面定义了一个求最大值的函数\ndef maopao(a,n)\n    #如果x>y，返回x，否则，返回y。\n    for i in 0..n-1\n        for j in 0..n-2\n            #交换位置方法。\n            if a[j]>a[j+1] then\n                temp=a[j];\n                a[j]=a[j+1];\n                a[j+1]=temp;\n            end\n        end\n    end\n    return a\nend\n#连续定义2个整形变量i,j。并赋予初始值。\na=[1,6,31,9,10,2,7,8,4,5];\n#定义指针变量B，获取返回结果，函数无法返回数组，有更优解法请留言。\nb=maopao(a,10);\nprint '冒泡排序结果为：'\nfor i in 0..9\n    print(b[i],' ');\nend\n",
        "#定义迷宫数组，用二维数组表达迷宫，1为墙，0为路\n#Ruby循环和传统语言不一样,是小于等于，不是小于，意味着循环10次是从0到9，不是从0到10.!!!!!!!!!!!!!\nA=[\n    [1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\n    [1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\n    [1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1],\n    [1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1],\n    [1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,0,1,1,1],\n    [1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,0,0,0,1],\n    [1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,1,1,0,1],\n    [1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,1,1,0,1],\n    [1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,0,1],\n    [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1]\n ];\nfor i in 1..9\n    for j in 1..9\n        if A[i][j]==0 then\n            print('□',' ')\n        else \n            print('▉',' ')\n        end\n    end\n    puts();\nend",
        "#Ruby和其他语言逻辑不一样，学习成本高。\n#Ruby的类名必须大写，数组名必须小写！！！！！！\n#Ruby的属性定义非常奇怪！！！\n#定义一个学生的结构体，包含了姓名，年龄，学号。定义在主函数之外，是全局变量\nclass Student\n    attr :name,true\n    attr :age,true\n    attr :number,true\n    def initialize() end\nend\nstu=Student.new()  #根据新类型student，生成一个学生变量。\nstu.name='张三';#给学生赋予姓名\nstu.age=15;#给学生赋予年龄\nstu.number=1001;#给学生赋予学号。\n#打印学生信息，打印字符串用%s， 代表空4格。\nprint(stu.name,' ',stu.age,' ',stu.number)",
        "#定义了一个递归函数，递归函数的特征是函数调用函数本身。\ndef dg(x,z)\n    if x<=10 then\n        z=z+x;\n        x=x+1;\n        #Ruby递归函数返回值必须在函数前面加return，很奇怪的一个问题？？\n        return dg(x,z);\n    else\n        return z;\n    end\nend\n#本题是用递归函数求1一直加到10的结果。\n#用递归实现循环。递归的作用是函数调用函数本身，速度比循环慢。但可以解决很多问题。\na=dg(1,0)\nprint '递归的结果：%d' %a ",
        "#定义汉诺塔的递归函数\ndef move(n,a,b,c)\n    if n==1 then\n        #ruby print函数换行必须用双引号\"\\n\"\n        print(a,'->',c,\"\\n\")     #当n只有1个的时候直接从a移动到c \n    else\n        move(n-1,a,c,b);            #第n-1个要从a通过c移动到b \n        print(a,'->',c,\"\\n\") \n        move(n-1,b,a,c);            #n-1个移动过来之后b变开始盘，b通过a移动到c，这边很难理解 \n    end\nend\n#定义汉诺塔个数。\nn=10; \nmove(n,'a','b','c'); ",
        "#二分函数写法\ndef erfen(a, key)\n     low = 0\n     high = 10\n     while low <= high\n          mid = (low + high) / 2;\n          if key == a[mid] \n               return mid;   #找到结果\n          else \n             if key < a[mid] \n                high = mid - 1;#从高位找\n             else\n                low = mid + 1;  #从低位找\n             end\n          end\n     end\n     return 0; #未找到，返回0\nend\n#二分查找一定是做排好序的序列里面查找\na=[1,2,3,4,5,6,7,8,9,10];\n#调用二分查找函数，查找值为7的元素做数组中位于第六位。\ni=erfen(a,7)\nprint('二分查找值为7的元素的索引为：',i)\n",
        "#!!!!!!!!!!!!!!!!!!本平台暂时不支持输入语句，寻求高手支持！！！！！！！！！！！！\nprintf(\"hello world\");\nscanf(\"%d\",$i);\nprintf(\"%d\\n\",$i);"
    ],
    [
        "#Perl注释方法和Python一样用#号\n#Perl最重要的特性是它内部集成了正则表达式的功能，以及巨大的第三方代码库CPAN。\n#Perl的输出语句如下\nprint '欢迎来到Perl的世界!';",
        "#Perl变量定义方法如下，很像PHP\n#Perl语句结束采用分号;\n$i=123;\n$i=45;\nprint($i);",
        "#Perl浮点型变量定义方法如下，很像PHP\n#Perl语句结束采用分号;\n#Perl输出多个语句用，号分隔，包括换行\n$i=123.123;\nprint($i,\"\\n\");\n$i=45.4564564564654;\nprint($i);",
        "#Perl字符型变量定义方法如下\n$i='张三';\nprint($i,\"\\n\");\n$i='李四';\nprint($i);",
        "#Perl条件语句如下.\n$i='张三';\nif($i=='张三') {\n    print('变量i等于张三');\n}\nelse{\n    print('变量i不等于张三');\n}",
        "#Perl本身不支持Switch case语句，只能通过其他方法予以实现。\n$i=75;\n#j=i/10表示变量j等于变量i除以10.在perl中，除号会有小数位，所以必须用函数取整。\n$j=$i/10;\n#取整数\n$j=int($j);\nprint($j);\n",
        "#定义整形变量i等于5。让i实现自加运算！\n$i=5;\nprint(\"第一次i等于：\",$i,\"\\n\");\n$i=$i+1;\nprint(\"运行i=i+1后$i等于:\",$i,\"\\n\");\n$i++;\nprint(\"运行i++后i等于：\",$i);\n#得出结论：i++其实是i自己加1.",
        "#Perl语言取模的方法，取模就是求余数，小学的课程。\n$i=5;\n$j=$i%4;\nprint('5模4的结果为：',$j,\"\\n\");#余数为1\n$j=$i%6;\nprint('5模6的结果为：',$j);#余数为5",
        "#Perl字符型变量定义方法如下\n$i='张三';\nprint($i,\"\\n\");\n$i='李四';\nprint($i);",
        "#Perl中的for循环语法\n#for为循环标识，i=0;i<10;i++ 分别是三条语句。i的初值为0 每次加1，i大于等于10退出循环\n#下面是循环输出10条Hellow world的语句。\nfor($i=0;$i<10;$i++){\n    print('hello world',\"\\n\");\n}",
        "#Perl中的while循环方法\n$i=0;\n#while为循环标识，i<10 为判断语句，满足条件执行 while中的内容。\n#下面是使用while循环输出10条Hellow world的语句。\nwhile($i<10){\n    print('hello world',\"\\n\");\n    $i++;\n}",
        "#Perl中的do whild循环，没执行do大括号中的语句一次，就和while中的条件匹配一次，知道不满足条件，退出循环。\n$i=0;\ndo{\n    print('hello world',\"\\n\");\n    $i++;\n}while($i<10);",
        "#Perl数组定义，数组变量带@符号，访问时用$,小括号中是数组的值\n@i=(1,1,1,1,0,1,1,1,1,1);\n#PHP一样可以用printf哦。。下面看看不一样的输出\n#输出数组的第一位，哈，数组从0开始的哦\nprint(\"数组第1个位置等于：\",$i[0],\"\\n\");\n#输出数组的第二位\nprint(\"数组第2个位置等于：\",$i[1],\"\\n\");\n#输出数组的第五位，第五位是0哦。但第五位标号是4哦。\nprint(\"数组第5个位置等于：\",$i[4],\"\\n\"); \n",
        "#Perl中循环输出数组中的值，是程序员经常要干的活。\n@arr=(1,9,8,10,2,3,4,5,6,7);\n#数组大小为10，刚好用循环可以输出数组的值，可以看出，数组和循环经常会结合在一起使用。\nfor($j=0;$j<10;$j++){\n    print($arr[$j],'  ');\n}",
        "#Perl中二维数组定义方法，第一维用小括号，第二维用中括号。\n@A=(\n    [1,0,1,1,1,1,1,1,1,1],\n    [1,0,1,1,1,1,1,1,1,1],\n    [1,0,0,0,0,0,0,0,1,1],\n    [1,1,1,1,1,1,1,0,1,1],\n    [1,1,1,1,1,1,1,0,1,1],\n    [1,1,1,1,1,1,1,0,1,1],\n    [1,1,1,1,1,1,1,0,1,1],\n    [1,1,1,1,1,1,1,0,1,1],\n    [1,1,1,1,1,1,1,0,0,0],\n    [1,1,1,1,1,1,1,1,1,1]\n);\n#二维数组输出方法,输出第一排第一个\nprint($A[0][0],\"\\n\");\n#输出第一排第二个\nprint($A[0][1],\"\\n\");\n#输出第二排第3个\nprint($A[1][2]);",
        "#Perl输出二维数组和PHP一样\n@A=(\n    [1,0,1,1,1,1,1,1,1,1],\n    [1,0,1,1,1,1,1,1,1,1],\n    [1,0,0,0,0,0,0,0,1,1],\n    [1,1,1,1,1,1,1,0,1,1],\n    [1,1,1,1,1,1,1,0,1,1],\n    [1,1,1,1,1,1,1,0,1,1],\n    [1,1,1,1,1,1,1,0,1,1],\n    [1,1,1,1,1,1,1,0,1,1],\n    [1,1,1,1,1,1,1,0,0,0],\n    [1,1,1,1,1,1,1,1,1,1]\n);\nfor($i=0;$i<10;$i++){\n    for($j=0;$j<10;$j++){\n        print($A[$i][$j],' ');\n    }\n    print(\"\\n\");\n}",
        "#Perl函数标识是sub，下面定义了一个求最大值的函数\n#Perl函数传参要写在方法体里面  my($x,$y)=@_; 这是比较怪异的地方。\nsub max{\n    my($x,$y)=@_;\n    #如果x>y，返回x，否则，返回y。\n    if($x>$y){ return $x;}\n    else{ return $y;}\n}\n#连续定义2个整形变量i,j。并赋予初始值。\n$i=10;\n$j=30;\n#调用函数max，求得最大值。。\n$z=max($i,$j);\n#输出最大值。\nprint('最大值为：', $z);",
        "#嗯，Perl实现99乘法表方法和PHP差不多。。\nfor($i=1;$i<10;$i++)\n{\n    for($j=1;$j<10;$j++)\n    {\n        print($i,'X',$j,'=',$i*$j,'  ');\n    }\n    print(\"\\n\");\n}   ",
        "#Perl实现冒泡排序的方法 Perl函数参数是一个硬伤，比较难用\n#Perl中把数组作为参数传递到函数中需要传递引用。\nsub maopao{\n    my($B,$n)=@_;\n    for($i=0;$i<$n;$i++) {\n        for($j=0;$j<$n-1;$j++){\n            #交换位置方法。\n            #Perl由于使用引用传递数组，则取值时更加古怪，需要形如@$B的模式才能取值\n            if(@$B[$j]>@$B[$j+1]){\n                $temp=@$B[$j];\n                @$B[$j]=@$B[$j+1];\n                @$B[$j+1]=$temp;\n            }\n        }\n    }\n    #由于使用引用作为参数，返回值时，需要使用@$B。\n    return @$B;\n}\n@A=(1,6,3,9,15,2,7,8,4,5);\nprint('排序前的结果为：');\nfor($i=0;$i<10;$i++){\n  print($A[$i],'  ');\n}\n#数组作为参数时传递引用，引用写法为\@A。加反斜杠。\n@B=maopao(\\@A,10);print(\"\\n冒泡排序的结果为：\");\nfor($i=0;$i<10;$i++){\n    print($B[$i],'   ');\n}\n",
        "#定义迷宫数组，用二维数组表达迷宫，1为墙，0为路 \n@A=(\n    [1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\n    [1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],\n    [1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1],\n    [1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1],\n    [1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,0,1,1,1],\n    [1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,0,0,0,1],\n    [1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,1,1,0,1],\n    [1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,1,1,0,1],\n    [1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,0,1],\n    [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1]\n);\n#使用循环输出二维数迷宫。\nfor($i=1;$i<10;$i++){\n    for($j=1;$j<20;$j++){\n        if($A[$i][$j]==0){\n             print('□');\n        }\n        else{ \n            print('▉');\n        }\n    }\n    print(\"\\n\");\n}    ",
        "#Perl不擅长定义类和结构体，或者是作者孤陋寡闻，无法办到，此篇章为空，留待后来者！！！！！！！！！！！！！！",
        "#定义了一个递归函数，递归函数的特征是函数调用函数本身。\nsub dg { \n    my($x,$z)=@_;\n    if($x<=10){\n        $z=$z+$x;\n        $x++;\n        #PHP递归函数返回值必须在函数前面加return，很奇怪的一个问题？？\n        return dg($x,$z);\n    }\n    else {\n        return $z;\n    }\n }     \n #本题是用递归函数求1一直加到10的结果。\n #用递归实现循环。递归的作用是函数调用函数本身，速度比循环慢。但可以解决很多问题。\n $a=dg(1,0);\n print('递归的结果：',$a); ",
        "#Perl定义汉诺塔的递归函数\nsub move{\n  my($n,$a,$b,$c)=@_;\n    if($n==1){\n        print($a,'->',$c,\"\\n\")     #当n只有1个的时候直接从a移动到c \n    }\n    else{\n        move($n-1,$a,$c,$b);            #第n-1个要从a通过c移动到b \n        print($a,'->',$c,\"\\n\");\n        move($n-1,$b,$a,$c);            #n-1个移动过来之后b变开始盘，b通过a移动到c，这边很难理解 \n    }\n}\n#定义汉诺塔个数。\n$n=10; \nmove($n,'a','b','c'); ",
        "#二分函数写法\nsub erfen{\n    my($a,$key)=@_; \n    #PHP变量不能用逗号连续定义，奇怪 \n    $low = 0;     $high = 14;     $mid=0;\n    while ($low <= $high) \n    {\n          $mid = ($low + $high) / 2;\n          if ($key == @$a[$mid]){\n               return $mid;\n          }\n          elsif ($key < @$a[$mid]){\n               $high = $mid - 1;\n          }\n          else{\n              $low = $mid + 1;\n          }\n    }\n    #return 0;//Perl函数不能返回固定值？奇怪了\n}\n#二分查找一定是做排好序的序列里面查找\n@A=(1,2,3,4,5,6,7,8,9,10);\n#调用二分查找函数，查找值为7的元素做数组中位于第六位。\n$i=erfen(\@A,7);\nprint('二分查找值为7的元素的索引为：',$i);",
        "#!!!!!!!!!!!!!!!!!!本平台暂时不支持输入语句，寻求高手支持！！！！！！！！！！！！\nprintf(\"hello world\");\nscanf(\"%d\",$i);\nprintf(\"%d\\n\",$i);"
    ],
    [
        ";Lisp语言没有详细错误提示，排除错误只能单行输出判断\n;Lisp语言采用分号作为注释，语句需要放在括弧里面。\n;这是经典的hello world\n(print \"欢迎您进入Lisp的世界！！\")",
        ";Lisp里的变量有两种类型：lexical和dynamic。lexical类似于局部变量，dynamic类似于全局变量\n;lisp所有语句必须包含在小括弧内，\n;lisp定义变量使用 setf标识。\n(setf x 5)\n(print x)\n(setf x 50)\n(print x)\n\n;format是另外一种输出方式，~%表示换行\n(format t \"~%\")\n\n;lisp加法示例：比如x=4+5 写法是(setf x (+ 4 5))。\n(setf x (+ 4 5))\n;lisp输出多条语句到终端使用format t 命令，~S相当于C的%d,~%表示换行\n(format t \"4加5的结果为：~S~%\"  x)\n\n;lisp减法示例：比如x=10-5 写法是\n(setf x (- 10 5))\n(format t \"10减5的结果为：~S~%\"  x)\n\n;lisp乘法：比如 x=10*5 写法是\n(setf x (* 10 5))\n(format t \"10乘5的结果为：~S\"  x)",
        ";lisp变量无类型，可以是任何类型，\n(setf x 5.123)\n(print x)\n(setf x 50.55555555555555555555)\n(print x)",
        ";lisp变量无类型，可以是任何类型，字符型变量用双引号，不能用单引号\n(setf x \"张三\")\n(print x)\n(setf x \"李四\")\n(print x)",
        ";lisp判断结构,真为T，假为Nil\n;下面的语句是判断3>2吗？输出T\n(setf x (> 3 2))\n(print x)\n\n;下面的语句判断3等于3吗，输出NIL\n(setf x (= 3 4))\n(print x)\n\n;下面用判断结构,您会发现lisp所有语句都是包含在小括弧之内的。\n;如果条件成立，返回第一个小括弧的内容，否则返回第二个小括弧的内容\n(if(= 3 3)\n    (print \"3等于3\")\n    (print \"3不等于3\")\n)",
        ";修改以下整形变量的值，得出成绩的优良中差。 \n(setf i 75)\n(print i)\n;j=i/10表示变量j等于变量i除以10. \n(setf j (/ i 10))\n(print j)    \n;lisp 除法的结果始终是分数 比如75/10 结果为15/2，想要小数，前面需要加 float;想要整数，前面加int\n(setf j (float (/ i 10)))\n(print j)\n;floor函数取整数\n(setf j (floor (/ i 10)))\n(print j)\n;cond 是多条件判断的标示符。满足不同条件，转向不同分支执行。\n(cond \n    ((= j 6) (print \"及格\"))\n    ((= j 7) (print \"良好\"))\n    ((= j 8) (print \"良好\"))\n    ((= j 9) (print \"优秀\"))\n    ((< j 6) (print \"不及格\"))\n)    ",
        ";定义整形变量i等于5。\n(setf i 5)\n(format t \"第一次i等于：~S~%\" i)\n(setf i (+ i 1))\n(format t \"运行自加后i等于：~S\" i)",
        ";定义整形变量i等于5。\n(setf i 5)\n(format t \"第一次i等于：~S~%\" i)\n;取模操作符为mod\n(setf j (mod i 4))\n(format t \"5模4的结果为：~S~%\" j)\n(setf j (mod i 6))\n(format t \"5模6的结果为：~S\" j)",
        ";lisp变量无类型，可以是任何类型，字符型变量用双引号，不能用单引号\n(setf x \"张三\")\n(print x)\n(setf x \"李四\")\n(print x)",
        ";lisp中的循环又称为迭代，看似复杂，但做起来像和人说话一样，自然\n(loop for i from 1 to 10 do\n     (format t \"Hello Lisp!~%\")\n)",
        ";再来看看lisp中的while循环\n;定义变量可以用setq 和 setf,至于他们的区别求高手指点。\n(setq i 1)\n(loop while (< i 10) do\n   (format t \"Hellow Lisp~%\")\n   (setq i (+ i 1))\n)",
        ";下面为Lisp的dowhile循环。\n(setq i 1)\n(loop until (> i 10) do\n    (format t \"hello Lisp!~%\")\n    (setq i (+ i 1))\n)",
        ";数组定义，这里使用的是变长数组，标识vector。\n(setf i (vector 1 1 1 1 0 1 1 1 1 1))\n;输出数组的第一位，哈，数组从0开始的哦\n;获取数组的某一个元素用aref函数完成\n(format t \"数组的第一位等于 ~S~%\" (aref i 0))\n(format t \"数组的第二位等于 ~S~%\" (aref i 1))\n(format t \"数组的第五位等于 ~S~%\" (aref i 4))\n",
        ";定义数组\n(setf A (vector 1 1 1 1 0 1 1 1 1 1))\n;循环输出数组\n(loop for i from 1 to 10 do\n     (format t \"~S  \" (aref A i))\n)",
        ";定义二维数组\n;输出二维数组的值\n(setq a (make-array '(10 10) :initial-contents\n   '((1 0 1 1 1 1 1 1 1 1)\n      (1 0 1 1 1 1 1 1 1 1)\n      (1 0 0 0 0 0 0 0 1 1)\n      (1 1 1 1 1 1 1 0 1 1)\n      (1 1 1 1 1 1 1 0 1 1)\n      (1 1 1 1 1 1 1 0 1 1)\n      (1 1 1 1 1 1 1 0 1 1)\n      (1 1 1 1 1 1 1 0 1 1)\n      (1 1 1 1 1 1 1 0 0 0)\n      (1 1 1 1 1 1 1 1 1 1))\n    )\n)\n;lisp二维数组访问方式为aref  A  i j  。变量i j为 二维数组的位置。\n(format t \"数组第一排第二位的值为  ~S~%\" (aref A 0 0))\n(format t \"数组第一排第二位的值为  ~S~%\" (aref A 0 1))\n(format t \"数组第三排第二位的值为  ~S\" (aref A 2 1))",
        ";定义二维数组\n;输出二维数组的值\n(setq A (make-array '(10 10) :initial-contents\n   '((1 0 1 1 1 1 1 1 1 1)\n      (1 0 1 1 1 1 1 1 1 1)\n      (1 0 0 0 0 0 0 0 1 1)\n      (1 1 1 1 1 1 1 0 1 1)\n      (1 1 1 1 1 1 1 0 1 1)\n      (1 1 1 1 1 1 1 0 1 1)\n      (1 1 1 1 1 1 1 0 1 1)\n      (1 1 1 1 1 1 1 0 1 1)\n      (1 1 1 1 1 1 1 0 0 0)\n      (1 1 1 1 1 1 1 1 1 1))\n    )\n)\n;lisp循环是从0到9，不是10。切记\n;lisp访问二维数组的方法是aref A i j\n(loop for i from 0 to 9 do\n     (loop for j from 0 to 9 do\n         (format t \"~S  \" (aref A i j))\n     )\n     (format t \"~%\")\n)",
        ";函数是lisp的核心\n;下面定义了一个求最大值的函数\n(defun mymax(x y)\n    ;如果x>y，返回x，否则，返回y。\n    (if(> x y) \n       ;lisp函数返回值有点纠结，需要return-from 函数名 加 返回值\n       (return-from mymax x)\n       (return-from mymax y)   \n    )\n)\n;连续定义2个整形变量i,j。并赋予初始值。\n(setf i 30)\n(setf j 20)\n;调用函数max，求得最大值。。\n(setf z (mymax i j))\n;输出最大值。\n(format t \"最大值为：~S\" z)\n ",
        ";lisp打印99乘法表,哈哈，不复杂\n(loop for i from 1 to 9 do\n     (loop for j from 1 to 9 do\n         (format t \"~SX~S=~S  \"  i j (* i j))\n     )\n     (format t \"~%\")\n)",
        ";lisp中的冒泡排序，太多坑，做了很久\n;下面定义了一个求最大值的函数\n(defun maopao(A n)\n    ;lisp和ruby循环都是0到9,不是0到10，所以n要减去1。\n    (loop for i from 0 to (- n 1)  do   \n        (loop for j from 0 to (- n 2) do\n            (if (> (aref A j)  (aref A (+ j 1)))     \n                    ;if中采用多条语句必须使用progn关键字标识\n                  (progn \n                        (setf temp (aref A j))\n                        (setf (aref A j) (aref A (+ j 1)))\n                        (setf (aref A (+ j 1)) temp)\n                  )\n            )\n        )    \n    )\n    (return-from maopao A)\n)\n;lisp一维数组的另外一种定义方式。\n(setf A (make-array 10 :initial-contents '(1 6 3 9 15 2 7 8 4 5)))\n;调用冒泡排序的方法\n(setf B (maopao A 10))\n(print \"冒泡排序结果为\")\n(loop for i from 0 to 9 do\n    (format t \"~S  \" (aref B i))\n)\n",
        ";定义二维数组\n(setq A (make-array '(10 10) :initial-contents\n   '((1 0 1 1 1 1 1 1 1 1)\n      (1 0 1 1 1 1 1 1 1 1)\n      (1 0 0 0 0 0 0 0 1 1)\n      (1 1 1 1 1 1 1 0 1 1)\n      (1 1 1 1 1 1 1 0 1 1)\n      (1 1 1 1 1 1 1 0 1 1)\n      (1 1 1 1 1 1 1 0 1 1)\n      (1 1 1 1 1 1 1 0 1 1)\n      (1 1 1 1 1 1 1 0 0 0)\n      (1 1 1 1 1 1 1 1 1 1))\n    )\n)\n;lisp循环是从0到9，不是10。切记\n;lisp访问二维数组的方法是aref A i j\n(loop for i from 0 to 9 do\n     (loop for j from 0 to 9 do\n         (if(= (aref A i j) 0)\n             (format t \"▉\")\n             (format t \"□\")\n         )\n     )\n     (format t \"~%\")\n)",
        ";一般的语言包括整形、浮点数、字符串、数组、结构体（或者类）等。但在Lisp中，数据类型列表（List）、符号（Symbol）、数组（Array）\n;lisp没有结构体\n(print \"Lisp 没有结构体\")",
        ";定义了一个递归函数，递归函数的特征是函数调用函数本身。\n(defun dg(x z)  \n     (if(<= x 10)\n        (progn\n           (setf z (+ z x))\n           (setf x (+ x 1))\n           (dg x z)\n         )\n        (return-from dg z)\n     )\n) \n;本题是用递归函数求1一直加到10的结果。\n;用递归实现循环。递归的作用是函数调用函数本身，速度比循环慢。但可以解决很多问题。\n(setf n (dg 1 0))\n(format t \"递归的结果~S\" n)) \n",
        ";Lisp实现汉诺塔\n(defun move(n a b c) \n    (if(= n 1) \n        (format t \"~S->~S~%\" a c)    ;当n只有1个的时候直接从a移动到c \n        (progn\n             (move (- n 1) a c b)            ;第n-1个要从a通过c移动到b \n             (format t \"~S->~S~%\" a c) \n             (move (- n 1) b a c)            ;n-1个移动过来之后b变开始盘，b通过a移动到c，这边很难理解 \n        )\n    ) \n)\n;定义汉诺塔个数。\n(setf n 10) \n(move n \"a\" \"b\" \"c\") \n ",
        ";二分查找函数定义\n(defun erfen(a key)\n     (setf low  0)\n     (setf high 14)\n     (setf mid  0)\n     (loop while (<= low high) do\n          (setf mid (/  (+ low high)  2))\n          ;if else if 语句的写法如下\n          (if (= key (aref a mid))\n              (return-from erfen mid)  \n              (if (< key (aref a mid))\n                  (setf high (-  mid  1))\n                  (setf low (+ mid 1))\n              )\n          )\n     )\n     (return-from erfen 0) ;//未找到，返回0\n)\n;二分查找一定是做排好序的序列里面查找\n(setf  A  (make-array 10 :initial-contents '(1 2 3 4 5 6 7 8 9 10)))\n;调用二分查找函数，查找值为7的元素做数组中位于第六位。\n(setf i (erfen A 7))\n(format t \"二分查找值为7的元素的索引为 ~S\" i)",
        "#!!!!!!!!!!!!!!!!!!本平台暂时不支持输入语句，寻求高手支持！！！！！！！！！！！！\nprintf(\"hello world\");\nscanf(\"%d\",$i);\nprintf(\"%d\\n\",$i);"
    ]
];
//一维中排序为：1、C语言   2、PHP语言  3、Net语言  4、Python语言  5、Nodejs语言 6、Ruby  7、Perl 8、Lisp 。。。。。
//给固态的示例定义guid，以便于评论。如果计入数据库，也是一种方案，调整福大较大
U.CD.CL.PLGuid = [
    ["D4DDA52A-B320-59AD-2605-DF66E0628A92", "DD920DE7-083E-EE55-7FE0-06A732EB8BAC", "DB4E5C95-6316-362B-BC01-EA5E48D50AE1", "EEC67CB3-AA1C-5749-5024-E287D351CFBD", "89BE3135-5BCD-B5D1-6D9E-39616B677249", "94030117-7776-318F-FDC4-96821EC044CB", "027BB629-6553-651B-BEE2-8EA0124E797E", "8D43630F-5AF9-2B6F-CEC4-ED0457C86947", "71ED2570-F91C-F0EA-2FD8-8BBA52F0204E", "6EBD195E-1FA6-94D2-15E1-CF6E4BBB9598", "641232F2-351C-E03A-0741-1C030A403290", "48D4F315-5E64-D76D-1FD1-D6D899838F81", "5EF62C8B-63D7-6AC2-0254-CBC98E148A0C", "D5164E1F-40A2-4BE7-457B-09DE6D7C1A8B", "422AE715-9987-ECA3-6979-8CA913858D68", "A83B5AC8-97EA-EC06-A332-476832500570", "EB43F875-E632-7713-09FC-66CC4A436C0E", "E913EC4A-CA81-61D8-F4EE-DE79B6CC3485", "9F52BE9D-9CBF-FE02-94CE-973CACF29716", "0C8D5658-14FB-F3DD-1788-D2F248C22922", "B95DB39D-2F18-A2CC-E23C-9B260687F735", "16A5D7A0-A0D9-CE33-AEEC-4F6144DD8611", "1DD98EAC-1F3C-9BDA-9AA9-A82BAC975FA3", "E0661164-F024-28BC-7163-C3C99B7A10F2", "F326B231-8561-3951-C448-11A5EEC1BE02"],
    ["316ECA88-B0A8-1F0A-66CA-AB0886BCB5D7", "1AF03AFB-8752-0737-483B-745868CAF28E", "239ACC5D-E8C5-0923-635D-3B1A09B6EE57", "B6BA76EF-E1D0-FB65-5E5A-D658666E2476", "D56D7B93-51EF-226C-221A-87001D9051CB", "B3470E5C-0BE6-8C76-A91C-80296BD68147", "04A7EBDE-8F4D-B1AF-828C-60BF6C034AE8", "D3C03666-8013-8559-7E8A-9B745F3A124C", "F16737EC-40F2-6506-38A0-0A1102D151DB", "5679E5F5-55D7-92EB-7575-290A38933F80", "0B094437-7344-284B-88AC-B87D867557FB", "683B0313-5F9C-ACE8-37FE-BF7232C79DC4", "C9D9F6E7-0B6B-C09A-D07E-2E7801CC9885", "0492453B-859E-83EB-6321-9E8FD9D26221", "35F264AA-B0B3-ACCC-5D66-E973D2BB4E59", "C3124CBE-DDD7-7464-F341-982F75F3F9F9", "9AF77288-B2FF-CAE9-0F39-650533E1CEAC", "11A76F17-00EC-7E96-BDAE-4DAF53CE484A", "E8EA6CC4-6E2C-42AC-4864-F2F3E33888CE", "5BD6B848-1C0E-C38D-7732-428B69A007DD", "41EE12B5-AA7F-34F2-AAF0-A85A65C66AD8", "9F12A131-3FED-071D-C797-4401D960D28B", "3513979B-7A0D-B03D-228F-DFBD68422B6D", "EBFDFAEC-6C9F-B6D2-EA38-A5A4CFF14D72", "26211881-1326-6A2C-BBA4-D028BCC0F873"],
    ["54B98F27-DA8A-F5F9-5B86-D2FC4148FA2E", "6261070E-27BE-BDF1-C750-B94475600ACE", "C829F57C-004C-2E8D-1391-B61C01912D15", "62690968-39DA-6FD1-CC76-24749BEC9F13", "5A451DD1-D5A6-A735-CD94-733DBB64A870", "B8E3CF05-6CF5-B597-C5CE-BAEC0690D34C", "795D0FA7-D36B-9E44-DC82-F95542E85CB6", "2E5A5A8F-546E-0417-2CE6-30D1C976E9AC", "90675E80-3062-69A9-0C8C-E7BBC5FBCDC3", "8A0040B3-3EF0-219C-5231-C54BC57F704B", "9647D330-DB32-1BEF-11A9-48B459659D18", "877C5C04-7EDE-FD6D-8210-D7A5D3E0CDDD", "0A1ACA3E-B154-2E36-0325-A11562F5B910", "79B375D1-2FBA-CC45-76DD-11660ED4B370", "DC7CC738-72F2-AF2D-6429-D4DC60B9B119", "1A9063FF-F892-E9C7-97F3-A568B73FF326", "C5DBBD11-F3D4-770E-3947-60C88D1DAEF3", "07D11BE5-4B6A-FEFC-85B9-23F637613BEA", "89B98B78-0953-E090-AAFC-68F4E01A94E7", "6CCD3A21-A1A1-EDD0-72AC-63E2C2783A2F", "A6F53134-B533-86EF-B547-1C72ED60C0FF", "59447F7A-3561-0185-C969-00A311719DA9", "F51E337F-0D9C-88D6-6428-EDE21F80F546", "4522C2B3-B806-E431-9FB7-ED6CBC888404", "AEB4BA5E-61FB-D064-1D2F-2112D011E4FC"],
    ["414FD768-858A-D93D-7691-9D48B1FFC8A3", "6878E1FA-1CEF-E026-7603-2D90BCE4E6D2", "5575E9E8-D4ED-BCD4-C730-403249BDB957", "75B0C0FE-E332-A508-17F1-764B5A254C26", "8ACCD00F-659F-4865-DD14-953075FDB017", "3977A3ED-6F88-CD59-3070-D6278188DD3A", "23E4CF1E-29EC-1C1C-7D11-D16F90F711BF", "E503FD7D-AB9E-24BF-EEB1-819EFE73FA6F", "816C5699-6E62-0D58-D955-1C59478D31C5", "22F48BF4-85FF-7534-8E25-BD53772BE282", "3402301B-FE41-3A2A-5275-20B220ED9AF7", "2F95337E-04FA-6CFD-6E06-E9B032F89DC0", "BAF7A436-C4E1-61CD-8575-32AF23443D33", "DE2F0D88-1688-09A8-B5E5-63803D530E46", "701D144B-6C1C-0220-26D5-8B1715640021", "0B4F2D1B-9D3D-0802-0732-B9866610A535", "208D8963-77B7-BA1B-2A96-1753DD6C3AED", "FC0F9837-3A30-D913-BBC2-B71B9E883CF3", "D276B808-5DD1-7157-B948-5E907C779103", "2A65F629-53DF-9C1B-3165-C3C533C0985E", "37E4F924-1C47-C476-7216-FBD42743B3C5", "FE6472EA-DA20-9D84-A260-17D36596070E", "4E89B7D4-CB22-36AB-79C8-2D1DFBD7894A", "F4915776-470C-DAE4-0B03-45F5DAEBAE85", "AC89D448-AC01-A82C-D6D5-F775D4363812"],
    ["B123D725-5CE0-0BF4-9C2D-99D872CBF871", "FA467B99-3680-91B2-9A6A-6011B60497C6", "80559209-20F0-B086-3ADC-CBBEF29AA5E4", "1924F4A6-A1A2-84ED-5673-3A695F2C86EF", "C3A94C43-938D-A388-8CAD-891B113B078D", "7758E1EB-6A40-7201-60A6-0B516F93A5AE", "CC385A62-A4F0-B2F5-1170-522C5F39DAEE", "10B0785F-566F-3202-628D-8113AFB9F57C", "A1F942B8-E723-BCD6-C9AC-2C908BF84CA2", "9C5D2B49-75E9-D668-B690-008FF46BDDDD", "380C13BA-7CED-D135-EA2D-AAE887D69F8A", "67BF4D1C-9F7A-3D93-1200-C7491F681621", "8E01EF53-C5BA-D91E-1C8C-C969035DF90D", "5E2D2556-EB69-6C38-FC1D-2292BD0AF415", "3E274B45-4685-4295-CCB5-1F7FCB64D253", "BDBEFB50-AAE1-2BE6-9228-3B93BEF49FC8", "F8D1667C-4FC2-3190-037A-E65C82448E7C", "F9169624-5C5C-6E7B-1863-F872D3BCAC3B", "6CA6736E-E04C-B5F2-4E13-549F35F9B5DB", "462FB179-1D0C-F69D-D821-7268DB8F9522", "1BE6F771-454A-8687-32B2-CEE0534E5633", "5A20E76B-1747-C53A-CAD2-80D8F9E3A19A", "9EB1DF1A-F718-C0F8-B205-6D57760B07EA", "D1EB8F5C-6DED-CBF9-9207-D970C41CABE5", "D25DC790-3339-2ECC-55C3-566C961B184A"],
    ["C84611CF-24DA-64BD-3C7F-453E0D374E24", "75B5FCE9-D336-8F5D-4C37-6E5711B958B9", "18643146-8645-0E17-5832-6AC8CE71F40D", "B243AD89-E092-66D6-10C8-DBB7149312F1", "CDBDC819-8533-ECC6-D15A-AD2DACFC51AD", "12A4D273-65AE-D227-2185-E130DBFFA23B", "40E07B51-9CDC-922F-1E7D-A03A9C9ABF19", "65C64CAA-FBB5-E007-41AC-8BFE581D31AC", "6131E27F-AD19-87D7-3975-91841F51F931", "0F3BB787-9586-EEE8-C938-B795AA021F57", "ABBEA49D-53C9-1FDB-E57F-A683A211C751", "447D7017-079D-8FF2-8169-E63AFEE58492", "4F0409E0-4340-0A6E-C240-0FAF76620611", "B73C5171-CCFD-6EFF-8E4C-6E9B48476327", "FBB68296-15AC-304F-ABD2-D092E90896FD", "2CA6A610-891D-BF94-E549-7E69511CF792", "E290A301-1D85-5246-E7CB-9CEDF5B3B551", "81B1CE33-C6CE-AEDA-D0AA-71F6AFF6B03D", "5F161430-B2F0-ED9C-9F4B-4AC717A52FB0", "9C671B2E-7428-5A99-0027-00C9163349B2", "CF67F9D4-7E31-E597-2605-598FB75A06DE", "CA2B5FCB-9B70-CD31-A66B-BF3C7C1D8FDE", "19024D26-3F0D-71F3-8E42-0E32B53AF17D", "0B0CB5A1-D907-7E98-23A8-7517AA1F4448", "5A92ACB2-913A-D259-09FA-A436913E44C6"],
    ["CA03F76E-0E54-DA4D-BD16-C9269EE9A947", "4AB62140-2DC5-46E0-98CC-13D5AF96C240", "824A7074-D1A4-4A59-E184-C1D5529B3243", "C3CF579F-297F-CD7E-8318-ED133A5BCA7F", "D19940CD-1B25-4743-7AE2-9ACC56EED8E7", "FCC6CF8C-B065-248C-21FE-C7E2203474DA", "777CF6CB-AEC0-ED0D-CCC4-6F85D4619765", "EED77F86-BE0C-9236-746D-C92DB0000C25", "C192DD4F-C30D-9532-5FF5-3AE9646187A6", "685D6DA6-5307-F0FE-012C-BCFF5184706E", "E4E37F23-6539-F596-7AFC-ABE948732789", "4C98BD7C-A756-8130-85E3-4597DB10DDB5", "C41EDF56-19F0-448B-A7A5-4F187E5C421D", "807CB2ED-D9CE-FF5C-F328-9F82042C97A7", "A2EBE693-3B47-E1C1-C591-8D443152FDDA", "04772A02-9C80-7FD5-3587-7AB87540FA56", "4632857E-93AA-044B-29B8-FF14081C8FDD", "BB3C03CE-5E2A-8F26-4B88-68B2F4416FF6", "01650C0B-B5BF-ED89-4AF8-959DD044141E", "5D90083F-7097-178F-28C1-5F872E5ACB92", "30CB35DA-9156-2139-7BA0-17FF063F0AAD", "1B10BCFC-AC14-8B7B-E5DA-D2069E9088CE", "A0C76B92-C54F-2257-2FF5-75FBBA93F9EA", "67F9B142-0FD2-D501-BD9B-DCCD11787099", "622BB938-2E89-352D-51C1-6F945409B5C5"],
    ["77FCBEB7-DF53-8A58-56F2-086945D522EC", "8B73F98B-33C4-A63E-20DB-11A4AECCCBEE", "E5FCBF48-BCD5-E751-DBFF-20662A4B0580", "671EB65F-4E93-164B-20AE-8775189F9518", "08E23805-40B9-0BD6-5E1F-9F733802178C", "8EEE3DF3-5142-4B43-92CA-C161A9FE6B2C", "755D78F5-8DEF-FF5C-06F4-307A6A542A7F", "74386D4F-E9BF-0645-FE68-70657C4C848A", "2CB6B1F5-6361-F969-9671-C4B45379FFB5", "D527AF9C-E18A-5E94-44F7-D6BE3CFCF43C", "F8947C94-2A5A-6F02-ADE1-BEC8CE2BCB37", "9F10B280-9A96-2198-C3A2-ED849DBB4F36", "73C75AE4-81F2-6529-67F6-B2E6CC539B71", "BDB34F76-493A-B7CF-01E0-5F46219C768B", "4013AB5C-C779-885A-BDCD-3BDEC2B725ED", "578A2A28-6B17-0ED1-6CFA-D79AC73D06AC", "E8F991B1-1BE0-8904-38FE-653A319C790E", "F70F83C7-FB07-083F-A096-27C50FF8EB9B", "F38254AD-6620-3CFF-729F-2A5ACA7512CA", "210CC36E-E201-EDC7-BC40-C049E4049A30", "9B09B10A-D2A8-060A-DF54-8A8DB290DC60", "D7DE3371-2507-6A1A-45F8-FF89D3AB6E46", "BB02A14F-4FC8-FD43-6859-B22C62B68B1C", "8BC573BB-500C-86E3-19B5-D55A3569ADFE", "65C91AA6-8715-63A5-5187-B8B2A3E0E603"]
];

U.CD.CL.LangMap = [
    'c++',
    'php',
    'C#',
    'python',
    'node',
    'ruby',
    'perl',
    'lisp'
]


//生成左边工具栏语言条。参数l代表了语言。
U.CD.CL.Init = function (l) {
    var i = U.CD.CL.Lang(l); //获取语言对应的下标
    //主面板
    var z = $("#UCD_TT_Z")[0];
    z.innerHTML = ""; //切换语言时清空重来
    var f = $$("div", { "innerHTML": "输出语句", "onclick": [U.CD.CL.Sample, ([i, 0])] }, z);
    $$("div", { "innerHTML": "变量定义", "onclick": [U.CD.CL.Sample, ([i, 1])] }, z);
    $$("div", { "innerHTML": "浮点型变量", "onclick": [U.CD.CL.Sample, ([i, 2])] }, z);
    $$("div", { "innerHTML": "字符型变量", "onclick": [U.CD.CL.Sample, ([i, 3])] }, z);
    $$("div", { "innerHTML": "判断", "onclick": [U.CD.CL.Sample, ([i, 4])] }, z);
    $$("div", { "innerHTML": "多重判断", "onclick": [U.CD.CL.Sample, ([i, 5])] }, z);
    $$("div", { "innerHTML": "自加运算符", "onclick": [U.CD.CL.Sample, ([i, 6])] }, z);
    $$("div", { "innerHTML": "取模运算符", "onclick": [U.CD.CL.Sample, ([i, 7])] }, z);
    $$("div", { "innerHTML": "字符串函数", "onclick": [U.CD.CL.Sample, ([i, 8])] }, z);
    $$("div", { "innerHTML": "for循环", "onclick": [U.CD.CL.Sample, ([i, 9])] }, z);
    $$("div", { "innerHTML": "while循环", "onclick": [U.CD.CL.Sample, ([i, 10])] }, z);
    $$("div", { "innerHTML": "do while循环", "onclick": [U.CD.CL.Sample, ([i, 11])] }, z);
    $$("div", { "innerHTML": "数组", "onclick": [U.CD.CL.Sample, ([i, 12])] }, z);
    $$("div", { "innerHTML": "循环与数组", "onclick": [U.CD.CL.Sample, ([i, 13])] }, z);
    $$("div", { "innerHTML": "二维数组", "onclick": [U.CD.CL.Sample, ([i, 14])] }, z);
    $$("div", { "innerHTML": "循环与二维数组", "onclick": [U.CD.CL.Sample, ([i, 15])] }, z);
    $$("div", { "innerHTML": "函数", "onclick": [U.CD.CL.Sample, ([i, 16])] }, z);
    $$("div", { "innerHTML": "99乘法表", "onclick": [U.CD.CL.Sample, ([i, 17])] }, z);
    $$("div", { "innerHTML": "冒泡排序", "onclick": [U.CD.CL.Sample, ([i, 18])] }, z);
    $$("div", { "innerHTML": "制作迷宫", "onclick": [U.CD.CL.Sample, ([i, 19])] }, z);
    $$("div", { "innerHTML": "结构体", "onclick": [U.CD.CL.Sample, ([i, 20])] }, z);
    $$("div", { "innerHTML": "递归算法", "onclick": [U.CD.CL.Sample, ([i, 21])] }, z);
    $$("div", { "innerHTML": "汉诺塔", "onclick": [U.CD.CL.Sample, ([i, 22])] }, z);
    $$("div", { "innerHTML": "二分查找", "onclick": [U.CD.CL.Sample, ([i, 23])] }, z);
    $$("div", { "innerHTML": "输入语句", "onclick": [U.CD.CL.Sample, ([i, 24])] }, z);
    //$$("div", { "innerHTML": "写示例帮助其他人", "id": "UCD_TT_Z_Help", "style": { "cssText": "color:#d87a69;border: 0;" }, "onclick": [U.CD.U.LoginApply, ([])] }, z);

    //执行输出语句，以便切换时用户能第一时间感受到语言的切换效果。
    f.onclick();
}

U.CD.CL.Sample = function (x, y) {
    var _c = U.CD.CL.LangArr[x][y], id = U.CD.CL.PLGuid[x][y]; //id是给用户对公有代码进行评论的。
    //如果用户已经登录，则新建一个选项卡，否则，直接做当前代码窗口赋值。
    if (U.CD.U.CUser) {
        U.CD.ExamWin.Content = _c;
        U.CD.R.LoadFC(U.CD.ExamWin, x);
        U.CD.CD.DrawCode(_c, false); //其实可以不用再次调用，但没时间再优化了，暂时如此。
        $("#UCD_TOP_L_BC")[0].onclick = function () { alert("示例程序不允许保存！"); }
    }
    else { U.CD.CD.DrawCode(_c, false); }
    $("#UCD_CT_IF_PL")[0].onclick = function () { U.CD.OU.Reply(id); } //给公有代码的回复添加id
}

//根据语言的标识C PHP等获取数组下标,如果找不到，默认返回0.
U.CD.CL.Lang = function (l) {
    var a = U.CD.Langs, i;
    for (i = 0; i < a.length; i++) { if (l == a[i]) return i; }
    return 0;
}



//切换语言类型,并弹出示例窗口,
U.CD.CL.Change = function (l) {
    if (l == "Html5") {
        U.UI.Confirm("<div style='margin-top:-20px; margin-left:20px;font-size:16px;text-align:left;color:red;'>你确定切换到前端吗？</br>前端:包括HTML,CSS,Javascript等知识.</br>后端:包括C语言,PHP语言,Ruby语言等.</div>", [U.CD.CL.ChHtml, ([""])], "");
        return;
    }
    U.CD.USLang = l; //更改当前语言
    U.CD.CL.Init(U.CD.USLang); //重新初始化左边语言栏目。
    //U.CD.R.ClearTab(); //清理文件选项卡,有点麻烦
    //U.CD.SL.Init(); //调用示例首页程序。
    //动画效果
    var c = $("#UCD_CT_Code")[0], d = $("#UCD_TT_T_N")[0];
    //    c.style.backgroundColor = "gray";
    d.innerHTML = U.CD.USLang + "语言";
    //    d.style.backgroundColor = "blue";
    document.location.hash = "#!/" + U.CD.USLang; //向地址栏写入语言的类型，形成诸如./#!/Lisp。
    if (US.userinfo.UserId) U.CD.U.LUData(US.userinfo); //装载各种语言的项目
    //    setTimeout(function () { c.style.backgroundColor = "white"; d.style.backgroundColor = "tomato" }, 1000);
    //$("#UCD_SL")[0].style.display = "none";
}
U.CD.CL.ChHtml = function () { window.open("http://d.1473.cn") }

//弹出切换语言窗体
U.CD.CL.OpenLang = function (o) {
    //U.ME.OpenWin("UCD_TOP_SY", "UCD_SL", document.body.clientWidth * 0.2 + "px", "50px", "960px", "690px", 300);
    U.CD.OU.GNU();
    //百度广告
    //U.D.AD.BDGG($("#UCD_L_C_GG")[0], '897767'); //百度广告
    //if (US.userinfo.UserId) U.CD.U.LUData(US.userinfo); //装载各种语言的项目
    //U.CD.SL.Init();

}
//关闭语言窗体特效
U.CD.CL.CloseChange = function (o) {
    U.ME.CloseWin("UCD_TOP_SY", "UCD_SL", 200, U.ME.ChangeColor("UCD_TOP_SY", "red"));
}



Namespace.register("U.ME"); //js特效库
//特效打开窗体,第一个参数为单击的按钮id str类型 第二个参数为弹出的窗体id str类型，ltwh是窗体的坐标和宽度,v是速度,按毫秒计算
//调用示例方法U.ME.OpenWin("UCD_TOP_Lang", "UCD_L", document.body.clientWidth * 0.3 + "px", "130px", "600px", "380px");
//需要此效果的窗体css定义position:absolute; display:none; top:0px; left:0px; width:0px; height:0px;overflow:hidden;
U.ME.OpenWin = function (b, d, l, t, w, h, v) {
    var r = U.M.GetElementInfo($("#" + b + "")[0]), o = $("#" + d + "");
    o[0].style.display = "block"; o[0].style.left = r.BCRL + "px"; o[0].style.top = r.BCRT + "px";
    o.animate({ "left": l, "top": t, "width": w, "height": h }, v);
}
//特效关闭窗体,第一个参数为单击的按钮id str类型 第二个参数为弹出的窗体id str类型,v是速度，按照毫秒计算,cb是关闭窗体后执行的其他特效函数。
U.ME.CloseWin = function (b, d, v, cb) {
    var r = U.M.GetElementInfo($("#" + b + "")[0]);
    $("#" + d + "").animate({ "left": r.BCRL + "px", "top": r.BCRT + "px", "width": "0px", "height": "0px" }, v, U.M.apply(this, "$('#" + d + "').css('display', 'none')"));
    if (cb) cb();
}

//获取元素的样式，可以得到元素的margin-top和margin-left
U.M.GetStyle = function (UEL, UV) {
    if (UEL.style[UV]) { return UEL.style[UV]; }
    else if (UEL.currentStyle) { return UEL.currentStyle[UV]; }
    return "";
}

//按钮抖动效果,参数b为按钮id,str类型,v为速度,此函数调用方法//U.ME.BShake(b,32);
//参考自：http://www.nowamagic.net/librarys/veda/detail/1063，绝对定位可行，相对定位有点问题
U.ME.BShake = function (d, v) {
    //k判断元素是相对定位还是决定定位，相对定位用marginTop,决定定位用Top。u是计时器,t,l是相对定位，决定定位的值，a b是计算变量
    var o, t, l, a, b = 0, u, k = 1, s;
    "string" == typeof (d) ? o = $("#" + d + "") : o = $(d);
    //如果元素是相对定位，不是absolute或者relative,采用marginTop属性抖动s = U.M.GetStyle(o[0]);不能批量获取
    if (U.M.GetStyle(o[0], "position") == "absolute" || U.M.GetStyle(o[0], "position") == "relative") { k = 0 }
    if (k) { t = U.M.GetStyle(o[0], "marginTop"); l = U.M.GetStyle(o[0], "marginLeft"); a = ['marginTop', 'marginLeft'] }
    else { t = U.M.GetStyle(o[0], "top"); l = U.M.GetStyle(o[0], "left"); a = ['top', 'left'] }
    u = setInterval(function () {
        b++;
        o[0].style[a[b % 2]] = b % 4 < 2 ? parseInt(U.M.GetStyle(o[0], a[b % 2])) - 2 + "px" : parseInt(U.M.GetStyle(o[0], a[b % 2])) + 2 + "px";
        if (b > 15) { clearInterval(u); b = 0; if (k) { o[0].style.marginTop = t; o[0].style.marginLeft = l; } }
    }, v)
}


//元素变色,参数b为按钮id,str类型，参数n为新的颜色
U.ME.ChangeColor = function (b, n) {
    var o = $("#" + b + "")[0], c = o.style.backgroundColor;
    o.style.backgroundColor = n;
    setTimeout(function () { o.style.backgroundColor = c; }, 1000)
}


//各个项目之间的切换效果，比如从编程端切换都主项目,s代表源,d代表目标。
U.ME.CHDiv = function (s, d) {

}






