文档章节

悠然乱弹:挑战编程极限的问题终于有解了

悠悠然然
 悠悠然然
发布于 2015/08/17 10:41
字数 4942
阅读 2710
收藏 63

问题的来历

在群里面一个小萝莉非要说拜我为师,呵呵,对于程序媛我一向--嗯嗯觉得程序不如人好看,再加上该名萝莉大学还没毕业,术语都多半没有听过,于是就想着拒绝,当时嘴一贱,就说了一句:你用一个For循环做个99表出来。

当然,这个对于小萝莉们来说,已经足够形成挑战了,但是对于群里的一众大佬们来说,自然是不在话下,3下5除二就搞定了。我又异想天开一下,如果不用判断语句,是不是也完成呢?粗想想是可以的,于是动手摆了几行代码,确实可以。于是就不断加码,不断增加新的完成条件,于是就形成了下面的问题,挑战极限这个定语,有一定的博眼球的意思,实际上不是那么难了。

挑战极限的问题

今天我想挑战一下OSCHINA的亲们的编程能力,出一道百度、谷歌不到答案的问题,第一个挑战成功的,直接奖励现金100元RMB(本人也是苦B码农,纯属意思一下)。

以前发过一条循环语句打印螺旋矩阵和蛇型矩阵的博客,今天我们来挑战只出现一条循环语句来打印99表。

注意,此题是考思想的,用“*”之外的运算符,如 "&  |  ^  >> << / % "的,虽然确实可以有解,但是代码逻辑与我倡导的:"一个好的算法首先是简单易懂的,其次是清晰明了的,再个一定是充满美感的"是相违背的。为什么下面条件这么多,实在是亲们的创意无限,我防不胜防哦。

特别声明:

  • n可以是任意正整数,只要N的平方不要溢出都可以
  • 一行一行print结果的无效
  • 不允许出现if,switch,?:语句及判断语句的变体,也就是只允许循环变量做条件比较以确定循环次数,不允许其它变量进行条件判断
  • 不允许出现异常
  • 循环语句中只能有一个变量
  • 代码行数超过100行的无效
  • 如果 @红薯 能抢先给出答案,奖金跃升为250元RMB
  • 提交问题并关注本人,回答才有效
  • 答案是否有效解释权归悠然所有

问题如下

不管是什么编程语言,只要是在程序中只用了一条循环语句正确的输出了99表,那么就算挑战成功。

下面是我的测试用例:

测试1:

public static void main(String[] args) {

        new Test99().print(9);

}

运行结果:

 1

 2 4

 3 6 9

 4 8 12 16

 5 10 15 20 25

 6 12 18 24 30 36

 7 14 21 28 35 42 49

 8 16 24 32 40 48 56 64

 9 18 27 36 45 54 63 72 81

测试2:

public static void main(String[] args) {

        new Test99().print(5);

}

运行结果:

 1

 2 4

 3 6 9

 4 8 12 16

 5 10 15 20 25

第一个回答正确的人将获得奖励,以时间为准。

攻城狮的答案

来自各种语言的攻城狮们,对偶的问题进行了长时间的轰炸,有的群大部分时间在讨论这个题有木有?半夜两点继续苦占的有没木有?避木不出的有没有(@红薯 ,别用帽子盖你的脑袋,偶看到你了)志有必得的有没有(工程的名字就叫GetMoney)?茶不思饭不香,没有思绪加班的有木有?

下面我们就一睹攻城狮们的风采:

利用语言特性搞定的

def main(row_count):
    for row_idx in range(1, row_count+1):
        row = map(lambda x:x*row_idx, range(1, row_idx+1))
        print(str(row)[1:-1].replace(",",""))
 
if __name__ == '__main__':
    print("-"*25)
    main(5)
    print("-"*25)
    main(9)
    print("-"*25)
    main(99)
这里有个技巧是 range(1, row_count+1):实际上是利用语言的特性来做了一个循环,不过,确实是非常简练的实现。

相当不错的Java版实现

 public static void print(int n){
            int i = 1;
            int j = 1;
            String flag[] = {"", "\n"};
            while(i <= n){
                System.out.print((i*j) + " ");
                int nextj = (j % i)+1;
                int nexti = (j / i) + i;
                System.out.print(flag[nexti - i]);
                i = nexti;
                j = nextj;
            }
        } 
这个实现也是非常不错的,唯一的就是利用了"%  /"小小的违规了一把,而且非常漂亮的把if语句给回避了-实际上是转换成上数组下标了。

依然不错的Java实现

public class MultiplicationTable2 {
 
    int line = 1;
    int cursor;
 
    public void print(final int maxLine) {
 
        for (cursor = 1; cursor <= line || enter() <= maxLine; cursor++) {
            System.out.print(cursor * line + "\t");
        }
 
    }
 
    public int enter() {
        System.out.print("\n");
        line++;
        cursor = 1;
        return line;
    }
 
    public static void main(String[] args) {
        new MultiplicationTable2().print(9);
    }
 
}
这个实现的也非常不错,唯一违规的地方是在For语句中夹带了判断语句。

一个for里面搞两个循环变量的

for (int i = 1, j = 1; j <= 9; i++)
    {
     System.out.printf("%d*%d=" + i * j + " ", i, j);
     if (i == j) {
      i = 0;
      j++;
      System.out.println();
     }
    } 
当然,里面还多一个if判断

一不小心用了两个For的解法 

package everydaydo;


public class OSC {


public static void main(String[] args) {
OSC.fun1(9);
}


public static void fun1(int n){
StringBuilder sb = new StringBuilder();
for(int i=1;i<=n;i++){
sb.append(fun2(i));
}
System.out.println(sb.toString());
}

public static String fun2(int m){
StringBuilder sb = new StringBuilder();
for(int i=1;i<=m;i++){
sb.append(i*m+"\t");
}
sb.append("\n");
return sb.toString();
}
}

有把历史实现直接过过冲奖的

class MulTable{
    public enum MulTableEnum{
        ASC,
        DESC
    }
    public void showMulTable(final int count, MulTableEnum e){
        if(MulTableEnum.ASC == e){
            ascMulTable(count);
        }else{
            descMulTable(count);
        }
    }
    private void descMulTable(final int count){
        if(count<1){
            i=0;
            return;
        }
        if(i!=count){
            i++;
            System.out.print(i+"*"+count+"="+i*count+"\t");
            descMulTable(count);
        }else{
            i=0;
            System.out.println();
            descMulTable(count-1);
        }
    }
    private void ascMulTable(final int count){
        if(j>count){
            j=1;
            return;
        }
        if(i!=j){
            i++;
            System.out.print(i+"*"+j+"="+i*j+"\t");
        }else{
            i=0;
            j++;
            System.out.println();
        }
        ascMulTable(count);
    }   
    private int i=0;
    private int j=1;
}
public class Test {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MulTable mul = new MulTable();
        mul.showMulTable(9, MulTable.MulTableEnum.DESC);
        mul.showMulTable(9, MulTable.MulTableEnum.ASC);
    }
 
}
亲,你这题目也不仔细看看,怎么可能对得上要求呢?

Java版递归来了

public void show(int n){
        if (n == 0) {
            return ;
        }else{
            show(--n);
        }
        for(int i = 1; i <= n ; i++){
            System.out.print(i*n + " ");
        }
        System.out.println();
         
    }
唯一的就是用了if语句,唉,楼上的那位兄弟,你那递归和这个相比,是不是有点偏Low了?

某攻城狮的再战作品

public class asdfasf {
 
    public static void main(String[] args) {
        int n = 9;
        int i = 1;
        int line = 1;
        int lastSq = 0;
        while (i <= n * n) {
            System.out.print(i + " ");
            int sq = (int) Math.sqrt(i);
            if (sq * sq == i && sq > lastSq) {
                line++;
                System.out.println();
                i = line;
                lastSq = sq;
            } else {
                i = i + line;
            }
        }
    }
 
}

这个代码可读性稍差一点,当然,里面有if判断,违规了

JavaScript版来了

我们的前端攻城狮也不甘寂寞,冲上来了

$(document).ready(function () {
            $("body").html(Print(5));
        });
        var PrintHtml = "";
        function Print(num) {
            var ThisHtml = "";
            for (var i = 1; i <= num; i++) {
                ThisHtml += (i * num).toString() + "&nbsp;&nbsp;";
            }
            PrintHtml = ThisHtml + "<br>" + PrintHtml;
            (num - 1) > 0 ? Print((num - 1)) : PrintHtml;
            return PrintHtml;
        }
嗯嗯,用了?:

某大神的第三次冲刺

public class asdfasf {
 
 
 public static void main(String[] args) {
 int n = 9;
 n = n * n;
 int i = 1;
 int line = 1;
 int times = line;
 while (i <= n) {
 System.out.print(i + " ");
 
 
 times = times - 1;
 try {
 System.out.println(1 / times);
 i = i + line;
 } catch (Exception e) {
 line++;
 times = line;
 i = line;
 System.out.println();
 }
 
 }
 }
 
}
这次居然用了反人类的异常来替换IF,确实是让我大大吃了一斤,亲我给归到使用if变体里了。

JavaScript再战

$(document).ready(function () {
            Print(5);
            $("body").html(PrintHtml);
        });
        var PrintHtml = "";
        function Print(num) {
            var ThisHtml = "";
            for (var i = 1; i <= num; i++) {
                ThisHtml += (i * num).toString() + "&nbsp;&nbsp;";
            } PrintHtml = ThisHtml + "<br>" + PrintHtml;
            while ((num - 1) > 0) {
                Print(num - 1);
                num = 0;
            }
        }
嗯嗯,用了两个循环

一个距离成功只有一步之遥的答案

public class Test99 {
    public static void main(String[] args) {
        Test99.print(20);
    }

    private static void print(int n) {
        for (int i = 1; i <= n; i++) {
            print2(i);
        }
    }

    private static void print2(int k) {
        for (int i = 1; i <= k; i++) {
            System.out.print(i * k + " ");
        }
        System.out.println();
    }
}
这个答案,实际上熟悉模式的同学,大致看看就能想出怎么把两个for语句干掉一个的办法,可惜了一点儿。

实践比想法困难的代表

某大神第4次挑战

public class MultiplicationTable {
 
    public static void main(String[] args) {
 
        char space = ' ';
        char enter = '\n';
 
        int n = 9;
 
        int i = 1;
        int line = 1;
        int col = 0;
        int current = 1;
        while (i <= (1 + n) * n / 2) {
            System.out.print(current);
 
            // col = col + 1;
            int isZero = ((line - col - 2) >> 31 & 1);
 
            line = line + 1 * isZero;
            col = (col + 1) - (col + 1) * isZero;
            current = line + current + (-current) * isZero;
            System.out.print((char) (space + (enter - space) * isZero));
            i++;
        }
 
    }
 
}
嗯嗯,里面有/有>>有&,总之各种小技巧。偶的答复:

亲,我觉得一个好的算法,首先是简单的,再一个是容易理解的,再一个是有技巧的。 

中间省略N个重复了的代码

C#版的来了

#include <iostream>
using namespace std;
 
typedef void (*pFun)(int m, int k);
 
void f0(int m, int k)
{
    cout<<endl;
}
 
void f1(int m, int k)
{
    pFun fun[2] = {f0, f1};
    cout<<m * k<<" ";
    fun[(k<m)](m, k+1);
}
 
void printLine(int m)
{
    f1(m, 1);
}
 
void run(int m)
{
    int i = 1;
    while (i <= m)
    {
        printLine(i);
        i++;
    }
}
 
int main()
{
    run(9);
    return 0;
}
里面用到了k<m判断语句

SCALA版来了

def mul(n: Long): String = (1L to n).map { i =>
  (1L to i).map(_ * i).mkString(" ")
}.mkString(System.getProperty("line.separator"))
太精练了!!!就是那to了两次是不是两个循环?

非常不错的实现

def test99(n):
    i = 1
    j = 1
    while i <= n:
        print '%d ' % (i * j),
        nj = (j % i) + 1
        ni = (j / i) + i
        print '\n' * (ni - i),
        i = ni
        j = nj
唯一就是小小的违规了。

这是啥语言版来着?

package object test {
  def main(args: Array[String]) {
    _99(9)
  }
 
  def _99(m: Int) {
    var i = 1;
    while (i <= m) {
      printLine(i);
      i += 1
    }
  }
 
  def printLine(m: Int) {
    printResult(m, 1);
  }
 
  def printResult(m: Int, k: Int) {
    print(m * k + "\t")
    matchResult(m - k > 0, m, k);
  }
 
  def matchResult(in: Any, m: Int, k: Int) = in match {
    case true => printResult(m, k + 1)
    case _ => println()
  }
 
}
里面有判断语句。

JavaScript版的解法

/**
javascript 版, chrome 浏览器, CTRL+SHIFT+I 打开调试器 -> console选项卡 粘贴代码并回车:
 
**/
function _99x(n){
    function iterate(n, callback){
        for(var idx = 1; idx <= n; idx++)
            callback(idx, n);
    }
    iterate(n, function(start, end){
        iterate(start, function(start, end){
            console.log(start * end);
        })
        console.log('-------')
    })
}
原来没有仔细看,以为callback是系统函数,今天仔细看,原来这个是OK的,唯一的问题是换行怎么处理的?

NIM版

## test.nim
 
for i in 1..9:
    for j in 1..i:
        write stdout, j * i
    write stdout, '\10'
 
## $ nim c -r test.nim
呵呵,标准的就是这么写的。

这个是啥版?

proc p(n: int) =
    proc walki(j: int, i: int) =
        if j <= i:
            write(stdout, j * i)
            walki(j + 1, i)
        else:
            write(stdout, '\10')
 
    proc walk(i: int) =
        if i <= n:
            walki(1, i)
            walk(i + 1)
    walk(1)
 
p(9)
明显有判断了。

C语言版来了

#include <stdio.h>
 
//输出一行
int print_one_row(int i, int n)
{
        return (i <= n) && ((printf("%d ", i*n), print_one_row(i+1, n)));
}
 
//整体输出
int print_all(int n)
{
        return (n && (print_all(n-1), print_one_row(1, n), printf("\n")));
}
 
int main(int argc, char *argv[])
{
        print_all(1); //测试1行
        print_all(9); //测试9行
        print_all(11); //测试11行
        return 0;
}
用了if变体

也不是错的实现

import sys, math
 
def test99(a):
    for i in xrange((1 + a) * a / 2):
        i = i + 1
        q = int(math.sqrt(i * 2))
        b = q * (q + 1) / 2 - i        
        sys.stdout.write(str(max(q * -b + -b, q * -b + q * q)))            
        sys.stdout.write(chr(10 - max(abs(b), 0) / max(abs(b), 1)))
         
test99(5)
这个性能确实有点差的,sqrt,* / max 好多运算哦

号称邪恶的解法

一个变量是挡不住邪恶的我的, 你是不是要考虑限制内存的使用?

package com.test;
  
  
public class Test99 {
      
    public void print(Integer... oneVar){
        oneVar = new Integer[]{oneVar[0], 1, 1};
        while(oneVar[1]<=oneVar[0]
                && System.out.printf(oneVar[1]*oneVar[2]+"\t")!=null
                &&((oneVar[1] == oneVar[2] && (oneVar[1]++>0 && System.out.printf("\n")!=null) && (oneVar[2]=0)==0) || true)
                ){
            oneVar[2]++;
        }
    }
  
}
简单的说,是把判断隐藏在while里了。

超级技巧版来了

function fun(n){
    (n - 1) && fun(n - 1);
    for(var idx = 1; idx <= n; idx++)
        process.stdout.write(idx * n + ' ')
    process.stdout.write('\n')
}
fun(process.argv[2]);
这里的技巧相当高明,隐藏得非常深。

C# 简短版

static int s = 9;
        public static void print(int k=1)
        {
            int m = 1;
            while (m <= k && k <= s)
            {
                Console.Write("{0}*{1}={2}\t", m, k, m * k);
                m++;
            }
            Console.WriteLine();
            if(m<=s) print(m);
        }<span></span>

C#版的,想来想去都要一个if来判断边界啊。

==嗯嗯,如果有一个if,这题就不难了:)

世界上最好的语言PHP版也来了

<?php
//生成1-9的数组,我只是快速定义好数组..这不算循环吧。23333
$number = range(1, 9);
//数组递归..
array_walk($number, function($param, $key) {
    for ($i = 1; $i < $key + 2; $i++) {
        echo $param * $i. " ";
    }
    echo '<br/>';
});
range函数是干啥的,里面有没有个循环语句帮你干活?

版本帝的第N版来了

public class MultiplicationTable3 {
 
    /**
     * 主要是使用了数组初始化后,未赋值的位置为0,来实现复位的效果。<br>
     * cursors数组运行中第一位总是0,变化过程如:<br>
     * {0,0,0,0,0,0,0,0,0}<br>
     * {0,1,0,0,0,0,0,0,0}<br>
     * {0,1,2,0,0,0,0,0,0}<br>
     * {0,1,2,3,0,0,0,0,0}<br>
     * 
     * @param n
     */
    public void print(final int n) {
        // 游标控制,多一位,容错
        int[] cursors = new int[n + 1];
        // 基数,系数
        int[] factor = new int[n];
        factor[0] = 1;
 
        // 字符后缀
        char[] suffixChars = new char[n];
        suffixChars[0] = '\n';
 
        int i = 0;
 
        while (factor[0] <= n) {
            int colValue = (cursors[i] + 1);
            System.out.print(colValue * (factor[0]) + " ");
 
            int temp = i;
            i = cursors[i + 1];
            cursors[temp + 1] = cursors[temp] + 1;
            factor[i] = factor[i] + 1;
 
            System.out.print(suffixChars[i]);
 
        }
 
    }
 
    public static void main(String[] args) {
        new MultiplicationTable3().print(9);
    }
 
}

JS版改进型

这里的undefined:部分是不是判断的变体呢?

多线程版来了

public class Test99 {
    private int rowNum;
    private int[] arr;
    private int i;
    public Test99(int rowNum, int[] arr, int i) throws InterruptedException {
        this.rowNum = rowNum;
        //初始化一个长度为N+1的数组,如rowNum=5,数组为[0,0,0,0,0,0]
        this.arr= arr;
        this.i = i;
        try {
            arr[i+1] = arr[i] + 1;
            PrintThread printThread = new PrintThread(arr[++i], rowNum);
            printThread.start();
            new Test99(rowNum, arr, i);
        }
        catch (Exception e) {
            Thread.sleep((arr[--i] + 1) * 100);
            Thread.interrupted();
        }
    }
}
 
class PrintThread extends Thread {
    int length = 0;
    int rowNum = 0;
    public PrintThread (int length, int rowNum) { 
        this.length = length;
        this.rowNum =rowNum;
    }
    @Override
    public void run() {
        try {
            Thread.sleep(length * 100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } 
        for (int i = 1; i <= length; i++) {
            System.out.print(i * length + "\t");
        }
        System.out.println();
    }
}
居然有线程,居然有异常,偶的心好凌乱....让偶缕缕

韦达定理版

public class Test99 {
    public void print(int n) {
        for (int i = 0; i < n * (n + 1) / 2; i++) {
            int row = (int)((Math.sqrt(1 + 8 * i) - 1) / 2);
            int column = i - row * (row + 1) / 2;
            int end = 10 + (int)Math.ceil(1.0 * (row - column) / (row + 1)) * 22;
            System.out.printf("%d%c", (row + 1) * (column + 1), end);
        }
    }
 
    public void printOneline(int n) {
        for (int i = 0; i < n * (n + 1) / 2; i++) {
            System.out.printf("%.0f%c", (Math.floor((Math.sqrt(1 + 8 * i) - 1) / 2) + 1) * (i - Math.floor((Math.sqrt(1 + 8 * i) - 1) / 2) * (Math.floor((Math.sqrt(1 + 8 * i) - 1) / 2) + 1) / 2 + 1), (int)(10 + (int)Math.ceil(1.0 * (Math.floor((Math.sqrt(1 + 8 * i) - 1) / 2) - i + Math.floor((Math.sqrt(1 + 8 * i) - 1) / 2) * (Math.floor((Math.sqrt(1 + 8 * i) - 1) / 2) + 1) / 2) / (Math.floor((Math.sqrt(1 + 8 * i) - 1) / 2) + 1)) * 22));
        }
    }
 
    public static void main(String[] args) {
        new Test99().print(5);
        new Test99().printOneline(9);
    }
}
亲,但是不允许用/,而且这个性能也太慢了........

至尊版来了,此版一出,天地为之变色,世人为之瞩目

data segment
a db 1 
b db ?
data ends
code segment
assume cs:code,ds:data
start:mov ax,data
mov ds,ax  
lop1: 
mov al,a  
mov cl,al  
 
mov b,1
lop:
mov ah,2  
or b,30h 
mov dl,b  
int 21h  
 
mov dl,'*'
int 21h
 
or a,30h  
mov dl,a 
mov ah,2
int 21h
 
mov dl,'='
int 21h
 
sub a,30h
sub b,30h  
mov al,a
 
mov bl,b
mul bl 
mov bl,10
div bl  
mov bh,al 
mov bl,ah
or bx,3030h
 
 
mov ah,2 
cmp bh,30h  
je lop2  
mov dl,bh  
int 21h
lop2: 
mov dl,bl  
int 21h
 
mov dl,' '
int 21h 
inc b  
loop lop
 
mov dl,13 
int 21h
mov dl,10 
int 21h
 
inc a
cmp a,10
jb lop1  
 
mov ah,4ch 
int 21h
code ends
end start

破绽在这里 cmp bh,30h je lop2

尽管你换了个马甲,照样认识你。

正解来了

function _99x(n){
    function iterate(n, callback){
        for(var idx = 1; idx <= n; idx++)
            callback(idx, n);
    }
    iterate(n, function(start, end){
        iterate(start, function(start, end){
            process.stdout.write(start * end + ' ');
        });
        process.stdout.write('\n');
    })
}

作者自述:

我第一次写的这个实际上跟此答案思路相似,都是模板方法,横向或纵向都是遍历, 不同的是遍历过程中的处理逻辑(一个是算乘积, 另一个是输出换行以及启动横向遍历过程), 实质上就是把循环逻辑抽取出来(比如一个叫"遍历器"或者叫"遍历模板"的东西), 留个回调方法, 做不同的逻辑处理,如果此题通过,我写的也算通过了

说白了,就是模板模式的应用。

悠然的解法

悠然的解法,说实际的,只花了几分钟的时间考虑,写了一个,估计已经算不得最优解了。当时我和群里的同学们有说过:如果我最后拿不出来一个解,估计被一干人等骂死了。

public class Test99 {
    public static void main(String[] args) {
        Iterator.iterate(5,new IAction());
    }
}
abstract class Iterator<T> {
    abstract void process(T n);
    static void iterate(int n, Iterator action) {
        for (int i = 1; i <= n; i++) {
            action.process(i);
        }
    }
}
class IAction extends Iterator<Integer> {
    public void process(Integer n) {
        iterate(n, new JAction(n));
        System.out.println();
    }
}
class JAction extends Iterator<Integer> {
    private final int x;
    JAction(int n) {
        this.x = n;
    }
    public void process(Integer n) {
        System.out.print(" "+x * n);
    }
}
解题思路解释:

实际上,只用一个For语句打印99表,无非是以下几种方案:

  1. 一个循环语句来完成:这种方案肯定需要一些其它指令来配合,比如/ % sqrt等等,同时换行符处理也非常难处理,如果没有IF的话,是非常难以解决的。
  2. 递归方式:递归方式一般来说肯定需要有退出条件判断,否是就变成死循环了
  3. 把一个For语句使用两次

再来看看我的注意事项:

注意,此题是考思想的,用“*”之外的运算符,如 "&  |  ^  >> << / % "的,虽然确实可以有解,但是代码逻辑与我倡导的:"一个好的算法首先是简单易懂的,其次是清晰明了的,再个一定是充满美感的"是相违背的。为什么下面条件这么多,实在是亲们的创意无限,我防不胜防哦。

这里,所有的限制都是为了把攻城狮向第3种方案逼,同时里面也有提醒:是考思想的。

接下来解释一下我的代码:

  • Iterator是一个迭代类,它的功能就是去做循环,然后干它应该干的事情,实际上为重用For语句埋好了伏笔。
  • IAction用于完成ForFor实现方式的第一层循环,从语义上来讲就是打印每一行的内容,然后换行
  • JAction用于完成ForFor实现方式的第二层循环,输出每行的计算式

里面没有任何和判断相关的代码,里面只出现了一次For循环语句,同时也没有乱七八糟的其它运算符和库函数。

代码扣除测试相关代码,也就是20行代码左右。

实际上,这个时候与上面说的正解的解法对比,仅仅是由于语言的特性导致的实现形式不一样而已,实际上思想是完全一致的。

大结局

感谢所有参与此项挑战的同学,不管你们采用的是什么语言,不管你们的方法是不是挑战成功,你们都是成功的,你们对自己的极限的挑战,对未知世界的探索的精神都是我学习的榜样。限于篇幅,有些同学的答案没有贴上来,在此表示歉意。

同时,对于我们来说,也有非常大的收获:

  1. 要敢于对我们已经习惯的方式进行挑战:有时候,我们已经习惯于遵守习惯,却丧失了打破习惯的勇气
  2. 知道不代表拥有:如果直接告诉你这个是应用什么什么模式来解决的,我想大多数的同学都是知道的,也是可以搞得定,但是只有想用就能用得出来的东西才是自己的。
  3. 群众们的表现,所有的参与者都学到了许多许多,再一次认识到自己的渺小,所以不要相信自己是最NB的几乎永远是对的。    

实际上,在这次挑战活动的收益最大的正是我自己,再次感谢所有同学,尤其是@红薯 为了我们搭建了这么好的平台,对了那100块奖金能不能给报销了?


© 著作权归作者所有

悠悠然然

悠悠然然

粉丝 2470
博文 185
码字总数 363071
作品 14
杭州
架构师
私信 提问
加载中

评论(36)

李嘉图
李嘉图

引用来自“赵紫川”的评论

```
(doseq [x (range 1 10)]
(apply println (map (partial * x) (range 1 (inc x)))))
```

clojure版本。

另外吐嘈一下,楼主的性别优越感优点不妥了。。。
优秀的妹子程序员少,只是因为基数小的原因。
事实上我就认识不少技术非常强大,甚至令人望其项背的女生,有些甚至在高中就超越了绝大多数现在网上活跃的很多技术圈的人。
别忘了,世界上第一个程序员就是个女性哦
以前我们学校学的好的,就很少有女生,女生这方面一般比男生差.
李嘉图
李嘉图
实际上数组下标隐含了判断,数组可以理解为下表是0,下标为1,下标为2情况的集合,这也算是语言特性吧,但是好像所有语言都有.
李嘉图
李嘉图
原来是利用数字之间的关系," ","\n"这个梗,无非就是输入个数字,输一个字符串,本来就可以用一个循环,唯一的禁锢就是把"\n"当成特殊的字符串了,所以才会想到双层循环,而利用一个递归一个循环,虽然递归也是循环,但是递归又需要结束条件,必须用if.我还是对题意理解不清楚呀,对字符串的理解不够.27
赵紫川
赵紫川
上面那个还是写在一行好了,避免缩进被吃了:

(doseq [x (range 1 10)] (apply println (map (partial * x) (range 1 (inc x)))))
赵紫川
赵紫川
卧槽好像评论不支持插入代码啊
赵紫川
赵紫川
```
(doseq [x (range 1 10)]
(apply println (map (partial * x) (range 1 (inc x)))))
```

clojure版本。

另外吐嘈一下,楼主的性别优越感优点不妥了。。。
优秀的妹子程序员少,只是因为基数小的原因。
事实上我就认识不少技术非常强大,甚至令人望其项背的女生,有些甚至在高中就超越了绝大多数现在网上活跃的很多技术圈的人。
别忘了,世界上第一个程序员就是个女性哦
悠悠然然
悠悠然然 博主

引用来自“百世经纶之傲笑红尘”的评论

都是神级人物的神级解法,看得我佩服得五体投地,本人汗颜,做IT小神也压力好大
难道你就是那个传说中的灰衣老僧?
百世经纶之傲笑红尘
百世经纶之傲笑红尘
都是神级人物的神级解法,看得我佩服得五体投地,本人汗颜,做IT小神也压力好大
悠悠然然
悠悠然然 博主

引用来自“codemonk”的评论

  var source=new string[]{
  "1*1=1",
"1*2=2 2*2=4",
"1*3=3 2*3=6 3*3=9",
"1*4=4 2*4=8 3*4=12 4*4=16",
  "1*5=5 2*5=10 3*5=15 4*5=20 5*5=25",
  "1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36",
  "1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49",
  "1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64",
  "1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81"};
  for (int i = 0; i < source.Length; i++)
    Console.WriteLine (source[i]);
44

来个 99999*99999的
codemonk
codemonk
  var source=new string[]{
  "1*1=1",
"1*2=2 2*2=4",
"1*3=3 2*3=6 3*3=9",
"1*4=4 2*4=8 3*4=12 4*4=16",
  "1*5=5 2*5=10 3*5=15 4*5=20 5*5=25",
  "1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36",
  "1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49",
  "1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64",
  "1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81"};
  for (int i = 0; i < source.Length; i++)
    Console.WriteLine (source[i]);
44
现金奖励:挑战编程极限的问题

今天我想挑战一下OSCHINA的亲们的编程能力,出一道百度、谷歌不到答案的问题,第一个挑战成功的,直接奖励现金100元RMB(本人也是苦B码农,纯属意思一下)。 以前发过一条循环语句打印螺旋矩...

悠悠然然
2015/08/14
4.7K
67
悠然乱弹:从几个方法的重构讲开去--性能大优化

上一篇讲到经过上面两篇的优化与重构,整体来说,前面提到的问题,除了性能问题之外,其它问题都已经顺利的解决了。 现在还存在多次扫描处理的问题,也就是说虽然代码结构性重构是成功的,但...

悠悠然然
2014/02/26
622
11
悠然乱弹:螺旋矩阵和蛇型矩阵的悠然版实现

螺旋矩阵和蛇型矩阵,是两个比较有趣的矩阵,有许多的公司面试题中有出现,这两个题的答案也有许多种,简单问一下度娘,就各自有N种实现,来源也非常丰富,比如CSDN、ITEYE、等等,当然也包括...

悠悠然然
2015/04/04
3K
17
Velocity宏定义的坑与解决办法

使用Velocity,当然就免不了要使用宏,或者说使用Velocity而不使用其宏,就相当于废了Velocity一半以上的武功,非常可惜的。 怎么使用Velocity的宏呢,才最大程度的发挥其作用但是又避免掉入...

悠悠然然
2014/04/14
937
2
OSChina 开源周刊 40 期 —— 2015 年五大移动端设计趋势

每周技术抢先看,总有你想要的! 移动开发 【博客】Android 4.4 的 init 进程详解 【博客】Android4.4的zygote进程 前端开发 【翻译】在 Microsoft Edge 提供快速的 JavaScript 性能 服务端开...

OSC编辑部
2015/06/28
4.9K
2

没有更多内容

加载失败,请刷新页面

加载更多

领域驱动中的“贫血症和失忆症”

贫血症严重危害着人类健康,并且伴随有危险的副作用。当贫血领域对象被首次提出来时,它并不是一个博得赞美的词汇,它描述的是一个缺少内在行为领域对象。奇怪的是,人们对于贫血领域对象的态...

还仙
11分钟前
3
0
条码打印软件中标签预览正常打印无反应怎么解决

在使用条码打印软件制作标签时,有客户反馈,标签打印预览正常的,但是打印无反应,咨询是怎么回事?今天针对这个情况,可以参考以下方法进行解决。 一、预览正常情况下,打印没反应 (1)在条码...

中琅软件
20分钟前
3
0
判断字符串的时候

判断字符串的时候一定把常量房前边, //报警程度 String leve = vo.getDeviceAlertDeal().getWarnLevel(); if(("0").equals(leve)) { row.add("无报警"); }else if(("1").equals(leve)) { ro......

简小姐
21分钟前
5
0
Linux maven3.6.2 install

PS:安装 maven 之前请先安装 jdk 1.安装 wget 命令(安装过就不用了) yum -y install wget 2.寻找需要的 maven 版本 https://maven.apache.org/download.cgi 3.进入 /var/local 文件夹 cd...

东方神祇
23分钟前
3
0
Tomcat源码分析二:先看看Tomcat的整体架构

Tomcat源码分析二:先看看Tomcat的整体架构 Tomcat架构图 我们先来看一张比较经典的Tomcat架构图: 从这张图中,我们可以看出Tomcat中含有Server、Service、Connector、Container等组件,接下...

flygrk
26分钟前
3
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部