《程序员模拟器》生涯困难1～12关攻略（上）

这份攻略整理的是一些过关思路，不是唯一解，更不是标准答案。很多关卡我自己也卡过，后来翻论坛、看别人分享才慢慢摸清楚。本人非专业人士，如果有写错的地方，欢迎大家指出！游戏有自己的规则，哪怕你写过 JavaScript，也得重新适应——比如游戏键盘里打不出冒号、分号和问号等，常见的 for 循环、对象字面量还有简洁的判断也就用不上。如果你是第一次接触困难难度，建议先自己试试。这部分的题目已经逐渐变态了——不只是动动脑子就可以的事情了，还得靠集思广益，实在卡住再来看攻略也不迟。
最后还是那句话：解法没有高下之分，能跑通就是好代码，享受琢磨的过程就好。
PS如果想单独复制某一关的代码，建议用手机浏览器打开此攻略，而不是客户端

变量a=输入
变量b=变量a[0]
变量c=1
while ( 变量c<变量a.length ){
    if (变量b<变量a[变量c] ){
        变量b=变量a[变量c]
    }
    变量c+=1
}
return 变量b

return Math.max(...输入)

str=输入
len=str.length
dp=[...Array(len)].map(()=>{
    return [...Array(len)].fill('')
})
i=0
while ( i<len ){
    dp[i][i]=1
    i+=1
}
subLen=2
while ( subLen<=len ){ 
    start=0
    while ( (start+subLen)<=len ){
        end=start+subLen-1     
        dp[start][end]
        =dp[start][end-1]+1     
        i=start
        while ( i<end ){
            dp[start][end]
            =Math.min(
            dp[start][end],
            dp[start][i]
            +dp[i+1][end]) 
            i+=1
        }       
        if ( str[start]==str[end] ){
            dp[start][end]
            =Math.min(
            dp[start][end],
            dp[start][end-1])
        }     
        start+=1     
    }
    subLen+=1
}
return dp[0][len-1]

pillar=输入
left=0
right=pillar.length-1
leftMax=0
rightMax=0
water=0
while ( left<right ){
    leftMax=Math.max(
    leftMax, pillar[left])
    rightMax=Math.max(
    rightMax, pillar[right])
    if (pillar[left]<pillar[right]) {
        water+=leftMax-pillar[left]
        left+=1
    } else {
        water+=rightMax-pillar[right]
        right-=1
    }
}
return water

这关的难度有点超出当前章节了。我用的是比较简化并且不能覆盖真实五子棋所有情况的，只用chk4判断了横竖两个方向上是否会出现四连。棋盘简化成7×7，足够解题用了，判断时只看中间5×5的区域。注意初始化棋盘时，把黑白棋加了1，这样0就成了空白。因为是只有黑白黑三步，所以白棋只有四连才能赢，黑棋就遍历模拟下一子，再看看有没有四连，没有就恢复棋盘。总之，能过关就行

pieces=输入
board=[...Array(7)].map(()=>{
    return [...Array(7)].map(()=>0)
})
i=0
while ( i<pieces.length ){
    p=pieces[i]
    board[p[0]][p[1]]=p[2]+1
    i+=1
}
if ( chk4(2) ) return 'white'
m=1
while ( m<6 ){
    n=1
    while ( n<6 ){
        if ( board[m][n]==0 ){
            board[m][n]=1
            if ( chk4(1) ) return 'black'
            board[m][n]=0
        }
        n+=1
    } 
    m+=1
}
return 'none'
function chk4(player){
    x=1
    while ( x<6 ){
        y=1
        while ( y<3 ){
            win=true
            i=0
            while ( i<4 ){
                if ( board[x][y+i]!=player ){
                    win=false
                    break
                }
                i+=1
            }
            if ( win ) return true
            y+=1
        }   
        x+=1
    }
    y=1
    while ( y<6 ){
        x=1
        while ( x<3 ){
            win=true
            i=0
            while ( i<4 ){
                if ( board[x+i][y]!=player ){
                    win=false
                    break
                }
                i+=1
            }
            if ( win ) return true
            x+=1
        }   
        y+=1
    }
    return false
}

变量a=[...输入]
变量b=变量a.length
变量c=Math.floor( 变量b/2 )
变量d=0
while ( 变量d<变量c ){
    [变量a[变量d],变量a[变量b-1-变量d]]=
    [变量a[变量b-1-变量d],变量a[变量d]]
    变量d+=1
}
return 变量a.join('')

return [...输入].reverse().join('')

变量a=输入
变量b=1
变量c=输入**(1/2)
变量d=2
while ( 变量d<变量c ){
    if ( 变量a%变量d==0 ){
        变量b+=变量d
        变量b+=变量a/变量d
        if ( 变量b>变量a ){
            return false
        }
    }
    变量d+=1
}
if ( 变量d==变量c ){
    变量b+=变量d
}
return 变量a==变量b

变量a=输入
if ( 变量a%2==1 ){
    return false
}
变量b=2
while ( true ){
    变量c=Math.pow( 2,变量b )-1
    变量d=Math.pow( 2,变量b-1 )*变量c
    if ( 变量d>变量a ){
        return false
    }
    if ( 变量d==变量a ){
        return true
    }
    变量b+=1
}

return [6,28,496,8128,33550336].includes(输入)

str = 输入
maxLen = 0
crtStr = ''
i=0
while ( i<str.length ){
    char = str[i]
    charIndex = crtStr.indexOf(char)
    if (charIndex !== -1) {
        crtStr = crtStr.slice(charIndex + 1)
    }
    crtStr += char
    maxLen = Math.max(
    maxLen,crtStr.length)
    i+=1
}
return maxLen

变量a=输入
变量b=变量a.length
变量c=0
while ( 变量c<变量b-1 ){
    变量d=0
    while ( 变量d<变量b-1-变量c ){
        if ( 变量a[变量d]>变量a[变量d+1] ){
            [变量a[变量d],变量a[变量d+1]]=
            [变量a[变量d+1],变量a[变量d]]
        }
        变量d+=1
    }
    变量c+=1
}
return 变量a

return 输入.sort((a,b)=>a-b)

变量a=输入
变量b=变量a.length
if ( 变量b==0 ){
    return 0
}
变量a.sort((a,b)=>a-b)
变量c=1
变量d=1
变量e=1
while ( 变量e<变量b ){
    if ( 变量a[变量e]!=变量a[变量e-1] ){
        if ( 变量a[变量e]==
        变量a[变量e-1]+1 ){
            变量d+=1
            变量c=Math.max( 变量c,变量d )
        } else {
            变量d=1
        }
    }
    变量e+=1
}
return 变量c

变量a=输入
变量b=变量a[0]
变量c=0
变量d=1
while ( 变量d<变量a.length ){
    变量e=变量a[变量d]-变量b
    变量c=Math.max( 变量c,变量e )
    变量b=Math.min( 变量b,变量a[变量d] )
    变量d+=1
}
return 变量c

numSet=输入[0]
target=输入[1]+''
lenN=numSet.length
lenT=target.length
powers=0
i=1
while ( i<lenT ){
    powers+=Math.pow( lenN,i )
    i+=1
}
i=0
while ( i<lenT ){
    isSame=false
    j=0
    while ( j<lenN ){
        if ( numSet[j]<target[i] ){
            powers+=Math.pow( lenN,
            lenT-i-1 )
        } else if ( numSet[j]==target[i] ){
            isSame=true
            break
        }
        j+=1
    }   
    i+=1
    if ( !isSame ){
        return powers
    }
}
return powers+1

list=输入[0]
cd=输入[1][0]-0
type=[]
count=[]
i=0
while ( list[i] ){
    task=type.indexOf(list[i])
    if ( task==-1 ){
        type.push( list[i] )
        count.push(1)
    } else {
        count[task]+=1
    }
    i+=1
}
maxc=Math.max( ...count )
maxct=0
i=0
while ( count[i] ){
    if ( count[i]==maxc ){
        maxct+=1
    }
    i+=1
}
total=(maxc-1)*(cd+1)+maxct
len=list.length
return Math.max( len,total )