精华内容
下载资源
问答
  • 磁盘容量排序
    2022-04-19 00:13:33

    注意!答案仅作为参考(实际考试中下列代码通过用例100%,但不代表最优解)
    磁盘的容量单位有M,G,T这三个等级
    他们之间的换算关系为
    1T=1024G
    1G=1024M
    现在给定N块磁盘的容量
    请对他们按从小到大的顺序进行稳定排序
    例如给定5块盘容量
    1T,20M,3G,10G6T,3M12G9M
    排序后的结果为20M,3G,3M12G9M,1T,10G6T

    注意单位可以重复出现
    上述3M12G9M为 3M+12G+9M和 12M12G相等

    输入描述:
    输入第一行包含一个整数N
    2<=N<=100 ,表示磁盘的个数
    接下来的N行每行一个字符串 长度 (2<l<30)
    表示磁盘的容量
    有一个或多个格式为 mv的子串组成
    其中m表示容量大小 v表示容量单位
    例如

    磁盘容量m的范围 1~1024正整数
    容量单位v的范围包含题目中提到的M,G,T

    输出描述:
    输出N行
    表示N块磁盘容量排序后的结果

     示例1:
     输入
         3
         1G
         2G
         1024M
    
     输出
        1G
        1024M
        2G
    
    说明 1G和1024M容量相等,稳定排序要求保留他们原来的相对位置
    故1G在1024M前
    
     示例二:
     输入
          3
          2G4M
          3M2G
          1T
    
      输出
        3M2G
        2G4M
        1T
        说明1T大于2G4M大于3M2G
    
    import 
    更多相关内容
  • 磁盘容量单位常用的有M,G,T这三个等级,它们之间的换算关系为1T = 1024G,1G = 1024M,现在给定n块磁盘容量,请对它们按从小到大的顺序进行稳定排序

    【编程题目 | 100分】磁盘容量排序 [ 100 / 中等 ] 

    题目描述

    磁盘的容量单位常用的有
    M G T
    他们之间的换算关系为 1T =1024G 1G=1024M
    现在给定n块磁盘的容量,请对他们按从小到大的顺序进行稳定排序
    例如给定5块盘的容量
    5
    1T
    20M
    3G
    10G6T
    3M12G9M
    排序后的结果为
    20M
    3G
    3M12G9M
    1T
    10G6T
    注意单位可以重复出现
    上述3M 12G 9M表示的容量即为 3M 12G 9M 和12M 12G相等。

    输入描述

    • 输入第一行包含一个整数n,2<=n<=100 表示磁盘的个数
    • 接下来的n行,每行一个字符串,2<长度<30,表示磁盘的容量,由一个或多个格式为MV的子串组成,其中m表示容量大小,v表示容量单位,例如20M 1T。
    • 磁盘容量的范围1~1024的正整数,单位 M G T。。

    输出描述

    输出n行,表示n块磁盘容量排序后的结果。

    示例1

    输入

    3
    1G
    2G
    1024M

    输出

    1G
    1024M
    2G

    说明:稳定排序要求相等值保留原来位置

    示例2

    输入

    3
    2G4M
    3M2G
    1T

    输出

    3M2G
    2G4M
    1T

    思路分析

    • 根据磁盘容量从小到大的顺序,首先要统一单位,转为最小单位。
    • 从字符串读取容量,可以使用正则表达式获取。
    • 稳定排序要求相等值保留原来位置。

    参考代码

    注:题目网上找的,参考代码是练习用,仅供参考,并不保证用例通过率。

    import java.util.ArrayList;
    import java.util.Comparator;
    import java.util.List;
    import java.util.Scanner;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    /**
     * 磁盘容量排序
     */
    public class Test0023 {
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            int n = scanner.nextInt();
            String s = scanner.nextLine(); // nextInt后有空行,先读取一次
    
            String[] disksStr = new String[n];
            for (int i = 0; i < n; i++) {
                disksStr[i] = scanner.nextLine();
            }
    
            List<Disk> diskList = new ArrayList<>(n);
    
            Pattern pattern = Pattern.compile("[0-9]+|M|G|T");
            String str;
            String diskStr;
            for (int i = 0; i < n; i++) {
                diskStr = disksStr[i];
                Matcher matcher = pattern.matcher(diskStr);
                Disk disk = new Disk();
                disk.index = i;
                disk.capacityStr = diskStr;
    
                int total = 0; // 单个磁盘总容量,最小单位M
                int current = 0; // 一个单位的数据容量
                while (matcher.find()) {
                    str = matcher.group();
                    if (str.matches("[0-9]+")) {
                        // 数字
                        current = Integer.parseInt(str);
                    } else {
                        // 单位
                        if ("T".equals(str)) {
                            current *= (1024 * 1024);
                        } else if ("G".equals(str)) {
                            current *= 1024;
                        }
                        total += current;
                    }
                }
                disk.capacity = total;
                diskList.add(disk);
            }
    
            diskList.sort(Comparator.comparingInt((Disk o) -> o.capacity).thenComparingInt(o -> o.index));
    
            for (Disk disk : diskList) {
                System.out.println(disk.capacityStr);
            }
        }
    
        static class Disk {
            public int index;
            public String capacityStr;
            public int capacity;
        }
    }
    

    展开全文
  • 现在给定N块磁盘容量,请对他们按从小到大的顺序进行稳定排序 例如给定5块盘容量,1T,20M,3G,10G6T,3M12G9M,排序后的结果为20M,3G,3M12G9M,1T,10G6T 注意单位可以重复出现,上述3M12G9M为 3M+12G+9M和12M12G相等 ...

    题目描述:

    磁盘的容量单位有M,G,T这三个等级
    他们之间的换算关系为
    1T=1024G
    1G=1024M
    现在给定N块磁盘的容量,请对他们按从小到大的顺序进行稳定排序
    例如给定5块盘容量,1T,20M,3G,10G6T,3M12G9M,排序后的结果为20M,3G,3M12G9M,1T,10G6T
    注意单位可以重复出现,上述3M12G9M为 3M+12G+9M和12M12G相等



    输入描述:

    输入第一行包含一个整数N,2<=N<=100,表示磁盘的个数
    接下来的N行每行一个字符串 长度 (2<l<30),表示磁盘的容量
    有一个或多个格式为mv的子串组成,其中m表示容量大小v表示容量单位
    磁盘容量m的范围 1~1024正整数容量单位v的范围包含题目中提到的M,G,T



    输出描述:

    输出N行
    表示N块磁盘容量排序后的结果



    示例

    输入:

    3
    1G
    2G
    1024M
    输出:

    1G
    1024M
    2G
    说明:1G和1024M容量相等,稳定排序要求保留他们原来的相对位置,故1G在1024M前
    输入:

    3
    2G4M
    3M2G
    1T
    输出:

    3M2G
    2G4M
    1T
    说明:1T大于2G4M大于3M2G

     #解题想法:由于存在3M2G的情况,所以需要做求和统计,通过浮标和累加进行单位换算到M,
    然后再对字典排序,输出排序后的key
    
    
    
    while 1:
            try:
                m=3
                s="1G 2G 1024M 3M2G 2G4M 1T"
    
                d={}
    
                l=s.split(" ")
                for i in range(len(l)):
                   sum = 0
                   t=0
                   for j in range(len(l[i])) :
                       if  l[i][j]=="T":
                           sum=sum+ int(l[i][t:j]) * 1024 * 1024
                           t=j+1
                       if l[i][j] == "G":
                           sum = sum + int(l[i][t:j]) * 1024
                           t = j+1
                       if l[i][j] == "M":
                           sum = sum + int(l[i][t:j])
                           t = j+1
                   d[l[i]]=sum
                e=sorted(d.items(),key=lambda x:x[1],reverse=False)
                for i in e:
                    print(i[0])
    
                break
            except Exception as e:
                print(e)
                break

    展开全文
  • 现在给定N块磁盘容量,请对他们按从小到大的顺序进行稳定排序 例如给定5块盘容量,1T,20M,3G,10G6T,3M12G9M,排序后的结果为20M,3G,3M12G9M,1T,10G6T 注意单位可以重复出现,上述3M12G9M为 3M+12G+9M和12M12G相等 ...

    🌈 Scala 实现

    题目描述:

    • 磁盘的容量单位有M,G,T这三个等级
    • 他们之间的换算关系为
      • 1T=1024G
      • 1G=1024M
    • 现在给定N块磁盘的容量,请对他们按从小到大的顺序进行稳定排序
    • 例如给定5块盘容量,1T,20M,3G,10G6T,3M12G9M,排序后的结果为20M,3G,3M12G9M,1T,10G6T
    • 注意单位可以重复出现,上述3M12G9M为 3M+12G+9M和12M12G相等

    输入描述:

    • 输入第一行包含一个整数N,2<=N<=100,表示磁盘的个数
    • 接下来的N行每行一个字符串 长度 (2<l<30),表示磁盘的容量
    • 有一个或多个格式为mv的子串组成,其中m表示容量大小v表示容量单位
    • 磁盘容量m的范围 1~1024正整数容量单位v的范围包含题目中提到的M,G,T

    输出描述:

    • 输出N行
    • 表示N块磁盘容量排序后的结果

    示例

    输入:

    • 3
    • 1G
    • 2G
    • 1024M

    输出:

    • 1G
    • 1024M
    • 2G

    说明:

    • 1G和1024M容量相等,稳定排序要求保留他们原来的相对位置,故1G在1024M前

    输入:

    • 3
    • 2G4M
    • 3M2G
    • 1T

    输出:

    • 3M2G
    • 2G4M
    • 1T

    说明:

    • 1T大于2G4M大于3M2G

    代码:

    def main(args: Array[String]): Unit = {
    
        // 获取输入
        val N = StdIn.readLine().toInt
        // 获取每一次磁盘容量
        var buffer = new ListBuffer[String]
        for (i <- 1 to N) {
            buffer += StdIn.readLine()
        }
    
        buffer.sortWith((o1, o2) => {
            val o1F = formatted(o1)
            val o2F = formatted(o2)
            if (o1F != o2F) o1F.compareTo(o2F) < 0 else o1F.compareTo(o2F) > 0
        }).foreach(println)
    
    }
    
    // 实现单位换算,同一换算为 M
    def formatted(str: String): Int = {
        var sum = 0
        var tmpIndex = -1
        for (i <- 0 to str.length - 1) {
            if (str(i) == 'M') {
                sum += Integer.parseInt(str.substring(tmpIndex + 1, i))
                tmpIndex = i
            } else if (str(i) == 'G') {
                sum += Integer.parseInt(str.substring(tmpIndex + 1, i)) * 1024
                tmpIndex = i
            } else if (str(i) == 'T') {
                sum += Integer.parseInt(str.substring(tmpIndex + 1, i)) * 1024 * 1024
                tmpIndex = i
            }
        }
        sum
    }
    

     


    ❤️ END ❤️
    展开全文
  • 题目52 磁盘容量排序(ok)

    千次阅读 2021-10-18 09:30:59
    现在给定N块磁盘容量,请对他们按从小到大的顺序进行稳定排序 例如给定5块盘容量:1T,20M,3G,10G6T,3M12G9M 排序后的结果为 20M,3G,3M12G9M,1T,10G6T 注意单位可以重复出现 上述3M12G9M为 3M+12G+9M和 12M12G相等...
  • * 磁盘容量排序 * 磁盘的容量单位常用的有M,G,T这三个等级,它们之间的换算关系为1T = 1024G,1G = * 1024M,现在给定n块磁盘的容量,请对它们按从小到大的顺序进行稳定排序,例如给定5块盘的容量,1T,20M...
  • 华为机试od社招刷题攻略-磁盘容量排序
  • 文章目录题目描述示例 1参考代码在输入时处理数据...磁盘容量单位常用的有有 M, G, T 这三个等级,它们之间的换算关系是 1T=1000G,1G=1000M,现在给定 n 块磁盘容量,请对它们按从小到大的顺序进行排序,......
  • 标题:磁盘容量排序| 磁盘的容量单位常用的有M,G,T这三个等级,它们之间的换算关系为1T = 1024G,1G = 1024M,现在给定n块磁盘的容量,请对它们按从小到大的顺序进行稳定排序,例如给定5块盘的容量,1T,20M,3G,...
  • 磁盘容量单位常用的有M,G,T这三个等级,它们之间的换算关系为1T = 1024G,1G = 1024M,需要针对输入的磁盘大小描述进行排序
  • 标题:磁盘容量排序| 磁盘的容量单位常用的有M,G,T这三个等级,它们之间的换算关系为1T = 1024G,1G = 1024M,现在给定n块磁盘的容量,请对它们按从小到大的顺序进行稳定排序,例如给定5块盘的容量,1T,20M,3G,...
  • 华为OD机试 :磁盘容量排序

    千次阅读 2020-03-08 22:34:09
    第一道题是磁盘容量排序,其实挺简单的,但我一直没调试好,导致心态直接崩了,后面第二题也没看,看来以后要好好刷题才行。 文章目录1.题目大意2.样例输入3.样例输出4.代码实现 1.题目大意 磁盘的容量单位有M、G、...
  • 华为笔试题-磁盘容量排序

    千次阅读 2020-12-15 11:44:59
    磁盘的容量单位有M、G、T,其关系为 1T = 1000G、1G = 1000M,如样例所示先输入磁盘的个数,再依次输入磁盘的容量大小,然后按照从小到大的顺序对磁盘容量进行排序并输出。 例如: 输入: 3 20M 1T 300G 输出: 20M ...
  • 磁盘的容量单位有M、G、T,其关系为 1T = 1000G、1G = 1000M,如样例所示先输入磁盘的个数,再依次输入磁盘的容量大小,然后按照从小到大的顺序对磁盘容量进行排序并输出。 例如: 输入: 3 20M 1T 300G 输出: 20M...
  • python题目52:磁盘容量排序

    千次阅读 2021-11-25 01:17:31
    /磁盘容量单位有M,G,T这三个等级 他们之间的换算关系为 1T=1024G 1G=1024M 现在给定N块磁盘容量 请对他们按从小到大的顺序进行稳定排序 例如给定5块盘容量 1T,20M,3G,10G6T,3M12G9M 排序后的结果为20M,3G,3M12G9...
  • 现在给定n块磁盘容量,请对它们按容量从小到大的顺序进行稳定排序,例如给定5块盘的容量,1T,20M,3G,10G6T,3M12G9M,排序后的结果为20M,3G,3M12G9M,1T,10G6T。输入第一行包含一个整数n (2
  • 华为OD 笔试题 磁盘容量排序问题

    千次阅读 2021-02-04 00:20:36
    磁盘的容量单位有M、G、T,其关系为 1T = 1000G、1G = 1000M,如样例所示先输入磁盘的个数,再依次输入磁盘的容量大小,然后按照从小到大的顺序对磁盘容量进行排序并输出。 例如 输入 3 20M 1T 300G 输出 20M 300G ...
  • 华为OD笔试 磁盘容量排序

    千次阅读 2020-04-05 15:45:58
    题目:磁盘的容量单位有M、G、T,其关系为 1T = 1000G、1G = 1000M,如样例所示先输入磁盘的个数,再依次输入磁盘的容量大小,然后按照从小到大的顺序对磁盘容量进行排序并输出。 笔试的时候没做对~ 当时想的是,把...
  • 主要介绍了C语言对磁盘文件进行快速排序简单实例的相关资料,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 56,082
精华内容 22,432
关键字:

磁盘容量排序