第 135 题：算法题 红、黄、蓝球排序

Question

在一个字符串数组中有红、黄、蓝三种颜色的球，且个数不相等、顺序不一致，请为该数组排序。使得排序后数组中球的顺序为:黄、红、蓝。例如：红蓝蓝黄红黄蓝红红黄红，排序后为：黄黄黄红红红红红蓝蓝蓝。

Answer 1

const str = ['红', '蓝', '蓝', '黄', '红', '黄', '蓝', '红', '红', '黄', '红']; function rank(list) { const map = { '黄': 0, '红': 1, '蓝': 2 } return list.sort((val, nextVal) => { return map[val] - map[nextVal] }) }

Answer 2

    var arr = '红蓝蓝黄红黄蓝红红黄红'
    var arrList = arr.split('')
    var obj = {
        "黄": [],
        "红": [],
        "蓝": []
    }
    arrList.map(item => obj[item].push(item))
    console.log([...obj['黄'], ...obj['红'], ...obj['蓝']].join(''))

Answer 3

let str = '蓝蓝黄红黄蓝红红黄红';
function sortColor(str){
let arrY = [],arrR = [],arrB = [];
let str1 = str.split('');
str1.map((item,index)=>{
if(item=='黄')arrY.push(item);
if(item=='红')arrR.push(item);
if(item=='蓝')arrB.push(item);
})
let newarr = (arrY.concat(arrR)).concat(arrB);
}
sortColor(str)

Answer 4

function Ball(inputStr){
inputarr = inputStr.split("");
var red = [];
var yellow = [];
var blue = [];
// yellow Red blue
// 黄 红 蓝
inputarr.forEach((item) => {
if(item === "黄") {
yellow.push(item)
}
if(item === "红"){
red.push(item)
}
if(item === "蓝") {
blue.push(item)
}
})
return yellow.join("")+red.join("")+blue.join("")
}

outstr = Ball("红红红黄黄蓝红黄蓝红蓝")
console.log(outstr)

Answer 5

let colorString = '红蓝蓝黄红黄蓝红红黄红';
   function formatColor(string) {
       let colorObj = {
           '黄': 1,
           '红': 2,
           '蓝': 3,
       }
       return Array.from(string).sort(function (a, b) { return colorObj[a] - colorObj[b] }).join('');
   }
   console.log(formatColor(colorString));  //黄黄黄红红红红红蓝蓝蓝

Answer 6

function sortStr(str) {
    var arr = [];
    var redIndex = 0;
    for(let i = 0; i< str.length; i++) {
        switch(str[i]) {
            case "黄":
                arr.unshift(str[i])
                redIndex++;
                break;
            case "红": 
                arr.splice(redIndex, 0, str[i])
                redIndex++
                break;
            case "蓝": 
                arr.push(str[i]);
                break;
        }
    }
    return arr.join("");
}
console.log(sortStr(str)); //黄黄黄红红红红红蓝蓝蓝

Answer 7

` function colorSort(str) {

if(!str) return null;

const match = {
    黄:0,
    红:1,
    蓝:2
};

const arr = str.split('');

arr.sort((a,b) => match[a]-match[b]);

console.log(arr.join(''));

}`

Answer 8

function sortColor(list) {
        if (list.length <= 1) return list
        let yellow = 0
        let blue = list.length - 1
        let pointer = 0
        while (list[yellow] === '黄') {
            yellow++
            pointer++
        }
        while (list[blue] === '蓝') {
            blue--
        }
        while (pointer <= blue) {
            if (list[pointer] === '黄') {
                swap(list, pointer, yellow)
                yellow++
                pointer++
            } else if (list[pointer] === '蓝') {
                swap(list, pointer, blue)
                blue--
            } else {
                pointer++
            }
        }

        return list
    }
    function swap(list, a, b) {
        [list[a], list[b]] = [list[b], list[a]]
    }

尝试用了三指针，类似快排的思想，原地交换。空间复杂度O(1),时间复杂度应该在O(n)吧
也可以先一遍把黄色分出来，然后再分红和蓝
不知道对不对啊

Answer 9

const colorStr = '红蓝蓝黄红黄蓝红红黄红';
function sortColor(colors) {
  let tmpArr = colors.split('');
  let obj = {
    '黄': [],
    '红': [],
    '蓝': []
  };
  for (let key of tmpArr) {
    obj[key].push(key);
  }
  return [...Object.values(obj)].flat(Infinity).join('');
}
sortColor(colorStr)

Answer 10

let originStr = '红蓝蓝黄红黄蓝红红黄红';
let sortStr = '黄红蓝';
originStr.split('').sort((prev, next) => {
return sortStr.indexOf(prev) - sortStr.indexOf(next)
}).toString()

Answer 11

/**
 * 根据order的顺序对数据排序
 * @param arr 排序数组
 * @param order 排序内容order
 */
function cunstomSort<T>(arr: Array<T>, order: Array<any>): Array<T> {
  return arr.sort((a, b) => order.indexOf(a) - order.indexOf(b));
}

console.log(
  cunstomSort('红蓝蓝黄红黄蓝红红黄红'.split(''), ['红', '黄', '蓝'])
);

Answer 12

GitHub markdown 语法高亮写法普及推广下: https://guides.github.com/features/mastering-markdown/

Answer 13

写的比较low，大神写的真秀，敬佩敬佩

     //  在一个字符串数组中有红、黄、蓝三种颜色的球，且个数不相等、顺序不一致，请为该数组排序。使得排序后数组中球的顺序为:黄、红、蓝。
      //例如：，排序后为：黄黄黄红红红红红蓝蓝蓝。

      let sort = (str, aimAry) =>
        Array.from(str)
          .reduce(
            (prev, item) => (prev[aimAry.indexOf(item)].push(item), prev),
            Array.from({ length: aimAry.length }, child => [])
          )
          .flat(1)
          .join('')
  
      let res = sort('红蓝蓝黄红黄蓝红红黄红', '黄红蓝')
      console.log(res)

Answer 14

const splitSource = (source) => {
    let targetArray = [[],[],[]];
    source.split('').forEach(element => {
        switch (element) {
            case '黄':
                targetArray[0].push(element)
                break;
            case '红':
                targetArray[1].push(element)
                break;
            case '蓝':
                targetArray[2].push(element)
                break;
        
            default:
                break;
        }
    });
    return targetArray.flat()
}

splitSource('红蓝蓝黄红黄蓝红红黄红')

用到了 flat
其实 sort() 和 charCodeAt() 也可以做的

看了楼上的高赞做的,这个做法是真秀,之前想用 charCodeAt() 来做排序的依据的,没想到换个思路自己给定义一下顺序就搞定了 真是秀

const stringOrder = {
    '黄':0,
    '红':1,
    '蓝':2
}
'红蓝蓝黄红黄蓝红红黄红'.split('').sort((a,b) =>stringOrder[a]-stringOrder[b] )

Answer 15

const balls = ['红', '蓝', '蓝', '黄', '红', '黄', '蓝', '红', '红', '黄', '红'];

// 定义排序规则，越小越靠前
const sortRule = new Map([
  ['黄', 1], ['红', 2], ['蓝', 3]
]);

balls.sort((a, b) => sortRule.get(a) - sortRule.get(b));

Answer 16

//只循环一次，应该比冒泡排序快，或许吧。。。
var a=[1,2,3,3,2,2,3,1,2,3,1,2,3,1,2,3,1,3,3,1,3,1,2];
var b=[[],[],[]];
for(var i=0;i<a.length;i++){
if(a[i]==1){
b[0].push(1)
}else if(a[i]==2){
b[1].push(2)
}else if(a[i]==3){b[2].push(3)}
}
console.log([...b[0],...b[1],...b[2]]);

Answer 17

var originStr = "红蓝蓝黄红黄蓝红红黄红";
var redCount = originStr.match(/红/ig).length;
var yellowCount = originStr.match(/黄/ig).length;
var blueCount = originStr.match(/蓝/ig).length;
console.log("红".repeat(redCount)+"黄".repeat(yellowCount)+"蓝".repeat(blueCount))

Answer 18

['黄','红','蓝'].map((o)=>o.repeat([...'红蓝蓝黄红黄蓝红红黄红'.matchAll(o)].length)).join('')

一行代码嘻嘻

Answer 19

var arr = ['蓝','黄','蓝','红','黄','蓝','红','黄','蓝','蓝','红','黄','黄','红'];
var arrNew = [];
var color = ['黄','红','蓝'];
function maps(arr,i){
for(var item of arr){
if(item == color[i]){
arrNew.push(item)
}
}
}
for(var i = 0; i < color.length; i++){
maps(arr,i)
}
console.log(arrNew)

Answer 20

sortColor = colorArr => {
if (Array.isArray(colorArr)) {
let map = {}
colorArr.map((item, index) => {
if (map[item]) {
map[item].push(item)
} else {
map[item] = []
map[item].push(item)
}
})
return [...map['黄'], ...map['红'], ...map['蓝']]
}
return colorArr;
}

Answer 21

    /**
     * 在一个字符串数组中有红、黄、蓝三种颜色的球，且个数不相等、顺序不一致，请为该数组排序。使得排序后数组中球的顺序为:黄、红、蓝。

     例如：红蓝蓝黄红黄蓝红红黄红，排序后为：黄黄黄红红红红红蓝蓝蓝。
     */
    let inputStr = "红蓝蓝黄红黄蓝红红黄红";

    /**
     * 过滤好拼接
     * @param inputStr
     * @returns {*}
     */
    function sortStr1(inputStr){
        let inputArr = inputStr.split("");
        let yellowArr = inputArr.filter(item => item === "黄");
        let redArr = inputArr.filter(item => item === "红");
        let blueArr = inputArr.filter(item => item === "蓝");
        return [...yellowArr, ...redArr, ...blueArr].join("");
    }

    console.log(sortStr1(inputStr));

    /**
     * 根据sort函数排序拼接
     * @param inputStr
     */
    function sortStr2(inputStr){
        let dict = {
            "黄": 0,
            "红": 1,
            "蓝": 2,
            0: "黄",
            1: "红",
            2: "蓝"
        };
        let inputArr = inputStr.split("").map(item => dict[item]);
        inputArr.sort((a, b) => a - b);
        inputArr = inputArr.map(item => dict[item]);
        return inputArr.join("");
    }

    console.log(sortStr2(inputStr));

    /**
     * 先数各几个，然后通过repeat拼接
     * @param inputStr
     */
    function sortStr3(inputStr){
        let yellowCount = 0;
        let redCount = 0;
        let blueCount = 0;
        for (let i = 0; i < inputStr.length; i++) {
            switch(inputStr[i]){
                case "黄":
                    yellowCount++;
                    break;
                case "红":
                    redCount++;
                    break;
                case "蓝":
                    blueCount++;
                    break;
            }
        }
        return "黄".repeat(yellowCount)+"红".repeat(redCount)+"蓝".repeat(blueCount);

    }

    console.log(sortStr3(inputStr));

Answer 22

Answer 23

Answer 24

Answer 25

const strList = '红蓝蓝黄红黄蓝红红黄红'
const sortRules = {'黄': 0, '红': 1, '蓝': 2,}
const list = [[],[],[]]
strList.split('').forEach(item => {list[sortRules[item]].push(item)})
list.reduce((pre, cur) => pre += cur.join(''), '')
//黄黄黄红红红红红蓝蓝蓝

Answer 26

function sortBalls (str) {
let arr = str.split('')
arr.sort((a, b) => {
return getNumByType(a) - getNumByType(b)
})

return arr.join('')

function getNumByType (type) {
  switch (type) {
    case '黄':
      return 1
    case '红':
      return 2
    default:
      return 3
  }
}

}