begining
题目描述，对于单个单词来说，输出字符串下标为奇数的全小写，下标为偶数的全大写。 对于多个空格隔开的单词来说，输出的每个单词适用于上一条规则。(初始下标为0，按偶数计)
个人代码如下：
function toWeirdCase(string){
myString = new String()
var j = 0
for(var i = 0; i < string.length; i++) {
if (string[i]=== ' ') {
j = 0s
myString += ' '
}
else if(j % 2 === 0) {
j++
myString += string[i].toUpperCase()
}
else {
j++
myString += string[i].toLowerCase()
}
}
return myString
}自己试过的坑：
1. 刚开始我在碰到偶数下标时用的string[i].toUpperCase()，但后来发现string.toUpperCase并不会改变原数组。
2. 之后尝试了string[i]=string[i].toUpperCase()，toUpperCase()方法返回的字符为什么没有将原字符替换掉，各中原理我不太清楚，但很明显没有奏效。
3. 之后搞了个空字符串myString，然后直接myString[i]=string[i].toUpperCase()，结果返回的结果很有意思，myString仍然为空字符串，但它的下标对应的元素却已经变更了。我没太明白，这意思是生成了新数组了吗？2333
- 当然了，我才不会告诉你我因为大意漏了题目描述，第一次一直以为是所有的字符奇偶排呢！
第四题
先贴自己搞错题意的代码。 宝宝这段代码实质上是把重复k次的word取出来再拼接到一块。被example误导了。马丹！
function longestConsec(strarr, k) {
if (strarr.length === 0 || strarr.length < k || k <= 0) {
return "";
}
else {
var result = new String();
var repeat = '', j = 0;
for (var i = 0; i < strarr.length; i++) {
repeat = strarr[i];
for(var z = 0; z < strarr.length; z++) {
if(strarr[z] === repeat) {
j++;
}
}
var pattern = new RegExp(repeat)
if (j === k && !pattern.test(result)) {
result += repeat;
}
j = 0;
}
return result;
}
}题意如下：
You are given an array strarr of strings and an integer k. Your task is to return the first longest string consisting of k consecutive strings taken in the array.
Example:
longest_consec(["zone", "abigail", "theta", "form", "libe", "zas", "theta", "abigail"], 2) --> "abigailtheta"
n being the length of the string array, if n = 0 or k > n or k <= 0 return "".妈个鸡，昨天就看错了。
再一次看错，我以为题意是找到最长的，然后连着后边k-1个排出来。 马丹 又错了
function longestConsec(strarr, k) {
if (strarr.length === 0 || strarr.length < k || k <= 0) {
return "";
}
else {
var result = new String();
var j = 0;
for (var i = 0; i < strarr.length; i++) {
if(strarr[j].length < strarr[i].length) {
j = i
}
}
// 此处之前以为是i+k越界就输出空
if(j + k > strarr.length) {
return "";
} else {
for (var z = j; z < j + k; z++){
result += strarr[z]
}
return result;
}
}
}
看懂题意之后终于明白自己的浅薄，算法不敢称，数学上还是要想明白的。
function longestConsec(strarr, k) {
if (strarr.length === 0 || strarr.length < k || k <= 0) {
return "";
}
else {
var result = '', store = [];
var j = 0, n=strarr.length;
for (var i = 0; i < n; i++) {
if(strarr[j].length < strarr[i].length) {
j = i
}
}
// todo 以j为中点，k为区间长度确定区间 找到答案
if(j-k > 0 && j+k < n) {
for (var x = j-k+1; x <= j; x++) {
var temp = ''
for (var z = 0; z < k; z++) {
temp += strarr[x+z]
}
store.push(temp)
}
var longer = 0
for(var l = 0; l < store.length; l++) {
if (store[l].length > store[longer].length) {
longer = l
}
}
result = store[longer]
return result
// todo k大于j 可选区间改变。
} else if (j-k > 0 && j+k >= n){
for (var x = j-k+1; x < n-k-1; x++) {
var temp = ''
for (var z = 0; z < k; z++) {
temp += strarr[x+z]
}
store.push(temp)
}
var longer = 0
for(var l = 0; l < store.length; l++) {
if (store[l].length > store[longer].length) {
longer = l
}
}
result = store[longer]
return result
} else if (j-k <= 0 && j+k >= n){
for (var x = 0; x < n-k-1; x++) {
var temp = ''
for (var z = 0; z < k; z++) {
temp += strarr[x+z]
}
store.push(temp)
}
var longer = 0
for(var l = 0; l < store.length; l++) {
if (store[l].length > store[longer].length) {
longer = l
}
}
result = store[longer]
return result
} else if (j-k <= 0 && j+k < n){
for (var x = 0; x < k+j-1; x++) {
var temp = ''
for (var z = 0; z < k; z++) {
temp += strarr[x+z]
}
store.push(temp)
}
var longer = 0
for(var l = 0; l < store.length; l++) {
if (store[l].length > store[longer].length) {
longer = l
}
}
result = store[longer]
return result
}
}
}妈个鸡 最后竟然简单成这样就解决了，能不能搞点有难度的啊！ :)
function longestConsec(strarr, k) {
if (strarr.length === 0 || strarr.length < k || k <= 0) {
return '';
} else {
var result = '';
var n = strarr.length;
for (var i = 0; i < n-k+1; i++) {
var temp = '';
for (var j = 0; j < k; j++) {
temp += strarr[i+j];
}
if (result.length < temp.length) {
result = temp;
}
}
return result;
}
}造一个塔
题目描述
Build Tower by the following given argument:
number of floors (integer and always greater than 0).
Tower block is represented as *
Python: return a list;
JavaScript: returns an Array;
C#: returns a string[];
PHP: returns an array;
C++: returns a vector<string>;
Haskell: returns a [String];
Have fun!这个用的时间还是比较短的。 思路，首先最长的先计算出来是2*n-1，然后往下迭代一次，首尾两端的用 ’ ‘代替*
首尾两端的筛选用 j >= i && j < l-1实现
function towerBuilder(nFloors) {
var n = nFloors;
var l = 2*n-1;
var str = new Array(n)
for (var i = 0; i < n; i++) {
var item = '';
for (var j = 0; j < l; j++) {
if (j >= i && j < l-i) {
item += '*'
} else {
item += ' '
}
}
str[i] = item
}
return str.reverse();
}Description
Middle Earth is about to go to war. The forces of good will have many battles with the forces of evil. Different races will certainly be involved. Each race has a certain 'worth' when battling against others. On the side of good we have the following races, with their associated worth:
Hobbits - 1
Men - 2
Elves - 3
Dwarves - 3
Eagles - 4
Wizards - 10
On the side of evil we have:
Orcs - 1
Men - 2
Wargs - 2
Goblins - 2
Uruk Hai - 3
Trolls - 5
Wizards - 10
Although weather, location, supplies and valor play a part in any battle, if you add up the worth of the side of good and compare it with the worth of the side of evil, the side with the larger worth will tend to win.
Thus, given the count of each of the races on the side of good, followed by the count of each of the races on the side of evil, determine which side wins.
Input:
The function will be given two parameters. Each parameter will be a string separated by a single space. Each string will contain the count of each race on the side of good and evil.
The first parameter will contain the count of each race on the side of good in the following order:
Hobbits, Men, Elves, Dwarves, Eagles, Wizards.
The second parameter will contain the count of each race on the side of evil in the following order:
Orcs, Men, Wargs, Goblins, Uruk Hai, Trolls, Wizards.
All values are non-negative integers. The resulting sum of the worth for each side will not exceed the limit of a 32-bit integer.
Output:
Return ""Battle Result: Good triumphs over Evil" if good wins, "Battle Result: Evil eradicates all trace of Good" if evil wins, or "Battle Result: No victor on this battle field" if it ends in a tie.考的点： - 输入的数组是由于空格的原因已经变成字符串数组 需要格式转换
- ! 与 %的优先级
- 对于字符串数组取数字时要提防位数超过个位数的数字。
- ” 与 ’ ‘是两回事 一个是空字符串 一个是带空格的字符串4
下边是我自己的代码
function goodVsEvil(good, evil){
var goodWorth = new Number();
var evilWorth = new Number();
var goodChange = [];
var evilChange = [];
var result = ''
var temp1 = ''
var temp2 = ''
for (var i = 0; i < good.length; i++) {
if(good[i] !== ' ') {
temp1 += good[i]
} else {
goodChange.push(Number(temp1))
temp1 = ''
}
}
goodChange.push(Number(temp1))
for (var j = 0; j < evil.length; j++) {
if (evil[j] !== ' ') {
temp2 += evil[j];
} else {
evilChange.push(Number(temp2))
temp2 = ''
}
}
evilChange.push(Number(temp2))
goodWorth = goodChange[0] + goodChange[1]*2 + goodChange[2]*3 + goodChange[3]*3 + goodChange[4]*4 + goodChange[5]*10;
evilWorth = evilChange[0] + evilChange[1]*2 + evilChange[2]*2 + evilChange[3]*2 + evilChange[4]*3 + evilChange[5]*5 + evilChange[6]*10;
if (goodWorth > evilWorth) {
result = 'Battle Result: Good triumphs over Evil'
} else if (goodWorth < evilWorth) {
result = 'Battle Result: Evil eradicates all trace of Good'
} else {
result = 'Battle Result: No victor on this battle field'
}
return result;
}我会告诉你因为把 Good triumphs over Evil 中的 triumphs敲错了而花了十分钟找错误吗？妈个鸡！！！
操作符 !的优先级确实高于%， 下次测试的时候分清 Boolean 与 Number好吗？
寻找公约数
题目描述
Create a function named divisors that takes an integer and returns an array with all of the integer's divisors(except for 1 and the number itself). If the number is prime return the string '(integer) is prime' (use Either String a in Haskell).这个思路还是比较简单，取余就好了。注意数字 + 字符串也会变成字符串。
function divisors(integer) {
var result = [];
for (var i = 2; i < integer; i++) {
if (integer % i === 0) {
result.push(i)
}
}
if (result.length) {
return result;
} else {
return integer + ' is prime';
}
}codewar欠债两天
又欠一天 明天必须来几发了
又欠一天 cognos核心的问题解决不掉，那我们永远都被困在这里。
遍历对象属性
// must return 2
cakes({flour: 500, sugar: 200, eggs: 1}, {flour: 1200, sugar: 1200, eggs: 5, milk: 200});
// must return 0
cakes({apples: 3, flour: 300, sugar: 150, milk: 100, oil: 100}, {sugar: 500, flour: 2000, milk: 2000});具体问题描述大概就是有个叫peter的小兄弟要做蛋糕，手里有食谱和原材料，你帮小兄弟算算能做几多蛋糕。
for...in...思路：先判断是否食谱对象的属性是原材料属性的子集或全集，是的话就分别把属性push到两个数组中，取商再把结果push到新的数组。最后的返回值即为数组最大元素。
代码如下
function cakes(recipe, available) {
var arr = new Array();
for (key in recipe) {
if(!available.hasOwnProperty(key)) {
break;
} else {
arr.push(parseInt(available[key]/recipe[key]))
}
}
if(arr.length) {
var result = arr[0]
for (var i = 0; i < arr.length; i++) {
if (result > arr[i]) {
result = arr[i]
}
}
return result;
} else {
return 0;
}
}自己碰到的坑： 1. hasOwnProperty方法判断对象是否具有某种属性
2. for...in...遍历对象的属性
3. []属性访问方法比.属性访问方法好的地方在于它可以接受变量，别问我为什么recipe.key通不过。
4. js的除法和取余是两码事，所以parseInt()函数的用处就是…
债务 update 欠债四次
Reverse words
Reverse each word which is in the string and splited with ’ ‘
- 鄙人代码
function reverseWords(str) {
var arr = []
var subArr = []
var text = ''
var result = ''
arr.push(subArr)
var result = ''
// 陈老师版 split() 23333
for (var i = 0; i < str.length; i++) {
if (str[i] === ' ') {
var subArr = [];
arr.push(subArr)
} else {
subArr.push(str[i])
}
}
// split()后reverse()
for (var j = 0; j < arr.length; j++) {
arr[j].reverse()
// 土法 join() ORZ
for (var z = 0; z < arr[j].length; z++) {
text += arr[j][z]
}
text += ' '
}
for (var x = 0 ; x < text.length-1; x++) {
result += text[x]
}
return result;
}- 他人代码
// 二次审视之后是最直观、简洁的答案 我最喜欢的答案
function reverseWords(str) {
return str.split(' ').map(function(word){
return word.split('').reverse().join('');
}).join(' ');
}- 他人代码二
function reverseWords(str) {
// Go for it
//split words into seperate arrays
// 思路同下
return str.split("").reverse().join("").split(" ").reverse().join(" ");
}- 更容易理解一些的代码
// 先颠倒一切顺序，最后交换word的顺序。
function reverseWords(str) {
var newStr = "";
for (var i = str.length - 1; i >= 0; i--) {
newStr += str[i];
}
return newStr.split(" ").reverse().join(" ");
}- 只能安慰自己独立思考还是很不错的，人和人的水平差距比人和猪都要大。
- 当然我觉得思路可能大差不差，字符串分割数组，
reverse方法后再拼接新的字符串，这就是代码功底差距的体现，这就是基础知识的问题。
-不知道的知识点： 1. str.split([seperator[,limit]]) 返回值是数组
2. arr.join(seperator) 返回值是分隔符链接的字符串，使用分隔符把数组中的元素连接起来，所以别担心最后一个元素会跟一个分隔符
3. arr.map(callback[, thisArg]) 返回值是数组’
Array Helpers
先记下一些原型方面的东西：
prototype属性指向的是一个对象，在这个对象中定义需要被继承的成员，
当前对象的原型对象需要通过_proto_访问。详情Object.create()返回一个参数为原型的对象。constructor指向创建该实例的构造器函数。 实例–>构造器–>Object (原型链)
题目描述：
This kata is designed to test your ability to extend the functionality of built-in ruby classes. In this case, we want you to extend the built-in Array class with the following methods: square(), cube(), average(), sum(), even() and odd().
The functions should return the same as what they look like but not change the instance itself.从上面的原型的知识讲当然是用原型搞了，因为输入的数组是Array的一个实例，所以它可以继承的方法都在Array的prototype里，直接在那里定义我们需要的函数就ok了。
Array.prototype.square = function() {
var result = []
for (var i = 0; i < this.length; i++) {
result.push(this[i]*this[i])
}
return result
}
Array.prototype.cube = function() {
var result = []
for (var i = 0; i < this.length; i++) {
result.push(this[i]*this[i]*this[i])
}
return result
}
Array.prototype.sum = function() {
var temp = 0
for (var i = 0; i < this.length; i++) {
temp += this[i]
}
return temp
}
Array.prototype.average = function() {
if (this.length) {
var temp = 0
for (var i = 0; i < this.length; i++) {
temp += this[i]
}
return temp/this.length
} else {
return NaN
}
}
Array.prototype.odd = function() {
var result = []
for (var i = 0; i < this.length; i++) {
if (this[i]%2) {
result.push(this[i])
}
}
return result
}
Array.prototype.even = function() {
var result = []
for (var i = 0; i < this.length; i++) {
if (this[i]%2 === 0) {
result.push(this[i])
}
}
return result
}别人家的代码
Array.prototype.square = function () { return this.map(function(n) { return n*n; }); }
Array.prototype.cube = function () { return this.map(function(n) { return n*n*n; }); }
Array.prototype.average = function () { return this.sum() / this.length; }
Array.prototype.sum = function () { return this.reduce(function(a, b) { return a + b; }, 0); }
Array.prototype.even = function () { return this.filter(function(item) { return 0 == item % 2; }); }
Array.prototype.odd = function () { return this.filter(function(item) { return 0 != item % 2; }); }- 做事情的思路是一样的，问题还是在基础知识上，补充一下
| 方法 | 返回 | 详情 |
|---|---|---|
| map() | 参数为回调函数，返回原数组元素经过回调函数折腾后组成的新数组 | 详细 |
| reduce | 参数为回调函数和一个初始值，初始值在回调函数里和数组元素挨个搞事情 | 详细 |
| filter() | 参数为回调函数，过滤器返回由通过测试条件元素组成的新数组 | 详情 |
所以刷codewar是一个特别正确的选择。刷出了自己不知道的东西还是比较幸福的。
未完待续，欠债4篇依旧。
Where my anagrams at?
- two words are anagrams of each other if they both contain the same letters.
Write a function that will find all the anagrams of a word from a list. You will be given two inputs a word and an array with words. You should return an array of all the anagrams or an empty array if there are none.
传入两个参数，一个是单词，另一个是单词数组。找到单词数组与单词字母组成相同的元素。返回由他们组成的新数组。
关键的点有两个:
- 如何判断两个字符串由相同的字符(顺序可能不同)组成？
- 如何筛选出来它们？
解决问题的关键点也与它们相对应
- 如果把要比较的两个字符串排成相同的顺序不就好比较了吗？
- 排序，数组有现成的方法。
sort()完美满足我们的需求。把字符串先用split()搞成数组排序后再join起来就满足了比较的条件。 - 关于筛选, 可用
for循环做，满足条件的push到新的数组。但既然所要的结果是原数组的子数组，数组自身的filter()属性就解决了我们的问题。
吹完了牛，代码如下
function anagrams(word, words) {
var getAnagrams = function (item) {
return item.split("").sort().join("") === word.split("").sort().join("")
}
return words.filter(getAnagrams)
}这也是我自己写的第一段看起来比较像样的js代码。当然了，可以更简洁直接把getAnagrams()作为匿名函数直接写在filter的callback里，算是熟悉了几个常用的函数。
依旧欠债4篇 今天很有收获 16-12-5
未提交的一道题(最后还是提交了)
题目大意是一个传入多个词以及空格组成的字符串，期望返回的是讲每个单词的首字母大写。
觉得关键的点如下：
toUpperCase()函数将首字母大写- 字符串先拆分为数组
- 使用数组的
map()方法，将首字母变为大写。 - 需要注意的是js中的字符串一段创建是不会变化的。所以我返回了新的变量。
不知道代码是否到了最简洁，代码如下:
function generateHashtag (str) {
if (str.length > 0 && str.length < 140) {
return '#' + str.split(' ').map(function(subStr){
var temp = subStr.toUpperCase()[0]
for (var i = 1; i < subStr.length; i++ ) {
temp += subStr[i]
}
return temp}).join('')
} else {
return false
}
}人家的代码
function generateHashtag (str) {
return str.length > 140 || str === '' ? false :
'#' + str.split(' ').map(capitalize).join('');
}
function capitalize(str) {
return str.charAt(0).toUpperCase() + str.slice(1); //slice(1)用的漂亮！
}
搞三个函数出来
- 搞三个函数
Math.round()四舍五入之用Math.floor()向下取整Math.ceil()向上取整
- 整个解决问题的基础就是
parseInt()方法
自己的代码
Math.round = function(number) {
if(number === parseInt(number)) {
return number
}
else if(number < parseInt(number)+0.5) {
return Math.floor(number);
} else {
return Math.ceil(number)
}
};
Math.ceil = function(number) {
if(number === parseInt(number)){
return number
} else {
return parseInt(number)+1;
}
};
Math.floor = function(number) {
return parseInt(number);
};
人家的代码
Math.round = function(number) {
return (number - parseInt(number) >= 0.5) ? parseInt(number) + 1 : parseInt(number) ;
};
Math.ceil = function(number) {
return (parseInt(number) === number) ? number : parseInt(number) + 1;
};
Math.floor = function(number) {
return parseInt(number);
};从中可以看到一个条件表达式多简洁地解决了问题，这就是基础知识的灵活运用带来的魅力。会写个for循环，搞个if判断就算是会写程序了？Naive！！！
第一次递归
题意大致是完成一个完成一个函数，其功能是得到一个颠倒顺序和自身相等的数，返回值是参数变为需要得到的数的步骤数，步骤是不满足结束要求时，参数和自己颠倒顺序的数相加做下一个参数。
大致需要考虑的事情如下：
- 如何判断输入和它自身颠倒顺序是否相等？
- 如果不满足，如何让它多次执行？并记录执行的次数？
解决方案如下：
- 因为数组有现成的逆排序方法
reverse()，而我们可以完成的类型转换是： Number–>String–>Array - 在不满足结束要求进行加和时，还要再次进行类型转换，使用
parseInt()方法。
- 因为数组有现成的逆排序方法
我的代码
var palindromeChainLength = function(n) {
var test = n
return palindrome(test,0)
}
var palindrome = function(n,length) { //这里再搞一个函数是因为如果在上一个函数定义累加器时，
var temp = n.toString().split('').reverse().join('') //每次都会置0，我不知道如何处理
if(temp == n.toString()) {
return length
} else {
length++
return palindrome(n+parseInt(temp),length)
}
}- 别人家的代码I
var palindromeChainLength = function(n) {
var x = parseInt( (""+n).split('').reverse().join('') ); //""+n，将n转换为string类型
if(n != x){
return 1 + palindromeChainLength (n + x); //用加一的方法解决如果在函数内初始化计数器最终会返回0的问题
}
return 0;
};- 别人家的代码II
var palindromeChainLength = function(n) {
var r = 1 * n.toString().split('').reverse().join(''); // 原理类似，用乘一的方法解决类型转换的问题
return n - r && 1 + palindromeChainLength(r + n); //当n==r 时，结束递归。
};- 首先可以看见人类思维的多角度，用不同的方法都可以解决掉问题。
- 然后可以见到，解决问题都是基于自身熟悉的一部分知识推向未知。
- 这道题也充分体现了js动态语言的魅力，不停地格式转换，很爽。
缝补旧事
- 这个没什么好讲的，依据本金、年利率、税率、期望值，计算达到期望值需要的年限。主要注意一下税率针对的是利息。
function calculateYears(principal, interest, tax, desired) {
// your code
var years = 0;
while(principal < desired){
principal += (principal * interest) * (1 - tax);
years++;
}
return years;
}- 别人的代码
function calculateYears(principal, interest, tax, desired) {
return Math.ceil(
Math.log(desired / principal) /
Math.log(1 + interest * (1 - tax))
);
}- 值得一记的是今天虽然没有欠账，但是完成的像例行公事一样。逻辑上绕圈子的都跳过去，从收藏里把这个东西扒了出来。甚是惭愧 。
- 总是写五分钟就搞定的代码还有什么意思。
- 自己的逻辑水平确实差…
- 从
codewar的提交数量上看，三分之一的人在这时候已经放弃了。你要接着玩下去啊！
欠债三篇
哈哈哈
- 先让我装波逼，我为什么如此英俊！！！
- 搞定了一个有难度的东西，那叫一个爽。
- 我不是针对谁，哪个姑娘不拜倒在我的智慧之下 2333
言归正传，继欠债三篇后的3个小时，我又搞定了一道之前认为比较麻烦的题，题意如下：就是用数组来表达井字棋，通过数组对井字棋状态进行判定。
we were to set up a Tic-Tac-Toe game, we would want to know whether the board's current state is solved, wouldn't we? Our goal is to create a function that will check that for us!
Assume that the board comes in the form of a 3x3 array, where the value is 0 if a spot is empty, 1 if it is an X, or 2 if it is an O, like so:
[[0,0,1],
[0,1,2],
[2,1,0]]
We want our function to return -1 if the board is not solved yet, 1 if X won, 2 if O won, or 0 if it's a cat's game (i.e. a draw).
You may assume that the board passed in is valid in the context of a game of Tic-Tac-Toe.井字棋的状态取决于以下几点：
- 一方获胜——或横、或纵、或对角。
- 平局——棋盘上还剩一个空格(待定？)
- 除去前面两种状态就是第三种——进行中。
我的代码
function isSolved(board) { var result = -1 var count = 0 board.map(function(item) { item.map(function(subItem){ if (subItem === 0) { count++ } }) }) if (count == 0) {result = 0} else { if(equalJudge([board[0][0], board[1][1], board[2][2]])|| equalJudge([board[0][2], board[1][1], board[2][0]])){ if (board[1][1] !== 0) { result = board[1][1] } } else { for(var i = 0; i < board.length; i++) { if (equalJudge(board[i]) && board[i][0] !== 0) { result = board[i][0] break; } else { var temp = board.map(function(item) { return item[i]; }) if(equalJudge(temp) && temp[0] !== 0) { result = temp[0] break; } } } } } return result } function equalJudge(arr) { var test = arr[0]; for (var i = 0; i < arr.length; i++) { if (test != arr[i]) { break; } } if(i === arr.length) { return true; } else { return false; } }当然，还有别人的代码系列
别人的代码一
function isSolved(board) {
board = board.join('-').replace(/,/g,'');
if(/222|2...2...2|2....2....2|2..2..2/.test(board)) return 2;
if(/111|1...1...1|1....1....1|1..1..1/.test(board)) return 1;
if(/0/.test(board)) return -1;
return 0;
}- 别人的代码二
function isSolved(board) {
function checkHor() {
var res;
board.forEach(function(item){
if (item[0] == item[1] &&
item[0] == item[2] &&
item[1] == item[2] &&
item[0] != 0)
res = item[0];
});
return res;
}
function checkVer() {
for (var a = 0; a< 3; a++)
{
if (board[0][a]==board[1][a]&&
board[1][a]==board[2][a]&&
board[2][a]==board[0][a]&&
board[0][a]!=0)
return board[0][a];
}
}
function checkA1(){
if ((board[0][0]==board[1][1]&&
board[1][1]==board[2][2]&&
board[2][2]==board[0][0])||
( board[0][2]==board[1][1]&&
board[1][1]==board[2][0]&&
board[2][0]==board[0][2]))
return board[1][1];
}
function gameOver() {
for (var x = 0; x < 3; x++)
for (var y = 0; y < 3; y++)
if (board[x][y] == 0)
return -1;
return 0;
}
return checkHor() || checkVer() || checkA1() || gameOver();
}- 别人的代码三
function isSolved(board) {
var win = [
[0,1,2], [3,4,5], [6,7,8], // Horizontal
[0,3,6], [1,4,7], [2,5,8], // Vertical
[0,4,8], [2,4,6] // Diagonal
];
board = board[0].concat(board[1], board[2]);
for (var i = 0, r; i < win.length; i++)
if (r = val(win[i], board))
return r;
return ~board.indexOf(0) ? -1 : 0;
}
// Return the value if all values are the same
function val(p, b) { return b[p[0]] == b[p[1]] && b[p[0]] == b[p[2]] && b[p[0]]; }
- 别人的代码四
function isSolved(board) {
function f(n) {
if (a[4] == n) for (i = 0; i < 4; i++)
if (a[i] == n && a[8 - i] == n) return true;
for (var x = 1, i = 1; i < 9; i += 2, x = i < 7 ? 3 : 1)
if (a[i] == n && a[i - x] == n && a[i + x] == n) return true;
}
var a = board.reduce(function(p,c){return p.concat(c)});
return f(1) ? 1 : f(2) ? 2 : a.some(function(i){return !i}) ? -1 : 0;
}- 别人的代码五
function isSolved(board) {
let r1 = '', r2 = '', r3 = '', r4 = '', r5 = '', _;
for (let i = 0; i < 3; i += 1) {
for (let j = 0, e; j < 3; j += 1) {
e = board[i][j], !e && (_ = 1);
board[i][j] = e === 1 ? 'X' : e === 2 ? 'O' : e;
}
}
for (let i = 0, e; i < 3; i += 1) {
e = board[i];
if (board[i].join('') === 'XXX') return 1;
if (board[i].join('') === 'OOO') return 2;
r1 += e[0], r2 += e[1], r3 += e[2], r4 += e[i], r5 += e[Math.abs(i - 2)];
}
if ([r1, r2, r3, r4, r5].some(v => v === 'XXX')) return 1;
if ([r1, r2, r3, r4, r5].some(v => v === 'OOO')) return 2;
return _ ? -1 : 0;
}
7174
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
