[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6XEJZ2EM534TK7STMCW6R5S":3,"skill-same:01M6XEJZ2EM534TK7STMCW6R5S":62},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":15,"categories":16,"keywords":17,"publishedAt":36,"linkOnly":37,"markdownContent":38,"markdownBody":39,"frontMatter":40,"refName":41,"commitSha":42,"skillDirectory":43,"forksCount":13,"repositoryHtmlUrl":44,"repositoryHomepageUrl":6,"ownerHtmlUrl":45,"ownerBlogUrl":6,"ownerDescription":46,"updatedAt":47,"install":48,"resources":61},"01M6XEJZ2EM534TK7STMCW6R5S","python-scala-collections",null,"Guide for translating Python collection operations to idiomatic Scala. Use when converting Python code that uses lists, dictionaries, sets, or involves collection transformations like map, filter, reduce, sorting, and aggregations.","Waaaalnut\u002Fskillsbench","Waaaalnut","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F103995656?v=4","01M6XCS9K1V51EY3JMB7DGMX24","01M6XCS9Q4WPW88W62C55G1H44",0,"Apache-2.0","https:\u002F\u002Fgithub.com\u002FWaaaalnut\u002Fskillsbench\u002Fblob\u002Fmain\u002Ftasks\u002Fpython-scala-translation\u002Fenvironment\u002Fskills\u002Fpython-scala-collections\u002FSKILL.md",[],[18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35],"scala","python","python scala collections","collections","when","idiomatic","dictionaries","reduce","for","python code","sorting","filter","map","use","guide","operations","collection","code","2026-11-10 10:12:30",false,"---\nname: python-scala-collections\ndescription: Guide for translating Python collection operations to idiomatic Scala. Use when converting Python code that uses lists, dictionaries, sets, or involves collection transformations like map, filter, reduce, sorting, and aggregations.\n---\n\n# Python to Scala Collections Translation\n\n## Collection Creation\n\n### Lists\n\n```python\n# Python\nempty = []\nnums = [1, 2, 3]\nrepeated = [0] * 5\nfrom_range = list(range(1, 11))\n```\n\n```scala\n\u002F\u002F Scala\nval empty = List.empty[Int]  \u002F\u002F or List[Int]()\nval nums = List(1, 2, 3)\nval repeated = List.fill(5)(0)\nval fromRange = (1 to 10).toList\n```\n\n### Dictionaries → Maps\n\n```python\n# Python\nempty = {}\nperson = {\"name\": \"Alice\", \"age\": 30}\nfrom_pairs = dict([(\"a\", 1), (\"b\", 2)])\n```\n\n```scala\n\u002F\u002F Scala\nval empty = Map.empty[String, Int]\nval person = Map(\"name\" -> \"Alice\", \"age\" -> 30)\nval fromPairs = List((\"a\", 1), (\"b\", 2)).toMap\n```\n\n### Sets\n\n```python\n# Python\nempty = set()\nnums = {1, 2, 3}\nfrom_list = set([1, 2, 2, 3])\n```\n\n```scala\n\u002F\u002F Scala\nval empty = Set.empty[Int]\nval nums = Set(1, 2, 3)\nval fromList = List(1, 2, 2, 3).toSet\n```\n\n## Transformation Operations\n\n### Map\n\n```python\n# Python\ndoubled = [x * 2 for x in nums]\ndoubled = list(map(lambda x: x * 2, nums))\n```\n\n```scala\n\u002F\u002F Scala\nval doubled = nums.map(_ * 2)\nval doubled = nums.map(x => x * 2)\n```\n\n### Filter\n\n```python\n# Python\nevens = [x for x in nums if x % 2 == 0]\nevens = list(filter(lambda x: x % 2 == 0, nums))\n```\n\n```scala\n\u002F\u002F Scala\nval evens = nums.filter(_ % 2 == 0)\nval evens = nums.filter(x => x % 2 == 0)\n```\n\n### Reduce\u002FFold\n\n```python\n# Python\nfrom functools import reduce\ntotal = reduce(lambda a, b: a + b, nums)\ntotal = sum(nums)\nproduct = reduce(lambda a, b: a * b, nums, 1)\n```\n\n```scala\n\u002F\u002F Scala\nval total = nums.reduce(_ + _)\nval total = nums.sum\nval product = nums.foldLeft(1)(_ * _)\n\u002F\u002F Use foldLeft when you need an initial value\n```\n\n### FlatMap\n\n```python\n# Python\nnested = [[1, 2], [3, 4]]\nflat = [x for sublist in nested for x in sublist]\n```\n\n```scala\n\u002F\u002F Scala\nval nested = List(List(1, 2), List(3, 4))\nval flat = nested.flatten\n\u002F\u002F or with transformation:\nval flat = nested.flatMap(identity)\n```\n\n## Common Operations\n\n### Length\u002FSize\n\n| Python | Scala |\n|--------|-------|\n| `len(lst)` | `lst.length` or `lst.size` |\n| `len(dct)` | `map.size` |\n\n### Access\n\n| Python | Scala |\n|--------|-------|\n| `lst[0]` | `lst(0)` or `lst.head` |\n| `lst[-1]` | `lst.last` |\n| `lst[1:3]` | `lst.slice(1, 3)` |\n| `lst[:3]` | `lst.take(3)` |\n| `lst[3:]` | `lst.drop(3)` |\n| `dct[\"key\"]` | `map(\"key\")` (throws if missing) |\n| `dct.get(\"key\")` | `map.get(\"key\")` (returns Option) |\n| `dct.get(\"key\", default)` | `map.getOrElse(\"key\", default)` |\n\n### Membership\n\n```python\n# Python\nif x in lst: ...\nif key in dct: ...\n```\n\n```scala\n\u002F\u002F Scala\nif (lst.contains(x)) ...\nif (map.contains(key)) ...\n```\n\n### Concatenation\n\n```python\n# Python\ncombined = list1 + list2\nmerged = {**dict1, **dict2}\n```\n\n```scala\n\u002F\u002F Scala\nval combined = list1 ++ list2\nval merged = map1 ++ map2\n```\n\n### Sorting\n\n```python\n# Python\nsorted_list = sorted(items)\nsorted_desc = sorted(items, reverse=True)\nsorted_by_key = sorted(items, key=lambda x: x.name)\nitems.sort()  # in-place\n```\n\n```scala\n\u002F\u002F Scala\nval sortedList = items.sorted\nval sortedDesc = items.sorted(Ordering[Int].reverse)\nval sortedByKey = items.sortBy(_.name)\n\u002F\u002F Note: Scala collections are immutable by default, no in-place sort\n```\n\n### Grouping\n\n```python\n# Python\nfrom itertools import groupby\nfrom collections import defaultdict\n\n# Group by key\ngrouped = defaultdict(list)\nfor item in items:\n    grouped[item.category].append(item)\n```\n\n```scala\n\u002F\u002F Scala\nval grouped = items.groupBy(_.category)\n\u002F\u002F Returns Map[Category, List[Item]]\n```\n\n### Aggregations\n\n```python\n# Python\ntotal = sum(nums)\nminimum = min(nums)\nmaximum = max(nums)\naverage = sum(nums) \u002F len(nums)\n```\n\n```scala\n\u002F\u002F Scala\nval total = nums.sum\nval minimum = nums.min\nval maximum = nums.max\nval average = nums.sum.toDouble \u002F nums.length\n```\n\n### Finding Elements\n\n```python\n# Python\nfirst_even = next((x for x in nums if x % 2 == 0), None)\nall_evens = all(x % 2 == 0 for x in nums)\nany_even = any(x % 2 == 0 for x in nums)\n```\n\n```scala\n\u002F\u002F Scala\nval firstEven = nums.find(_ % 2 == 0)  \u002F\u002F Returns Option[Int]\nval allEvens = nums.forall(_ % 2 == 0)\nval anyEven = nums.exists(_ % 2 == 0)\n```\n\n### Zipping\n\n```python\n# Python\npairs = list(zip(list1, list2))\nindexed = list(enumerate(items))\n```\n\n```scala\n\u002F\u002F Scala\nval pairs = list1.zip(list2)\nval indexed = items.zipWithIndex\n```\n\n## Dictionary\u002FMap Operations\n\n```python\n# Python\nkeys = list(dct.keys())\nvalues = list(dct.values())\nitems = list(dct.items())\n\nfor key, value in dct.items():\n    process(key, value)\n\n# Update\ndct[\"new_key\"] = value\nupdated = {**dct, \"new_key\": value}\n```\n\n```scala\n\u002F\u002F Scala\nval keys = map.keys.toList\nval values = map.values.toList\nval items = map.toList  \u002F\u002F List[(K, V)]\n\nfor ((key, value) \u003C- map) {\n  process(key, value)\n}\n\n\u002F\u002F Update (creates new map, immutable)\nval updated = map + (\"new_key\" -> value)\nval updated = map.updated(\"new_key\", value)\n```\n\n## Mutable vs Immutable\n\nPython collections are mutable by default. Scala defaults to immutable.\n\n```python\n# Python - mutable\nlst.append(4)\nlst.extend([5, 6])\ndct[\"key\"] = value\n```\n\n```scala\n\u002F\u002F Scala - immutable (creates new collection)\nval newList = lst :+ 4\nval newList = lst ++ List(5, 6)\nval newMap = map + (\"key\" -> value)\n\n\u002F\u002F Scala - mutable (when needed)\nimport scala.collection.mutable\nval mutableList = mutable.ListBuffer(1, 2, 3)\nmutableList += 4\nmutableList ++= List(5, 6)\n```\n\n## enum type\n\nUse UPPERCASE for enum and constant names in Scala (same as in Python) E.g.\n\n```python\nclass TokenType(Enum):\n    STRING = \"string\"\n    NUMERIC = \"numeric\"\n    TEMPORAL = \"temporal\"\n    STRUCTURED = \"structured\"\n    BINARY = \"binary\"\n    NULL = \"null\"\n```\n\n```scala\nobject BaseType {\n  case object STRING extends BaseType { val value = \"string\" }\n  case object NUMERIC extends BaseType { val value = \"numeric\" }\n  case object TEMPORAL extends BaseType { val value = \"temporal\" }\n  case object STRUCTURED extends BaseType { val value = \"structured\" }\n  case object BINARY extends BaseType { val value = \"binary\" }\n}\n```\n\nDo not use PascalCase. E.g. the following is against the principle:\n\n```scala\nobject BaseType {\n  case object String extends BaseType { val value = \"string\" }\n}\n```\n","# Python to Scala Collections Translation\n\n## Collection Creation\n\n### Lists\n\n```python\n# Python\nempty = []\nnums = [1, 2, 3]\nrepeated = [0] * 5\nfrom_range = list(range(1, 11))\n```\n\n```scala\n\u002F\u002F Scala\nval empty = List.empty[Int]  \u002F\u002F or List[Int]()\nval nums = List(1, 2, 3)\nval repeated = List.fill(5)(0)\nval fromRange = (1 to 10).toList\n```\n\n### Dictionaries → Maps\n\n```python\n# Python\nempty = {}\nperson = {\"name\": \"Alice\", \"age\": 30}\nfrom_pairs = dict([(\"a\", 1), (\"b\", 2)])\n```\n\n```scala\n\u002F\u002F Scala\nval empty = Map.empty[String, Int]\nval person = Map(\"name\" -> \"Alice\", \"age\" -> 30)\nval fromPairs = List((\"a\", 1), (\"b\", 2)).toMap\n```\n\n### Sets\n\n```python\n# Python\nempty = set()\nnums = {1, 2, 3}\nfrom_list = set([1, 2, 2, 3])\n```\n\n```scala\n\u002F\u002F Scala\nval empty = Set.empty[Int]\nval nums = Set(1, 2, 3)\nval fromList = List(1, 2, 2, 3).toSet\n```\n\n## Transformation Operations\n\n### Map\n\n```python\n# Python\ndoubled = [x * 2 for x in nums]\ndoubled = list(map(lambda x: x * 2, nums))\n```\n\n```scala\n\u002F\u002F Scala\nval doubled = nums.map(_ * 2)\nval doubled = nums.map(x => x * 2)\n```\n\n### Filter\n\n```python\n# Python\nevens = [x for x in nums if x % 2 == 0]\nevens = list(filter(lambda x: x % 2 == 0, nums))\n```\n\n```scala\n\u002F\u002F Scala\nval evens = nums.filter(_ % 2 == 0)\nval evens = nums.filter(x => x % 2 == 0)\n```\n\n### Reduce\u002FFold\n\n```python\n# Python\nfrom functools import reduce\ntotal = reduce(lambda a, b: a + b, nums)\ntotal = sum(nums)\nproduct = reduce(lambda a, b: a * b, nums, 1)\n```\n\n```scala\n\u002F\u002F Scala\nval total = nums.reduce(_ + _)\nval total = nums.sum\nval product = nums.foldLeft(1)(_ * _)\n\u002F\u002F Use foldLeft when you need an initial value\n```\n\n### FlatMap\n\n```python\n# Python\nnested = [[1, 2], [3, 4]]\nflat = [x for sublist in nested for x in sublist]\n```\n\n```scala\n\u002F\u002F Scala\nval nested = List(List(1, 2), List(3, 4))\nval flat = nested.flatten\n\u002F\u002F or with transformation:\nval flat = nested.flatMap(identity)\n```\n\n## Common Operations\n\n### Length\u002FSize\n\n| Python | Scala |\n|--------|-------|\n| `len(lst)` | `lst.length` or `lst.size` |\n| `len(dct)` | `map.size` |\n\n### Access\n\n| Python | Scala |\n|--------|-------|\n| `lst[0]` | `lst(0)` or `lst.head` |\n| `lst[-1]` | `lst.last` |\n| `lst[1:3]` | `lst.slice(1, 3)` |\n| `lst[:3]` | `lst.take(3)` |\n| `lst[3:]` | `lst.drop(3)` |\n| `dct[\"key\"]` | `map(\"key\")` (throws if missing) |\n| `dct.get(\"key\")` | `map.get(\"key\")` (returns Option) |\n| `dct.get(\"key\", default)` | `map.getOrElse(\"key\", default)` |\n\n### Membership\n\n```python\n# Python\nif x in lst: ...\nif key in dct: ...\n```\n\n```scala\n\u002F\u002F Scala\nif (lst.contains(x)) ...\nif (map.contains(key)) ...\n```\n\n### Concatenation\n\n```python\n# Python\ncombined = list1 + list2\nmerged = {**dict1, **dict2}\n```\n\n```scala\n\u002F\u002F Scala\nval combined = list1 ++ list2\nval merged = map1 ++ map2\n```\n\n### Sorting\n\n```python\n# Python\nsorted_list = sorted(items)\nsorted_desc = sorted(items, reverse=True)\nsorted_by_key = sorted(items, key=lambda x: x.name)\nitems.sort()  # in-place\n```\n\n```scala\n\u002F\u002F Scala\nval sortedList = items.sorted\nval sortedDesc = items.sorted(Ordering[Int].reverse)\nval sortedByKey = items.sortBy(_.name)\n\u002F\u002F Note: Scala collections are immutable by default, no in-place sort\n```\n\n### Grouping\n\n```python\n# Python\nfrom itertools import groupby\nfrom collections import defaultdict\n\n# Group by key\ngrouped = defaultdict(list)\nfor item in items:\n    grouped[item.category].append(item)\n```\n\n```scala\n\u002F\u002F Scala\nval grouped = items.groupBy(_.category)\n\u002F\u002F Returns Map[Category, List[Item]]\n```\n\n### Aggregations\n\n```python\n# Python\ntotal = sum(nums)\nminimum = min(nums)\nmaximum = max(nums)\naverage = sum(nums) \u002F len(nums)\n```\n\n```scala\n\u002F\u002F Scala\nval total = nums.sum\nval minimum = nums.min\nval maximum = nums.max\nval average = nums.sum.toDouble \u002F nums.length\n```\n\n### Finding Elements\n\n```python\n# Python\nfirst_even = next((x for x in nums if x % 2 == 0), None)\nall_evens = all(x % 2 == 0 for x in nums)\nany_even = any(x % 2 == 0 for x in nums)\n```\n\n```scala\n\u002F\u002F Scala\nval firstEven = nums.find(_ % 2 == 0)  \u002F\u002F Returns Option[Int]\nval allEvens = nums.forall(_ % 2 == 0)\nval anyEven = nums.exists(_ % 2 == 0)\n```\n\n### Zipping\n\n```python\n# Python\npairs = list(zip(list1, list2))\nindexed = list(enumerate(items))\n```\n\n```scala\n\u002F\u002F Scala\nval pairs = list1.zip(list2)\nval indexed = items.zipWithIndex\n```\n\n## Dictionary\u002FMap Operations\n\n```python\n# Python\nkeys = list(dct.keys())\nvalues = list(dct.values())\nitems = list(dct.items())\n\nfor key, value in dct.items():\n    process(key, value)\n\n# Update\ndct[\"new_key\"] = value\nupdated = {**dct, \"new_key\": value}\n```\n\n```scala\n\u002F\u002F Scala\nval keys = map.keys.toList\nval values = map.values.toList\nval items = map.toList  \u002F\u002F List[(K, V)]\n\nfor ((key, value) \u003C- map) {\n  process(key, value)\n}\n\n\u002F\u002F Update (creates new map, immutable)\nval updated = map + (\"new_key\" -> value)\nval updated = map.updated(\"new_key\", value)\n```\n\n## Mutable vs Immutable\n\nPython collections are mutable by default. Scala defaults to immutable.\n\n```python\n# Python - mutable\nlst.append(4)\nlst.extend([5, 6])\ndct[\"key\"] = value\n```\n\n```scala\n\u002F\u002F Scala - immutable (creates new collection)\nval newList = lst :+ 4\nval newList = lst ++ List(5, 6)\nval newMap = map + (\"key\" -> value)\n\n\u002F\u002F Scala - mutable (when needed)\nimport scala.collection.mutable\nval mutableList = mutable.ListBuffer(1, 2, 3)\nmutableList += 4\nmutableList ++= List(5, 6)\n```\n\n## enum type\n\nUse UPPERCASE for enum and constant names in Scala (same as in Python) E.g.\n\n```python\nclass TokenType(Enum):\n    STRING = \"string\"\n    NUMERIC = \"numeric\"\n    TEMPORAL = \"temporal\"\n    STRUCTURED = \"structured\"\n    BINARY = \"binary\"\n    NULL = \"null\"\n```\n\n```scala\nobject BaseType {\n  case object STRING extends BaseType { val value = \"string\" }\n  case object NUMERIC extends BaseType { val value = \"numeric\" }\n  case object TEMPORAL extends BaseType { val value = \"temporal\" }\n  case object STRUCTURED extends BaseType { val value = \"structured\" }\n  case object BINARY extends BaseType { val value = \"binary\" }\n}\n```\n\nDo not use PascalCase. E.g. the following is against the principle:\n\n```scala\nobject BaseType {\n  case object String extends BaseType { val value = \"string\" }\n}\n```\n",{"name":5,"description":7},"main","7eeb258ada72b7f58119b0e7a2c00ea89d9beedd","tasks\u002Fpython-scala-translation\u002Fenvironment\u002Fskills\u002Fpython-scala-collections","https:\u002F\u002Fgithub.com\u002FWaaaalnut\u002Fskillsbench","https:\u002F\u002Fgithub.com\u002FWaaaalnut","student of Zhejiang University","2026-04-21 23:16:23",{"source":8,"skillName":5,"commands":49,"prompt":59,"zipAvailable":60},[50,53,56],{"tool":51,"command":52},"npx","npx skills add Waaaalnut\u002Fskillsbench --skill python-scala-collections",{"tool":54,"command":55},"bunx","bunx skills add Waaaalnut\u002Fskillsbench --skill python-scala-collections",{"tool":57,"command":58},"pnpm","pnpm dlx skills add Waaaalnut\u002Fskillsbench --skill python-scala-collections","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FWaaaalnut\u002Fskillsbench\u002Fblob\u002Fmain\u002Ftasks\u002Fpython-scala-translation\u002Fenvironment\u002Fskills\u002Fpython-scala-collections\u002FSKILL.md",true,[],[63,77,92,117,139,157],{"skillNo":64,"name":65,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":66,"categories":67,"keywords":73,"publishedAt":36},"01M6XEWMJ6VY3ZC53MPDCPG3GH","data-reconciliation","https:\u002F\u002Fgithub.com\u002FWaaaalnut\u002Fskillsbench\u002Fblob\u002Fmain\u002Ftasks\u002Fxlsx-recover-data\u002Fenvironment\u002Fskills\u002Fdata-reconciliation\u002FSKILL.md",[68],{"categoryNo":69,"categoryName":70,"taxonomyType":71,"taxonomyTypeDesc":72},"01JBSEEDCAT000000000000033","数据分析师","PROFESSION","适用职业",[74,75,76],"data reconciliation","reconciliation","data",{"skillNo":78,"name":79,"nameZh":6,"description":80,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":81,"categories":82,"keywords":83,"publishedAt":36},"01M6XEW8MNPMF1KRXV6ATGFRQF","speech-to-text","Transcribe video to timestamped text using Whisper tiny model (pre-installed).","https:\u002F\u002Fgithub.com\u002FWaaaalnut\u002Fskillsbench\u002Fblob\u002Fmain\u002Ftasks\u002Fvideo-tutorial-indexer\u002Fenvironment\u002Fskills\u002Fspeech-to-text\u002FSKILL.md",[],[84,85,86,87,88,89,90,91],"speech","text","speech to text","transcribe video","whisper","model","Video","transcribe",{"skillNo":93,"name":94,"nameZh":6,"description":95,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":96,"categories":97,"keywords":103,"publishedAt":36},"01M6XEW3FQZP0T1RKQQJFXVY9T","video-processor","Process videos by removing segments and concatenating remaining parts. Use when you need to remove detected pauses\u002Fopenings from videos, create highlight reels, or batch process segment removals using ffmpeg filter_complex.","https:\u002F\u002Fgithub.com\u002FWaaaalnut\u002Fskillsbench\u002Fblob\u002Fmain\u002Ftasks\u002Fvideo-silence-remover\u002Fenvironment\u002Fskills\u002Fvideo-processor\u002FSKILL.md",[98],{"categoryNo":99,"categoryName":100,"taxonomyType":101,"taxonomyTypeDesc":102},"01JBSEEDCAT000000000000016","图像与多媒体","SCENARIO","使用场景",[90,104,105,106,107,108,22,109,110,111,112,113,114,29,115,31,116],"processor","video processor","batch","create","reels","parts","segments","process","videos","you","segment","ffmpeg","remove",{"skillNo":118,"name":119,"nameZh":6,"description":120,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":121,"categories":122,"keywords":124,"publishedAt":36},"01M6XEVXJ5KZ0NTY3XZKRY4AS1","silence-detector","Detect initial silence segments in audio\u002Fvideo using energy-based analysis. Use when you need to find low-energy periods at the start of recordings (title slides, setup time, pre-roll silence).","https:\u002F\u002Fgithub.com\u002FWaaaalnut\u002Fskillsbench\u002Fblob\u002Fmain\u002Ftasks\u002Fvideo-silence-remover\u002Fenvironment\u002Fskills\u002Fsilence-detector\u002FSKILL.md",[123],{"categoryNo":99,"categoryName":100,"taxonomyType":101,"taxonomyTypeDesc":102},[125,126,127,128,22,113,129,130,131,132,133,110,134,135,90,136,137,138,31],"detector","silence detector","title","slides","time","energy","at","recordings","detect","find","Audio","analysis","start","setup",{"skillNo":140,"name":141,"nameZh":6,"description":142,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":143,"categories":144,"keywords":145,"publishedAt":36},"01M6XEVT3NGRN1FT7JPMAPXS6M","segment-combiner","Combine multiple segment detection results into a unified list. Use when you need to merge segments from different detectors, prepare removal lists for video processing, or consolidate detection outputs.","https:\u002F\u002Fgithub.com\u002FWaaaalnut\u002Fskillsbench\u002Fblob\u002Fmain\u002Ftasks\u002Fvideo-silence-remover\u002Fenvironment\u002Fskills\u002Fsegment-combiner\u002FSKILL.md",[],[114,146,90,147,148,149,150,26,22,151,152,110,113,153,154,31,155,156],"segment combiner","detection","prepare","merge","video processing","outputs","combine","processing","consolidate","results","list",{"skillNo":158,"name":159,"nameZh":6,"description":160,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":161,"categories":162,"keywords":166,"publishedAt":36},"01M6XEVMPVASGS2KX86QK4FMT7","report-generator","Generate compression reports for video processing. Use when you need to create structured JSON reports with duration statistics, compression ratios, and segment details after video processing.","https:\u002F\u002Fgithub.com\u002FWaaaalnut\u002Fskillsbench\u002Fblob\u002Fmain\u002Ftasks\u002Fvideo-silence-remover\u002Fenvironment\u002Fskills\u002Freport-generator\u002FSKILL.md",[163],{"categoryNo":164,"categoryName":165,"taxonomyType":71,"taxonomyTypeDesc":72},"01JBSEEDCAT000000000000034","行政与办公人员",[167,168,169,114,22,26,113,170,153,171,172,173,31,150,174,90,175,176,107],"generator","report generator","report","with","statistics","structured","reports","json","compression","generate"]