From fa2a811e5d8308603d757192b4d935ac9dcc63c9 Mon Sep 17 00:00:00 2001 From: 0xff-dev Date: Wed, 3 Dec 2025 09:46:52 +0800 Subject: [PATCH] add 3601-3700 problems --- cmd/main.go | 3 +- .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../3606.Coupon-Code-Validator/README.md | 32 +++++++++++++++ .../3606.Coupon-Code-Validator/Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../3607.Power-Grid-Maintenance/README.md | 32 +++++++++++++++ .../3607.Power-Grid-Maintenance/Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../3620.Network-Recovery-Pathways/README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../3636.Threshold-Majority-Queries/README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../3601-3700/3637.Trionic-Array-I/README.md | 32 +++++++++++++++ .../3637.Trionic-Array-I/Solution.go | 5 +++ .../3637.Trionic-Array-I/Solution_test.go | 39 +++++++++++++++++++ .../3638.Maximum-Balanced-Shipments/README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../3601-3700/3640.Trionic-Array-II/README.md | 32 +++++++++++++++ .../3640.Trionic-Array-II/Solution.go | 5 +++ .../3640.Trionic-Array-II/Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../3649.Number-of-Perfect-Pairs/README.md | 32 +++++++++++++++ .../3649.Number-of-Perfect-Pairs/Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../3658.GCD-of-Odd-and-Even-Sums/README.md | 32 +++++++++++++++ .../3658.GCD-of-Odd-and-Even-Sums/Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../3601-3700/3660.Jump-Game-IX/README.md | 32 +++++++++++++++ .../3601-3700/3660.Jump-Game-IX/Solution.go | 5 +++ .../3660.Jump-Game-IX/Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../3664.Two-Letter-Card-Game/README.md | 32 +++++++++++++++ .../3664.Two-Letter-Card-Game/Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../3665.Twisted-Mirror-Path-Count/README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../3668.Restore-Finishing-Order/README.md | 32 +++++++++++++++ .../3668.Restore-Finishing-Order/Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../3676.Count-Bowl-Subarrays/README.md | 32 +++++++++++++++ .../3676.Count-Bowl-Subarrays/Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../3680.Generate-Schedule/README.md | 32 +++++++++++++++ .../3680.Generate-Schedule/Solution.go | 5 +++ .../3680.Generate-Schedule/Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../3693.Climbing-Stairs-II/README.md | 32 +++++++++++++++ .../3693.Climbing-Stairs-II/Solution.go | 5 +++ .../3693.Climbing-Stairs-II/Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../3699.Number-of-ZigZag-Arrays-I/README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ .../3700.Number-of-ZigZag-Arrays-II/README.md | 32 +++++++++++++++ .../Solution.go | 5 +++ .../Solution_test.go | 39 +++++++++++++++++++ 241 files changed, 6082 insertions(+), 1 deletion(-) create mode 100755 leetcode/3601-3700/3602.Hexadecimal-and-Hexatrigesimal-Conversion/README.md create mode 100644 leetcode/3601-3700/3602.Hexadecimal-and-Hexatrigesimal-Conversion/Solution.go create mode 100644 leetcode/3601-3700/3602.Hexadecimal-and-Hexatrigesimal-Conversion/Solution_test.go create mode 100755 leetcode/3601-3700/3603.Minimum-Cost-Path-with-Alternating-Directions-II/README.md create mode 100644 leetcode/3601-3700/3603.Minimum-Cost-Path-with-Alternating-Directions-II/Solution.go create mode 100644 leetcode/3601-3700/3603.Minimum-Cost-Path-with-Alternating-Directions-II/Solution_test.go create mode 100755 leetcode/3601-3700/3604.Minimum-Time-to-Reach-Destination-in-Directed-Graph/README.md create mode 100644 leetcode/3601-3700/3604.Minimum-Time-to-Reach-Destination-in-Directed-Graph/Solution.go create mode 100644 leetcode/3601-3700/3604.Minimum-Time-to-Reach-Destination-in-Directed-Graph/Solution_test.go create mode 100755 leetcode/3601-3700/3605.Minimum-Stability-Factor-of-Array/README.md create mode 100644 leetcode/3601-3700/3605.Minimum-Stability-Factor-of-Array/Solution.go create mode 100644 leetcode/3601-3700/3605.Minimum-Stability-Factor-of-Array/Solution_test.go create mode 100755 leetcode/3601-3700/3606.Coupon-Code-Validator/README.md create mode 100644 leetcode/3601-3700/3606.Coupon-Code-Validator/Solution.go create mode 100644 leetcode/3601-3700/3606.Coupon-Code-Validator/Solution_test.go create mode 100755 leetcode/3601-3700/3607.Power-Grid-Maintenance/README.md create mode 100644 leetcode/3601-3700/3607.Power-Grid-Maintenance/Solution.go create mode 100644 leetcode/3601-3700/3607.Power-Grid-Maintenance/Solution_test.go create mode 100755 leetcode/3601-3700/3608.Minimum-Time-for-K-Connected-Components/README.md create mode 100644 leetcode/3601-3700/3608.Minimum-Time-for-K-Connected-Components/Solution.go create mode 100644 leetcode/3601-3700/3608.Minimum-Time-for-K-Connected-Components/Solution_test.go create mode 100755 leetcode/3601-3700/3609.Minimum-Moves-to-Reach-Target-in-Grid/README.md create mode 100644 leetcode/3601-3700/3609.Minimum-Moves-to-Reach-Target-in-Grid/Solution.go create mode 100644 leetcode/3601-3700/3609.Minimum-Moves-to-Reach-Target-in-Grid/Solution_test.go create mode 100755 leetcode/3601-3700/3612.Process-String-with-Special-Operations-I/README.md create mode 100644 leetcode/3601-3700/3612.Process-String-with-Special-Operations-I/Solution.go create mode 100644 leetcode/3601-3700/3612.Process-String-with-Special-Operations-I/Solution_test.go create mode 100755 leetcode/3601-3700/3613.Minimize-Maximum-Component-Cost/README.md create mode 100644 leetcode/3601-3700/3613.Minimize-Maximum-Component-Cost/Solution.go create mode 100644 leetcode/3601-3700/3613.Minimize-Maximum-Component-Cost/Solution_test.go create mode 100755 leetcode/3601-3700/3614.Process-String-with-Special-Operations-II/README.md create mode 100644 leetcode/3601-3700/3614.Process-String-with-Special-Operations-II/Solution.go create mode 100644 leetcode/3601-3700/3614.Process-String-with-Special-Operations-II/Solution_test.go create mode 100755 leetcode/3601-3700/3615.Longest-Palindromic-Path-in-Graph/README.md create mode 100644 leetcode/3601-3700/3615.Longest-Palindromic-Path-in-Graph/Solution.go create mode 100644 leetcode/3601-3700/3615.Longest-Palindromic-Path-in-Graph/Solution_test.go create mode 100755 leetcode/3601-3700/3618.Split-Array-by-Prime-Indices/README.md create mode 100644 leetcode/3601-3700/3618.Split-Array-by-Prime-Indices/Solution.go create mode 100644 leetcode/3601-3700/3618.Split-Array-by-Prime-Indices/Solution_test.go create mode 100755 leetcode/3601-3700/3619.Count-Islands-With-Total-Value-Divisible-by-K/README.md create mode 100644 leetcode/3601-3700/3619.Count-Islands-With-Total-Value-Divisible-by-K/Solution.go create mode 100644 leetcode/3601-3700/3619.Count-Islands-With-Total-Value-Divisible-by-K/Solution_test.go create mode 100755 leetcode/3601-3700/3620.Network-Recovery-Pathways/README.md create mode 100644 leetcode/3601-3700/3620.Network-Recovery-Pathways/Solution.go create mode 100644 leetcode/3601-3700/3620.Network-Recovery-Pathways/Solution_test.go create mode 100755 leetcode/3601-3700/3621.Number-of-Integers-With-Popcount-Depth-Equal-to-K-I/README.md create mode 100644 leetcode/3601-3700/3621.Number-of-Integers-With-Popcount-Depth-Equal-to-K-I/Solution.go create mode 100644 leetcode/3601-3700/3621.Number-of-Integers-With-Popcount-Depth-Equal-to-K-I/Solution_test.go create mode 100755 leetcode/3601-3700/3622.Check-Divisibility-by-Digit-Sum-and-Product/README.md create mode 100644 leetcode/3601-3700/3622.Check-Divisibility-by-Digit-Sum-and-Product/Solution.go create mode 100644 leetcode/3601-3700/3622.Check-Divisibility-by-Digit-Sum-and-Product/Solution_test.go create mode 100755 leetcode/3601-3700/3623.Count-Number-of-Trapezoids-I/README.md create mode 100644 leetcode/3601-3700/3623.Count-Number-of-Trapezoids-I/Solution.go create mode 100644 leetcode/3601-3700/3623.Count-Number-of-Trapezoids-I/Solution_test.go create mode 100755 leetcode/3601-3700/3624.Number-of-Integers-With-Popcount-Depth-Equal-to-K-II/README.md create mode 100644 leetcode/3601-3700/3624.Number-of-Integers-With-Popcount-Depth-Equal-to-K-II/Solution.go create mode 100644 leetcode/3601-3700/3624.Number-of-Integers-With-Popcount-Depth-Equal-to-K-II/Solution_test.go create mode 100755 leetcode/3601-3700/3625.Count-Number-of-Trapezoids-II/README.md create mode 100644 leetcode/3601-3700/3625.Count-Number-of-Trapezoids-II/Solution.go create mode 100644 leetcode/3601-3700/3625.Count-Number-of-Trapezoids-II/Solution_test.go create mode 100755 leetcode/3601-3700/3627.Maximum-Median-Sum-of-Subsequences-of-Size-3/README.md create mode 100644 leetcode/3601-3700/3627.Maximum-Median-Sum-of-Subsequences-of-Size-3/Solution.go create mode 100644 leetcode/3601-3700/3627.Maximum-Median-Sum-of-Subsequences-of-Size-3/Solution_test.go create mode 100755 leetcode/3601-3700/3628.Maximum-Number-of-Subsequences-After-One-Inserting/README.md create mode 100644 leetcode/3601-3700/3628.Maximum-Number-of-Subsequences-After-One-Inserting/Solution.go create mode 100644 leetcode/3601-3700/3628.Maximum-Number-of-Subsequences-After-One-Inserting/Solution_test.go create mode 100755 leetcode/3601-3700/3629.Minimum-Jumps-to-Reach-End-via-Prime-Teleportation/README.md create mode 100644 leetcode/3601-3700/3629.Minimum-Jumps-to-Reach-End-via-Prime-Teleportation/Solution.go create mode 100644 leetcode/3601-3700/3629.Minimum-Jumps-to-Reach-End-via-Prime-Teleportation/Solution_test.go create mode 100755 leetcode/3601-3700/3630.Partition-Array-for-Maximum-XOR-and-AND/README.md create mode 100644 leetcode/3601-3700/3630.Partition-Array-for-Maximum-XOR-and-AND/Solution.go create mode 100644 leetcode/3601-3700/3630.Partition-Array-for-Maximum-XOR-and-AND/Solution_test.go create mode 100755 leetcode/3601-3700/3633.Earliest-Finish-Time-for-Land-and-Water-Rides-I/README.md create mode 100644 leetcode/3601-3700/3633.Earliest-Finish-Time-for-Land-and-Water-Rides-I/Solution.go create mode 100644 leetcode/3601-3700/3633.Earliest-Finish-Time-for-Land-and-Water-Rides-I/Solution_test.go create mode 100755 leetcode/3601-3700/3634.Minimum-Removals-to-Balance-Array/README.md create mode 100644 leetcode/3601-3700/3634.Minimum-Removals-to-Balance-Array/Solution.go create mode 100644 leetcode/3601-3700/3634.Minimum-Removals-to-Balance-Array/Solution_test.go create mode 100755 leetcode/3601-3700/3635.Earliest-Finish-Time-for-Land-and-Water-Rides-II/README.md create mode 100644 leetcode/3601-3700/3635.Earliest-Finish-Time-for-Land-and-Water-Rides-II/Solution.go create mode 100644 leetcode/3601-3700/3635.Earliest-Finish-Time-for-Land-and-Water-Rides-II/Solution_test.go create mode 100755 leetcode/3601-3700/3636.Threshold-Majority-Queries/README.md create mode 100644 leetcode/3601-3700/3636.Threshold-Majority-Queries/Solution.go create mode 100644 leetcode/3601-3700/3636.Threshold-Majority-Queries/Solution_test.go create mode 100755 leetcode/3601-3700/3637.Trionic-Array-I/README.md create mode 100644 leetcode/3601-3700/3637.Trionic-Array-I/Solution.go create mode 100644 leetcode/3601-3700/3637.Trionic-Array-I/Solution_test.go create mode 100755 leetcode/3601-3700/3638.Maximum-Balanced-Shipments/README.md create mode 100644 leetcode/3601-3700/3638.Maximum-Balanced-Shipments/Solution.go create mode 100644 leetcode/3601-3700/3638.Maximum-Balanced-Shipments/Solution_test.go create mode 100755 leetcode/3601-3700/3639.Minimum-Time-to-Activate-String/README.md create mode 100644 leetcode/3601-3700/3639.Minimum-Time-to-Activate-String/Solution.go create mode 100644 leetcode/3601-3700/3639.Minimum-Time-to-Activate-String/Solution_test.go create mode 100755 leetcode/3601-3700/3640.Trionic-Array-II/README.md create mode 100644 leetcode/3601-3700/3640.Trionic-Array-II/Solution.go create mode 100644 leetcode/3601-3700/3640.Trionic-Array-II/Solution_test.go create mode 100755 leetcode/3601-3700/3643.Flip-Square-Submatrix-Vertically/README.md create mode 100644 leetcode/3601-3700/3643.Flip-Square-Submatrix-Vertically/Solution.go create mode 100644 leetcode/3601-3700/3643.Flip-Square-Submatrix-Vertically/Solution_test.go create mode 100755 leetcode/3601-3700/3644.Maximum-K-to-Sort-a-Permutation/README.md create mode 100644 leetcode/3601-3700/3644.Maximum-K-to-Sort-a-Permutation/Solution.go create mode 100644 leetcode/3601-3700/3644.Maximum-K-to-Sort-a-Permutation/Solution_test.go create mode 100755 leetcode/3601-3700/3645.Maximum-Total-from-Optimal-Activation-Order/README.md create mode 100644 leetcode/3601-3700/3645.Maximum-Total-from-Optimal-Activation-Order/Solution.go create mode 100644 leetcode/3601-3700/3645.Maximum-Total-from-Optimal-Activation-Order/Solution_test.go create mode 100755 leetcode/3601-3700/3646.Next-Special-Palindrome-Number/README.md create mode 100644 leetcode/3601-3700/3646.Next-Special-Palindrome-Number/Solution.go create mode 100644 leetcode/3601-3700/3646.Next-Special-Palindrome-Number/Solution_test.go create mode 100755 leetcode/3601-3700/3648.Minimum-Sensors-to-Cover-Grid/README.md create mode 100644 leetcode/3601-3700/3648.Minimum-Sensors-to-Cover-Grid/Solution.go create mode 100644 leetcode/3601-3700/3648.Minimum-Sensors-to-Cover-Grid/Solution_test.go create mode 100755 leetcode/3601-3700/3649.Number-of-Perfect-Pairs/README.md create mode 100644 leetcode/3601-3700/3649.Number-of-Perfect-Pairs/Solution.go create mode 100644 leetcode/3601-3700/3649.Number-of-Perfect-Pairs/Solution_test.go create mode 100755 leetcode/3601-3700/3650.Minimum-Cost-Path-with-Edge-Reversals/README.md create mode 100644 leetcode/3601-3700/3650.Minimum-Cost-Path-with-Edge-Reversals/Solution.go create mode 100644 leetcode/3601-3700/3650.Minimum-Cost-Path-with-Edge-Reversals/Solution_test.go create mode 100755 leetcode/3601-3700/3651.Minimum-Cost-Path-with-Teleportations/README.md create mode 100644 leetcode/3601-3700/3651.Minimum-Cost-Path-with-Teleportations/Solution.go create mode 100644 leetcode/3601-3700/3651.Minimum-Cost-Path-with-Teleportations/Solution_test.go create mode 100755 leetcode/3601-3700/3652.Best-Time-to-Buy-and-Sell-Stock-using-Strategy/README.md create mode 100644 leetcode/3601-3700/3652.Best-Time-to-Buy-and-Sell-Stock-using-Strategy/Solution.go create mode 100644 leetcode/3601-3700/3652.Best-Time-to-Buy-and-Sell-Stock-using-Strategy/Solution_test.go create mode 100755 leetcode/3601-3700/3653.XOR-After-Range-Multiplication-Queries-I/README.md create mode 100644 leetcode/3601-3700/3653.XOR-After-Range-Multiplication-Queries-I/Solution.go create mode 100644 leetcode/3601-3700/3653.XOR-After-Range-Multiplication-Queries-I/Solution_test.go create mode 100755 leetcode/3601-3700/3654.Minimum-Sum-After-Divisible-Sum-Deletions/README.md create mode 100644 leetcode/3601-3700/3654.Minimum-Sum-After-Divisible-Sum-Deletions/Solution.go create mode 100644 leetcode/3601-3700/3654.Minimum-Sum-After-Divisible-Sum-Deletions/Solution_test.go create mode 100755 leetcode/3601-3700/3655.XOR-After-Range-Multiplication-Queries-II/README.md create mode 100644 leetcode/3601-3700/3655.XOR-After-Range-Multiplication-Queries-II/Solution.go create mode 100644 leetcode/3601-3700/3655.XOR-After-Range-Multiplication-Queries-II/Solution_test.go create mode 100755 leetcode/3601-3700/3658.GCD-of-Odd-and-Even-Sums/README.md create mode 100644 leetcode/3601-3700/3658.GCD-of-Odd-and-Even-Sums/Solution.go create mode 100644 leetcode/3601-3700/3658.GCD-of-Odd-and-Even-Sums/Solution_test.go create mode 100755 leetcode/3601-3700/3659.Partition-Array-Into-K-Distinct-Groups/README.md create mode 100644 leetcode/3601-3700/3659.Partition-Array-Into-K-Distinct-Groups/Solution.go create mode 100644 leetcode/3601-3700/3659.Partition-Array-Into-K-Distinct-Groups/Solution_test.go create mode 100755 leetcode/3601-3700/3660.Jump-Game-IX/README.md create mode 100644 leetcode/3601-3700/3660.Jump-Game-IX/Solution.go create mode 100644 leetcode/3601-3700/3660.Jump-Game-IX/Solution_test.go create mode 100755 leetcode/3601-3700/3661.Maximum-Walls-Destroyed-by-Robots/README.md create mode 100644 leetcode/3601-3700/3661.Maximum-Walls-Destroyed-by-Robots/Solution.go create mode 100644 leetcode/3601-3700/3661.Maximum-Walls-Destroyed-by-Robots/Solution_test.go create mode 100755 leetcode/3601-3700/3663.Find-The-Least-Frequent-Digit/README.md create mode 100644 leetcode/3601-3700/3663.Find-The-Least-Frequent-Digit/Solution.go create mode 100644 leetcode/3601-3700/3663.Find-The-Least-Frequent-Digit/Solution_test.go create mode 100755 leetcode/3601-3700/3664.Two-Letter-Card-Game/README.md create mode 100644 leetcode/3601-3700/3664.Two-Letter-Card-Game/Solution.go create mode 100644 leetcode/3601-3700/3664.Two-Letter-Card-Game/Solution_test.go create mode 100755 leetcode/3601-3700/3665.Twisted-Mirror-Path-Count/README.md create mode 100644 leetcode/3601-3700/3665.Twisted-Mirror-Path-Count/Solution.go create mode 100644 leetcode/3601-3700/3665.Twisted-Mirror-Path-Count/Solution_test.go create mode 100755 leetcode/3601-3700/3666.Minimum-Operations-to-Equalize-Binary-String/README.md create mode 100644 leetcode/3601-3700/3666.Minimum-Operations-to-Equalize-Binary-String/Solution.go create mode 100644 leetcode/3601-3700/3666.Minimum-Operations-to-Equalize-Binary-String/Solution_test.go create mode 100755 leetcode/3601-3700/3668.Restore-Finishing-Order/README.md create mode 100644 leetcode/3601-3700/3668.Restore-Finishing-Order/Solution.go create mode 100644 leetcode/3601-3700/3668.Restore-Finishing-Order/Solution_test.go create mode 100755 leetcode/3601-3700/3669.Balanced-K-Factor-Decomposition/README.md create mode 100644 leetcode/3601-3700/3669.Balanced-K-Factor-Decomposition/Solution.go create mode 100644 leetcode/3601-3700/3669.Balanced-K-Factor-Decomposition/Solution_test.go create mode 100755 leetcode/3601-3700/3670.Maximum-Product-of-Two-Integers-With-No-Common-Bits/README.md create mode 100644 leetcode/3601-3700/3670.Maximum-Product-of-Two-Integers-With-No-Common-Bits/Solution.go create mode 100644 leetcode/3601-3700/3670.Maximum-Product-of-Two-Integers-With-No-Common-Bits/Solution_test.go create mode 100755 leetcode/3601-3700/3671.Sum-of-Beautiful-Subsequences/README.md create mode 100644 leetcode/3601-3700/3671.Sum-of-Beautiful-Subsequences/Solution.go create mode 100644 leetcode/3601-3700/3671.Sum-of-Beautiful-Subsequences/Solution_test.go create mode 100755 leetcode/3601-3700/3674.Minimum-Operations-to-Equalize-Array/README.md create mode 100644 leetcode/3601-3700/3674.Minimum-Operations-to-Equalize-Array/Solution.go create mode 100644 leetcode/3601-3700/3674.Minimum-Operations-to-Equalize-Array/Solution_test.go create mode 100755 leetcode/3601-3700/3675.Minimum-Operations-to-Transform-String/README.md create mode 100644 leetcode/3601-3700/3675.Minimum-Operations-to-Transform-String/Solution.go create mode 100644 leetcode/3601-3700/3675.Minimum-Operations-to-Transform-String/Solution_test.go create mode 100755 leetcode/3601-3700/3676.Count-Bowl-Subarrays/README.md create mode 100644 leetcode/3601-3700/3676.Count-Bowl-Subarrays/Solution.go create mode 100644 leetcode/3601-3700/3676.Count-Bowl-Subarrays/Solution_test.go create mode 100755 leetcode/3601-3700/3677.Count-Binary-Palindromic-Numbers/README.md create mode 100644 leetcode/3601-3700/3677.Count-Binary-Palindromic-Numbers/Solution.go create mode 100644 leetcode/3601-3700/3677.Count-Binary-Palindromic-Numbers/Solution_test.go create mode 100755 leetcode/3601-3700/3678.Smallest-Absent-Positive-Greater-Than-Average/README.md create mode 100644 leetcode/3601-3700/3678.Smallest-Absent-Positive-Greater-Than-Average/Solution.go create mode 100644 leetcode/3601-3700/3678.Smallest-Absent-Positive-Greater-Than-Average/Solution_test.go create mode 100755 leetcode/3601-3700/3679.Minimum-Discards-to-Balance-Inventory/README.md create mode 100644 leetcode/3601-3700/3679.Minimum-Discards-to-Balance-Inventory/Solution.go create mode 100644 leetcode/3601-3700/3679.Minimum-Discards-to-Balance-Inventory/Solution_test.go create mode 100755 leetcode/3601-3700/3680.Generate-Schedule/README.md create mode 100644 leetcode/3601-3700/3680.Generate-Schedule/Solution.go create mode 100644 leetcode/3601-3700/3680.Generate-Schedule/Solution_test.go create mode 100755 leetcode/3601-3700/3681.Maximum-XOR-of-Subsequences/README.md create mode 100644 leetcode/3601-3700/3681.Maximum-XOR-of-Subsequences/Solution.go create mode 100644 leetcode/3601-3700/3681.Maximum-XOR-of-Subsequences/Solution_test.go create mode 100755 leetcode/3601-3700/3683.Earliest-Time-to-Finish-One-Task/README.md create mode 100644 leetcode/3601-3700/3683.Earliest-Time-to-Finish-One-Task/Solution.go create mode 100644 leetcode/3601-3700/3683.Earliest-Time-to-Finish-One-Task/Solution_test.go create mode 100755 leetcode/3601-3700/3684.Maximize-Sum-of-At-Most-K-Distinct-Elements/README.md create mode 100644 leetcode/3601-3700/3684.Maximize-Sum-of-At-Most-K-Distinct-Elements/Solution.go create mode 100644 leetcode/3601-3700/3684.Maximize-Sum-of-At-Most-K-Distinct-Elements/Solution_test.go create mode 100755 leetcode/3601-3700/3685.Subsequence-Sum-After-Capping-Elements/README.md create mode 100644 leetcode/3601-3700/3685.Subsequence-Sum-After-Capping-Elements/Solution.go create mode 100644 leetcode/3601-3700/3685.Subsequence-Sum-After-Capping-Elements/Solution_test.go create mode 100755 leetcode/3601-3700/3686.Number-of-Stable-Subsequences/README.md create mode 100644 leetcode/3601-3700/3686.Number-of-Stable-Subsequences/Solution.go create mode 100644 leetcode/3601-3700/3686.Number-of-Stable-Subsequences/Solution_test.go create mode 100755 leetcode/3601-3700/3688.Bitwise-OR-of-Even-Numbers-in-an-Array/README.md create mode 100644 leetcode/3601-3700/3688.Bitwise-OR-of-Even-Numbers-in-an-Array/Solution.go create mode 100644 leetcode/3601-3700/3688.Bitwise-OR-of-Even-Numbers-in-an-Array/Solution_test.go create mode 100755 leetcode/3601-3700/3689.Maximum-Total-Subarray-Value-I/README.md create mode 100644 leetcode/3601-3700/3689.Maximum-Total-Subarray-Value-I/Solution.go create mode 100644 leetcode/3601-3700/3689.Maximum-Total-Subarray-Value-I/Solution_test.go create mode 100755 leetcode/3601-3700/3690.Split-and-Merge-Array-Transformation/README.md create mode 100644 leetcode/3601-3700/3690.Split-and-Merge-Array-Transformation/Solution.go create mode 100644 leetcode/3601-3700/3690.Split-and-Merge-Array-Transformation/Solution_test.go create mode 100755 leetcode/3601-3700/3691.Maximum-Total-Subarray-Value-II/README.md create mode 100644 leetcode/3601-3700/3691.Maximum-Total-Subarray-Value-II/Solution.go create mode 100644 leetcode/3601-3700/3691.Maximum-Total-Subarray-Value-II/Solution_test.go create mode 100755 leetcode/3601-3700/3692.Majority-Frequency-Characters/README.md create mode 100644 leetcode/3601-3700/3692.Majority-Frequency-Characters/Solution.go create mode 100644 leetcode/3601-3700/3692.Majority-Frequency-Characters/Solution_test.go create mode 100755 leetcode/3601-3700/3693.Climbing-Stairs-II/README.md create mode 100644 leetcode/3601-3700/3693.Climbing-Stairs-II/Solution.go create mode 100644 leetcode/3601-3700/3693.Climbing-Stairs-II/Solution_test.go create mode 100755 leetcode/3601-3700/3694.Distinct-Points-Reachable-After-Substring-Removal/README.md create mode 100644 leetcode/3601-3700/3694.Distinct-Points-Reachable-After-Substring-Removal/Solution.go create mode 100644 leetcode/3601-3700/3694.Distinct-Points-Reachable-After-Substring-Removal/Solution_test.go create mode 100755 leetcode/3601-3700/3695.Maximize-Alternating-Sum-Using-Swaps/README.md create mode 100644 leetcode/3601-3700/3695.Maximize-Alternating-Sum-Using-Swaps/Solution.go create mode 100644 leetcode/3601-3700/3695.Maximize-Alternating-Sum-Using-Swaps/Solution_test.go create mode 100755 leetcode/3601-3700/3697.Compute-Decimal-Representation/README.md create mode 100644 leetcode/3601-3700/3697.Compute-Decimal-Representation/Solution.go create mode 100644 leetcode/3601-3700/3697.Compute-Decimal-Representation/Solution_test.go create mode 100755 leetcode/3601-3700/3698.Split-Array-With-Minimum-Difference/README.md create mode 100644 leetcode/3601-3700/3698.Split-Array-With-Minimum-Difference/Solution.go create mode 100644 leetcode/3601-3700/3698.Split-Array-With-Minimum-Difference/Solution_test.go create mode 100755 leetcode/3601-3700/3699.Number-of-ZigZag-Arrays-I/README.md create mode 100644 leetcode/3601-3700/3699.Number-of-ZigZag-Arrays-I/Solution.go create mode 100644 leetcode/3601-3700/3699.Number-of-ZigZag-Arrays-I/Solution_test.go create mode 100755 leetcode/3601-3700/3700.Number-of-ZigZag-Arrays-II/README.md create mode 100644 leetcode/3601-3700/3700.Number-of-ZigZag-Arrays-II/Solution.go create mode 100644 leetcode/3601-3700/3700.Number-of-ZigZag-Arrays-II/Solution_test.go diff --git a/cmd/main.go b/cmd/main.go index 759d7345b..39cacb62d 100644 --- a/cmd/main.go +++ b/cmd/main.go @@ -36,7 +36,8 @@ func main() { //leetcode.MakeDirFromTo(problems, 3101, 3200) //leetcode.MakeDirFromTo(problems, 3201, 3300) //leetcode.MakeDirFromTo(problems, 3301, 3400) - leetcode.MakeDirFromTo(problems, 3401, 3500) + //leetcode.MakeDirFromTo(problems, 3401, 3500) + leetcode.MakeDirFromTo(problems, 3601, 3700) // leetcode.MakeDir(problems) diff --git a/leetcode/3601-3700/3602.Hexadecimal-and-Hexatrigesimal-Conversion/README.md b/leetcode/3601-3700/3602.Hexadecimal-and-Hexatrigesimal-Conversion/README.md new file mode 100755 index 000000000..a995d7061 --- /dev/null +++ b/leetcode/3601-3700/3602.Hexadecimal-and-Hexatrigesimal-Conversion/README.md @@ -0,0 +1,32 @@ +# [3602.Hexadecimal and Hexatrigesimal Conversion][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Hexadecimal and Hexatrigesimal Conversion +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/hexadecimal-and-hexatrigesimal-conversion/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3602.Hexadecimal-and-Hexatrigesimal-Conversion/Solution.go b/leetcode/3601-3700/3602.Hexadecimal-and-Hexatrigesimal-Conversion/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3602.Hexadecimal-and-Hexatrigesimal-Conversion/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3602.Hexadecimal-and-Hexatrigesimal-Conversion/Solution_test.go b/leetcode/3601-3700/3602.Hexadecimal-and-Hexatrigesimal-Conversion/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3602.Hexadecimal-and-Hexatrigesimal-Conversion/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3603.Minimum-Cost-Path-with-Alternating-Directions-II/README.md b/leetcode/3601-3700/3603.Minimum-Cost-Path-with-Alternating-Directions-II/README.md new file mode 100755 index 000000000..acd72ad1b --- /dev/null +++ b/leetcode/3601-3700/3603.Minimum-Cost-Path-with-Alternating-Directions-II/README.md @@ -0,0 +1,32 @@ +# [3603.Minimum Cost Path with Alternating Directions II][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Minimum Cost Path with Alternating Directions II +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/minimum-cost-path-with-alternating-directions-ii/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3603.Minimum-Cost-Path-with-Alternating-Directions-II/Solution.go b/leetcode/3601-3700/3603.Minimum-Cost-Path-with-Alternating-Directions-II/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3603.Minimum-Cost-Path-with-Alternating-Directions-II/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3603.Minimum-Cost-Path-with-Alternating-Directions-II/Solution_test.go b/leetcode/3601-3700/3603.Minimum-Cost-Path-with-Alternating-Directions-II/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3603.Minimum-Cost-Path-with-Alternating-Directions-II/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3604.Minimum-Time-to-Reach-Destination-in-Directed-Graph/README.md b/leetcode/3601-3700/3604.Minimum-Time-to-Reach-Destination-in-Directed-Graph/README.md new file mode 100755 index 000000000..c72367d30 --- /dev/null +++ b/leetcode/3601-3700/3604.Minimum-Time-to-Reach-Destination-in-Directed-Graph/README.md @@ -0,0 +1,32 @@ +# [3604.Minimum Time to Reach Destination in Directed Graph][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Minimum Time to Reach Destination in Directed Graph +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/minimum-time-to-reach-destination-in-directed-graph/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3604.Minimum-Time-to-Reach-Destination-in-Directed-Graph/Solution.go b/leetcode/3601-3700/3604.Minimum-Time-to-Reach-Destination-in-Directed-Graph/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3604.Minimum-Time-to-Reach-Destination-in-Directed-Graph/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3604.Minimum-Time-to-Reach-Destination-in-Directed-Graph/Solution_test.go b/leetcode/3601-3700/3604.Minimum-Time-to-Reach-Destination-in-Directed-Graph/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3604.Minimum-Time-to-Reach-Destination-in-Directed-Graph/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3605.Minimum-Stability-Factor-of-Array/README.md b/leetcode/3601-3700/3605.Minimum-Stability-Factor-of-Array/README.md new file mode 100755 index 000000000..dd2247a1d --- /dev/null +++ b/leetcode/3601-3700/3605.Minimum-Stability-Factor-of-Array/README.md @@ -0,0 +1,32 @@ +# [3605.Minimum Stability Factor of Array][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Minimum Stability Factor of Array +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/minimum-stability-factor-of-array/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3605.Minimum-Stability-Factor-of-Array/Solution.go b/leetcode/3601-3700/3605.Minimum-Stability-Factor-of-Array/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3605.Minimum-Stability-Factor-of-Array/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3605.Minimum-Stability-Factor-of-Array/Solution_test.go b/leetcode/3601-3700/3605.Minimum-Stability-Factor-of-Array/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3605.Minimum-Stability-Factor-of-Array/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3606.Coupon-Code-Validator/README.md b/leetcode/3601-3700/3606.Coupon-Code-Validator/README.md new file mode 100755 index 000000000..84f3a2205 --- /dev/null +++ b/leetcode/3601-3700/3606.Coupon-Code-Validator/README.md @@ -0,0 +1,32 @@ +# [3606.Coupon Code Validator][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Coupon Code Validator +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/coupon-code-validator/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3606.Coupon-Code-Validator/Solution.go b/leetcode/3601-3700/3606.Coupon-Code-Validator/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3606.Coupon-Code-Validator/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3606.Coupon-Code-Validator/Solution_test.go b/leetcode/3601-3700/3606.Coupon-Code-Validator/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3606.Coupon-Code-Validator/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3607.Power-Grid-Maintenance/README.md b/leetcode/3601-3700/3607.Power-Grid-Maintenance/README.md new file mode 100755 index 000000000..9b12a71d8 --- /dev/null +++ b/leetcode/3601-3700/3607.Power-Grid-Maintenance/README.md @@ -0,0 +1,32 @@ +# [3607.Power Grid Maintenance][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Power Grid Maintenance +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/power-grid-maintenance/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3607.Power-Grid-Maintenance/Solution.go b/leetcode/3601-3700/3607.Power-Grid-Maintenance/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3607.Power-Grid-Maintenance/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3607.Power-Grid-Maintenance/Solution_test.go b/leetcode/3601-3700/3607.Power-Grid-Maintenance/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3607.Power-Grid-Maintenance/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3608.Minimum-Time-for-K-Connected-Components/README.md b/leetcode/3601-3700/3608.Minimum-Time-for-K-Connected-Components/README.md new file mode 100755 index 000000000..293cfedab --- /dev/null +++ b/leetcode/3601-3700/3608.Minimum-Time-for-K-Connected-Components/README.md @@ -0,0 +1,32 @@ +# [3608.Minimum Time for K Connected Components][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Minimum Time for K Connected Components +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/minimum-time-for-k-connected-components/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3608.Minimum-Time-for-K-Connected-Components/Solution.go b/leetcode/3601-3700/3608.Minimum-Time-for-K-Connected-Components/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3608.Minimum-Time-for-K-Connected-Components/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3608.Minimum-Time-for-K-Connected-Components/Solution_test.go b/leetcode/3601-3700/3608.Minimum-Time-for-K-Connected-Components/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3608.Minimum-Time-for-K-Connected-Components/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3609.Minimum-Moves-to-Reach-Target-in-Grid/README.md b/leetcode/3601-3700/3609.Minimum-Moves-to-Reach-Target-in-Grid/README.md new file mode 100755 index 000000000..5bd3af049 --- /dev/null +++ b/leetcode/3601-3700/3609.Minimum-Moves-to-Reach-Target-in-Grid/README.md @@ -0,0 +1,32 @@ +# [3609.Minimum Moves to Reach Target in Grid][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Minimum Moves to Reach Target in Grid +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/minimum-moves-to-reach-target-in-grid/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3609.Minimum-Moves-to-Reach-Target-in-Grid/Solution.go b/leetcode/3601-3700/3609.Minimum-Moves-to-Reach-Target-in-Grid/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3609.Minimum-Moves-to-Reach-Target-in-Grid/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3609.Minimum-Moves-to-Reach-Target-in-Grid/Solution_test.go b/leetcode/3601-3700/3609.Minimum-Moves-to-Reach-Target-in-Grid/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3609.Minimum-Moves-to-Reach-Target-in-Grid/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3612.Process-String-with-Special-Operations-I/README.md b/leetcode/3601-3700/3612.Process-String-with-Special-Operations-I/README.md new file mode 100755 index 000000000..59d9b1374 --- /dev/null +++ b/leetcode/3601-3700/3612.Process-String-with-Special-Operations-I/README.md @@ -0,0 +1,32 @@ +# [3612.Process String with Special Operations I][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Process String with Special Operations I +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/process-string-with-special-operations-i/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3612.Process-String-with-Special-Operations-I/Solution.go b/leetcode/3601-3700/3612.Process-String-with-Special-Operations-I/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3612.Process-String-with-Special-Operations-I/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3612.Process-String-with-Special-Operations-I/Solution_test.go b/leetcode/3601-3700/3612.Process-String-with-Special-Operations-I/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3612.Process-String-with-Special-Operations-I/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3613.Minimize-Maximum-Component-Cost/README.md b/leetcode/3601-3700/3613.Minimize-Maximum-Component-Cost/README.md new file mode 100755 index 000000000..7c47435d7 --- /dev/null +++ b/leetcode/3601-3700/3613.Minimize-Maximum-Component-Cost/README.md @@ -0,0 +1,32 @@ +# [3613.Minimize Maximum Component Cost][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Minimize Maximum Component Cost +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/minimize-maximum-component-cost/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3613.Minimize-Maximum-Component-Cost/Solution.go b/leetcode/3601-3700/3613.Minimize-Maximum-Component-Cost/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3613.Minimize-Maximum-Component-Cost/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3613.Minimize-Maximum-Component-Cost/Solution_test.go b/leetcode/3601-3700/3613.Minimize-Maximum-Component-Cost/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3613.Minimize-Maximum-Component-Cost/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3614.Process-String-with-Special-Operations-II/README.md b/leetcode/3601-3700/3614.Process-String-with-Special-Operations-II/README.md new file mode 100755 index 000000000..55c747dd4 --- /dev/null +++ b/leetcode/3601-3700/3614.Process-String-with-Special-Operations-II/README.md @@ -0,0 +1,32 @@ +# [3614.Process String with Special Operations II][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Process String with Special Operations II +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/process-string-with-special-operations-ii/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3614.Process-String-with-Special-Operations-II/Solution.go b/leetcode/3601-3700/3614.Process-String-with-Special-Operations-II/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3614.Process-String-with-Special-Operations-II/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3614.Process-String-with-Special-Operations-II/Solution_test.go b/leetcode/3601-3700/3614.Process-String-with-Special-Operations-II/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3614.Process-String-with-Special-Operations-II/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3615.Longest-Palindromic-Path-in-Graph/README.md b/leetcode/3601-3700/3615.Longest-Palindromic-Path-in-Graph/README.md new file mode 100755 index 000000000..267b68a89 --- /dev/null +++ b/leetcode/3601-3700/3615.Longest-Palindromic-Path-in-Graph/README.md @@ -0,0 +1,32 @@ +# [3615.Longest Palindromic Path in Graph][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Longest Palindromic Path in Graph +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/longest-palindromic-path-in-graph/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3615.Longest-Palindromic-Path-in-Graph/Solution.go b/leetcode/3601-3700/3615.Longest-Palindromic-Path-in-Graph/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3615.Longest-Palindromic-Path-in-Graph/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3615.Longest-Palindromic-Path-in-Graph/Solution_test.go b/leetcode/3601-3700/3615.Longest-Palindromic-Path-in-Graph/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3615.Longest-Palindromic-Path-in-Graph/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3618.Split-Array-by-Prime-Indices/README.md b/leetcode/3601-3700/3618.Split-Array-by-Prime-Indices/README.md new file mode 100755 index 000000000..753f1bf18 --- /dev/null +++ b/leetcode/3601-3700/3618.Split-Array-by-Prime-Indices/README.md @@ -0,0 +1,32 @@ +# [3618.Split Array by Prime Indices][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Split Array by Prime Indices +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/split-array-by-prime-indices/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3618.Split-Array-by-Prime-Indices/Solution.go b/leetcode/3601-3700/3618.Split-Array-by-Prime-Indices/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3618.Split-Array-by-Prime-Indices/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3618.Split-Array-by-Prime-Indices/Solution_test.go b/leetcode/3601-3700/3618.Split-Array-by-Prime-Indices/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3618.Split-Array-by-Prime-Indices/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3619.Count-Islands-With-Total-Value-Divisible-by-K/README.md b/leetcode/3601-3700/3619.Count-Islands-With-Total-Value-Divisible-by-K/README.md new file mode 100755 index 000000000..3298e0b40 --- /dev/null +++ b/leetcode/3601-3700/3619.Count-Islands-With-Total-Value-Divisible-by-K/README.md @@ -0,0 +1,32 @@ +# [3619.Count Islands With Total Value Divisible by K][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Count Islands With Total Value Divisible by K +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/count-islands-with-total-value-divisible-by-k/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3619.Count-Islands-With-Total-Value-Divisible-by-K/Solution.go b/leetcode/3601-3700/3619.Count-Islands-With-Total-Value-Divisible-by-K/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3619.Count-Islands-With-Total-Value-Divisible-by-K/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3619.Count-Islands-With-Total-Value-Divisible-by-K/Solution_test.go b/leetcode/3601-3700/3619.Count-Islands-With-Total-Value-Divisible-by-K/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3619.Count-Islands-With-Total-Value-Divisible-by-K/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3620.Network-Recovery-Pathways/README.md b/leetcode/3601-3700/3620.Network-Recovery-Pathways/README.md new file mode 100755 index 000000000..a54ac9420 --- /dev/null +++ b/leetcode/3601-3700/3620.Network-Recovery-Pathways/README.md @@ -0,0 +1,32 @@ +# [3620.Network Recovery Pathways][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Network Recovery Pathways +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/network-recovery-pathways/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3620.Network-Recovery-Pathways/Solution.go b/leetcode/3601-3700/3620.Network-Recovery-Pathways/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3620.Network-Recovery-Pathways/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3620.Network-Recovery-Pathways/Solution_test.go b/leetcode/3601-3700/3620.Network-Recovery-Pathways/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3620.Network-Recovery-Pathways/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3621.Number-of-Integers-With-Popcount-Depth-Equal-to-K-I/README.md b/leetcode/3601-3700/3621.Number-of-Integers-With-Popcount-Depth-Equal-to-K-I/README.md new file mode 100755 index 000000000..30c7d6cba --- /dev/null +++ b/leetcode/3601-3700/3621.Number-of-Integers-With-Popcount-Depth-Equal-to-K-I/README.md @@ -0,0 +1,32 @@ +# [3621.Number of Integers With Popcount-Depth Equal to K I][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Number of Integers With Popcount-Depth Equal to K I +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/number-of-integers-with-popcount-depth-equal-to-k-i/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3621.Number-of-Integers-With-Popcount-Depth-Equal-to-K-I/Solution.go b/leetcode/3601-3700/3621.Number-of-Integers-With-Popcount-Depth-Equal-to-K-I/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3621.Number-of-Integers-With-Popcount-Depth-Equal-to-K-I/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3621.Number-of-Integers-With-Popcount-Depth-Equal-to-K-I/Solution_test.go b/leetcode/3601-3700/3621.Number-of-Integers-With-Popcount-Depth-Equal-to-K-I/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3621.Number-of-Integers-With-Popcount-Depth-Equal-to-K-I/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3622.Check-Divisibility-by-Digit-Sum-and-Product/README.md b/leetcode/3601-3700/3622.Check-Divisibility-by-Digit-Sum-and-Product/README.md new file mode 100755 index 000000000..7af8f888a --- /dev/null +++ b/leetcode/3601-3700/3622.Check-Divisibility-by-Digit-Sum-and-Product/README.md @@ -0,0 +1,32 @@ +# [3622.Check Divisibility by Digit Sum and Product][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Check Divisibility by Digit Sum and Product +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/check-divisibility-by-digit-sum-and-product/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3622.Check-Divisibility-by-Digit-Sum-and-Product/Solution.go b/leetcode/3601-3700/3622.Check-Divisibility-by-Digit-Sum-and-Product/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3622.Check-Divisibility-by-Digit-Sum-and-Product/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3622.Check-Divisibility-by-Digit-Sum-and-Product/Solution_test.go b/leetcode/3601-3700/3622.Check-Divisibility-by-Digit-Sum-and-Product/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3622.Check-Divisibility-by-Digit-Sum-and-Product/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3623.Count-Number-of-Trapezoids-I/README.md b/leetcode/3601-3700/3623.Count-Number-of-Trapezoids-I/README.md new file mode 100755 index 000000000..f0661db50 --- /dev/null +++ b/leetcode/3601-3700/3623.Count-Number-of-Trapezoids-I/README.md @@ -0,0 +1,32 @@ +# [3623.Count Number of Trapezoids I][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Count Number of Trapezoids I +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/count-number-of-trapezoids-i/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3623.Count-Number-of-Trapezoids-I/Solution.go b/leetcode/3601-3700/3623.Count-Number-of-Trapezoids-I/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3623.Count-Number-of-Trapezoids-I/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3623.Count-Number-of-Trapezoids-I/Solution_test.go b/leetcode/3601-3700/3623.Count-Number-of-Trapezoids-I/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3623.Count-Number-of-Trapezoids-I/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3624.Number-of-Integers-With-Popcount-Depth-Equal-to-K-II/README.md b/leetcode/3601-3700/3624.Number-of-Integers-With-Popcount-Depth-Equal-to-K-II/README.md new file mode 100755 index 000000000..e464830fe --- /dev/null +++ b/leetcode/3601-3700/3624.Number-of-Integers-With-Popcount-Depth-Equal-to-K-II/README.md @@ -0,0 +1,32 @@ +# [3624.Number of Integers With Popcount-Depth Equal to K II][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Number of Integers With Popcount-Depth Equal to K II +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/number-of-integers-with-popcount-depth-equal-to-k-ii/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3624.Number-of-Integers-With-Popcount-Depth-Equal-to-K-II/Solution.go b/leetcode/3601-3700/3624.Number-of-Integers-With-Popcount-Depth-Equal-to-K-II/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3624.Number-of-Integers-With-Popcount-Depth-Equal-to-K-II/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3624.Number-of-Integers-With-Popcount-Depth-Equal-to-K-II/Solution_test.go b/leetcode/3601-3700/3624.Number-of-Integers-With-Popcount-Depth-Equal-to-K-II/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3624.Number-of-Integers-With-Popcount-Depth-Equal-to-K-II/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3625.Count-Number-of-Trapezoids-II/README.md b/leetcode/3601-3700/3625.Count-Number-of-Trapezoids-II/README.md new file mode 100755 index 000000000..1f379be55 --- /dev/null +++ b/leetcode/3601-3700/3625.Count-Number-of-Trapezoids-II/README.md @@ -0,0 +1,32 @@ +# [3625.Count Number of Trapezoids II][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Count Number of Trapezoids II +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/count-number-of-trapezoids-ii/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3625.Count-Number-of-Trapezoids-II/Solution.go b/leetcode/3601-3700/3625.Count-Number-of-Trapezoids-II/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3625.Count-Number-of-Trapezoids-II/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3625.Count-Number-of-Trapezoids-II/Solution_test.go b/leetcode/3601-3700/3625.Count-Number-of-Trapezoids-II/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3625.Count-Number-of-Trapezoids-II/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3627.Maximum-Median-Sum-of-Subsequences-of-Size-3/README.md b/leetcode/3601-3700/3627.Maximum-Median-Sum-of-Subsequences-of-Size-3/README.md new file mode 100755 index 000000000..4245d830a --- /dev/null +++ b/leetcode/3601-3700/3627.Maximum-Median-Sum-of-Subsequences-of-Size-3/README.md @@ -0,0 +1,32 @@ +# [3627.Maximum Median Sum of Subsequences of Size 3][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Maximum Median Sum of Subsequences of Size 3 +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/maximum-median-sum-of-subsequences-of-size-3/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3627.Maximum-Median-Sum-of-Subsequences-of-Size-3/Solution.go b/leetcode/3601-3700/3627.Maximum-Median-Sum-of-Subsequences-of-Size-3/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3627.Maximum-Median-Sum-of-Subsequences-of-Size-3/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3627.Maximum-Median-Sum-of-Subsequences-of-Size-3/Solution_test.go b/leetcode/3601-3700/3627.Maximum-Median-Sum-of-Subsequences-of-Size-3/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3627.Maximum-Median-Sum-of-Subsequences-of-Size-3/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3628.Maximum-Number-of-Subsequences-After-One-Inserting/README.md b/leetcode/3601-3700/3628.Maximum-Number-of-Subsequences-After-One-Inserting/README.md new file mode 100755 index 000000000..931ef2464 --- /dev/null +++ b/leetcode/3601-3700/3628.Maximum-Number-of-Subsequences-After-One-Inserting/README.md @@ -0,0 +1,32 @@ +# [3628.Maximum Number of Subsequences After One Inserting][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Maximum Number of Subsequences After One Inserting +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/maximum-number-of-subsequences-after-one-inserting/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3628.Maximum-Number-of-Subsequences-After-One-Inserting/Solution.go b/leetcode/3601-3700/3628.Maximum-Number-of-Subsequences-After-One-Inserting/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3628.Maximum-Number-of-Subsequences-After-One-Inserting/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3628.Maximum-Number-of-Subsequences-After-One-Inserting/Solution_test.go b/leetcode/3601-3700/3628.Maximum-Number-of-Subsequences-After-One-Inserting/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3628.Maximum-Number-of-Subsequences-After-One-Inserting/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3629.Minimum-Jumps-to-Reach-End-via-Prime-Teleportation/README.md b/leetcode/3601-3700/3629.Minimum-Jumps-to-Reach-End-via-Prime-Teleportation/README.md new file mode 100755 index 000000000..7b221ce1c --- /dev/null +++ b/leetcode/3601-3700/3629.Minimum-Jumps-to-Reach-End-via-Prime-Teleportation/README.md @@ -0,0 +1,32 @@ +# [3629.Minimum Jumps to Reach End via Prime Teleportation][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Minimum Jumps to Reach End via Prime Teleportation +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/minimum-jumps-to-reach-end-via-prime-teleportation/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3629.Minimum-Jumps-to-Reach-End-via-Prime-Teleportation/Solution.go b/leetcode/3601-3700/3629.Minimum-Jumps-to-Reach-End-via-Prime-Teleportation/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3629.Minimum-Jumps-to-Reach-End-via-Prime-Teleportation/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3629.Minimum-Jumps-to-Reach-End-via-Prime-Teleportation/Solution_test.go b/leetcode/3601-3700/3629.Minimum-Jumps-to-Reach-End-via-Prime-Teleportation/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3629.Minimum-Jumps-to-Reach-End-via-Prime-Teleportation/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3630.Partition-Array-for-Maximum-XOR-and-AND/README.md b/leetcode/3601-3700/3630.Partition-Array-for-Maximum-XOR-and-AND/README.md new file mode 100755 index 000000000..aa0e2f013 --- /dev/null +++ b/leetcode/3601-3700/3630.Partition-Array-for-Maximum-XOR-and-AND/README.md @@ -0,0 +1,32 @@ +# [3630.Partition Array for Maximum XOR and AND][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Partition Array for Maximum XOR and AND +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/partition-array-for-maximum-xor-and-and/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3630.Partition-Array-for-Maximum-XOR-and-AND/Solution.go b/leetcode/3601-3700/3630.Partition-Array-for-Maximum-XOR-and-AND/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3630.Partition-Array-for-Maximum-XOR-and-AND/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3630.Partition-Array-for-Maximum-XOR-and-AND/Solution_test.go b/leetcode/3601-3700/3630.Partition-Array-for-Maximum-XOR-and-AND/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3630.Partition-Array-for-Maximum-XOR-and-AND/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3633.Earliest-Finish-Time-for-Land-and-Water-Rides-I/README.md b/leetcode/3601-3700/3633.Earliest-Finish-Time-for-Land-and-Water-Rides-I/README.md new file mode 100755 index 000000000..b54eef3f8 --- /dev/null +++ b/leetcode/3601-3700/3633.Earliest-Finish-Time-for-Land-and-Water-Rides-I/README.md @@ -0,0 +1,32 @@ +# [3633.Earliest Finish Time for Land and Water Rides I][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Earliest Finish Time for Land and Water Rides I +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/earliest-finish-time-for-land-and-water-rides-i/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3633.Earliest-Finish-Time-for-Land-and-Water-Rides-I/Solution.go b/leetcode/3601-3700/3633.Earliest-Finish-Time-for-Land-and-Water-Rides-I/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3633.Earliest-Finish-Time-for-Land-and-Water-Rides-I/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3633.Earliest-Finish-Time-for-Land-and-Water-Rides-I/Solution_test.go b/leetcode/3601-3700/3633.Earliest-Finish-Time-for-Land-and-Water-Rides-I/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3633.Earliest-Finish-Time-for-Land-and-Water-Rides-I/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3634.Minimum-Removals-to-Balance-Array/README.md b/leetcode/3601-3700/3634.Minimum-Removals-to-Balance-Array/README.md new file mode 100755 index 000000000..31493fd61 --- /dev/null +++ b/leetcode/3601-3700/3634.Minimum-Removals-to-Balance-Array/README.md @@ -0,0 +1,32 @@ +# [3634.Minimum Removals to Balance Array][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Minimum Removals to Balance Array +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/minimum-removals-to-balance-array/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3634.Minimum-Removals-to-Balance-Array/Solution.go b/leetcode/3601-3700/3634.Minimum-Removals-to-Balance-Array/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3634.Minimum-Removals-to-Balance-Array/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3634.Minimum-Removals-to-Balance-Array/Solution_test.go b/leetcode/3601-3700/3634.Minimum-Removals-to-Balance-Array/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3634.Minimum-Removals-to-Balance-Array/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3635.Earliest-Finish-Time-for-Land-and-Water-Rides-II/README.md b/leetcode/3601-3700/3635.Earliest-Finish-Time-for-Land-and-Water-Rides-II/README.md new file mode 100755 index 000000000..8055bb5ef --- /dev/null +++ b/leetcode/3601-3700/3635.Earliest-Finish-Time-for-Land-and-Water-Rides-II/README.md @@ -0,0 +1,32 @@ +# [3635.Earliest Finish Time for Land and Water Rides II][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Earliest Finish Time for Land and Water Rides II +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/earliest-finish-time-for-land-and-water-rides-ii/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3635.Earliest-Finish-Time-for-Land-and-Water-Rides-II/Solution.go b/leetcode/3601-3700/3635.Earliest-Finish-Time-for-Land-and-Water-Rides-II/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3635.Earliest-Finish-Time-for-Land-and-Water-Rides-II/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3635.Earliest-Finish-Time-for-Land-and-Water-Rides-II/Solution_test.go b/leetcode/3601-3700/3635.Earliest-Finish-Time-for-Land-and-Water-Rides-II/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3635.Earliest-Finish-Time-for-Land-and-Water-Rides-II/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3636.Threshold-Majority-Queries/README.md b/leetcode/3601-3700/3636.Threshold-Majority-Queries/README.md new file mode 100755 index 000000000..ce792e01f --- /dev/null +++ b/leetcode/3601-3700/3636.Threshold-Majority-Queries/README.md @@ -0,0 +1,32 @@ +# [3636.Threshold Majority Queries][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Threshold Majority Queries +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/threshold-majority-queries/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3636.Threshold-Majority-Queries/Solution.go b/leetcode/3601-3700/3636.Threshold-Majority-Queries/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3636.Threshold-Majority-Queries/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3636.Threshold-Majority-Queries/Solution_test.go b/leetcode/3601-3700/3636.Threshold-Majority-Queries/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3636.Threshold-Majority-Queries/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3637.Trionic-Array-I/README.md b/leetcode/3601-3700/3637.Trionic-Array-I/README.md new file mode 100755 index 000000000..1be819871 --- /dev/null +++ b/leetcode/3601-3700/3637.Trionic-Array-I/README.md @@ -0,0 +1,32 @@ +# [3637.Trionic Array I][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Trionic Array I +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/trionic-array-i/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3637.Trionic-Array-I/Solution.go b/leetcode/3601-3700/3637.Trionic-Array-I/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3637.Trionic-Array-I/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3637.Trionic-Array-I/Solution_test.go b/leetcode/3601-3700/3637.Trionic-Array-I/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3637.Trionic-Array-I/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3638.Maximum-Balanced-Shipments/README.md b/leetcode/3601-3700/3638.Maximum-Balanced-Shipments/README.md new file mode 100755 index 000000000..3b799cf0d --- /dev/null +++ b/leetcode/3601-3700/3638.Maximum-Balanced-Shipments/README.md @@ -0,0 +1,32 @@ +# [3638.Maximum Balanced Shipments][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Maximum Balanced Shipments +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/maximum-balanced-shipments/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3638.Maximum-Balanced-Shipments/Solution.go b/leetcode/3601-3700/3638.Maximum-Balanced-Shipments/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3638.Maximum-Balanced-Shipments/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3638.Maximum-Balanced-Shipments/Solution_test.go b/leetcode/3601-3700/3638.Maximum-Balanced-Shipments/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3638.Maximum-Balanced-Shipments/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3639.Minimum-Time-to-Activate-String/README.md b/leetcode/3601-3700/3639.Minimum-Time-to-Activate-String/README.md new file mode 100755 index 000000000..c0c5d877b --- /dev/null +++ b/leetcode/3601-3700/3639.Minimum-Time-to-Activate-String/README.md @@ -0,0 +1,32 @@ +# [3639.Minimum Time to Activate String][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Minimum Time to Activate String +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/minimum-time-to-activate-string/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3639.Minimum-Time-to-Activate-String/Solution.go b/leetcode/3601-3700/3639.Minimum-Time-to-Activate-String/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3639.Minimum-Time-to-Activate-String/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3639.Minimum-Time-to-Activate-String/Solution_test.go b/leetcode/3601-3700/3639.Minimum-Time-to-Activate-String/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3639.Minimum-Time-to-Activate-String/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3640.Trionic-Array-II/README.md b/leetcode/3601-3700/3640.Trionic-Array-II/README.md new file mode 100755 index 000000000..cbc14893a --- /dev/null +++ b/leetcode/3601-3700/3640.Trionic-Array-II/README.md @@ -0,0 +1,32 @@ +# [3640.Trionic Array II][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Trionic Array II +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/trionic-array-ii/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3640.Trionic-Array-II/Solution.go b/leetcode/3601-3700/3640.Trionic-Array-II/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3640.Trionic-Array-II/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3640.Trionic-Array-II/Solution_test.go b/leetcode/3601-3700/3640.Trionic-Array-II/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3640.Trionic-Array-II/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3643.Flip-Square-Submatrix-Vertically/README.md b/leetcode/3601-3700/3643.Flip-Square-Submatrix-Vertically/README.md new file mode 100755 index 000000000..5117d396d --- /dev/null +++ b/leetcode/3601-3700/3643.Flip-Square-Submatrix-Vertically/README.md @@ -0,0 +1,32 @@ +# [3643.Flip Square Submatrix Vertically][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Flip Square Submatrix Vertically +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/flip-square-submatrix-vertically/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3643.Flip-Square-Submatrix-Vertically/Solution.go b/leetcode/3601-3700/3643.Flip-Square-Submatrix-Vertically/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3643.Flip-Square-Submatrix-Vertically/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3643.Flip-Square-Submatrix-Vertically/Solution_test.go b/leetcode/3601-3700/3643.Flip-Square-Submatrix-Vertically/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3643.Flip-Square-Submatrix-Vertically/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3644.Maximum-K-to-Sort-a-Permutation/README.md b/leetcode/3601-3700/3644.Maximum-K-to-Sort-a-Permutation/README.md new file mode 100755 index 000000000..6e4ec25f3 --- /dev/null +++ b/leetcode/3601-3700/3644.Maximum-K-to-Sort-a-Permutation/README.md @@ -0,0 +1,32 @@ +# [3644.Maximum K to Sort a Permutation][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Maximum K to Sort a Permutation +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/maximum-k-to-sort-a-permutation/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3644.Maximum-K-to-Sort-a-Permutation/Solution.go b/leetcode/3601-3700/3644.Maximum-K-to-Sort-a-Permutation/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3644.Maximum-K-to-Sort-a-Permutation/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3644.Maximum-K-to-Sort-a-Permutation/Solution_test.go b/leetcode/3601-3700/3644.Maximum-K-to-Sort-a-Permutation/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3644.Maximum-K-to-Sort-a-Permutation/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3645.Maximum-Total-from-Optimal-Activation-Order/README.md b/leetcode/3601-3700/3645.Maximum-Total-from-Optimal-Activation-Order/README.md new file mode 100755 index 000000000..ce7fa0a99 --- /dev/null +++ b/leetcode/3601-3700/3645.Maximum-Total-from-Optimal-Activation-Order/README.md @@ -0,0 +1,32 @@ +# [3645.Maximum Total from Optimal Activation Order][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Maximum Total from Optimal Activation Order +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/maximum-total-from-optimal-activation-order/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3645.Maximum-Total-from-Optimal-Activation-Order/Solution.go b/leetcode/3601-3700/3645.Maximum-Total-from-Optimal-Activation-Order/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3645.Maximum-Total-from-Optimal-Activation-Order/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3645.Maximum-Total-from-Optimal-Activation-Order/Solution_test.go b/leetcode/3601-3700/3645.Maximum-Total-from-Optimal-Activation-Order/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3645.Maximum-Total-from-Optimal-Activation-Order/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3646.Next-Special-Palindrome-Number/README.md b/leetcode/3601-3700/3646.Next-Special-Palindrome-Number/README.md new file mode 100755 index 000000000..d59e19ca0 --- /dev/null +++ b/leetcode/3601-3700/3646.Next-Special-Palindrome-Number/README.md @@ -0,0 +1,32 @@ +# [3646.Next Special Palindrome Number][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Next Special Palindrome Number +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/next-special-palindrome-number/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3646.Next-Special-Palindrome-Number/Solution.go b/leetcode/3601-3700/3646.Next-Special-Palindrome-Number/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3646.Next-Special-Palindrome-Number/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3646.Next-Special-Palindrome-Number/Solution_test.go b/leetcode/3601-3700/3646.Next-Special-Palindrome-Number/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3646.Next-Special-Palindrome-Number/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3648.Minimum-Sensors-to-Cover-Grid/README.md b/leetcode/3601-3700/3648.Minimum-Sensors-to-Cover-Grid/README.md new file mode 100755 index 000000000..4e930f99f --- /dev/null +++ b/leetcode/3601-3700/3648.Minimum-Sensors-to-Cover-Grid/README.md @@ -0,0 +1,32 @@ +# [3648.Minimum Sensors to Cover Grid][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Minimum Sensors to Cover Grid +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/minimum-sensors-to-cover-grid/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3648.Minimum-Sensors-to-Cover-Grid/Solution.go b/leetcode/3601-3700/3648.Minimum-Sensors-to-Cover-Grid/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3648.Minimum-Sensors-to-Cover-Grid/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3648.Minimum-Sensors-to-Cover-Grid/Solution_test.go b/leetcode/3601-3700/3648.Minimum-Sensors-to-Cover-Grid/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3648.Minimum-Sensors-to-Cover-Grid/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3649.Number-of-Perfect-Pairs/README.md b/leetcode/3601-3700/3649.Number-of-Perfect-Pairs/README.md new file mode 100755 index 000000000..8f4970816 --- /dev/null +++ b/leetcode/3601-3700/3649.Number-of-Perfect-Pairs/README.md @@ -0,0 +1,32 @@ +# [3649.Number of Perfect Pairs][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Number of Perfect Pairs +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/number-of-perfect-pairs/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3649.Number-of-Perfect-Pairs/Solution.go b/leetcode/3601-3700/3649.Number-of-Perfect-Pairs/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3649.Number-of-Perfect-Pairs/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3649.Number-of-Perfect-Pairs/Solution_test.go b/leetcode/3601-3700/3649.Number-of-Perfect-Pairs/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3649.Number-of-Perfect-Pairs/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3650.Minimum-Cost-Path-with-Edge-Reversals/README.md b/leetcode/3601-3700/3650.Minimum-Cost-Path-with-Edge-Reversals/README.md new file mode 100755 index 000000000..491dfc4cd --- /dev/null +++ b/leetcode/3601-3700/3650.Minimum-Cost-Path-with-Edge-Reversals/README.md @@ -0,0 +1,32 @@ +# [3650.Minimum Cost Path with Edge Reversals][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Minimum Cost Path with Edge Reversals +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/minimum-cost-path-with-edge-reversals/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3650.Minimum-Cost-Path-with-Edge-Reversals/Solution.go b/leetcode/3601-3700/3650.Minimum-Cost-Path-with-Edge-Reversals/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3650.Minimum-Cost-Path-with-Edge-Reversals/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3650.Minimum-Cost-Path-with-Edge-Reversals/Solution_test.go b/leetcode/3601-3700/3650.Minimum-Cost-Path-with-Edge-Reversals/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3650.Minimum-Cost-Path-with-Edge-Reversals/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3651.Minimum-Cost-Path-with-Teleportations/README.md b/leetcode/3601-3700/3651.Minimum-Cost-Path-with-Teleportations/README.md new file mode 100755 index 000000000..eb6b742fc --- /dev/null +++ b/leetcode/3601-3700/3651.Minimum-Cost-Path-with-Teleportations/README.md @@ -0,0 +1,32 @@ +# [3651.Minimum Cost Path with Teleportations][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Minimum Cost Path with Teleportations +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/minimum-cost-path-with-teleportations/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3651.Minimum-Cost-Path-with-Teleportations/Solution.go b/leetcode/3601-3700/3651.Minimum-Cost-Path-with-Teleportations/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3651.Minimum-Cost-Path-with-Teleportations/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3651.Minimum-Cost-Path-with-Teleportations/Solution_test.go b/leetcode/3601-3700/3651.Minimum-Cost-Path-with-Teleportations/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3651.Minimum-Cost-Path-with-Teleportations/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3652.Best-Time-to-Buy-and-Sell-Stock-using-Strategy/README.md b/leetcode/3601-3700/3652.Best-Time-to-Buy-and-Sell-Stock-using-Strategy/README.md new file mode 100755 index 000000000..e38705154 --- /dev/null +++ b/leetcode/3601-3700/3652.Best-Time-to-Buy-and-Sell-Stock-using-Strategy/README.md @@ -0,0 +1,32 @@ +# [3652.Best Time to Buy and Sell Stock using Strategy][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Best Time to Buy and Sell Stock using Strategy +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/best-time-to-buy-and-sell-stock-using-strategy/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3652.Best-Time-to-Buy-and-Sell-Stock-using-Strategy/Solution.go b/leetcode/3601-3700/3652.Best-Time-to-Buy-and-Sell-Stock-using-Strategy/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3652.Best-Time-to-Buy-and-Sell-Stock-using-Strategy/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3652.Best-Time-to-Buy-and-Sell-Stock-using-Strategy/Solution_test.go b/leetcode/3601-3700/3652.Best-Time-to-Buy-and-Sell-Stock-using-Strategy/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3652.Best-Time-to-Buy-and-Sell-Stock-using-Strategy/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3653.XOR-After-Range-Multiplication-Queries-I/README.md b/leetcode/3601-3700/3653.XOR-After-Range-Multiplication-Queries-I/README.md new file mode 100755 index 000000000..41988071a --- /dev/null +++ b/leetcode/3601-3700/3653.XOR-After-Range-Multiplication-Queries-I/README.md @@ -0,0 +1,32 @@ +# [3653.XOR After Range Multiplication Queries I][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +XOR After Range Multiplication Queries I +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/xor-after-range-multiplication-queries-i/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3653.XOR-After-Range-Multiplication-Queries-I/Solution.go b/leetcode/3601-3700/3653.XOR-After-Range-Multiplication-Queries-I/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3653.XOR-After-Range-Multiplication-Queries-I/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3653.XOR-After-Range-Multiplication-Queries-I/Solution_test.go b/leetcode/3601-3700/3653.XOR-After-Range-Multiplication-Queries-I/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3653.XOR-After-Range-Multiplication-Queries-I/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3654.Minimum-Sum-After-Divisible-Sum-Deletions/README.md b/leetcode/3601-3700/3654.Minimum-Sum-After-Divisible-Sum-Deletions/README.md new file mode 100755 index 000000000..869bdc3db --- /dev/null +++ b/leetcode/3601-3700/3654.Minimum-Sum-After-Divisible-Sum-Deletions/README.md @@ -0,0 +1,32 @@ +# [3654.Minimum Sum After Divisible Sum Deletions][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Minimum Sum After Divisible Sum Deletions +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/minimum-sum-after-divisible-sum-deletions/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3654.Minimum-Sum-After-Divisible-Sum-Deletions/Solution.go b/leetcode/3601-3700/3654.Minimum-Sum-After-Divisible-Sum-Deletions/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3654.Minimum-Sum-After-Divisible-Sum-Deletions/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3654.Minimum-Sum-After-Divisible-Sum-Deletions/Solution_test.go b/leetcode/3601-3700/3654.Minimum-Sum-After-Divisible-Sum-Deletions/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3654.Minimum-Sum-After-Divisible-Sum-Deletions/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3655.XOR-After-Range-Multiplication-Queries-II/README.md b/leetcode/3601-3700/3655.XOR-After-Range-Multiplication-Queries-II/README.md new file mode 100755 index 000000000..84e997acb --- /dev/null +++ b/leetcode/3601-3700/3655.XOR-After-Range-Multiplication-Queries-II/README.md @@ -0,0 +1,32 @@ +# [3655.XOR After Range Multiplication Queries II][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +XOR After Range Multiplication Queries II +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/xor-after-range-multiplication-queries-ii/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3655.XOR-After-Range-Multiplication-Queries-II/Solution.go b/leetcode/3601-3700/3655.XOR-After-Range-Multiplication-Queries-II/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3655.XOR-After-Range-Multiplication-Queries-II/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3655.XOR-After-Range-Multiplication-Queries-II/Solution_test.go b/leetcode/3601-3700/3655.XOR-After-Range-Multiplication-Queries-II/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3655.XOR-After-Range-Multiplication-Queries-II/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3658.GCD-of-Odd-and-Even-Sums/README.md b/leetcode/3601-3700/3658.GCD-of-Odd-and-Even-Sums/README.md new file mode 100755 index 000000000..62aac5af5 --- /dev/null +++ b/leetcode/3601-3700/3658.GCD-of-Odd-and-Even-Sums/README.md @@ -0,0 +1,32 @@ +# [3658.GCD of Odd and Even Sums][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +GCD of Odd and Even Sums +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/gcd-of-odd-and-even-sums/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3658.GCD-of-Odd-and-Even-Sums/Solution.go b/leetcode/3601-3700/3658.GCD-of-Odd-and-Even-Sums/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3658.GCD-of-Odd-and-Even-Sums/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3658.GCD-of-Odd-and-Even-Sums/Solution_test.go b/leetcode/3601-3700/3658.GCD-of-Odd-and-Even-Sums/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3658.GCD-of-Odd-and-Even-Sums/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3659.Partition-Array-Into-K-Distinct-Groups/README.md b/leetcode/3601-3700/3659.Partition-Array-Into-K-Distinct-Groups/README.md new file mode 100755 index 000000000..fd193e32b --- /dev/null +++ b/leetcode/3601-3700/3659.Partition-Array-Into-K-Distinct-Groups/README.md @@ -0,0 +1,32 @@ +# [3659.Partition Array Into K-Distinct Groups][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Partition Array Into K-Distinct Groups +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/partition-array-into-k-distinct-groups/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3659.Partition-Array-Into-K-Distinct-Groups/Solution.go b/leetcode/3601-3700/3659.Partition-Array-Into-K-Distinct-Groups/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3659.Partition-Array-Into-K-Distinct-Groups/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3659.Partition-Array-Into-K-Distinct-Groups/Solution_test.go b/leetcode/3601-3700/3659.Partition-Array-Into-K-Distinct-Groups/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3659.Partition-Array-Into-K-Distinct-Groups/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3660.Jump-Game-IX/README.md b/leetcode/3601-3700/3660.Jump-Game-IX/README.md new file mode 100755 index 000000000..78a8638d6 --- /dev/null +++ b/leetcode/3601-3700/3660.Jump-Game-IX/README.md @@ -0,0 +1,32 @@ +# [3660.Jump Game IX][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Jump Game IX +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/jump-game-ix/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3660.Jump-Game-IX/Solution.go b/leetcode/3601-3700/3660.Jump-Game-IX/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3660.Jump-Game-IX/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3660.Jump-Game-IX/Solution_test.go b/leetcode/3601-3700/3660.Jump-Game-IX/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3660.Jump-Game-IX/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3661.Maximum-Walls-Destroyed-by-Robots/README.md b/leetcode/3601-3700/3661.Maximum-Walls-Destroyed-by-Robots/README.md new file mode 100755 index 000000000..dbeba778e --- /dev/null +++ b/leetcode/3601-3700/3661.Maximum-Walls-Destroyed-by-Robots/README.md @@ -0,0 +1,32 @@ +# [3661.Maximum Walls Destroyed by Robots][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Maximum Walls Destroyed by Robots +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/maximum-walls-destroyed-by-robots/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3661.Maximum-Walls-Destroyed-by-Robots/Solution.go b/leetcode/3601-3700/3661.Maximum-Walls-Destroyed-by-Robots/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3661.Maximum-Walls-Destroyed-by-Robots/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3661.Maximum-Walls-Destroyed-by-Robots/Solution_test.go b/leetcode/3601-3700/3661.Maximum-Walls-Destroyed-by-Robots/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3661.Maximum-Walls-Destroyed-by-Robots/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3663.Find-The-Least-Frequent-Digit/README.md b/leetcode/3601-3700/3663.Find-The-Least-Frequent-Digit/README.md new file mode 100755 index 000000000..dcd263af7 --- /dev/null +++ b/leetcode/3601-3700/3663.Find-The-Least-Frequent-Digit/README.md @@ -0,0 +1,32 @@ +# [3663.Find The Least Frequent Digit][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Find The Least Frequent Digit +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/find-the-least-frequent-digit/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3663.Find-The-Least-Frequent-Digit/Solution.go b/leetcode/3601-3700/3663.Find-The-Least-Frequent-Digit/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3663.Find-The-Least-Frequent-Digit/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3663.Find-The-Least-Frequent-Digit/Solution_test.go b/leetcode/3601-3700/3663.Find-The-Least-Frequent-Digit/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3663.Find-The-Least-Frequent-Digit/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3664.Two-Letter-Card-Game/README.md b/leetcode/3601-3700/3664.Two-Letter-Card-Game/README.md new file mode 100755 index 000000000..ee4de4722 --- /dev/null +++ b/leetcode/3601-3700/3664.Two-Letter-Card-Game/README.md @@ -0,0 +1,32 @@ +# [3664.Two-Letter Card Game][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Two-Letter Card Game +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/two-letter-card-game/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3664.Two-Letter-Card-Game/Solution.go b/leetcode/3601-3700/3664.Two-Letter-Card-Game/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3664.Two-Letter-Card-Game/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3664.Two-Letter-Card-Game/Solution_test.go b/leetcode/3601-3700/3664.Two-Letter-Card-Game/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3664.Two-Letter-Card-Game/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3665.Twisted-Mirror-Path-Count/README.md b/leetcode/3601-3700/3665.Twisted-Mirror-Path-Count/README.md new file mode 100755 index 000000000..fa538e149 --- /dev/null +++ b/leetcode/3601-3700/3665.Twisted-Mirror-Path-Count/README.md @@ -0,0 +1,32 @@ +# [3665.Twisted Mirror Path Count][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Twisted Mirror Path Count +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/twisted-mirror-path-count/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3665.Twisted-Mirror-Path-Count/Solution.go b/leetcode/3601-3700/3665.Twisted-Mirror-Path-Count/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3665.Twisted-Mirror-Path-Count/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3665.Twisted-Mirror-Path-Count/Solution_test.go b/leetcode/3601-3700/3665.Twisted-Mirror-Path-Count/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3665.Twisted-Mirror-Path-Count/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3666.Minimum-Operations-to-Equalize-Binary-String/README.md b/leetcode/3601-3700/3666.Minimum-Operations-to-Equalize-Binary-String/README.md new file mode 100755 index 000000000..5c1a129fd --- /dev/null +++ b/leetcode/3601-3700/3666.Minimum-Operations-to-Equalize-Binary-String/README.md @@ -0,0 +1,32 @@ +# [3666.Minimum Operations to Equalize Binary String][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Minimum Operations to Equalize Binary String +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/minimum-operations-to-equalize-binary-string/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3666.Minimum-Operations-to-Equalize-Binary-String/Solution.go b/leetcode/3601-3700/3666.Minimum-Operations-to-Equalize-Binary-String/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3666.Minimum-Operations-to-Equalize-Binary-String/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3666.Minimum-Operations-to-Equalize-Binary-String/Solution_test.go b/leetcode/3601-3700/3666.Minimum-Operations-to-Equalize-Binary-String/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3666.Minimum-Operations-to-Equalize-Binary-String/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3668.Restore-Finishing-Order/README.md b/leetcode/3601-3700/3668.Restore-Finishing-Order/README.md new file mode 100755 index 000000000..19d52e884 --- /dev/null +++ b/leetcode/3601-3700/3668.Restore-Finishing-Order/README.md @@ -0,0 +1,32 @@ +# [3668.Restore Finishing Order][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Restore Finishing Order +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/restore-finishing-order/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3668.Restore-Finishing-Order/Solution.go b/leetcode/3601-3700/3668.Restore-Finishing-Order/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3668.Restore-Finishing-Order/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3668.Restore-Finishing-Order/Solution_test.go b/leetcode/3601-3700/3668.Restore-Finishing-Order/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3668.Restore-Finishing-Order/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3669.Balanced-K-Factor-Decomposition/README.md b/leetcode/3601-3700/3669.Balanced-K-Factor-Decomposition/README.md new file mode 100755 index 000000000..aeb54b920 --- /dev/null +++ b/leetcode/3601-3700/3669.Balanced-K-Factor-Decomposition/README.md @@ -0,0 +1,32 @@ +# [3669.Balanced K-Factor Decomposition][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Balanced K-Factor Decomposition +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/balanced-k-factor-decomposition/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3669.Balanced-K-Factor-Decomposition/Solution.go b/leetcode/3601-3700/3669.Balanced-K-Factor-Decomposition/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3669.Balanced-K-Factor-Decomposition/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3669.Balanced-K-Factor-Decomposition/Solution_test.go b/leetcode/3601-3700/3669.Balanced-K-Factor-Decomposition/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3669.Balanced-K-Factor-Decomposition/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3670.Maximum-Product-of-Two-Integers-With-No-Common-Bits/README.md b/leetcode/3601-3700/3670.Maximum-Product-of-Two-Integers-With-No-Common-Bits/README.md new file mode 100755 index 000000000..7f1a3aca1 --- /dev/null +++ b/leetcode/3601-3700/3670.Maximum-Product-of-Two-Integers-With-No-Common-Bits/README.md @@ -0,0 +1,32 @@ +# [3670.Maximum Product of Two Integers With No Common Bits][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Maximum Product of Two Integers With No Common Bits +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/maximum-product-of-two-integers-with-no-common-bits/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3670.Maximum-Product-of-Two-Integers-With-No-Common-Bits/Solution.go b/leetcode/3601-3700/3670.Maximum-Product-of-Two-Integers-With-No-Common-Bits/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3670.Maximum-Product-of-Two-Integers-With-No-Common-Bits/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3670.Maximum-Product-of-Two-Integers-With-No-Common-Bits/Solution_test.go b/leetcode/3601-3700/3670.Maximum-Product-of-Two-Integers-With-No-Common-Bits/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3670.Maximum-Product-of-Two-Integers-With-No-Common-Bits/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3671.Sum-of-Beautiful-Subsequences/README.md b/leetcode/3601-3700/3671.Sum-of-Beautiful-Subsequences/README.md new file mode 100755 index 000000000..cba390497 --- /dev/null +++ b/leetcode/3601-3700/3671.Sum-of-Beautiful-Subsequences/README.md @@ -0,0 +1,32 @@ +# [3671.Sum of Beautiful Subsequences][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Sum of Beautiful Subsequences +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/sum-of-beautiful-subsequences/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3671.Sum-of-Beautiful-Subsequences/Solution.go b/leetcode/3601-3700/3671.Sum-of-Beautiful-Subsequences/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3671.Sum-of-Beautiful-Subsequences/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3671.Sum-of-Beautiful-Subsequences/Solution_test.go b/leetcode/3601-3700/3671.Sum-of-Beautiful-Subsequences/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3671.Sum-of-Beautiful-Subsequences/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3674.Minimum-Operations-to-Equalize-Array/README.md b/leetcode/3601-3700/3674.Minimum-Operations-to-Equalize-Array/README.md new file mode 100755 index 000000000..d6fb2792d --- /dev/null +++ b/leetcode/3601-3700/3674.Minimum-Operations-to-Equalize-Array/README.md @@ -0,0 +1,32 @@ +# [3674.Minimum Operations to Equalize Array][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Minimum Operations to Equalize Array +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/minimum-operations-to-equalize-array/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3674.Minimum-Operations-to-Equalize-Array/Solution.go b/leetcode/3601-3700/3674.Minimum-Operations-to-Equalize-Array/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3674.Minimum-Operations-to-Equalize-Array/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3674.Minimum-Operations-to-Equalize-Array/Solution_test.go b/leetcode/3601-3700/3674.Minimum-Operations-to-Equalize-Array/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3674.Minimum-Operations-to-Equalize-Array/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3675.Minimum-Operations-to-Transform-String/README.md b/leetcode/3601-3700/3675.Minimum-Operations-to-Transform-String/README.md new file mode 100755 index 000000000..86b18bd6c --- /dev/null +++ b/leetcode/3601-3700/3675.Minimum-Operations-to-Transform-String/README.md @@ -0,0 +1,32 @@ +# [3675.Minimum Operations to Transform String][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Minimum Operations to Transform String +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/minimum-operations-to-transform-string/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3675.Minimum-Operations-to-Transform-String/Solution.go b/leetcode/3601-3700/3675.Minimum-Operations-to-Transform-String/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3675.Minimum-Operations-to-Transform-String/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3675.Minimum-Operations-to-Transform-String/Solution_test.go b/leetcode/3601-3700/3675.Minimum-Operations-to-Transform-String/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3675.Minimum-Operations-to-Transform-String/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3676.Count-Bowl-Subarrays/README.md b/leetcode/3601-3700/3676.Count-Bowl-Subarrays/README.md new file mode 100755 index 000000000..67876f7e3 --- /dev/null +++ b/leetcode/3601-3700/3676.Count-Bowl-Subarrays/README.md @@ -0,0 +1,32 @@ +# [3676.Count Bowl Subarrays][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Count Bowl Subarrays +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/count-bowl-subarrays/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3676.Count-Bowl-Subarrays/Solution.go b/leetcode/3601-3700/3676.Count-Bowl-Subarrays/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3676.Count-Bowl-Subarrays/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3676.Count-Bowl-Subarrays/Solution_test.go b/leetcode/3601-3700/3676.Count-Bowl-Subarrays/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3676.Count-Bowl-Subarrays/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3677.Count-Binary-Palindromic-Numbers/README.md b/leetcode/3601-3700/3677.Count-Binary-Palindromic-Numbers/README.md new file mode 100755 index 000000000..eafff9f06 --- /dev/null +++ b/leetcode/3601-3700/3677.Count-Binary-Palindromic-Numbers/README.md @@ -0,0 +1,32 @@ +# [3677.Count Binary Palindromic Numbers][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Count Binary Palindromic Numbers +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/count-binary-palindromic-numbers/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3677.Count-Binary-Palindromic-Numbers/Solution.go b/leetcode/3601-3700/3677.Count-Binary-Palindromic-Numbers/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3677.Count-Binary-Palindromic-Numbers/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3677.Count-Binary-Palindromic-Numbers/Solution_test.go b/leetcode/3601-3700/3677.Count-Binary-Palindromic-Numbers/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3677.Count-Binary-Palindromic-Numbers/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3678.Smallest-Absent-Positive-Greater-Than-Average/README.md b/leetcode/3601-3700/3678.Smallest-Absent-Positive-Greater-Than-Average/README.md new file mode 100755 index 000000000..e2c67517d --- /dev/null +++ b/leetcode/3601-3700/3678.Smallest-Absent-Positive-Greater-Than-Average/README.md @@ -0,0 +1,32 @@ +# [3678.Smallest Absent Positive Greater Than Average][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Smallest Absent Positive Greater Than Average +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/smallest-absent-positive-greater-than-average/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3678.Smallest-Absent-Positive-Greater-Than-Average/Solution.go b/leetcode/3601-3700/3678.Smallest-Absent-Positive-Greater-Than-Average/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3678.Smallest-Absent-Positive-Greater-Than-Average/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3678.Smallest-Absent-Positive-Greater-Than-Average/Solution_test.go b/leetcode/3601-3700/3678.Smallest-Absent-Positive-Greater-Than-Average/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3678.Smallest-Absent-Positive-Greater-Than-Average/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3679.Minimum-Discards-to-Balance-Inventory/README.md b/leetcode/3601-3700/3679.Minimum-Discards-to-Balance-Inventory/README.md new file mode 100755 index 000000000..899640e23 --- /dev/null +++ b/leetcode/3601-3700/3679.Minimum-Discards-to-Balance-Inventory/README.md @@ -0,0 +1,32 @@ +# [3679. Minimum Discards to Balance Inventory][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... + Minimum Discards to Balance Inventory +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/minimum-discards-to-balance-inventory/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3679.Minimum-Discards-to-Balance-Inventory/Solution.go b/leetcode/3601-3700/3679.Minimum-Discards-to-Balance-Inventory/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3679.Minimum-Discards-to-Balance-Inventory/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3679.Minimum-Discards-to-Balance-Inventory/Solution_test.go b/leetcode/3601-3700/3679.Minimum-Discards-to-Balance-Inventory/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3679.Minimum-Discards-to-Balance-Inventory/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3680.Generate-Schedule/README.md b/leetcode/3601-3700/3680.Generate-Schedule/README.md new file mode 100755 index 000000000..6a215192a --- /dev/null +++ b/leetcode/3601-3700/3680.Generate-Schedule/README.md @@ -0,0 +1,32 @@ +# [3680.Generate Schedule][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Generate Schedule +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/generate-schedule/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3680.Generate-Schedule/Solution.go b/leetcode/3601-3700/3680.Generate-Schedule/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3680.Generate-Schedule/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3680.Generate-Schedule/Solution_test.go b/leetcode/3601-3700/3680.Generate-Schedule/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3680.Generate-Schedule/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3681.Maximum-XOR-of-Subsequences/README.md b/leetcode/3601-3700/3681.Maximum-XOR-of-Subsequences/README.md new file mode 100755 index 000000000..1af017946 --- /dev/null +++ b/leetcode/3601-3700/3681.Maximum-XOR-of-Subsequences/README.md @@ -0,0 +1,32 @@ +# [3681.Maximum XOR of Subsequences][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Maximum XOR of Subsequences +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/maximum-xor-of-subsequences/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3681.Maximum-XOR-of-Subsequences/Solution.go b/leetcode/3601-3700/3681.Maximum-XOR-of-Subsequences/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3681.Maximum-XOR-of-Subsequences/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3681.Maximum-XOR-of-Subsequences/Solution_test.go b/leetcode/3601-3700/3681.Maximum-XOR-of-Subsequences/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3681.Maximum-XOR-of-Subsequences/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3683.Earliest-Time-to-Finish-One-Task/README.md b/leetcode/3601-3700/3683.Earliest-Time-to-Finish-One-Task/README.md new file mode 100755 index 000000000..d3e2b86b4 --- /dev/null +++ b/leetcode/3601-3700/3683.Earliest-Time-to-Finish-One-Task/README.md @@ -0,0 +1,32 @@ +# [3683.Earliest Time to Finish One Task][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Earliest Time to Finish One Task +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/earliest-time-to-finish-one-task/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3683.Earliest-Time-to-Finish-One-Task/Solution.go b/leetcode/3601-3700/3683.Earliest-Time-to-Finish-One-Task/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3683.Earliest-Time-to-Finish-One-Task/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3683.Earliest-Time-to-Finish-One-Task/Solution_test.go b/leetcode/3601-3700/3683.Earliest-Time-to-Finish-One-Task/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3683.Earliest-Time-to-Finish-One-Task/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3684.Maximize-Sum-of-At-Most-K-Distinct-Elements/README.md b/leetcode/3601-3700/3684.Maximize-Sum-of-At-Most-K-Distinct-Elements/README.md new file mode 100755 index 000000000..7427c259e --- /dev/null +++ b/leetcode/3601-3700/3684.Maximize-Sum-of-At-Most-K-Distinct-Elements/README.md @@ -0,0 +1,32 @@ +# [3684.Maximize Sum of At Most K Distinct Elements][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Maximize Sum of At Most K Distinct Elements +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/maximize-sum-of-at-most-k-distinct-elements/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3684.Maximize-Sum-of-At-Most-K-Distinct-Elements/Solution.go b/leetcode/3601-3700/3684.Maximize-Sum-of-At-Most-K-Distinct-Elements/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3684.Maximize-Sum-of-At-Most-K-Distinct-Elements/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3684.Maximize-Sum-of-At-Most-K-Distinct-Elements/Solution_test.go b/leetcode/3601-3700/3684.Maximize-Sum-of-At-Most-K-Distinct-Elements/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3684.Maximize-Sum-of-At-Most-K-Distinct-Elements/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3685.Subsequence-Sum-After-Capping-Elements/README.md b/leetcode/3601-3700/3685.Subsequence-Sum-After-Capping-Elements/README.md new file mode 100755 index 000000000..7d5eee0c0 --- /dev/null +++ b/leetcode/3601-3700/3685.Subsequence-Sum-After-Capping-Elements/README.md @@ -0,0 +1,32 @@ +# [3685.Subsequence Sum After Capping Elements][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Subsequence Sum After Capping Elements +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/subsequence-sum-after-capping-elements/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3685.Subsequence-Sum-After-Capping-Elements/Solution.go b/leetcode/3601-3700/3685.Subsequence-Sum-After-Capping-Elements/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3685.Subsequence-Sum-After-Capping-Elements/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3685.Subsequence-Sum-After-Capping-Elements/Solution_test.go b/leetcode/3601-3700/3685.Subsequence-Sum-After-Capping-Elements/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3685.Subsequence-Sum-After-Capping-Elements/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3686.Number-of-Stable-Subsequences/README.md b/leetcode/3601-3700/3686.Number-of-Stable-Subsequences/README.md new file mode 100755 index 000000000..2feeca896 --- /dev/null +++ b/leetcode/3601-3700/3686.Number-of-Stable-Subsequences/README.md @@ -0,0 +1,32 @@ +# [3686.Number of Stable Subsequences][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Number of Stable Subsequences +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/number-of-stable-subsequences/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3686.Number-of-Stable-Subsequences/Solution.go b/leetcode/3601-3700/3686.Number-of-Stable-Subsequences/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3686.Number-of-Stable-Subsequences/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3686.Number-of-Stable-Subsequences/Solution_test.go b/leetcode/3601-3700/3686.Number-of-Stable-Subsequences/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3686.Number-of-Stable-Subsequences/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3688.Bitwise-OR-of-Even-Numbers-in-an-Array/README.md b/leetcode/3601-3700/3688.Bitwise-OR-of-Even-Numbers-in-an-Array/README.md new file mode 100755 index 000000000..f4eb5aeb6 --- /dev/null +++ b/leetcode/3601-3700/3688.Bitwise-OR-of-Even-Numbers-in-an-Array/README.md @@ -0,0 +1,32 @@ +# [3688.Bitwise OR of Even Numbers in an Array][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Bitwise OR of Even Numbers in an Array +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/bitwise-or-of-even-numbers-in-an-array/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3688.Bitwise-OR-of-Even-Numbers-in-an-Array/Solution.go b/leetcode/3601-3700/3688.Bitwise-OR-of-Even-Numbers-in-an-Array/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3688.Bitwise-OR-of-Even-Numbers-in-an-Array/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3688.Bitwise-OR-of-Even-Numbers-in-an-Array/Solution_test.go b/leetcode/3601-3700/3688.Bitwise-OR-of-Even-Numbers-in-an-Array/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3688.Bitwise-OR-of-Even-Numbers-in-an-Array/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3689.Maximum-Total-Subarray-Value-I/README.md b/leetcode/3601-3700/3689.Maximum-Total-Subarray-Value-I/README.md new file mode 100755 index 000000000..d85b39179 --- /dev/null +++ b/leetcode/3601-3700/3689.Maximum-Total-Subarray-Value-I/README.md @@ -0,0 +1,32 @@ +# [3689.Maximum Total Subarray Value I][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Maximum Total Subarray Value I +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/maximum-total-subarray-value-i/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3689.Maximum-Total-Subarray-Value-I/Solution.go b/leetcode/3601-3700/3689.Maximum-Total-Subarray-Value-I/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3689.Maximum-Total-Subarray-Value-I/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3689.Maximum-Total-Subarray-Value-I/Solution_test.go b/leetcode/3601-3700/3689.Maximum-Total-Subarray-Value-I/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3689.Maximum-Total-Subarray-Value-I/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3690.Split-and-Merge-Array-Transformation/README.md b/leetcode/3601-3700/3690.Split-and-Merge-Array-Transformation/README.md new file mode 100755 index 000000000..db35312dd --- /dev/null +++ b/leetcode/3601-3700/3690.Split-and-Merge-Array-Transformation/README.md @@ -0,0 +1,32 @@ +# [3690.Split and Merge Array Transformation][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Split and Merge Array Transformation +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/split-and-merge-array-transformation/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3690.Split-and-Merge-Array-Transformation/Solution.go b/leetcode/3601-3700/3690.Split-and-Merge-Array-Transformation/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3690.Split-and-Merge-Array-Transformation/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3690.Split-and-Merge-Array-Transformation/Solution_test.go b/leetcode/3601-3700/3690.Split-and-Merge-Array-Transformation/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3690.Split-and-Merge-Array-Transformation/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3691.Maximum-Total-Subarray-Value-II/README.md b/leetcode/3601-3700/3691.Maximum-Total-Subarray-Value-II/README.md new file mode 100755 index 000000000..050499518 --- /dev/null +++ b/leetcode/3601-3700/3691.Maximum-Total-Subarray-Value-II/README.md @@ -0,0 +1,32 @@ +# [3691.Maximum Total Subarray Value II][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Maximum Total Subarray Value II +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/maximum-total-subarray-value-ii/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3691.Maximum-Total-Subarray-Value-II/Solution.go b/leetcode/3601-3700/3691.Maximum-Total-Subarray-Value-II/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3691.Maximum-Total-Subarray-Value-II/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3691.Maximum-Total-Subarray-Value-II/Solution_test.go b/leetcode/3601-3700/3691.Maximum-Total-Subarray-Value-II/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3691.Maximum-Total-Subarray-Value-II/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3692.Majority-Frequency-Characters/README.md b/leetcode/3601-3700/3692.Majority-Frequency-Characters/README.md new file mode 100755 index 000000000..7bec7759d --- /dev/null +++ b/leetcode/3601-3700/3692.Majority-Frequency-Characters/README.md @@ -0,0 +1,32 @@ +# [3692.Majority Frequency Characters][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Majority Frequency Characters +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/majority-frequency-characters/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3692.Majority-Frequency-Characters/Solution.go b/leetcode/3601-3700/3692.Majority-Frequency-Characters/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3692.Majority-Frequency-Characters/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3692.Majority-Frequency-Characters/Solution_test.go b/leetcode/3601-3700/3692.Majority-Frequency-Characters/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3692.Majority-Frequency-Characters/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3693.Climbing-Stairs-II/README.md b/leetcode/3601-3700/3693.Climbing-Stairs-II/README.md new file mode 100755 index 000000000..bdf62a5ee --- /dev/null +++ b/leetcode/3601-3700/3693.Climbing-Stairs-II/README.md @@ -0,0 +1,32 @@ +# [3693.Climbing Stairs II][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Climbing Stairs II +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/climbing-stairs-ii/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3693.Climbing-Stairs-II/Solution.go b/leetcode/3601-3700/3693.Climbing-Stairs-II/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3693.Climbing-Stairs-II/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3693.Climbing-Stairs-II/Solution_test.go b/leetcode/3601-3700/3693.Climbing-Stairs-II/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3693.Climbing-Stairs-II/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3694.Distinct-Points-Reachable-After-Substring-Removal/README.md b/leetcode/3601-3700/3694.Distinct-Points-Reachable-After-Substring-Removal/README.md new file mode 100755 index 000000000..807ccbe88 --- /dev/null +++ b/leetcode/3601-3700/3694.Distinct-Points-Reachable-After-Substring-Removal/README.md @@ -0,0 +1,32 @@ +# [3694.Distinct Points Reachable After Substring Removal][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Distinct Points Reachable After Substring Removal +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/distinct-points-reachable-after-substring-removal/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3694.Distinct-Points-Reachable-After-Substring-Removal/Solution.go b/leetcode/3601-3700/3694.Distinct-Points-Reachable-After-Substring-Removal/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3694.Distinct-Points-Reachable-After-Substring-Removal/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3694.Distinct-Points-Reachable-After-Substring-Removal/Solution_test.go b/leetcode/3601-3700/3694.Distinct-Points-Reachable-After-Substring-Removal/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3694.Distinct-Points-Reachable-After-Substring-Removal/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3695.Maximize-Alternating-Sum-Using-Swaps/README.md b/leetcode/3601-3700/3695.Maximize-Alternating-Sum-Using-Swaps/README.md new file mode 100755 index 000000000..fad6fd027 --- /dev/null +++ b/leetcode/3601-3700/3695.Maximize-Alternating-Sum-Using-Swaps/README.md @@ -0,0 +1,32 @@ +# [3695.Maximize Alternating Sum Using Swaps][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Maximize Alternating Sum Using Swaps +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/maximize-alternating-sum-using-swaps/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3695.Maximize-Alternating-Sum-Using-Swaps/Solution.go b/leetcode/3601-3700/3695.Maximize-Alternating-Sum-Using-Swaps/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3695.Maximize-Alternating-Sum-Using-Swaps/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3695.Maximize-Alternating-Sum-Using-Swaps/Solution_test.go b/leetcode/3601-3700/3695.Maximize-Alternating-Sum-Using-Swaps/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3695.Maximize-Alternating-Sum-Using-Swaps/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3697.Compute-Decimal-Representation/README.md b/leetcode/3601-3700/3697.Compute-Decimal-Representation/README.md new file mode 100755 index 000000000..02396442b --- /dev/null +++ b/leetcode/3601-3700/3697.Compute-Decimal-Representation/README.md @@ -0,0 +1,32 @@ +# [3697.Compute Decimal Representation][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Compute Decimal Representation +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/compute-decimal-representation/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3697.Compute-Decimal-Representation/Solution.go b/leetcode/3601-3700/3697.Compute-Decimal-Representation/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3697.Compute-Decimal-Representation/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3697.Compute-Decimal-Representation/Solution_test.go b/leetcode/3601-3700/3697.Compute-Decimal-Representation/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3697.Compute-Decimal-Representation/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3698.Split-Array-With-Minimum-Difference/README.md b/leetcode/3601-3700/3698.Split-Array-With-Minimum-Difference/README.md new file mode 100755 index 000000000..3c22170b3 --- /dev/null +++ b/leetcode/3601-3700/3698.Split-Array-With-Minimum-Difference/README.md @@ -0,0 +1,32 @@ +# [3698.Split Array With Minimum Difference][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Split Array With Minimum Difference +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/split-array-with-minimum-difference/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3698.Split-Array-With-Minimum-Difference/Solution.go b/leetcode/3601-3700/3698.Split-Array-With-Minimum-Difference/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3698.Split-Array-With-Minimum-Difference/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3698.Split-Array-With-Minimum-Difference/Solution_test.go b/leetcode/3601-3700/3698.Split-Array-With-Minimum-Difference/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3698.Split-Array-With-Minimum-Difference/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3699.Number-of-ZigZag-Arrays-I/README.md b/leetcode/3601-3700/3699.Number-of-ZigZag-Arrays-I/README.md new file mode 100755 index 000000000..5034eebb2 --- /dev/null +++ b/leetcode/3601-3700/3699.Number-of-ZigZag-Arrays-I/README.md @@ -0,0 +1,32 @@ +# [3699.Number of ZigZag Arrays I][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Number of ZigZag Arrays I +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/number-of-zigzag-arrays-i/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3699.Number-of-ZigZag-Arrays-I/Solution.go b/leetcode/3601-3700/3699.Number-of-ZigZag-Arrays-I/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3699.Number-of-ZigZag-Arrays-I/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3699.Number-of-ZigZag-Arrays-I/Solution_test.go b/leetcode/3601-3700/3699.Number-of-ZigZag-Arrays-I/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3699.Number-of-ZigZag-Arrays-I/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +} diff --git a/leetcode/3601-3700/3700.Number-of-ZigZag-Arrays-II/README.md b/leetcode/3601-3700/3700.Number-of-ZigZag-Arrays-II/README.md new file mode 100755 index 000000000..a997dcede --- /dev/null +++ b/leetcode/3601-3700/3700.Number-of-ZigZag-Arrays-II/README.md @@ -0,0 +1,32 @@ +# [3700.Number of ZigZag Arrays II][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-algorithm) + +## Description + +**Example 1:** + +``` +Input: a = "11", b = "1" +Output: "100" +``` + +## 题意 +> ... + +## 题解 + +### 思路1 +> ... +Number of ZigZag Arrays II +```go +``` + + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/number-of-zigzag-arrays-ii/ +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/3601-3700/3700.Number-of-ZigZag-Arrays-II/Solution.go b/leetcode/3601-3700/3700.Number-of-ZigZag-Arrays-II/Solution.go new file mode 100644 index 000000000..d115ccf5e --- /dev/null +++ b/leetcode/3601-3700/3700.Number-of-ZigZag-Arrays-II/Solution.go @@ -0,0 +1,5 @@ +package Solution + +func Solution(x bool) bool { + return x +} diff --git a/leetcode/3601-3700/3700.Number-of-ZigZag-Arrays-II/Solution_test.go b/leetcode/3601-3700/3700.Number-of-ZigZag-Arrays-II/Solution_test.go new file mode 100644 index 000000000..14ff50eb4 --- /dev/null +++ b/leetcode/3601-3700/3700.Number-of-ZigZag-Arrays-II/Solution_test.go @@ -0,0 +1,39 @@ +package Solution + +import ( + "reflect" + "strconv" + "testing" +) + +func TestSolution(t *testing.T) { + // 测试用例 + cases := []struct { + name string + inputs bool + expect bool + }{ + {"TestCase", true, true}, + {"TestCase", true, true}, + {"TestCase", false, false}, + } + + // 开始测试 + for i, c := range cases { + t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) { + got := Solution(c.inputs) + if !reflect.DeepEqual(got, c.expect) { + t.Fatalf("expected: %v, but got: %v, with inputs: %v", + c.expect, got, c.inputs) + } + }) + } +} + +// 压力测试 +func BenchmarkSolution(b *testing.B) { +} + +// 使用案列 +func ExampleSolution() { +}