ninefive
diff --git a/‎src/1409.Queries-on-a-Permutation-With-Key/README.md
Lines changed: 59 additions & 0 deletions b/‎src/1409.Queries-on-a-Permutation-With-Key/README.md
Lines changed: 59 additions & 0 deletions
diff --git a/‎src/1409.Queries-on-a-Permutation-With-Key/Solution.go
Lines changed: 23 additions & 0 deletions b/‎src/1409.Queries-on-a-Permutation-With-Key/Solution.go
Lines changed: 23 additions & 0 deletions
diff --git a/‎src/1409.Queries-on-a-Permutation-With-Key/Solution_test.go
Lines changed: 42 additions & 0 deletions b/‎src/1409.Queries-on-a-Permutation-With-Key/Solution_test.go
Lines changed: 42 additions & 0 deletions
@@ -0,0 +1,59 @@
+# [1362.Closest Divisors][title]
+
+> [!WARNING|style:flat]
+> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-leetcode)
+
+## Description
+
+Given the array queries of positive integers between 1 and m, you have to process all queries[i] (from i=0 to i=queries.length-1) according to the following rules:
+
+    In the beginning, you have the permutation P=[1,2,3,...,m].
+    For the current i, find the position of queries[i] in the permutation P (indexing from 0) and then move this at the beginning of the permutation P. Notice that the position of queries[i] in P is the result for queries[i].
+
+Return an array containing the result for the given queries.
+
+**Example 1:**
+
+```
+Input: queries = [3,1,2,1], m = 5
+Output: [2,1,2,1]
+Explanation: The queries are processed as follow:
+For i=0: queries[i]=3, P=[1,2,3,4,5], position of 3 in P is 2, then we move 3 to the beginning of P resulting in P=[3,1,2,4,5].
+For i=1: queries[i]=1, P=[3,1,2,4,5], position of 1 in P is 1, then we move 1 to the beginning of P resulting in P=[1,3,2,4,5].
+For i=2: queries[i]=2, P=[1,3,2,4,5], position of 2 in P is 2, then we move 2 to the beginning of P resulting in P=[2,1,3,4,5].
+For i=3: queries[i]=1, P=[2,1,3,4,5], position of 1 in P is 1, then we move 1 to the beginning of P resulting in P=[1,2,3,4,5].
+Therefore, the array containing the result is [2,1,2,1].
+```
+
+**Example 2:**
+
+```
+Input: queries = [4,1,2,2], m = 4
+Output: [3,1,2,0]
+```
+
+**Example 3:**
+
+```
+Input: queries = [7,5,5,8,3], m = 8
+Output: [6,5,0,7,5]
+```
+
+## 题意
+> ...
+
+## 题解
+
+> ...
+Closest Divisors
+```go
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-leetcode][me]
+
+[title]: https://leetcode.com/problems/closest-divisors/
+[me]: https://github.com/kylesliu/awesome-golang-leetcode
@@ -0,0 +1,23 @@
+package Solution
+
+func Solution(queries []int, m int) []int {
+	res, p := make([]int, len(queries)), make([]int, m)
+	for i := 0; i < m; i++ {
+		p[i] = i + 1
+	}
+	for idx, q := range queries {
+		pos := -1
+		for i, v := range p {
+			if v == q {
+				pos = i
+				break
+			}
+		}
+		res[idx] = pos
+		for i := pos; i > 0; i-- {
+			p[i] = p[i-1]
+		}
+		p[0] = q
+	}
+	return res
+}
@@ -0,0 +1,42 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name    string
+		queries []int
+		m       int
+		expect  []int
+	}{
+		{"TestCase", []int{3, 1, 2, 1}, 5, []int{2, 1, 2, 1}},
+		{"TestCase", []int{4, 1, 2, 2}, 4, []int{3, 1, 2, 0}},
+		{"TestCase", []int{7, 5, 5, 8, 3}, 8, []int{6, 5, 0, 7, 5}},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := Solution(c.queries, c.m)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v %v",
+					c.expect, got, c.queries, c.m)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+
+}
+
+//	使用案列
+func ExampleSolution() {
+
+}