feat: add rust solution to lc No.3093

.agents/skills/git-commit/SKILL.md

@@ -0,0 +1,125 @@
+---
+name: git-commit
+description: 'Execute git commit with conventional commit message analysis, intelligent staging, and message generation. Use when user asks to commit changes, create a git commit, or mentions "/commit". Supports: (1) Auto-detecting type and scope from changes, (2) Generating conventional commit messages from diff, (3) Interactive commit with optional type/scope/description overrides, (4) Intelligent file staging for logical grouping'
+license: MIT
+allowed-tools: Bash
+---
+
+# Git Commit with Conventional Commits
+
+## Overview
+
+Create standardized, semantic git commits using the Conventional Commits specification. Analyze the actual diff to determine appropriate type, scope, and message.
+
+## Conventional Commit Format
+
+```
+<type>[optional scope]: <description>
+
+[optional body]
+
+[optional footer(s)]
+```
+
+## Commit Types
+
+| Type       | Purpose                        |
+| ---------- | ------------------------------ |
+| `feat`     | New feature                    |
+| `fix`      | Bug fix                        |
+| `docs`     | Documentation only             |
+| `style`    | Formatting/style (no logic)    |
+| `refactor` | Code refactor (no feature/fix) |
+| `perf`     | Performance improvement        |
+| `test`     | Add/update tests               |
+| `build`    | Build system/dependencies      |
+| `ci`       | CI/config changes              |
+| `chore`    | Maintenance/misc               |
+| `revert`   | Revert commit                  |
+
+## Breaking Changes
+
+```
+# Exclamation mark after type/scope
+feat!: remove deprecated endpoint
+
+# BREAKING CHANGE footer
+feat: allow config to extend other configs
+
+BREAKING CHANGE: `extends` key behavior changed
+```
+
+## Workflow
+
+### 1. Analyze Diff
+
+```bash
+# If files are staged, use staged diff
+git diff --staged
+
+# If nothing staged, use working tree diff
+git diff
+
+# Also check status
+git status --porcelain
+```
+
+### 2. Stage Files (if needed)
+
+If nothing is staged or you want to group changes differently:
+
+```bash
+# Stage specific files
+git add path/to/file1 path/to/file2
+
+# Stage by pattern
+git add *.test.*
+git add src/components/*
+
+# Interactive staging
+git add -p
+```
+
+**Never commit secrets** (.env, credentials.json, private keys).
+
+### 3. Generate Commit Message
+
+Analyze the diff to determine:
+
+- **Type**: What kind of change is this?
+- **Scope**: What area/module is affected?
+- **Description**: One-line summary of what changed (present tense, imperative mood, <72 chars)
+
+### 4. Execute Commit
+
+```bash
+# Single line
+git commit -m "<type>[scope]: <description>"
+
+# Multi-line with body/footer
+git commit -m "$(cat <<'EOF'
+<type>[scope]: <description>
+
+<optional body>
+
+<optional footer>
+EOF
+)"
+```
+
+## Best Practices
+
+- One logical change per commit
+- Present tense: "add" not "added"
+- Imperative mood: "fix bug" not "fixes bug"
+- Reference issues: `Closes #123`, `Refs #456`
+- Keep description under 72 characters
+- **Always use English for commit messages.** Never use other languages.
+
+## Git Safety Protocol
+
+- NEVER update git config
+- NEVER run destructive commands (--force, hard reset) without explicit request
+- NEVER skip hooks (--no-verify) unless user asks
+- NEVER force push to main/master
+- If commit fails due to hooks, fix and create NEW commit (don't amend)

solution/3000-3099/3093.Longest Common Suffix Queries/README.md

@@ -382,6 +382,73 @@ function stringIndices(wordsContainer: string[], wordsQuery: string[]): number[]
 }
 ```
 
+#### Rust
+
+```rust
+const INF: i32 = i32::MAX;
+
+struct TrieNode {
+    children: [Option<Box<TrieNode>>; 26],
+    length: i32,
+    idx: i32,
+}
+
+impl TrieNode {
+    fn new() -> Self {
+        Self {
+            children: Default::default(),
+            length: INF,
+            idx: INF,
+        }
+    }
+
+    fn insert(&mut self, w: &[u8], i: i32) {
+        let len = w.len() as i32;
+        if self.length > len {
+            self.length = len;
+            self.idx = i;
+        }
+        let mut node = self;
+        for c in w.iter().rev() {
+            let idx = (*c - b'a') as usize;
+            if node.children[idx].is_none() {
+                node.children[idx] = Some(Box::new(TrieNode::new()));
+            }
+            node = node.children[idx].as_mut().unwrap();
+            if node.length > len {
+                node.length = len;
+                node.idx = i;
+            }
+        }
+    }
+
+    fn query(&self, w: &[u8]) -> i32 {
+        let mut node = self;
+        for c in w.iter().rev() {
+            let idx = (*c - b'a') as usize;
+            match &node.children[idx] {
+                Some(child) => node = child,
+                None => break,
+            }
+        }
+        node.idx
+    }
+}
+
+impl Solution {
+    pub fn string_indices(words_container: Vec<String>, words_query: Vec<String>) -> Vec<i32> {
+        let mut trie = TrieNode::new();
+        for (i, w) in words_container.iter().enumerate() {
+            trie.insert(w.as_bytes(), i as i32);
+        }
+        words_query
+            .iter()
+            .map(|w| trie.query(w.as_bytes()))
+            .collect()
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3000-3099/3093.Longest Common Suffix Queries/README_EN.md

@@ -380,6 +380,73 @@ function stringIndices(wordsContainer: string[], wordsQuery: string[]): number[]
 }
 ```
 
+#### Rust
+
+```rust
+const INF: i32 = i32::MAX;
+
+struct TrieNode {
+    children: [Option<Box<TrieNode>>; 26],
+    length: i32,
+    idx: i32,
+}
+
+impl TrieNode {
+    fn new() -> Self {
+        Self {
+            children: Default::default(),
+            length: INF,
+            idx: INF,
+        }
+    }
+
+    fn insert(&mut self, w: &[u8], i: i32) {
+        let len = w.len() as i32;
+        if self.length > len {
+            self.length = len;
+            self.idx = i;
+        }
+        let mut node = self;
+        for c in w.iter().rev() {
+            let idx = (*c - b'a') as usize;
+            if node.children[idx].is_none() {
+                node.children[idx] = Some(Box::new(TrieNode::new()));
+            }
+            node = node.children[idx].as_mut().unwrap();
+            if node.length > len {
+                node.length = len;
+                node.idx = i;
+            }
+        }
+    }
+
+    fn query(&self, w: &[u8]) -> i32 {
+        let mut node = self;
+        for c in w.iter().rev() {
+            let idx = (*c - b'a') as usize;
+            match &node.children[idx] {
+                Some(child) => node = child,
+                None => break,
+            }
+        }
+        node.idx
+    }
+}
+
+impl Solution {
+    pub fn string_indices(words_container: Vec<String>, words_query: Vec<String>) -> Vec<i32> {
+        let mut trie = TrieNode::new();
+        for (i, w) in words_container.iter().enumerate() {
+            trie.insert(w.as_bytes(), i as i32);
+        }
+        words_query
+            .iter()
+            .map(|w| trie.query(w.as_bytes()))
+            .collect()
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3000-3099/3093.Longest Common Suffix Queries/Solution.rs

@@ -0,0 +1,62 @@
+const INF: i32 = i32::MAX;
+
+struct TrieNode {
+    children: [Option<Box<TrieNode>>; 26],
+    length: i32,
+    idx: i32,
+}
+
+impl TrieNode {
+    fn new() -> Self {
+        Self {
+            children: Default::default(),
+            length: INF,
+            idx: INF,
+        }
+    }
+
+    fn insert(&mut self, w: &[u8], i: i32) {
+        let len = w.len() as i32;
+        if self.length > len {
+            self.length = len;
+            self.idx = i;
+        }
+        let mut node = self;
+        for c in w.iter().rev() {
+            let idx = (*c - b'a') as usize;
+            if node.children[idx].is_none() {
+                node.children[idx] = Some(Box::new(TrieNode::new()));
+            }
+            node = node.children[idx].as_mut().unwrap();
+            if node.length > len {
+                node.length = len;
+                node.idx = i;
+            }
+        }
+    }
+
+    fn query(&self, w: &[u8]) -> i32 {
+        let mut node = self;
+        for c in w.iter().rev() {
+            let idx = (*c - b'a') as usize;
+            match &node.children[idx] {
+                Some(child) => node = child,
+                None => break,
+            }
+        }
+        node.idx
+    }
+}
+
+impl Solution {
+    pub fn string_indices(words_container: Vec<String>, words_query: Vec<String>) -> Vec<i32> {
+        let mut trie = TrieNode::new();
+        for (i, w) in words_container.iter().enumerate() {
+            trie.insert(w.as_bytes(), i as i32);
+        }
+        words_query
+            .iter()
+            .map(|w| trie.query(w.as_bytes()))
+            .collect()
+    }
+}