From 24fd559a56d1c88e2f582a9f44bb2861764984a3 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sat, 13 Jun 2026 05:00:01 +0000 Subject: [PATCH] feat: add solution for 3838. Weighted Word Mapping --- .../3838-weighted-word-mapping/analysis.md | 81 +++++++++++++++++++ .../3838-weighted-word-mapping/problem.md | 81 +++++++++++++++++++ .../solution_daily_20260613.go | 21 +++++ .../solution_daily_20260613_test.go | 61 ++++++++++++++ 4 files changed, 244 insertions(+) create mode 100644 problems/3838-weighted-word-mapping/analysis.md create mode 100644 problems/3838-weighted-word-mapping/problem.md create mode 100644 problems/3838-weighted-word-mapping/solution_daily_20260613.go create mode 100644 problems/3838-weighted-word-mapping/solution_daily_20260613_test.go diff --git a/problems/3838-weighted-word-mapping/analysis.md b/problems/3838-weighted-word-mapping/analysis.md new file mode 100644 index 0000000..11716d1 --- /dev/null +++ b/problems/3838-weighted-word-mapping/analysis.md @@ -0,0 +1,81 @@ +# 3838. Weighted Word Mapping + +[LeetCode Link](https://leetcode.com/problems/weighted-word-mapping/) + +Difficulty: Easy +Topics: Array, String, Simulation +Acceptance Rate: 88.1% + +## Hints + +### Hint 1 + +This is a pure simulation problem — there is no clever trick or hidden data +structure. Read the rules carefully and translate each rule directly into code. +Think about what information you need for a single word before worrying about +the whole array. + +### Hint 2 + +For one word you need its *weight*: the sum of `weights[i]` for each character, +where `i` is the position of the character in the alphabet. Recall that for a +lowercase byte `c`, the index is `c - 'a'`. Once you have the weight, the +problem tells you to reduce it with `weight % 26`. + +### Hint 3 + +The only part that trips people up is the *reverse alphabetical* mapping: +`0 -> 'z'`, `1 -> 'y'`, ..., `25 -> 'a'`. Notice that the index and the letter +move in opposite directions, and they always sum to 25 (`'z'` is index 25 from +`'a'`). So the mapped letter is simply `'z' - r`, or equivalently +`'a' + (25 - r)`. Build the answer one byte at a time and you are done. + +## Approach + +We process each word independently and build the result string character by +character. + +1. **Compute the weight of a word.** Walk over its characters. For each + character `c`, its alphabet index is `c - 'a'`, so add `weights[c-'a']` to a + running sum. The constraints (word length ≤ 10, weight ≤ 100) mean this sum + easily fits in an `int`. + +2. **Reduce modulo 26.** Let `r = weight % 26`. This gives a value in the range + `[0, 25]`. + +3. **Map to a letter in reverse order.** The rule is `0 -> 'z'`, `1 -> 'y'`, + ..., `25 -> 'a'`. Because index `r` and the target letter sum to the value of + `'z'` (index 25 above `'a'`), the mapped byte is `'z' - r`. For example + `r = 8` gives `'z' - 8 = 'r'`, matching the first example. + +4. **Concatenate.** Append each mapped byte to a `[]byte` (or + `strings.Builder`) in word order, then convert to a string at the end. + +Using a byte slice that we append to and convert once avoids repeated string +allocations, keeping the work proportional to the total number of characters. + +Worked example for `words = ["abcd"]` with the third example's weights +`[7,5,3,4,...]`: weight = `7 + 5 + 3 + 4 = 19`, `19 % 26 = 19`, and +`'z' - 19 = 'g'`, so the answer is `"g"`. ✔ + +## Complexity Analysis + +Time Complexity: O(N · L) where N is the number of words and L is the maximum +word length — we touch every character of every word exactly once. (Given the +constraints this is at most 100 · 10 = 1000 operations.) +Space Complexity: O(N) for the output string of one character per word, ignoring +the input. The per-word computation uses O(1) extra space. + +## Edge Cases + +- **Single-character words.** Words like `"a"` or `"c"` are valid; the weight is + just `weights[c-'a']`. Example 2 covers this. +- **Single word in the array.** With `words.length == 1` the output is a single + character (Example 3). Make sure the loop and the builder handle a length-one + result. +- **Weight divisible by 26 (`r == 0`).** This maps to `'z'`, the start of the + reverse alphabet. It is easy to accidentally produce a wrong byte here, so it + is worth a dedicated test. +- **Maximum-weight words.** The largest single word weight is 10 · 100 = 1000, + which is well within `int` range — no overflow concern, but good to confirm + the modulo arithmetic is correct for large sums. diff --git a/problems/3838-weighted-word-mapping/problem.md b/problems/3838-weighted-word-mapping/problem.md new file mode 100644 index 0000000..099a14b --- /dev/null +++ b/problems/3838-weighted-word-mapping/problem.md @@ -0,0 +1,81 @@ +--- +number: "3838" +frontend_id: "3838" +title: "Weighted Word Mapping" +slug: "weighted-word-mapping" +difficulty: "Easy" +topics: + - "Array" + - "String" + - "Simulation" +acceptance_rate: 8810.3 +is_premium: false +created_at: "2026-06-13T04:58:37.349563+00:00" +fetched_at: "2026-06-13T04:58:37.349563+00:00" +link: "https://leetcode.com/problems/weighted-word-mapping/" +date: "2026-06-13" +--- + +# 3838. Weighted Word Mapping + +You are given an array of strings `words`, where each string represents a word containing lowercase English letters. + +You are also given an integer array `weights` of length 26, where `weights[i]` represents the weight of the `ith` lowercase English letter. + +The **weight** of a word is defined as the **sum** of the weights of its characters. + +For each word, take its weight modulo 26 and map the result to a lowercase English letter using reverse alphabetical order (`0 -> 'z', 1 -> 'y', ..., 25 -> 'a'`). + +Return a string formed by concatenating the mapped characters for all words in order. + + + +**Example 1:** + +**Input:** words = ["abcd","def","xyz"], weights = [5,3,12,14,1,2,3,2,10,6,6,9,7,8,7,10,8,9,6,9,9,8,3,7,7,2] + +**Output:** "rij" + +**Explanation:** + + * The weight of `"abcd"` is `5 + 3 + 12 + 14 = 34`. The result modulo 26 is `34 % 26 = 8`, which maps to `'r'`. + * The weight of `"def"` is `14 + 1 + 2 = 17`. The result modulo 26 is `17 % 26 = 17`, which maps to `'i'`. + * The weight of `"xyz"` is `7 + 7 + 2 = 16`. The result modulo 26 is `16 % 26 = 16`, which maps to `'j'`. + + + +Thus, the string formed by concatenating the mapped characters is `"rij"`. + +**Example 2:** + +**Input:** words = ["a","b","c"], weights = [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1] + +**Output:** "yyy" + +**Explanation:** + +Each word has weight 1. The result modulo 26 is `1 % 26 = 1`, which maps to `'y'`. + +Thus, the string formed by concatenating the mapped characters is `"yyy"`. + +**Example 3:** + +**Input:** words = ["abcd"], weights = [7,5,3,4,3,5,4,9,4,2,2,7,10,2,5,10,6,1,2,2,4,1,3,4,4,5] + +**Output:** "g" + +**Explanation:​​​​​​​** + +The weight of `"abcd"` is `7 + 5 + 3 + 4 = 19`. The result modulo 26 is `19 % 26 = 19`, which maps to `'g'`. + +Thus, the string formed by concatenating the mapped characters is `"g"`. + + + +**Constraints:** + + * `1 <= words.length <= 100` + * `1 <= words[i].length <= 10` + * `weights.length == 26` + * `1 <= weights[i] <= 100` + * `words[i]` consists of lowercase English letters. diff --git a/problems/3838-weighted-word-mapping/solution_daily_20260613.go b/problems/3838-weighted-word-mapping/solution_daily_20260613.go new file mode 100644 index 0000000..32ad38d --- /dev/null +++ b/problems/3838-weighted-word-mapping/solution_daily_20260613.go @@ -0,0 +1,21 @@ +package main + +// 3838. Weighted Word Mapping +// +// Pure simulation. For each word we sum the weights of its characters +// (weights[c-'a']), reduce the sum modulo 26, then map the result r to a +// lowercase letter in reverse alphabetical order (0 -> 'z', ..., 25 -> 'a'). +// Since index r and its target letter sum to the value of 'z', the mapped byte +// is simply 'z' - r. Results are appended to a byte slice and converted once. +func weightedWordMapping(words []string, weights []int) string { + result := make([]byte, 0, len(words)) + for _, word := range words { + weight := 0 + for i := 0; i < len(word); i++ { + weight += weights[word[i]-'a'] + } + r := weight % 26 + result = append(result, byte('z'-r)) + } + return string(result) +} diff --git a/problems/3838-weighted-word-mapping/solution_daily_20260613_test.go b/problems/3838-weighted-word-mapping/solution_daily_20260613_test.go new file mode 100644 index 0000000..16c9360 --- /dev/null +++ b/problems/3838-weighted-word-mapping/solution_daily_20260613_test.go @@ -0,0 +1,61 @@ +package main + +import "testing" + +func TestWeightedWordMapping(t *testing.T) { + tests := []struct { + name string + words []string + weights []int + expected string + }{ + { + name: "example 1: multiple multi-char words", + words: []string{"abcd", "def", "xyz"}, + weights: []int{5, 3, 12, 14, 1, 2, 3, 2, 10, 6, 6, 9, 7, 8, 7, 10, 8, 9, 6, 9, 9, 8, 3, 7, 7, 2}, + expected: "rij", + }, + { + name: "example 2: single-char words, all weights 1", + words: []string{"a", "b", "c"}, + weights: []int{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, + expected: "yyy", + }, + { + name: "example 3: single word", + words: []string{"abcd"}, + weights: []int{7, 5, 3, 4, 3, 5, 4, 9, 4, 2, 2, 7, 10, 2, 5, 10, 6, 1, 2, 2, 4, 1, 3, 4, 4, 5}, + expected: "g", + }, + { + name: "edge case: weight divisible by 26 maps to 'z'", + words: []string{"a"}, + weights: []int{26, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, + // weight = 26, 26 % 26 = 0 -> 'z' + expected: "z", + }, + { + name: "edge case: max-length word with max weights", + words: []string{"aaaaaaaaaa"}, + weights: []int{100, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, + // weight = 10 * 100 = 1000, 1000 % 26 = 12 -> 'z' - 12 = 'n' + expected: "n", + }, + { + name: "edge case: word using last letter of alphabet", + words: []string{"z"}, + weights: []int{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 25}, + // weight = 25, 25 % 26 = 25 -> 'z' - 25 = 'a' + expected: "a", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := weightedWordMapping(tt.words, tt.weights) + if result != tt.expected { + t.Errorf("weightedWordMapping(%v, ...) = %q, want %q", tt.words, result, tt.expected) + } + }) + } +}