(B卷,100分)- 分班（Java & JS & Python）

题目描述

幼儿园两个班的小朋友在排队时混在了一起，每位小朋友都知道自己是否与前面一位小朋友同班，请你帮忙把同班的小朋友找出来。

小朋友的编号是整数，与前一位小朋友同班用Y表示，不同班用N表示。

输入描述

输入为空格分开的小朋友编号和是否同班标志。

比如：6/N 2/Y 3/N 4/Y，表示4位小朋友，2和6同班，3和2不同班，4和3同班。

其中，小朋友总数不超过999，每个小朋友编号大于0，小于等于999。

不考虑输入格式错误问题。

输出描述

输出为两行，每一行记录一个班小朋友的编号，编号用空格分开，且：

1. 编号需按照大小升序排列，分班记录中第一个编号小的排在第一行。
2. 若只有一个班的小朋友，第二行为空行。
3. 若输入不符合要求，则直接输出字符串ERROR。

用例

题目解析

本题应该只是逻辑分析题。

我的解题思路如下：

定义一个标志preBelongToOne，记录前一个小朋友是否属于一班，初始时为false，表示不属于一班。

然后遍历排队的小朋友，被遍历的小朋友为kid，然后kid的标志如果是Y，则表示和前面一个小朋友同班，否则不同班。我们定义一个标志 isSameWithPre，来记录当前kid是否和前面一个小朋友同班。

• 如果 preBelongToOne == true，则前一个小朋友属于一班：

1. 若 isSameWithPre == true，则当前小朋友也属于一班
2. 若 isSameWithPre == false，则当前小朋友属于二班，同时当前小朋友变为新的前一个小朋友，即需要更新preBelongToOne = false

• 如果 preBelongToOne == false，则前一个小朋友属于二班：

1. 若 isSameWithPre == true，则当前小朋友也属于二班
2. 若 isSameWithPre == false，则当前小朋友属于一班，同时当前小朋友变为新的前一个小朋友，即需要更新preBelongToOne = true

之后就是关注题目的校验要求和打印要求。

关于校验要求，如果不符合下面要求，打印“None”：

• 小朋友总数不超过999
• 999 >= 小朋友编号 > 0

关于打印要求：

• 一班、二班需要各自升序，且比较第一个小朋友编号小的，则首先打印
• 如果二班没有小朋友，则打印空行

Java算法源码

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import java.util.StringJoiner;

public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    getResult(sc.nextLine());
  }

  public static void getResult(String str) {
    String[][] kids = Arrays.stream(str.split(" ")).map(s -> s.split("/")).toArray(String[][]::new);

    // 小朋友总数不超过999
    if (kids.length > 999) {
      // 若输入不符合要求，则直接输出字符串ERROR
      System.out.println("ERROR");
      return;
    }

    ArrayList<Integer> one = new ArrayList<>();
    ArrayList<Integer> two = new ArrayList<>();

    // 第一个小朋友前面没有人，因此第一个小朋友不可能和前面不存在的人同班
    if ("Y".equals(kids[0][1])) {
      System.out.println("ERROR");
      return;
    }

    boolean preBelongToOne = false;

    for (String[] kid : kids) {
      int id = Integer.parseInt(kid[0]);

      // 每个小朋友编号大于0，小于等于999
      if (id <= 0 || id > 999) {
        // 若输入不符合要求，则直接输出字符串ERROR
        System.out.println("ERROR");
        return;
      }

      boolean isSameWithPre = "Y".equals(kid[1]);

      if (preBelongToOne) {
        if (isSameWithPre) {
          one.add(id);
        } else {
          two.add(id);
          preBelongToOne = false;
        }
      } else {
        if (isSameWithPre) {
          two.add(id);
        } else {
          one.add(id);
          preBelongToOne = true;
        }
      }
    }

    // 编号需按照大小升序排列
    one.sort((a, b) -> a - b);
    String oneStr = getStr(one);

    // 若只有一个班的小朋友，第二行为空行。
    if (two.size() == 0) {
      System.out.println(oneStr);
      System.out.println("");
      return;
    }

    // 编号需按照大小升序排列
    two.sort((a, b) -> a - b);
    String twoStr = getStr(two);

    // 分班记录中第一个编号小的排在第一行
    if (one.get(0) < two.get(0)) {
      System.out.println(oneStr);
      System.out.println(twoStr);
    } else {
      System.out.println(twoStr);
      System.out.println(oneStr);
    }
  }

  public static String getStr(ArrayList<Integer> list) {
    StringJoiner sj = new StringJoiner(" ");
    for (Integer v : list) {
      sj.add(v + "");
    }
    return sj.toString();
  }
}

JS算法源码

/* JavaScript Node ACM模式 控制台输入获取 */
const readline = require("readline");

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

rl.on("line", (line) => {
  getResult(line);
});

function getResult(str) {
  const kids = str.split(" ").map((s) => s.split("/"));

  // 小朋友总数不超过999
  if (kids.length > 999) {
    // 若输入不符合要求，则直接输出字符串ERROR
    console.log("ERROR");
    return;
  }

  const one = [];
  const two = [];
  
  // 第一个小朋友前面没有人，因此第一个小朋友不可能和前面不存在的人同班
  if(kids[0][1] == "Y") {
  console.log("ERROR");
  return;
  }

  let preBelongToOne = false;

  for (let kid of kids) {
    const id = parseInt(kid[0]);

    // 每个小朋友编号大于0，小于等于999
    if (id <= 0 || id > 999) {
      // 若输入不符合要求，则直接输出字符串ERROR
      console.log("ERROR");
      return;
    }

    const isSameWithPre = "Y" == kid[1];

    if (preBelongToOne) {
      if (isSameWithPre) {
        one.push(id);
      } else {
        two.push(id);
        preBelongToOne = false;
      }
    } else {
      if (isSameWithPre) {
        two.push(id);
      } else {
        one.push(id);
        preBelongToOne = true;
      }
    }
  }

  // 编号需按照大小升序排列
  one.sort((a, b) => a - b);
  const oneStr = one.join(" ");

  // 若只有一个班的小朋友，第二行为空行。
  if (two.length == 0) {
    console.log(oneStr);
    console.log("");
    return;
  }

  // 编号需按照大小升序排列
  two.sort((a, b) => a - b);
  const twoStr = two.join(" ");

  // 分班记录中第一个编号小的排在第一行
  if (one[0] < two[0]) {
    console.log(oneStr);
    console.log(twoStr);
  } else {
    console.log(twoStr);
    console.log(oneStr);
  }
}

Python算法源码

# 输入获取
s = input()


# 算法入口
def getResult():
    kids = list(map(lambda x: x.split("/"), s.split()))

    # 小朋友总数不超过999
    if len(kids) > 999:
        # 若输入不符合要求，则直接输出字符串ERROR
        print("ERROR")
        return

    one = []
    two = []

    # 第一个小朋友前面没有人，因此第一个小朋友不可能和前面不存在的人同班
    if kids[0][1] == "Y":
        print("ERROR")
        return

    preBelongToOne = False

    for kid in kids:
        idx = int(kid[0])

        # 每个小朋友编号大于0，小于等于999
        if idx <= 0 or idx > 999:
            # 若输入不符合要求，则直接输出字符串ERROR
            print("ERROR")
            return

        isSameWithPre = "Y" == kid[1]

        if preBelongToOne:
            if isSameWithPre:
                one.append(idx)
            else:
                two.append(idx)
                preBelongToOne = False
        else:
            if isSameWithPre:
                two.append(idx)
            else:
                one.append(idx)
                preBelongToOne = True

    # 编号需按照大小升序排列
    one.sort()
    oneStr = " ".join(map(str, one))

    # 若只有一个班的小朋友，第二行为空行。
    if len(two) == 0:
        print(oneStr)
        print("")
        return

    # 编号需按照大小升序排列
    two.sort()
    twoStr = " ".join(map(str, two))

    # 分班记录中第一个编号小的排在第一行
    if one[0] < two[0]:
        print(oneStr)
        print(twoStr)
    else:
        print(twoStr)
        print(oneStr)


# 算法调用
getResult()