From 63ef8751414491601ae307b79eb810434dbede58 Mon Sep 17 00:00:00 2001 From: linwt <1076538498@qq.com> Date: Thu, 4 Aug 2022 21:17:44 +0800 Subject: [PATCH 1/3] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E5=BD=92=E5=B9=B6?= =?UTF-8?q?=E6=8E=92=E5=BA=8F=E9=94=99=E8=AF=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Merge.java" | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git "a/\345\215\201\345\244\247\346\216\222\345\272\217\347\256\227\346\263\225_Java/Merge.java" "b/\345\215\201\345\244\247\346\216\222\345\272\217\347\256\227\346\263\225_Java/Merge.java" index 74466cd..89c321c 100644 --- "a/\345\215\201\345\244\247\346\216\222\345\272\217\347\256\227\346\263\225_Java/Merge.java" +++ "b/\345\215\201\345\244\247\346\216\222\345\272\217\347\256\227\346\263\225_Java/Merge.java" @@ -33,9 +33,9 @@ private int[] combine(int[] left, int[] right) { } else if (r >= right.length) { res[i] = left[l++]; } else if (left[l] < right[r]) { - res[i] = left[r++]; + res[i] = left[l++]; } else { - res[i] = right[l++]; + res[i] = right[r++]; } } return res; From 5acb54ef4aaa2e721df7711d587319d0a06a8e4c Mon Sep 17 00:00:00 2001 From: linwt <1076538498@qq.com> Date: Tue, 9 Aug 2022 08:19:04 +0800 Subject: [PATCH 2/3] =?UTF-8?q?=E7=AE=80=E5=8C=96=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- leetcode_Java/Solution0042.java | 2 +- leetcode_Java/Solution0047.java | 5 +- leetcode_Java/Solution0051.java | 14 +++--- leetcode_Java/Solution0096.java | 3 +- leetcode_Java/Solution0098.java | 6 +-- leetcode_Java/Solution0101.java | 4 +- leetcode_Java/Solution0104.java | 4 +- leetcode_Java/Solution0110.java | 4 +- leetcode_Java/Solution0114.java | 48 +++++++++++++++++-- leetcode_Java/Solution0198.java | 2 +- leetcode_Java/Solution0236.java | 7 +++ leetcode_Java/Solution0297.java | 22 ++++----- leetcode_Java/Solution0543.java | 2 +- .../JZ14.java" | 2 +- .../JZ28.java" | 4 +- .../JZ31.java" | 2 +- .../JZ34.java" | 14 +++--- .../JZ44.java" | 14 +++--- .../JZ54.java" | 38 ++++++++++----- .../JZ70.java" | 3 +- 20 files changed, 125 insertions(+), 75 deletions(-) diff --git a/leetcode_Java/Solution0042.java b/leetcode_Java/Solution0042.java index a67b9b4..92462ab 100644 --- a/leetcode_Java/Solution0042.java +++ b/leetcode_Java/Solution0042.java @@ -79,7 +79,7 @@ public int trap(int[] height) { for (int i = 1; i < n - 1; i++) { dpLeft[i] = Math.max(dpLeft[i - 1], height[i - 1]); } - for (int i = n - 2; i >= 0; i--) { + for (int i = n - 2; i > 0; i--) { dpRight[i] = Math.max(dpRight[i + 1], height[i + 1]); } for (int i = 1; i < n - 1; i++) { diff --git a/leetcode_Java/Solution0047.java b/leetcode_Java/Solution0047.java index dd95d9e..8c8d255 100644 --- a/leetcode_Java/Solution0047.java +++ b/leetcode_Java/Solution0047.java @@ -9,7 +9,10 @@ 4、定义递归函数 1）终止条件，子结果大小满足条件，存储子结果 2）for循环遍历数组：剪枝条件 → 做选择 → 递归 → 撤销选择，回溯 - ① 剪枝条件：当前元素使用过则跳过；或者当前元素未使用过，但同一层前面有同样的元素未使用过，该元素在本层可以使用，则需要跳过重复选择 + ① 剪枝条件：当前元素使用过则跳过；或者当前元素未使用过，但同层前面有同样的元素使用过，则跳过重复选择 + 去重代码 i > 0 && nums[i] == nums[i - 1] && !used[i - 1] + used[i - 1] = false 表示树层去重，即前一个状态已撤销，为同层。效率更高，避免无效处理。 + used[i - 1] = true 表示树枝去重，即前一个状态未撤销，为递归，不同层。 ② 做选择：元素只加入子结果，标记当前元素已使用 ③ 递归：进入下一层，同样遍历整个数组，通过used标记判断元素是否有效可用 ④ 回溯：撤销选择，移除子结果最后一个元素，标记当前元素未使用 diff --git a/leetcode_Java/Solution0051.java b/leetcode_Java/Solution0051.java index bcb5e5c..8caa891 100644 --- a/leetcode_Java/Solution0051.java +++ b/leetcode_Java/Solution0051.java @@ -19,25 +19,27 @@ class Solution { private List> res = new ArrayList<>(); private char[][] chessBoard; + private int n; public List> solveNQueens(int n) { - chessBoard = new char[n][n]; + this.n = n; + this.chessBoard = new char[n][n]; for (char[] c : chessBoard) { Arrays.fill(c, '.'); } - backtrack(n, 0); + backtrack(0); return res; } - private void backtrack(int n, int row) { + private void backtrack(int row) { if (row == n) { res.add(arrayToList()); return; } for (int col = 0; col < n; col++) { - if (isValid(n, row, col)) { + if (isValid(row, col)) { chessBoard[row][col] = 'Q'; - backtrack(n, row + 1); + backtrack(row + 1); chessBoard[row][col] = '.'; } } @@ -53,7 +55,7 @@ private List arrayToList() { } // 检查是否有皇后 - private boolean isValid(int n, int row, int col) { + private boolean isValid(int row, int col) { // 检查列 for (int i = 0; i < row; i++) { if (chessBoard[i][col] == 'Q') { diff --git a/leetcode_Java/Solution0096.java b/leetcode_Java/Solution0096.java index 6557a3c..d8135fd 100644 --- a/leetcode_Java/Solution0096.java +++ b/leetcode_Java/Solution0096.java @@ -17,8 +17,7 @@ class Solution { public int numTrees(int n) { int[] dp = new int[n + 1]; - dp[0] = 1; - dp[1] = 1; + dp[0] = dp[1] = 1; for (int i = 2; i <= n; i++) { for (int j = 1; j <= i; j++) { dp[i] += dp[j - 1] * dp[i - j]; diff --git a/leetcode_Java/Solution0098.java b/leetcode_Java/Solution0098.java index 1161a9e..8a9a2be 100644 --- a/leetcode_Java/Solution0098.java +++ b/leetcode_Java/Solution0098.java @@ -59,7 +59,7 @@ public boolean isValidBST(TreeNode root) { /* 递归： -1、方法功能：入参是节点、最小值、最大值，判断节点值是否有效，即是否满足 min < val < max，有效效返回true，无效返回false +1、方法功能：入参是节点、最小值、最大值，判断节点值是否有效，即是否满足 min < val < max，有效返回true，无效返回false 2、终止条件：节点为空返回true 3、单节点处理过程和返回结果：判断节点值是否有效，即是否满足 min < val < max，有效效返回true，无效返回false 4、递归调用：左右节点需要同样的操作，因此调用同样的方法处理，获取结果 @@ -75,10 +75,10 @@ private boolean isValid(TreeNode root, TreeNode min, TreeNode max) { if (root == null) { return true; } - if (max != null && root.val >= max.val) { + if (min != null && root.val <= min.val) { return false; } - if (min != null && root.val <= min.val) { + if (max != null && root.val >= max.val) { return false; } return isValid(root.left, min, root) && isValid(root.right, root, max); diff --git a/leetcode_Java/Solution0101.java b/leetcode_Java/Solution0101.java index 8335d47..ace2c1e 100644 --- a/leetcode_Java/Solution0101.java +++ b/leetcode_Java/Solution0101.java @@ -58,9 +58,7 @@ public boolean isSameTree(TreeNode p, TreeNode q) { return true; } if (p != null && q != null && p.val == q.val) { - boolean l = isSameTree(p.left, q.right); - boolean r = isSameTree(p.right, q.left); - return l && r; + return isSameTree(p.left, q.right) && isSameTree(p.right, q.left); } return false; } diff --git a/leetcode_Java/Solution0104.java b/leetcode_Java/Solution0104.java index bc37af7..233cc23 100644 --- a/leetcode_Java/Solution0104.java +++ b/leetcode_Java/Solution0104.java @@ -39,9 +39,7 @@ public int maxDepth(TreeNode root) { if (root == null) { return 0; } - int l = maxDepth(root.left); - int r = maxDepth(root.right); - return 1 + Math.max(l, r); + return 1 + Math.max(maxDepth(root.left), maxDepth(root.right)); } } diff --git a/leetcode_Java/Solution0110.java b/leetcode_Java/Solution0110.java index abbad33..2def0de 100644 --- a/leetcode_Java/Solution0110.java +++ b/leetcode_Java/Solution0110.java @@ -84,9 +84,7 @@ private int treeDepth(TreeNode root) { if (map.get(root) != null) { return map.get(root); } - int left = treeDepth(root.left); - int right = treeDepth(root.right); - int depth = 1 + Math.max(left, right); + int depth = 1 + Math.max(treeDepth(root.left), treeDepth(root.right)); map.put(root, depth); return depth; } diff --git a/leetcode_Java/Solution0114.java b/leetcode_Java/Solution0114.java index aacdcf1..5ce2799 100644 --- a/leetcode_Java/Solution0114.java +++ b/leetcode_Java/Solution0114.java @@ -34,7 +34,7 @@ * 4、遍历逻辑： * 1）根指针的移动代表着前序遍历的顺序，循环遍历条件是根指针不为空 * 2）如果根节点的左节点不为空，则进行节点连接步骤；如果为空，则将节点值存入列表 -* 3）根节点处理完后看，根指针指向右节点，准备下一轮判断 +* 3）根节点处理完后，根指针指向右节点，准备下一轮判断 * 5、“144.二叉树的前序遍历”展开为链表的解法 * */ class Solution { @@ -49,9 +49,8 @@ public List flatten(TreeNode root) { pre.right = root.right; root.right = root.left; root.left = null; - } else { - list.add(root.val); } + list.add(root.val); root = root.right; } return list; @@ -80,13 +79,52 @@ public List flatten(TreeNode root) { pre.right = root.right; root.right = root.left; root.left = null; - } else { - list.add(root.val); } + list.add(root.val); if (root.right != null) { queue.offer(root.right); } } return list; } +} + + +// 方法返回空写法。迭代 +class Solution { + public void flatten(TreeNode root) { + while (root != null) { + if (root.left != null) { + TreeNode pre = root.left; + while (pre.right != null) { + pre = pre.right; + } + pre.right = root.right; + root.right = root.left; + root.left = null; + } + root = root.right; + } + } +} + + +// 递归 +class Solution { + public void flatten(TreeNode root) { + if (root == null) { + return; + } + if (root.left != null) { + TreeNode pre = root.left; + while (pre.right != null) { + pre = pre.right; + } + pre.right = root.right; + root.right = root.left; + root.left = null; + } + flatten(root.left); + flatten(root.right); + } } \ No newline at end of file diff --git a/leetcode_Java/Solution0198.java b/leetcode_Java/Solution0198.java index d6ac899..1d91dcd 100644 --- a/leetcode_Java/Solution0198.java +++ b/leetcode_Java/Solution0198.java @@ -8,7 +8,7 @@ 1）dp[0]=0 表示没有偷窃时金额为0，dp[1]=nums[0] 表示第1号房屋时偷窃最高金额为nums[0] 2）因为状态转移方程由前两项推出，所以要先初始化前两项 3、状态转移方程： - 1）如果偷窃第i号房屋，那么i-1号房屋不能偷窃，则最高金额为 dp[i-2] + nums[i - 1] + 1）如果偷窃第i号房屋，那么i-1号房屋不能偷窃，则最高金额为 dp[i - 2] + nums[i - 1] 2）如果不偷窃第i号房屋，那么最高金额同i-1号房屋一样，即 dp[i - 1] 3）在 偷窃 和 不偷窃 选择最高金额，即 dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i - 1]); 4、遍历dp数组填表：从索引2开始遍历，根据状态转移方程填表 diff --git a/leetcode_Java/Solution0236.java b/leetcode_Java/Solution0236.java index f982599..8e7063d 100644 --- a/leetcode_Java/Solution0236.java +++ b/leetcode_Java/Solution0236.java @@ -68,4 +68,11 @@ public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { } return null; } + + // 再简化 + public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { + if (root == null || root == p || root == q) { + return root; + } + } } \ No newline at end of file diff --git a/leetcode_Java/Solution0297.java b/leetcode_Java/Solution0297.java index fe95100..2cac3a7 100644 --- a/leetcode_Java/Solution0297.java +++ b/leetcode_Java/Solution0297.java @@ -77,20 +77,16 @@ public String serialize(TreeNode root) { return "X,"; } StringBuilder sb = new StringBuilder(); - ArrayDeque queue = new ArrayDeque<>(); + Queue queue = new LinkedList<>(); queue.add(root); while (!queue.isEmpty()) { - int size = queue.size(); - while (size > 0) { - TreeNode node = queue.poll(); - if (node != null) { - sb.append(node.val + ","); - queue.add(node.left); - queue.add(node.right); - } else { - sb.append("X,"); - } - size--; + TreeNode node = queue.poll(); + if (node != null) { + sb.append(node.val + ","); + queue.add(node.left); + queue.add(node.right); + } else { + sb.append("X,"); } } return sb.toString(); @@ -101,7 +97,7 @@ public TreeNode deserialize(String data) { return null; } String[] splits = data.split(","); - Deque queue = new ArrayDeque<>(); + Queue queue = new LinkedList<>(); TreeNode root = new TreeNode(Integer.parseInt(splits[0])); queue.add(root); int i = 1; diff --git a/leetcode_Java/Solution0543.java b/leetcode_Java/Solution0543.java index 7c1f269..114f59b 100644 --- a/leetcode_Java/Solution0543.java +++ b/leetcode_Java/Solution0543.java @@ -26,7 +26,7 @@ 递归 + 最大路径长度成员变量 计算深度递归函数 -1、方法功能：入参是一个节，返回节点的深度 +1、方法功能：入参是一个节点，返回节点的深度 2、终止条件：节点为空时返回0 3、一个节点处理过程和返回结果：节点不为空时返回1 4、递归调用：左右节点同样需要计算深度，因此调用同样的方法处理，获取结果 diff --git "a/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ14.java" "b/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ14.java" index c014308..d13bf3c 100644 --- "a/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ14.java" +++ "b/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ14.java" @@ -65,7 +65,7 @@ public int cutRope (int target) { /* 1、以上解法通过公式直接计算 2、x表示余数，余1时跟一个3凑成4进行乘积更大，余2时最后乘上即可，余0则刚好等分直接计算 -3、y表示有多少段3, +3、y表示有多少段3 */ public class Solution { public int cutRope(int target) { diff --git "a/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ28.java" "b/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ28.java" index 5933a05..ce3d2e6 100644 --- "a/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ28.java" +++ "b/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ28.java" @@ -14,9 +14,7 @@ boolean isSameTree(TreeNode p, TreeNode q) { return true; } if (p != null && q != null && p.val == q.val) { - boolean l = isSameTree(p.left, q.right); - boolean r = isSameTree(p.right, q.left); - return l && r; + return isSameTree(p.left, q.right) && isSameTree(p.right, q.left); } return false; } diff --git "a/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ31.java" "b/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ31.java" index 3fe61e0..0119d39 100644 --- "a/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ31.java" +++ "b/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ31.java" @@ -1,8 +1,8 @@ // 31. 栈的压入、弹出序列 +// 数据入栈，当数据与弹出序列头元素相等时，则数据出栈且序列头元素弹出，重复以上步骤，最终若栈为空则该序列是符合的弹出序列 public class Solution { - // 数据入栈，当数据与弹出序列头元素相等时，则数据出栈且序列头元素弹出，重复以上步骤，最终若栈为空则该序列是符合的弹出序列 public boolean IsPopOrder(int[] pushA, int[] popA) { if (pushA.length == 0) { return false; diff --git "a/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ34.java" "b/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ34.java" index 58ac321..ee60338 100644 --- "a/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ34.java" +++ "b/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ34.java" @@ -5,7 +5,7 @@ 回溯： 1、变量作用： 1）成员变量 list 保存回溯过程产生的子结果 - 2）局部变量 pathList 保存递归到当前节点时路径上的节点值 + 2）成员变量 pathList 保存递归到当前节点时路径上的节点值 3）局部变量 target 表示到达当前节点后剩余目标值，当剩余0时表示凑到了期望值 2、递归： 1）函数作用：累减剩余目标值，将当前节点值加入路径列表，判断剩余目标值是否为0 且 是否为叶结点，若是则将路径列表加入全局列表 @@ -14,15 +14,15 @@ 4）回溯：返回到上一层前需要将当前层加入的节点值移除，不影响其他路径递归 */ public class Solution { - ArrayList> list = new ArrayList<>(); + private ArrayList> list = new ArrayList<>(); + private ArrayList pathList = new ArrayList<>(); public ArrayList> FindPath(TreeNode root,int expectNumber) { - ArrayList pathList = new ArrayList<>(); - backtrack(root, expectNumber, pathList); + backtrack(root, expectNumber); return list; } - private void backtrack(TreeNode root, int target, ArrayList pathList) { + private void backtrack(TreeNode root, int target) { if (root == null) { return; } @@ -31,8 +31,8 @@ private void backtrack(TreeNode root, int target, ArrayList pathList) { if (target == 0 && root.left == null && root.right == null) { list.add(new ArrayList<>(pathList)); } - backtrack(root.left, target, pathList); - backtrack(root.right, target, pathList); + backtrack(root.left, target); + backtrack(root.right, target); pathList.remove(pathList.size() - 1); } } \ No newline at end of file diff --git "a/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ44.java" "b/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ44.java" index 9ee263b..f79c87c 100644 --- "a/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ44.java" +++ "b/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ44.java" @@ -4,8 +4,8 @@ /* 1、变量含义 1）digit：每个数字的位数 - 2）lowLimit：相同位数数字的区间起始值 - 3）highLimit：相同位数数字的区间终止值 + 2）low：相同位数数字的区间起始值 + 3）high：相同位数数字的区间终止值 4）count：相同位数数字的区间内数字个数 2、算法过程 1）初始化变量 @@ -23,15 +23,15 @@ public class Solution { public int findNthDigit (int n) { int digit = 1; - long lowLimit = 0, highLimit = 10, count = 10; + long low = 0, high = 10, count = 10; while (n > count) { n -= count; - lowLimit = highLimit; - highLimit *= 10; + low = high; + high *= 10; digit++; - count = (highLimit - lowLimit) * digit; + count = (high - low) * digit; } - int num = lowLimit + n / digit; + int num = low + n / digit; int offset = n % digit; return String.valueOf(num).charAt(offset) - '0'; } diff --git "a/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ54.java" "b/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ54.java" index b4dcb29..0067319 100644 --- "a/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ54.java" +++ "b/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ54.java" @@ -29,23 +29,35 @@ private void inOrder(TreeNode root) { } +/* +1、方法功能：入参是 一个节点 和 目标节点位号，遍历找出并返回目标节点，没有则返回空 +2、终止条件：节点为空时，返回空 +3、一个节点处理过程和返回结果：累加位号，如果等于目标节点位号则返回该节点，否则返回空 +4、递归调用：左右节点同样需要寻找判断是否目标节点，因此调用同样的方法 +5、递归顺序：中序遍历，可以从小到大遍历节点 +6、使用递归调用结果和返回结果： + 1）左节点递归结果不为空时，说明找到了目标节点，返回该结果，否则继续判断根节点 + 2）累加位号，如果等于目标节点位号则返回该节点，否则继续判断右节点 + 3）右节点递归结果不为空时，说明找到了目标节点，返回该结果。否则说明没有目标位号的节点，返回空 + */ public class Solution { int count = 0; TreeNode KthNode(TreeNode pRoot, int k) { - if (pRoot != null) { - TreeNode node = KthNode(pRoot.left, k); - if (node != null) { - return node; - } - count++; - if (count == k) { - return pRoot; - } - node = KthNode(pRoot.right, k); - if (node != null) { - return node; - } + if (pRoot == null) { + return null; + } + TreeNode node = KthNode(pRoot.left, k); + if (node != null) { + return node; + } + count++; + if (count == k) { + return pRoot; + } + node = KthNode(pRoot.right, k); + if (node != null) { + return node; } return null; } diff --git "a/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ70.java" "b/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ70.java" index af36424..57ec6b4 100644 --- "a/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ70.java" +++ "b/\345\211\221\346\214\207Offer_Java_\346\226\260\347\211\210/JZ70.java" @@ -5,8 +5,9 @@ public class Solution { public int RectCover(int target) { int a = 0, b = 1; - if (target == 0) + if (target == 0) { return 0; + } for (int i = 0; i < target; i++) { int temp = a; a = b; From 1a59291b2718249d34eb365f9a86976da17109ce Mon Sep 17 00:00:00 2001 From: Boy ln <37769342+linwt@users.noreply.github.com> Date: Wed, 27 Mar 2024 09:34:42 +0800 Subject: [PATCH 3/3] Update Solution0152.java --- leetcode_Java/Solution0152.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/leetcode_Java/Solution0152.java b/leetcode_Java/Solution0152.java index fd454fb..2953e88 100644 --- a/leetcode_Java/Solution0152.java +++ b/leetcode_Java/Solution0152.java @@ -9,7 +9,7 @@ class Solution { public int maxProduct(int[] nums) { int res = nums[0], imax = 1, imin = 1; - for (int i = 1; i < nums.length; i++) { + for (int i = 0; i < nums.length; i++) { if (nums[i] < 0) { int temp = imax; imax = imin; @@ -69,4 +69,4 @@ public int maxProduct(int[] nums) { } return res; } -} \ No newline at end of file +}