├── .github └── workflows │ └── rust.yml ├── .gitignore ├── 1002-find-common-characters.rs ├── 1006-clumsy-factorial.rs ├── 1009-complement-of-base-10-integer.rs ├── 1021-remove-outermost-parentheses.rs ├── 1029-two-city-scheduling.rs ├── 1046-last-stone-weight.rs ├── 1047-remove-all-adjacent-duplicates-in-string.rs ├── 1051-height-checker.rs ├── 1078-occurrences-after-bigram.rs ├── 1089-duplicate-zeros.rs ├── 1103-distribute-candies-to-people.rs ├── 1122-relative-sort-array.rs ├── 1137-n-th-tribonacci-number.rs ├── 1154-day-of-the-year.rs ├── 1170-compare-strings-by-frequency-of-the-smallest-character.rs ├── 1184-distance-between-bus-stops.rs ├── 1189-maximum-number-of-balloons.rs ├── 119-pascals-triangle-ii.rs ├── 12-integer-to-roman.rs ├── 1200-minimum-absolute-difference.rs ├── 1207-unique-number-of-occurrences.rs ├── 1217-minimum-cost-to-move-chips-to-the-same-position.rs ├── 122-best-time-to-buy-and-sell-stock-ii.rs ├── 1221-split-a-string-in-balanced-strings.rs ├── 1252-cells-with-odd-values-in-a-matrix.rs ├── 1260-shift-2d-grid.rs ├── 1266-minimum-time-visiting-all-points.rs ├── 1287-element-appearing-more-than-25-in-sorted-array.rs ├── 1290-convert-binary-number-in-a-linked-list-to-integer.rs ├── 1299-replace-elements-with-greatest-element-on-right-side.rs ├── 1304-find-n-unique-integers-sum-up-to-zero.rs ├── 1309-decrypt-string-from-alphabet-to-integer-mapping.rs ├── 1317-convert-integer-to-the-sum-of-two-no-zero-integers.rs ├── 1323-maximum-69-number.rs ├── 1331-rank-transform-of-an-array.rs ├── 1338-reduce-array-size-to-the-half.rs ├── 1351-count-negative-numbers-in-a-sorted-matrix.rs ├── 1356-sort-integers-by-the-number-of-1-bits.rs ├── 136-single-number.rs ├── 1374-generate-a-string-with-characters-that-have-odd-counts.rs ├── 1380-lucky-numbers-in-a-matrix.rs ├── 1381-design-a-stack-with-increment-operation.rs ├── 1385-find-the-distance-value-between-two-arrays.rs ├── 1387-sort-integers-by-the-power-value.rs ├── 1394-find-lucky-integer-in-an-array.rs ├── 1395-count-number-of-teams.rs ├── 1399-count-largest-group.rs ├── 1408-string-matching-in-an-array.rs ├── 1413-minimum-value-to-get-positive-step-by-step-sum.rs ├── 1414-find-the-minimum-number-of-fibonacci-numbers-whose-sum-is-k.rs ├── 1431-kids-with-the-greatest-number-of-candies.rs ├── 1433-check-if-a-string-can-break-another-string.rs ├── 1436-destination-city.rs ├── 1441-build-an-array-with-stack-operations.rs ├── 1446-consecutive-characters.rs ├── 1450-number-of-students-doing-homework-at-a-given-time.rs ├── 1455-check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence.rs ├── 1460-make-two-arrays-equal-by-reversing-sub-arrays.rs ├── 1464-maximum-product-of-two-elements-in-an-array.rs ├── 147-insertion-sort-list.rs ├── 1470-shuffle-the-array.rs ├── 1472-design-browser-history.rs ├── 1475-final-prices-with-a-special-discount-in-a-shop.rs ├── 1486-xor-operation-in-an-array.rs ├── 1491-average-salary-excluding-the-minimum-and-maximum-salary.rs ├── 1502-can-make-arithmetic-progression-from-sequence.rs ├── 1512-number-of-good-pairs.rs ├── 1518-water-bottles.rs ├── 1523-count-odd-numbers-in-an-interval-range.rs ├── 1528-shuffle-string.rs ├── 1529-minimum-suffix-flips.rs ├── 1534-count-good-triplets.rs ├── 1534-count-operations-to-obtain-zero.rs ├── 1544-make-the-string-great.rs ├── 155-min-stack.rs ├── 1550-three-consecutive-odds.rs ├── 1551-minimum-operations-to-make-array-equal.rs ├── 1556-thousand-separator.rs ├── 1572-matrix-diagonal-sum.rs ├── 1582-special-positions-in-a-binary-matrix.rs ├── 1588-sum-of-all-odd-length-subarrays.rs ├── 1598-crawler-log-folder.rs ├── 1603-design-parking-system.rs ├── 1608-special-array-with-x-elements-greater-than-or-equal-x.rs ├── 1614-maximum-nesting-depth-of-the-parentheses.rs ├── 1619-mean-of-array-after-removing-some-elements.rs ├── 1624-largest-substring-between-two-equal-characters.rs ├── 1636-sort-array-by-increasing-frequency.rs ├── 1640-check-array-formation-through-concatenation.rs ├── 1641-count-sorted-vowel-strings.rs ├── 1652-defuse-the-bomb.rs ├── 1662-check-if-two-string-arrays-are-equivalent.rs ├── 1669-merge-in-between-linked-lists.rs ├── 1672-richest-customer-wealth.rs ├── 1678-goal-parser-interpretation.rs ├── 1684-count-the-number-of-consistent-strings.rs ├── 1688-count-of-matches-in-tournament.rs ├── 1689-partitioning-into-minimum-number-of-deci-binary-numbers.rs ├── 1694-reformat-phone-number.rs ├── 1701-average-waiting-time.rs ├── 1704-determine-if-string-halves-are-alike.rs ├── 1710-maximum-units-on-a-truck.rs ├── 1716-calculate-money-in-leetcode-bank.rs ├── 171_title_to_number.rs ├── 1720-decode-xored-array.rs ├── 1725-number-of-rectangles-that-can-form-the-largest-square.rs ├── 1742-maximum-number-of-balls-in-a-box.rs ├── 1743-restore-the-array-from-adjacent-pairs.rs ├── 1748-sum-of-unique-elements.rs ├── 1752-check-if-array-is-sorted-and-rotated.rs ├── 1758-minimum-changes-to-make-alternating-binary-string.rs ├── 1763-longest-nice-substring.rs ├── 1763-ongest-nice-substring.rs ├── 1768-merge-strings-alternately.rs ├── 1773-count-items-matching-a-rule.rs ├── 1780-check-if-number-is-a-sum-of-powers-of-three.rs ├── 1784-check-if-binary-string-has-at-most-one-segment-of-ones.rs ├── 1790-check-if-one-string-swap-can-make-strings-equal.rs ├── 1791-find-center-of-star-graph.rs ├── 1800-maximum-ascending-subarray-sum.rs ├── 1807-evaluate-the-bracket-pairs-of-a-string.rs ├── 1816-truncate-sentence.rs ├── 1817-finding-the-users-active-minutes.rs ├── 1822-sign-of-the-product-of-an-array.rs ├── 1827-minimum-operations-to-make-the-array-increasing.rs ├── 1828-queries-on-number-of-points-inside-a-circle.rs ├── 1829-maximum-xor-for-each-query.rs ├── 1832-check-if-the-sentence-is-pangram.rs ├── 1833-maximum-ice-cream-bars.rs ├── 1837-sum-of-digits-in-base-k.rs ├── 1844-replace-all-digits-with-characters.rs ├── 1848-minimum-distance-to-the-target-element.rs ├── 1859-sorting-the-sentence.rs ├── 1863-sum-of-all-subset-xor-totals.rs ├── 1869-longer-contiguous-segments-of-ones-than-zeros.rs ├── 1876-substrings-of-size-three-with-distinct-characters.rs ├── 1880-check-if-word-equals-summation-of-two-words.rs ├── 1887-reduction-operations-to-make-the-array-elements-equal.rs ├── 1893-check-if-all-the-integers-in-a-range-are-covered.rs ├── 1897-redistribute-characters-to-make-all-strings-equal.rs ├── 1903-largest-odd-number-in-string.rs ├── 1910-remove-all-occurrences-of-a-substring.rs ├── 1913-maximum-product-difference-between-two-pairs.rs ├── 1920-build-array-from-permutation.rs ├── 1925-count-square-sum-triples.rs ├── 1929-concatenation-of-array.rs ├── 1935-maximum-number-of-words-you-can-type.rs ├── 1941-check-if-all-characters-have-equal-number-of-occurrences.rs ├── 1945-sum-of-digits-of-string-after-convert.rs ├── 1952-three-divisors.rs ├── 1957-make_fancy_string.rs ├── 196-next-greater-element-i.rs ├── 1967-number-of-strings-that-appear-as-substrings-in-word.rs ├── 1974_minimum-time-to-type-word-using-special-typewriter.rs ├── 1979-find-greatest-common-divisor-of-array.rs ├── 1980-find-unique-binary-string.rs ├── 1984-minimum-difference-between-highest-and-lowest-of-k-scores.rs ├── 1991-find-the-middle-index-in-array.rs ├── 1995-count-special-quadruplets.rs ├── 2000-reverse-prefix-of-word.rs ├── 2006-count-number-of-pairs-with-absolute-difference-k.rs ├── 2011-final-value-of-variable-after-performing-operations.rs ├── 202-happy-number.rs ├── 2023-number-of-pairs-of-strings-with-concatenation-equal-to-target.rs ├── 2027-minimum-moves-to-convert-string.rs ├── 2032-two-out-of-three.rs ├── 2037-minimum-number-of-moves-to-seat-everyone.rs ├── 2042-check-if-numbers-are-ascending-in-a-sentence.rs ├── 2043-simple-bank-system.rs ├── 2053-kth-distinct-string-in-an-arra.rs ├── 206-reverse-linked-list.rs ├── 2062-count-vowel-substrings-of-a-string.rs ├── 2068-check-whether-two-strings-are-almost-equivalent.rs ├── 2073-time-needed-to-buy-tickets.rs ├── 2078-two-furthest-houses-with-different-colors.rs ├── 2085-count-common-words-with-one-occurrence.rs ├── 2089-find-target-indices-after-sorting-array.rs ├── 2094-finding-3-digit-even-numbers.rs ├── 2103-rings-and-rods.rs ├── 2108-find-first-palindromic-string-in-the-array.rs ├── 2109-adding-spaces-to-a-string.rs ├── 2114-maximum-number-of-words-found-in-sentences.rs ├── 2119-a-number-after-a-double-reversal.rs ├── 2120-execution-of-all-suffix-instructions-staying-in-a-grid.rs ├── 2124-check-if-all-as-appears-before-all-bs.rs ├── 2125-number-of-laser-beams-in-a-bank.rs ├── 2129-capitalize-the-title.rs ├── 2130-maximum-twin-sum-of-a-linked-list.rs ├── 2133-check-if-every-row-and-column-contains-all-numbers.rs ├── 2138-divide-a-string-into-groups-of-size-k.rs ├── 2144-minimum-cost-of-buying-candies-with-discount.rs ├── 2148-count-elements-with-strictly-smaller-and-greater-elements.rs ├── 2149-rearrange-array-elements-by-sign.rs ├── 2150-find-all-lonely-numbers-in-the-array.rs ├── 2154-keep-multiplying-found-values-by-two.rs ├── 216-combination-sum-iii.rs ├── 2160-minimum-sum-of-four-digit-number-after-splitting-digits.rs ├── 2164-sort-even-and-odd-indices-independently.rs ├── 2177-find-three-consecutive-integers-that-sum-to-a-given-number.rs ├── 2180-count-integers-with-even-digit-sum.rs ├── 2181-merge-nodes-in-between-zeros.rs ├── 2185-counting-words-with-a-given-prefix.rs ├── 2194-cells-in-a-range-on-an-excel-sheet.rs ├── 2215-find-the-difference-of-two-arrays.rs ├── 2224-minimum-number-of-operations-to-convert-time.rs ├── 2231-largest-number-after-digit-swaps-by-parity.rs ├── 2243-calculate-digit-sum-of-a-string.rs ├── 2248-intersection-of-multiple-arrays.rs ├── 225-implement-stack-using-queues.rs ├── 2264-largest-3-same-digit-number-in-string.rs ├── 2278-percentage-of-letter-in-string.rs ├── 228-summary-ranges.rs ├── 2287-rearrange-characters-to-make-target-string.rs ├── 2293-min-max-game.rs ├── 2294-partition-array-such-that-maximum-difference-is-k.rs ├── 2303-calculate-amount-paid-in-taxes.rs ├── 2309-greatest-english-letter-in-upper-and-lower-case.rs ├── 2315-count-asterisks.rs ├── 232-implement-queue-using-stacks.rs ├── 23350-minimum-amount-of-time-to-fill-cups.rs ├── 2336-smallest-number-in-infinite-set.rs ├── 2341-maximum-number-of-pairs-in-array.rs ├── 238-product-of-array-except-self.rs ├── 2389-longest-subsequence-with-limited-sum.rs ├── 2390-removing-stars-from-a-string.rs ├── 242-valid-anagram.rs ├── 2452-words-within-two-edits-of-dictionary.rs ├── 2455-average-value-of-even-numbers-that-are-divisible-by-three.rs ├── 2460-apply-operations-to-an-array.rs ├── 2490-circular-sentence.rs ├── 2566-maximum-difference-by-remapping-a-digit.rs ├── 258-add-digits.rs ├── 260-single-number-iii.rs ├── 268-missing-number.rs ├── 283-move-zeroes.rs ├── 29-divide-two-integers.rs ├── 318-maximum-product-of-word-lengths.rs ├── 338-counting-bits.rs ├── 345-reverse-vowels-of-a-string.rs ├── 347-top-k-frequent-elements.rs ├── 350-intersection-of-two-arrays-ii.rs ├── 352-data-stream-as-disjoint-intervals.rs ├── 384-shuffle-an-array.rs ├── 387-first-unique-character-in-a-string.rs ├── 389-find-the-difference.rs ├── 398-random-pick-index.rs ├── 412-fizz-buzz.rs ├── 413-arithmetic-slices.rs ├── 423-reconstruct-original-digits-from-english.rs ├── 434-number-of-segments-in-a-string.rs ├── 442-find-all-duplicates-in-an-array.rs ├── 448-find-all-numbers-disappeared-in-an-array.rs ├── 451-sort-characters-by-frequency.rs ├── 46-permutations.rs ├── 461-hamming-distance.rs ├── 476-number-complement.rs ├── 485-max-consecutive-ones.rs ├── 492-construct-the-rectangle.rs ├── 495-teemo-attacking.rs ├── 503-next-greater-element-ii.rs ├── 506-relative-ranks.rs ├── 509-fibonacci-number.rs ├── 520-detect-capital.rs ├── 537-complex-number-multiplication.rs ├── 539-minimum-time-difference.rs ├── 541-reverse-string-ii.rs ├── 557-reverse-words-in-a-string-iii.rs ├── 561-array-partition-i.rs ├── 566-reshape-the-matrix.rs ├── 599-minimum-index-sum-of-two-lists.rs ├── 6124-first-letter-to-appear-twice.rs ├── 647-palindromic-substrings.rs ├── 648-replace-words.rs ├── 657-robot-return-to-origin.rs ├── 661-image-smoother.rs ├── 676-implement-magic-dictionary.rs ├── 677-map-sum-pairs.rs ├── 682-baseball-game.rs ├── 693-binary-number-with-alternating-bits.rs ├── 696-count-binary-substrings.rs ├── 697-degree-of-an-array.rs ├── 700-search-in-a-binary-search-tree.rs ├── 704-binary-search.rs ├── 705-design-hashset.rs ├── 706-design-hashmap.rs ├── 717-1-bit-and-2-bit-characters.rs ├── 724-find-pivot-index.rs ├── 728-self-dividing-numbers.rs ├── 739-daily-temperatures.rs ├── 744-find-smallest-letter-greater-than-target.rs ├── 747-largest-number-at-least-twice-of-others.rs ├── 748-shortest-completing-word.rs ├── 75-sort-colors.rs ├── 762-prime-number-of-set-bits-in-binary-representation.rs ├── 766-toeplitz-matrix.rs ├── 77-combinations.rs ├── 78-subsets.rs ├── 784-letter-case-permutation.rs ├── 788-rotated-digits.rs ├── 789-escape-the-ghosts.rs ├── 791-custom-sort-string.rs ├── 796-rotate-string.rs ├── 804-unique-morse-code-words.rs ├── 806-number-of-lines-to-write-string.rs ├── 807-max-increase-to-keep-city-skyline.rs ├── 811-subdomain-visit-count.rs ├── 812-largest-triangle-area.rs ├── 821-shortest-distance-to-a-character.rs ├── 824-goat-latin.rs ├── 830-positions-of-large-groups.rs ├── 832-flipping-an-image.rs ├── 841-keys-and-rooms.rs ├── 844-backspace-string-compare.rs ├── 852-peak-index-in-a-mountain-array.rs ├── 859-buddy-strings.rs ├── 867-transpose-matrix.rs ├── 868-binary-gap.rs ├── 869-reordered-power-of-2.rs ├── 884-uncommon-words-from-two-sentences.rs ├── 888-fair-candy-swap.rs ├── 892-surface-area-of-3d-shapes.rs ├── 896-monotonic-array.rs ├── 905-sort_array_by_parity.rs ├── 917-reverse-only-letters.rs ├── 929-unique-email-addresses.rs ├── 942-di-string-match.rs ├── 944-delete-columns-to-make-sorted.rs ├── 946-validate-stack-sequences.rs ├── 961-n-repeated-element-in-size-2n-array.rs ├── 977-squares-of-a-sorted-array.rs ├── 985-sum-of-even-numbers-after-queries.rs ├── README.txt ├── commit.sh ├── lcp-50-WHnhjV.rs ├── lcp-61-6CE719.rs ├── lcp06-na-ying-bi.rs ├── lcp17-nGK0Fy.rs ├── lcp55-PTXy4P.rs └── lcs-WqXACV.rs /.github/workflows/rust.yml: -------------------------------------------------------------------------------- 1 | name: Rust 2 | 3 | on: 4 | push: 5 | branches: [ "main" ] 6 | pull_request: 7 | branches: [ "main" ] 8 | 9 | env: 10 | CARGO_TERM_COLOR: always 11 | 12 | jobs: 13 | build: 14 | 15 | runs-on: ubuntu-latest 16 | 17 | steps: 18 | - uses: actions/checkout@v3 19 | - name: Build & Run 20 | run: | 21 | for changed_file in ${{ steps.files.outputs.all }}; do 22 | rustc changed_file -o bin 23 | ./bin 24 | done 25 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | 2 | *.pdb 3 | *.exe 4 | *.rb 5 | * 6 | !*.rs 7 | !commit.sh 8 | -------------------------------------------------------------------------------- /1006-clumsy-factorial.rs: -------------------------------------------------------------------------------- 1 | pub fn clumsy(n: i32) -> i32 { 2 | if n == 1 { return 1 } 3 | if n == 2 { return 2 } 4 | let mut ret = n * (n-1) / (n-2) + n-3; 5 | let mut tmp = 0; 6 | for (i, num) in (1..=n-4).rev().enumerate() { 7 | match i % 4 { 8 | 0 => { tmp = num }, 9 | 1 => { tmp *= num }, 10 | 2 => { 11 | ret -= (tmp as f64 / num as f64).floor() as i32; 12 | tmp = 0 13 | }, 14 | 3 => { ret += num }, 15 | _ => { }, 16 | } 17 | } 18 | ret - tmp 19 | } 20 | 21 | fn main() { 22 | println!("{:?}", clumsy(2)); 23 | } 24 | -------------------------------------------------------------------------------- /1009-complement-of-base-10-integer.rs: -------------------------------------------------------------------------------- 1 | pub fn bitwise_complement(n: i32) -> i32 { 2 | let a = format!("{:b}", n).chars() 3 | .map(|e| 4 | if e == '0' { 5 | "1" 6 | } else { 7 | "0" 8 | } 9 | ) 10 | .collect::>() 11 | .join(""); 12 | isize::from_str_radix(&a, 2).unwrap() as i32 13 | } 14 | 15 | fn main() { 16 | println!("{:?}", bitwise_complement(7)); 17 | } 18 | -------------------------------------------------------------------------------- /1021-remove-outermost-parentheses.rs: -------------------------------------------------------------------------------- 1 | // 抄答案啦 2 | // 可以理解为，将level=1 以上的括号写入结果，level 指的是深度 3 | // 妙啊 4 | 5 | pub fn remove_outer_parentheses(s: String) -> String { 6 | let mut level = 0; 7 | let mut ret = String::new(); 8 | for c in s.chars() { 9 | if c == ')' { 10 | level -= 1; 11 | } 12 | if level >= 1 { 13 | ret.push(c); 14 | } 15 | if c == '(' { 16 | level += 1; 17 | } 18 | } 19 | ret 20 | } 21 | 22 | fn main() { 23 | let s = "(()())(())".to_string(); 24 | println!("{:?}", remove_outer_parentheses(s)); 25 | } 26 | -------------------------------------------------------------------------------- /1029-two-city-scheduling.rs: -------------------------------------------------------------------------------- 1 | pub fn two_city_sched_cost(costs: Vec>) -> i32 { 2 | let n = costs.len(); 3 | let mut sorted_costs = costs.clone(); 4 | sorted_costs.sort_by(|a, b|(a[0]-a[1]).cmp(&(b[0]-b[1]))); 5 | &sorted_costs[0..n/2].iter().map(|e|e[0]).sum::() + &sorted_costs[n/2..].iter().map(|e|e[1]).sum::() 6 | } 7 | 8 | fn main() { 9 | let costs = vec![[10,20],[30,200],[400,50],[30,20]].iter().map(|e|e.to_vec()).collect(); 10 | println!("{:?}", two_city_sched_cost(costs)); 11 | } 12 | -------------------------------------------------------------------------------- /1046-last-stone-weight.rs: -------------------------------------------------------------------------------- 1 | pub fn last_stone_weight(stones: Vec) -> i32 { 2 | let mut stones = stones.clone(); 3 | while stones.len() > 1 { 4 | stones.sort_by(|a, b|b.cmp(&a)); 5 | if stones[0] == stones[1] { 6 | stones.remove(0); 7 | } else { 8 | stones[1] = (stones[1]-stones[0]).abs(); 9 | } 10 | stones.remove(0); 11 | } 12 | if stones.len() > 0 { 13 | stones[0] 14 | } else { 15 | 0 16 | } 17 | } 18 | 19 | fn main() { 20 | println!("{:?}", last_stone_weight(vec![2,2])); 21 | } 22 | -------------------------------------------------------------------------------- /1047-remove-all-adjacent-duplicates-in-string.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | println!("{}", remove_duplicates("abbaca".to_string())); 3 | } 4 | 5 | pub fn remove_duplicates(s: String) -> String { 6 | let mut stack = Vec::new(); 7 | for c in s.chars() { 8 | if stack.is_empty() { 9 | stack.push(c); 10 | } else { 11 | if c != *stack.last().unwrap() { 12 | stack.push(c); 13 | } else { 14 | stack.pop(); 15 | } 16 | } 17 | } 18 | stack.into_iter().collect() 19 | } 20 | -------------------------------------------------------------------------------- /1051-height-checker.rs: -------------------------------------------------------------------------------- 1 | // 示例： 2 | 3 | // 输入：heights = [1,1,4,2,1,3] 4 | // 输出：3 5 | // 解释： 6 | // 高度：[1,1,4,2,1,3] 7 | // 预期：[1,1,1,2,3,4] 8 | // 下标 2 、4 、5 处的学生高度不匹配。 9 | 10 | // 来源：力扣（LeetCode） 11 | // 链接：https://leetcode-cn.com/problems/height-checker 12 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 13 | 14 | pub fn height_checker(heights: Vec) -> i32 { 15 | let mut res = 0; 16 | let mut sorted_heights = heights.clone(); 17 | sorted_heights.sort(); 18 | for (i, h) in heights.into_iter().enumerate() { 19 | if h != sorted_heights[i] { 20 | res += 1; 21 | } 22 | } 23 | res 24 | } 25 | -------------------------------------------------------------------------------- /1078-occurrences-after-bigram.rs: -------------------------------------------------------------------------------- 1 | pub fn find_ocurrences(text: String, first: String, second: String) -> Vec { 2 | let strs: Vec = text.split(" ").map(|s|s.to_string()).collect(); 3 | let tail_index = &strs.len() - 2; 4 | let mut res: Vec = Vec::new(); 5 | for i in 0..tail_index { 6 | if strs[i] == first && strs[i+1] == second { 7 | res.push(strs[i+2].clone()); 8 | } 9 | } 10 | res 11 | } 12 | 13 | fn main() { 14 | let text = "we will we will rock you".to_string(); 15 | let first = "we".to_string(); 16 | let second = "will".to_string(); 17 | 18 | println!("{:?}", find_ocurrences(text, first, second)); 19 | } 20 | -------------------------------------------------------------------------------- /1089-duplicate-zeros.rs: -------------------------------------------------------------------------------- 1 | // 从后往前冒泡交换，然后将最后一个元素冒泡到0后面一位，然后将它变为0 2 | // 因为最后一个元素是要被挤出去的那一个 3 | 4 | pub fn duplicate_zeros(arr: &mut Vec) { 5 | let mut i = 0; 6 | while i < arr.len() { 7 | if arr[i] == 0 { 8 | for j in (i+1..arr.len()).rev() { 9 | let tmp = arr[j]; 10 | arr[j] = arr[j-1]; 11 | arr[j-1] = tmp; 12 | } 13 | arr[i] = 0; 14 | i+=1; 15 | } 16 | i+=1; 17 | } 18 | } 19 | 20 | fn main() { 21 | let mut arr = vec![1,0,2,3,0,4,5,0]; 22 | duplicate_zeros(&mut arr); 23 | println!("{:?}", arr); 24 | } 25 | -------------------------------------------------------------------------------- /1103-distribute-candies-to-people.rs: -------------------------------------------------------------------------------- 1 | pub fn distribute_candies(candies: i32, num_people: i32) -> Vec { 2 | let mut ret = vec![0; num_people as usize]; 3 | let mut candies = candies; 4 | let mut tmp = 1; 5 | while candies > 0 { 6 | for i in 0..ret.len() { 7 | if candies >= tmp { 8 | ret[i] += tmp; 9 | candies -= tmp; 10 | } else { 11 | ret[i] += candies; 12 | candies = 0; 13 | } 14 | tmp += 1; 15 | } 16 | } 17 | ret 18 | } 19 | 20 | fn main() { 21 | println!("{:?}", distribute_candies(7, 4)); 22 | } 23 | -------------------------------------------------------------------------------- /1122-relative-sort-array.rs: -------------------------------------------------------------------------------- 1 | pub fn relative_sort_array(arr1: Vec, arr2: Vec) -> Vec { 2 | use std::collections::HashMap; 3 | let mut mmp = HashMap::new(); 4 | for num in arr1 { 5 | if arr2.contains(&num) { 6 | mmp.entry(num).or_insert(Vec::new()).push(num); 7 | } else { 8 | mmp.entry(-1).or_insert(Vec::new()).push(num); 9 | } 10 | } 11 | let mut res: Vec = Vec::new(); 12 | for num in arr2 { 13 | let mut tmp = mmp[&num].clone(); 14 | res.append(&mut tmp); 15 | } 16 | 17 | if mmp.get(&-1) != None { 18 | let mut tmp = mmp[&-1].clone(); 19 | tmp.sort(); 20 | res.append(&mut tmp); 21 | } 22 | res 23 | } 24 | 25 | fn main() { 26 | let arr1 = vec![943,790,427,722,860,550,225,846,715,320]; 27 | let arr2 = vec![943,715,427,790,860,722,225,320,846,550]; 28 | println!("{:?}", relative_sort_array(arr1, arr2)); 29 | } 30 | -------------------------------------------------------------------------------- /1137-n-th-tribonacci-number.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | 4 | // 超时 5 | // impl Solution { 6 | // pub fn tribonacci(n: i32) -> i32 { 7 | // if n == 0 { return 0; } 8 | // if n == 1 { return 1; } 9 | // if n == 2 { return 1; } 10 | // Self::tribonacci(n-1) + Self::tribonacci(n-2) + Self::tribonacci(n-3) 11 | // } 12 | // } 13 | 14 | // 动态规划 15 | impl Solution { 16 | pub fn tribonacci(n: i32) -> i32 { 17 | let mut ret = vec![0; 38]; 18 | ret[0] = 0; 19 | ret[1] = 1; 20 | ret[2] = 1; 21 | for i in 3..38 { 22 | ret[i] = ret[i-1] + ret[i-2] + ret[i-3]; 23 | } 24 | ret[n as usize] 25 | } 26 | } 27 | 28 | fn main() { 29 | println!("{:?}", Solution::tribonacci(35)); 30 | } 31 | -------------------------------------------------------------------------------- /1184-distance-between-bus-stops.rs: -------------------------------------------------------------------------------- 1 | pub fn distance_between_bus_stops(distance: Vec, start: i32, destination: i32) -> i32 { 2 | let left = vec![start, destination].into_iter().min().unwrap(); 3 | let right = vec![start, destination].into_iter().max().unwrap(); 4 | vec![distance[left as usize..right as usize].iter().sum::(), 5 | distance[0..left as usize].iter().sum::() + 6 | distance[right as usize..].iter().sum::() 7 | ].into_iter().min().unwrap() 8 | } 9 | 10 | fn main() { 11 | let distance = vec![1, 2, 3, 4]; 12 | let start = 0; 13 | let destination = 1; 14 | println!("{:?}", distance_between_bus_stops(distance, start, destination)); 15 | let distance = vec![7,10,1,12,11,14,5,0]; 16 | let start = 7; 17 | let destination = 2; 18 | println!("{:?}", distance_between_bus_stops(distance, start, destination)); 19 | } 20 | -------------------------------------------------------------------------------- /1189-maximum-number-of-balloons.rs: -------------------------------------------------------------------------------- 1 | pub fn max_number_of_balloons(text: String) -> i32 { 2 | let mut stats = vec![0; 5]; // b a l o n 3 | for c in text.chars().collect::>() { 4 | match c { 5 | 'b' => stats[0] += 1, 6 | 'a' => stats[1] += 1, 7 | 'l' => stats[2] += 1, 8 | 'o' => stats[3] += 1, 9 | 'n' => stats[4] += 1, 10 | _ => {}, 11 | } 12 | } 13 | stats[2] /= 2; 14 | stats[3] /= 2; 15 | *stats.iter().min().unwrap() 16 | } 17 | 18 | fn main() { 19 | let text = "loonbalxballpoon".to_string(); 20 | println!("{:?}", max_number_of_balloons(text)); 21 | } 22 | -------------------------------------------------------------------------------- /119-pascals-triangle-ii.rs: -------------------------------------------------------------------------------- 1 | pub fn get_row(row_index: i32) -> Vec { 2 | let mut ret = vec![vec![1], vec![1, 1]]; 3 | for i in 2..=row_index as usize { 4 | let mut tmp = vec![]; 5 | for j in 1..ret[i-1].len() { 6 | tmp.push(ret[i-1][j] + ret[i-1][j-1]) 7 | } 8 | tmp.push(1); 9 | tmp.insert(0, 1); 10 | ret.push(tmp); 11 | } 12 | ret[row_index as usize].clone() 13 | } 14 | 15 | fn main() { 16 | println!("{:?}", get_row(0)); 17 | println!("{:?}", get_row(1)); 18 | println!("{:?}", get_row(2)); 19 | println!("{:?}", get_row(3)); 20 | } 21 | -------------------------------------------------------------------------------- /12-integer-to-roman.rs: -------------------------------------------------------------------------------- 1 | pub fn int_to_roman(num: i32) -> String { 2 | let mut num = num; 3 | let values = vec![1000,900,500,400,100,90,50,40,10,9,5,4,1]; 4 | let reps = vec!["M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"]; 5 | let mut ret = String::new(); 6 | for i in 0..13 { 7 | while num >= values[i] { 8 | num -= values[i]; 9 | ret.push_str(reps[i]); 10 | } 11 | } 12 | ret.to_string() 13 | } 14 | 15 | fn main() { 16 | let num = 1994; 17 | println!("{:?}", int_to_roman(num)); 18 | } 19 | -------------------------------------------------------------------------------- /1200-minimum-absolute-difference.rs: -------------------------------------------------------------------------------- 1 | pub fn minimum_abs_difference(arr: Vec) -> Vec> { 2 | let mut sorted_arr = arr.clone(); 3 | sorted_arr.sort(); 4 | use std::collections::HashMap; 5 | let mut mmp = HashMap::new(); 6 | for i in 1..arr.len() { 7 | mmp.entry((sorted_arr[i]-sorted_arr[i-1]).abs()) 8 | .or_insert(Vec::new()) 9 | .push(vec!(sorted_arr[i-1], sorted_arr[i])); 10 | } 11 | let mut mmp_vec: Vec<_> = mmp.iter().collect(); 12 | mmp_vec.sort_by(|a, b|a.0.cmp(b.0)); 13 | mmp_vec[0].1.to_vec() 14 | } 15 | 16 | fn main() { 17 | let arr = vec![3, 8, -10, 23, 19, -4, -14, 27]; 18 | println!("{:?}", minimum_abs_difference(arr)); 19 | } 20 | -------------------------------------------------------------------------------- /1207-unique-number-of-occurrences.rs: -------------------------------------------------------------------------------- 1 | // sort_unstable() + dedup() = "unique()" 2 | 3 | pub fn unique_occurrences(arr: Vec) -> bool { 4 | use std::collections::HashMap; 5 | let mut count_map = HashMap::new(); 6 | for num in arr { 7 | let counter = count_map.entry(num).or_insert(0); 8 | *counter += 1; 9 | } 10 | let mut uniq_vals: Vec = count_map.values().cloned().collect(); 11 | uniq_vals.sort_unstable(); //必须加这行，不然不是unique。 12 | uniq_vals.dedup(); 13 | count_map.values().len() == uniq_vals.len() 14 | } 15 | 16 | fn main() { 17 | println!("{:?}", unique_occurrences(vec![26,2,16,16,5,5,26,2,5,20,20,5,2,20,2,2,20,2,16,20,16,17,16,2,16,20,26,16])); 18 | } 19 | -------------------------------------------------------------------------------- /1217-minimum-cost-to-move-chips-to-the-same-position.rs: -------------------------------------------------------------------------------- 1 | // 因为移动2个位置不需要代价，那么奇数位置移到奇数位置不用代价， 2 | // 偶数位置移到偶数位置不用代价，那就分别统计奇数位置和偶数位置的个数， 3 | // 相当于把所有奇数放一起，所有偶数的放一起，然后比较奇数的少还是偶数的少， 4 | // 将少的个数移到多的个数位置上去就可以了12. 5 | 6 | pub fn min_cost_to_move_chips(position: Vec) -> i32 { 7 | let mut count = vec!(0; 2); 8 | for p in position { 9 | if p % 2 == 0 { 10 | count[0] += 1; 11 | } else { 12 | count[1] += 1; 13 | } 14 | } 15 | *count.iter().min().unwrap() 16 | } 17 | 18 | fn main() { 19 | let position = vec![2,3,2,3,2]; 20 | println!("{:?}", min_cost_to_move_chips(position)); 21 | } 22 | -------------------------------------------------------------------------------- /122-best-time-to-buy-and-sell-stock-ii.rs: -------------------------------------------------------------------------------- 1 | // 算法可以直接简化为只要今天比昨天大，就卖出，同时也可以买进（但不知道明天是否会涨呢？）。 2 | // 上帝视角： 扫描一遍 只要后一天比前一天大 就把这两天的差值加一下 3 | 4 | pub fn max_profit(prices: Vec) -> i32 { 5 | let mut ret = 0; 6 | for i in 0 .. prices.len() - 1 { 7 | if prices[i+1] > prices[i] { ret += prices[i+1] - prices[i] } 8 | } 9 | ret 10 | } 11 | 12 | fn main() { 13 | println!("{:?}", max_profit(vec![7,1,5,3,6,4])); 14 | } 15 | -------------------------------------------------------------------------------- /1221-split-a-string-in-balanced-strings.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：s = "RLRRLLRLRL" 4 | // 输出：4 5 | // 解释：s 可以分割为 "RL"、"RRLL"、"RL"、"RL" ，每个子字符串中都包含相同数量的 'L' 和 'R' 。 6 | 7 | // 来源：力扣（LeetCode） 8 | // 链接：https://leetcode-cn.com/problems/split-a-string-in-balanced-strings 9 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 10 | // RLLLLRRRLR 3 11 | // LLLLRRRR 1 12 | // RLRRRLLRLL 2 13 | 14 | 15 | fn main() { 16 | let str = "RLRRRLLRLL".to_string(); 17 | let res = balanced_string_split(str); 18 | println!("{:?}", res); 19 | } 20 | 21 | pub fn balanced_string_split(s: String) -> i32 { 22 | let mut r_count = 0; 23 | let mut l_count = 0; 24 | let mut res = 0; 25 | for char in s.chars() { 26 | if char == 'R' { 27 | r_count += 1; 28 | } else { 29 | l_count += 1; 30 | } 31 | if l_count == r_count { 32 | res += 1; 33 | r_count = 0; 34 | l_count = 0; 35 | } 36 | } 37 | res 38 | } -------------------------------------------------------------------------------- /1252-cells-with-odd-values-in-a-matrix.rs: -------------------------------------------------------------------------------- 1 | pub fn odd_cells(m: i32, n: i32, indices: Vec>) -> i32 { 2 | // let v = vec![0; 10]; // ten zeroes 3 | // 用以上方法构造矩阵 4 | // [[0, 0, 0], [0, 0, 0]] 5 | let mut a = vec![vec![0; n as usize]; m as usize]; 6 | for index in indices { 7 | for i in 0..n { 8 | a[index[0] as usize][i as usize] += 1; 9 | } 10 | for j in 0..m { 11 | a[j as usize][index[1] as usize] += 1; 12 | } 13 | } 14 | let mut counter = 0; 15 | for row in a { 16 | for e in row { 17 | if e % 2 != 0{ 18 | counter += 1 19 | } 20 | } 21 | } 22 | counter 23 | } 24 | 25 | fn main() { 26 | let (m, n) = (2, 2); 27 | let indices = vec![vec![1,1],vec![0,0]]; 28 | println!("{:?}", odd_cells(m, n, indices)); 29 | } 30 | -------------------------------------------------------------------------------- /1260-shift-2d-grid.rs: -------------------------------------------------------------------------------- 1 | pub fn shift_grid(grid: Vec>, k: i32) -> Vec> { 2 | let grid_len = grid[0].len(); 3 | let mut a = grid.into_iter().flatten().collect::>(); 4 | let a_len = a.len(); 5 | a.rotate_right(k as usize % a_len); 6 | a.chunks(grid_len).into_iter().map(|e|e.to_vec()).collect() 7 | } 8 | 9 | fn main() { 10 | let grid = vec![vec![3,8,1,9],vec![19,7,2,5],vec![4,6,11,10],vec![12,0,21,13]]; 11 | let k = 4; 12 | println!("{:?}", shift_grid(grid, k)); 13 | let grid = vec![vec![1]]; 14 | let k = 100; 15 | println!("{:?}", shift_grid(grid, k)); 16 | } 17 | -------------------------------------------------------------------------------- /1266-minimum-time-visiting-all-points.rs: -------------------------------------------------------------------------------- 1 | // 输入：points = [[1,1],[3,4],[-1,0]] 2 | // 输出：7 3 | // 解释：一条最佳的访问路径是： [1,1] -> [2,2] -> [3,3] -> [3,4] -> [2,3] -> [1,2] -> [0,1] -> [-1,0] 4 | // 从 [1,1] 到 [3,4] 需要 3 秒 5 | // 从 [3,4] 到 [-1,0] 需要 4 秒 6 | // 一共需要 7 秒 7 | 8 | // 来源：力扣（LeetCode） 9 | // 链接：https://leetcode-cn.com/problems/minimum-time-visiting-all-points 10 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 11 | 12 | fn main() { 13 | let points = vec!( 14 | vec!(1,1), 15 | vec!(3,4), 16 | vec!(-1,0) 17 | ); 18 | println!("{:?}", min_time_to_visit_all_points(points)); 19 | } 20 | 21 | // 归纳总结题目。经过归纳总结发现，发现2点间取x距离或y距离的较大那个就是时间。 22 | pub fn min_time_to_visit_all_points(points: Vec>) -> i32 { 23 | let mut start = points[0].clone(); 24 | let mut steps = 0; 25 | for point in points { 26 | let x_distance = (point[0] - start[0]).abs(); 27 | let y_distance = (point[1] - start[1]).abs(); 28 | if x_distance > y_distance { 29 | steps += x_distance; 30 | } else { 31 | steps += y_distance; 32 | } 33 | start = point.clone(); 34 | } 35 | steps 36 | } 37 | -------------------------------------------------------------------------------- /1287-element-appearing-more-than-25-in-sorted-array.rs: -------------------------------------------------------------------------------- 1 | pub fn find_special_integer(arr: Vec) -> i32 { 2 | let limit_line = arr.len() as f64 * 0.25; 3 | use std::collections::HashMap; 4 | let mut mmp = HashMap::new(); 5 | let mut res: i32 = 0; 6 | for num in arr { 7 | let counter = mmp.entry(num).or_insert(0.0); 8 | *counter += 1.0; 9 | if *counter > limit_line { 10 | res = num; 11 | break; 12 | } 13 | } 14 | res 15 | } 16 | 17 | fn main() { 18 | let arr = vec![1,2,2,6,6,6,6,7,10]; 19 | println!("{:?}", find_special_integer(arr)); 20 | } 21 | -------------------------------------------------------------------------------- /1299-replace-elements-with-greatest-element-on-right-side.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：arr = [17,18,5,4,6,1] 4 | // 输出：[18,6,6,6,1,-1] 5 | // 解释： 6 | // - 下标 0 的元素 --> 右侧最大元素是下标 1 的元素 (18) 7 | // - 下标 1 的元素 --> 右侧最大元素是下标 4 的元素 (6) 8 | // - 下标 2 的元素 --> 右侧最大元素是下标 4 的元素 (6) 9 | // - 下标 3 的元素 --> 右侧最大元素是下标 4 的元素 (6) 10 | // - 下标 4 的元素 --> 右侧最大元素是下标 5 的元素 (1) 11 | // - 下标 5 的元素 --> 右侧没有其他元素，替换为 -1 12 | 13 | // 来源：力扣（LeetCode） 14 | // 链接：https://leetcode-cn.com/problems/replace-elements-with-greatest-element-on-right-side 15 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 16 | 17 | pub fn replace_elements(arr: Vec) -> Vec { 18 | arr.iter().enumerate().map(|(i, _)|{ 19 | let max_value = &arr[i+1..].iter().max(); 20 | match max_value { 21 | Some(i) => **i as i32, 22 | None => -1 as i32, 23 | } 24 | }).collect() 25 | } 26 | 27 | fn main() { 28 | let arr = vec![17,18,5,4,6,1]; 29 | println!("{:?}", replace_elements(arr)); 30 | } 31 | -------------------------------------------------------------------------------- /1304-find-n-unique-integers-sum-up-to-zero.rs: -------------------------------------------------------------------------------- 1 | pub fn sum_zero(n: i32) -> Vec { 2 | let mut res: Vec = (1..n).collect(); 3 | res.push(n * (n-1) / -2); 4 | res 5 | } 6 | 7 | fn main() { 8 | println!("{:?}", sum_zero(5)); 9 | } 10 | -------------------------------------------------------------------------------- /1317-convert-integer-to-the-sum-of-two-no-zero-integers.rs: -------------------------------------------------------------------------------- 1 | pub fn get_no_zero_integers(n: i32) -> Vec { 2 | pub fn is_contain_zero(n: i32) -> bool { 3 | n.to_string().chars().collect::>().contains(&'0') 4 | } 5 | let mut ret = vec!(); 6 | for i in 1..=n/2 { 7 | if !is_contain_zero(i) && !is_contain_zero(n-i) { 8 | ret.push(i); 9 | ret.push(n-i); 10 | break; 11 | } 12 | } 13 | ret 14 | } 15 | 16 | fn main() { 17 | let n = 2; 18 | println!("{:?}", get_no_zero_integers(n)); 19 | } 20 | -------------------------------------------------------------------------------- /1323-maximum-69-number.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：num = 9669 4 | // 输出：9969 5 | // 解释： 6 | // 改变第一位数字可以得到 6669 。 7 | // 改变第二位数字可以得到 9969 。 8 | // 改变第三位数字可以得到 9699 。 9 | // 改变第四位数字可以得到 9666 。 10 | // 其中最大的数字是 9969 。 11 | 12 | // 来源：力扣（LeetCode） 13 | // 链接：https://leetcode-cn.com/problems/maximum-69-number 14 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 15 | 16 | pub fn maximum69_number (num: i32) -> i32 { 17 | let mut flag = true; 18 | let a: String = num.to_string().chars().map(|d| 19 | if d != '9' && flag { 20 | flag = false; 21 | '9' 22 | } else { 23 | d 24 | } 25 | ).into_iter().collect(); 26 | a.parse::().unwrap() 27 | } 28 | 29 | fn main() { 30 | println!("{:?}", maximum69_number(9669)); 31 | } 32 | -------------------------------------------------------------------------------- /1331-rank-transform-of-an-array.rs: -------------------------------------------------------------------------------- 1 | pub fn array_rank_transform(arr: Vec) -> Vec { 2 | let mut sorted_arr = arr.clone(); 3 | sorted_arr.sort_unstable(); 4 | sorted_arr.dedup(); 5 | use std::collections::HashMap; 6 | let mut mmp = HashMap::new(); 7 | for (i, e) in sorted_arr.iter().enumerate() { 8 | mmp.insert(e, i as i32 + 1); 9 | } 10 | arr.iter().map(|e|mmp[e]).collect() 11 | } 12 | 13 | fn main() { 14 | let arr = vec![40,10,20,30]; 15 | println!("{:?}", array_rank_transform(arr)); 16 | } 17 | -------------------------------------------------------------------------------- /1338-reduce-array-size-to-the-half.rs: -------------------------------------------------------------------------------- 1 | pub fn min_set_size(arr: Vec) -> i32 { 2 | let arr_len = arr.len(); 3 | use std::collections::HashMap; 4 | let mut mmp = HashMap::new(); 5 | for e in arr { 6 | mmp.entry(e).and_modify(|e|*e+=1).or_insert(1); 7 | } 8 | let mut mmp_vec: Vec<_> = mmp.iter().collect(); 9 | mmp_vec.sort_by(|b, a|a.1.cmp(&b.1)); 10 | let mut tmp = 0; 11 | let mut ret = 0; 12 | for p in mmp_vec { 13 | tmp += p.1; 14 | ret += 1; 15 | if tmp >= arr_len / 2 { break } 16 | } 17 | ret 18 | } 19 | 20 | fn main() { 21 | println!("{:?}", min_set_size(vec![3, 3, 3, 3, 5, 5, 5, 2, 2, 7])); 22 | println!("{:?}", min_set_size(vec![7, 7, 7, 7, 7, 7])); 23 | println!("{:?}", min_set_size(vec![1, 9])); 24 | } 25 | -------------------------------------------------------------------------------- /1351-count-negative-numbers-in-a-sorted-matrix.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：grid = [[4,3,2,-1],[3,2,1,-1],[1,1,-1,-2],[-1,-1,-2,-3]] 4 | // 输出：8 5 | // 解释：矩阵中共有 8 个负数。 6 | 7 | // 来源：力扣（LeetCode） 8 | // 链接：https://leetcode-cn.com/problems/count-negative-numbers-in-a-sorted-matrix 9 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 10 | 11 | pub fn count_negatives(grid: Vec>) -> i32 { 12 | grid.iter().map(|arr| 13 | arr.iter().map(|e| 14 | if *e < 0 { 15 | 1 16 | } else { 17 | 0 18 | } 19 | ).sum::() 20 | ).sum() 21 | } 22 | 23 | fn main() { 24 | let grid = vec!( 25 | vec!(4,3,2,-1), 26 | vec!(3,2,1,-1), 27 | vec!(1,1,-1,-2), 28 | vec!(-1,-1,-2,-3) 29 | ); 30 | println!("{:?}", count_negatives(grid)); 31 | } 32 | -------------------------------------------------------------------------------- /1356-sort-integers-by-the-number-of-1-bits.rs: -------------------------------------------------------------------------------- 1 | pub fn sort_by_bits(arr: Vec) -> Vec { 2 | use std::collections::HashMap; 3 | let mut count_map: HashMap> = HashMap::new(); 4 | for num in arr { 5 | let num_binary: Vec = format!("{:b}", num).chars().collect(); 6 | let count_binary = num_binary.iter().filter(|&n|*n=='1').count(); 7 | count_map.entry(count_binary).or_insert(Vec::new()).push(num); 8 | } 9 | let mut count_vec: Vec<_> = count_map.iter().collect(); 10 | count_vec.sort_by(|a, b| a.0.cmp(b.0)); 11 | let mut res: Vec = vec!(); 12 | for e in count_vec { 13 | let mut sorted_arr = e.1.clone(); 14 | sorted_arr.sort(); 15 | for i in sorted_arr { 16 | res.push(i); 17 | } 18 | } 19 | res 20 | } 21 | 22 | fn main() { 23 | println!("{:?}", sort_by_bits(vec![0,1,2,3,4,5,6,7,8])); 24 | println!("{:?}", sort_by_bits(vec![1024,512,256,128,64,32,16,8,4,2,1])); 25 | println!("{:?}", sort_by_bits(vec![10,100,1000,10000])); 26 | } 27 | -------------------------------------------------------------------------------- /136-single-number.rs: -------------------------------------------------------------------------------- 1 | // 给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。 2 | 3 | // 说明： 4 | 5 | // 你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？ 6 | 7 | // 示例 1: 8 | 9 | // 输入: [2,2,1] 10 | // 输出: 1 11 | 12 | // 来源：力扣（LeetCode） 13 | // 链接：https://leetcode-cn.com/problems/single-number 14 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 15 | 16 | pub fn single_number(nums: Vec) -> i32 { 17 | use std::collections::HashMap; 18 | let mut kvm = HashMap::new(); 19 | for num in nums { 20 | if !kvm.contains_key(&num) { 21 | kvm.insert(num, true); 22 | } else { 23 | kvm.remove(&num); 24 | } 25 | } 26 | *kvm.keys().nth(0).unwrap() 27 | } 28 | 29 | 30 | fn main() { 31 | println!("{:?}", single_number(vec!(2,2,1))); 32 | } -------------------------------------------------------------------------------- /1374-generate-a-string-with-characters-that-have-odd-counts.rs: -------------------------------------------------------------------------------- 1 | pub fn generate_the_string(n: i32) -> String { 2 | let mut res: String; 3 | if n % 2 == 0 { 4 | res = "a".repeat(n as usize-1); 5 | res.push('b'); 6 | } else { 7 | res = "a".repeat(n as usize); 8 | } 9 | res 10 | } 11 | 12 | fn main() { 13 | println!("{:?}", generate_the_string(4)); 14 | } 15 | -------------------------------------------------------------------------------- /1380-lucky-numbers-in-a-matrix.rs: -------------------------------------------------------------------------------- 1 | pub fn lucky_numbers (matrix: Vec>) -> Vec { 2 | let mut res = Vec::new(); 3 | 'outer: for row in &matrix { 4 | let row_min = row.iter().min().unwrap(); 5 | let i = row.iter().position(|&r| r == *row_min).unwrap(); 6 | for r in &matrix { 7 | if r[i] > *row_min { 8 | continue 'outer; 9 | } 10 | } 11 | res.push(*row_min); 12 | } 13 | res 14 | } 15 | 16 | fn main() { 17 | let matrix = vec!(vec!(3,7,8),vec!(9,11,13),vec!(15,16,17)); 18 | println!("{:?}", lucky_numbers(matrix)); 19 | } 20 | -------------------------------------------------------------------------------- /1385-find-the-distance-value-between-two-arrays.rs: -------------------------------------------------------------------------------- 1 | pub fn find_the_distance_value(arr1: Vec, arr2: Vec, d: i32) -> i32 { 2 | let mut res = 0; 3 | 'outer: for num in arr1 { 4 | for e in &arr2 { 5 | if (num - e).abs() <= d { 6 | continue 'outer; 7 | } 8 | } 9 | res += 1; 10 | } 11 | res 12 | } 13 | 14 | fn main() { 15 | let arr1 = vec![4,5,8]; 16 | let arr2 = vec![10,9,1,8]; 17 | let d = 2; 18 | println!("{:?}", find_the_distance_value(arr1, arr2, d)); 19 | } 20 | -------------------------------------------------------------------------------- /1387-sort-integers-by-the-power-value.rs: -------------------------------------------------------------------------------- 1 | pub fn get_kth(lo: i32, hi: i32, k: i32) -> i32 { 2 | use std::collections::HashMap; 3 | let mut mmp = HashMap::new(); 4 | for i in lo..=hi { 5 | let mut tmp = i; 6 | let mut count = 0; 7 | while tmp != 1 { 8 | if tmp % 2 == 0 { 9 | tmp /= 2; 10 | } else { 11 | tmp = 3 * tmp + 1; 12 | } 13 | count += 1; 14 | } 15 | mmp.entry(count).or_insert(Vec::new()).push(i); 16 | } 17 | let mut mmp_vec: Vec<_> = mmp.iter().collect(); 18 | mmp_vec.sort_by(|a, b|a.0.cmp(b.0)); 19 | *mmp_vec.into_iter().map(|e|e.1).collect::>().into_iter().flatten().collect::>()[k as usize - 1] 20 | } 21 | 22 | fn main() { 23 | println!("{:?}", get_kth(12, 15, 2)); 24 | } 25 | -------------------------------------------------------------------------------- /1394-find-lucky-integer-in-an-array.rs: -------------------------------------------------------------------------------- 1 | pub fn find_lucky(arr: Vec) -> i32 { 2 | use std::collections::HashMap; 3 | let mut mmp = HashMap::new(); 4 | for num in arr { 5 | let counter = mmp.entry(num).or_insert(0); 6 | *counter += 1; 7 | } 8 | mmp.retain(|k, v|k==v); 9 | let mut mmp_vec: Vec<_> = mmp.iter().collect(); 10 | mmp_vec.sort_by(|a, b|b.0.cmp(a.0)); 11 | if mmp_vec.iter().count() == 0 { 12 | -1 13 | } else { 14 | *mmp_vec[0].0 15 | } 16 | } 17 | 18 | fn main() { 19 | let arr = vec![2,2,3,4]; 20 | println!("{:?}", find_lucky(arr)); 21 | } 22 | -------------------------------------------------------------------------------- /1399-count-largest-group.rs: -------------------------------------------------------------------------------- 1 | pub fn count_largest_group(n: i32) -> i32 { 2 | let mut count = vec![0;99]; 3 | for i in 1..=n { 4 | let a = i.to_string().chars().map(|c| c.to_digit(10).unwrap()).sum::(); 5 | count[a as usize] += 1; 6 | } 7 | let m = *count.iter().max().unwrap(); 8 | let mut ret = 0; 9 | for i in count { 10 | if i == m { 11 | ret += 1; 12 | } 13 | } 14 | ret 15 | } 16 | 17 | fn main() { 18 | println!("{:?}", count_largest_group(13)); 19 | } 20 | -------------------------------------------------------------------------------- /1408-string-matching-in-an-array.rs: -------------------------------------------------------------------------------- 1 | pub fn string_matching(words: Vec) -> Vec { 2 | let mut ret: Vec = vec!(); 3 | for word in &words { 4 | for w in &words { 5 | if word != w && w.contains(word) { 6 | ret.push(word.to_string()); 7 | break; 8 | } 9 | } 10 | } 11 | ret 12 | } 13 | 14 | fn main() { 15 | let words: Vec = vec!["leetcoder","leetcode","od","hamlet","am"] 16 | .iter().map(|e|e.to_string()).collect(); 17 | println!("{:?}", string_matching(words)); 18 | } 19 | -------------------------------------------------------------------------------- /1413-minimum-value-to-get-positive-step-by-step-sum.rs: -------------------------------------------------------------------------------- 1 | pub fn min_start_value(nums: Vec) -> i32 { 2 | let mut start_value = 1; 3 | 'outer: loop { 4 | let mut tmp_sum = start_value; 5 | for num in &nums { 6 | tmp_sum += num; 7 | if tmp_sum < 1 { 8 | start_value += 1; 9 | continue 'outer; 10 | } 11 | } 12 | break; 13 | } 14 | start_value 15 | } 16 | 17 | fn main() { 18 | let nums = vec![1,-2,-3]; 19 | println!("{:?}", min_start_value(nums)); 20 | } 21 | -------------------------------------------------------------------------------- /1414-find-the-minimum-number-of-fibonacci-numbers-whose-sum-is-k.rs: -------------------------------------------------------------------------------- 1 | pub fn find_min_fibonacci_numbers(k: i32) -> i32 { 2 | let mut fib_seq = vec![1]; 3 | let mut tmp = 1; 4 | // 动态规划，列出1000000000以内fib数列 5 | while tmp < 10_i32.pow(9) { 6 | fib_seq.push(tmp); 7 | let len = fib_seq.len(); 8 | tmp = fib_seq[len-1] + fib_seq[len-2]; 9 | } 10 | let mut ret = 0; 11 | let mut k = k; 12 | // 贪心算法 13 | while k != 0 { 14 | for i in fib_seq.iter().rev() { 15 | if k - i >= 0 { 16 | k -= i; 17 | ret += 1; 18 | } 19 | } 20 | } 21 | ret 22 | } 23 | 24 | fn main() { 25 | println!("{:?}", find_min_fibonacci_numbers(7)); 26 | } 27 | -------------------------------------------------------------------------------- /1431-kids-with-the-greatest-number-of-candies.rs: -------------------------------------------------------------------------------- 1 | // 输入：candies = [2,3,5,1,3], extraCandies = 3 2 | // 输出：[true,true,true,false,true] 3 | // 解释： 4 | // 孩子 1 有 2 个糖果，如果他得到所有额外的糖果（3个），那么他总共有 5 个糖果，他将成为拥有最多糖果的孩子。 5 | // 孩子 2 有 3 个糖果，如果他得到至少 2 个额外糖果，那么他将成为拥有最多糖果的孩子。 6 | // 孩子 3 有 5 个糖果，他已经是拥有最多糖果的孩子。 7 | // 孩子 4 有 1 个糖果，即使他得到所有额外的糖果，他也只有 4 个糖果，无法成为拥有糖果最多的孩子。 8 | // 孩子 5 有 3 个糖果，如果他得到至少 2 个额外糖果，那么他将成为拥有最多糖果的孩子。 9 | 10 | // 来源：力扣（LeetCode） 11 | // 链接：https://leetcode-cn.com/problems/kids-with-the-greatest-number-of-candies 12 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 13 | 14 | fn main() { 15 | let candies = vec!(2,3,5,1,3); 16 | let extra_candies = 3; 17 | let res = kids_with_candies(candies, extra_candies); 18 | println!("{:?}", res); 19 | } 20 | 21 | pub fn kids_with_candies(candies: Vec, extra_candies: i32) -> Vec { 22 | let max = *candies.iter().max().unwrap(); 23 | candies.into_iter().map(|e|e+extra_candies>=max).collect() 24 | } -------------------------------------------------------------------------------- /1436-destination-city.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let paths = vec!( 3 | vec!("London".to_string(), "New York".to_string()), 4 | vec!("New York".to_string(), "Lima".to_string()), 5 | vec!("Lima".to_string(), "Sao Paulo".to_string()) 6 | ); 7 | println!("{:?}", dest_city(paths)); 8 | } 9 | 10 | pub fn dest_city(paths: Vec>) -> String { 11 | let mut res = vec!(); 12 | for path in paths { 13 | for (i, des) in path.into_iter().enumerate() { 14 | if res.contains(&des) { 15 | res.retain(|value| *value != des); 16 | } else { 17 | if i == 0 { 18 | res.insert(0, des); 19 | } else { 20 | res.push(des); 21 | } 22 | } 23 | } 24 | } 25 | res[1].to_string() 26 | } 27 | -------------------------------------------------------------------------------- /1441-build-an-array-with-stack-operations.rs: -------------------------------------------------------------------------------- 1 | 2 | pub fn build_array(target: Vec, n: i32) -> Vec { 3 | let mut ret = vec!(); 4 | let mut last = 0; 5 | for i in target { 6 | if i-last == 1 { 7 | ret.push("Push".to_string()); 8 | } else { 9 | for _ in 0..(i-last) { 10 | ret.push("Push".to_string()); 11 | ret.push("Pop".to_string()); 12 | } 13 | ret.remove(ret.len()-1); 14 | } 15 | last = i; 16 | } 17 | ret 18 | } 19 | 20 | fn main() { 21 | let target = vec![1,2]; 22 | let n = 4; 23 | println!("{:?}", build_array(target, n)); 24 | } 25 | -------------------------------------------------------------------------------- /1446-consecutive-characters.rs: -------------------------------------------------------------------------------- 1 | pub fn max_power(s: String) -> i32 { 2 | let mut current_char = '!'; 3 | let mut current_len = 1; 4 | let mut ret = 0; 5 | for c in s.chars() { 6 | if c == current_char { 7 | current_len += 1; 8 | } else { 9 | current_len = 1; 10 | current_char = c; 11 | } 12 | if current_len > ret { 13 | ret = current_len; 14 | } 15 | } 16 | ret 17 | } 18 | 19 | fn main() { 20 | let s = "leetcode".to_string(); 21 | println!("{:?}", max_power(s)); 22 | } -------------------------------------------------------------------------------- /1450-number-of-students-doing-homework-at-a-given-time.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：startTime = [1,2,3], endTime = [3,2,7], queryTime = 4 4 | // 输出：1 5 | // 解释：一共有 3 名学生。 6 | // 第一名学生在时间 1 开始写作业，并于时间 3 完成作业，在时间 4 没有处于做作业的状态。 7 | // 第二名学生在时间 2 开始写作业，并于时间 2 完成作业，在时间 4 没有处于做作业的状态。 8 | // 第三名学生在时间 3 开始写作业，预计于时间 7 完成作业，这是是唯一一名在时间 4 时正在做作业的学生。 9 | 10 | // 来源：力扣（LeetCode） 11 | // 链接：https://leetcode-cn.com/problems/number-of-students-doing-homework-at-a-given-time 12 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 13 | 14 | fn main() { 15 | let start_time = vec!(1,2,3); 16 | let end_time = vec!(3,2,7); 17 | let query_time = 4; 18 | println!("{:?}", busy_student(start_time, end_time, query_time)); 19 | } 20 | 21 | pub fn busy_student(start_time: Vec, end_time: Vec, query_time: i32) -> i32 { 22 | let length = start_time.len(); 23 | let mut counter = 0; 24 | for i in 0..length { 25 | if start_time[i] <= query_time && query_time <= end_time[i] { 26 | counter += 1; 27 | } 28 | } 29 | counter 30 | } 31 | -------------------------------------------------------------------------------- /1455-check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence.rs: -------------------------------------------------------------------------------- 1 | pub fn is_prefix_of_word(sentence: String, search_word: String) -> i32 { 2 | for (i, w) in sentence.split(" ").enumerate() { 3 | if w.starts_with(&search_word) { 4 | return (i+1) as i32; 5 | } 6 | } 7 | -1 8 | } 9 | 10 | fn main() { 11 | let sentence = "this problem is an easy problem".to_string(); 12 | let search_word = "pro".to_string(); 13 | println!("{:?}", is_prefix_of_word(sentence, search_word)); 14 | } 15 | -------------------------------------------------------------------------------- /1460-make-two-arrays-equal-by-reversing-sub-arrays.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：target = [1,2,3,4], arr = [2,4,1,3] 4 | // 输出：true 5 | // 解释：你可以按照如下步骤使 arr 变成 target： 6 | // 1- 翻转子数组 [2,4,1] ，arr 变成 [1,4,2,3] 7 | // 2- 翻转子数组 [4,2] ，arr 变成 [1,2,4,3] 8 | // 3- 翻转子数组 [4,3] ，arr 变成 [1,2,3,4] 9 | // 上述方法并不是唯一的，还存在多种将 arr 变成 target 的方法。 10 | 11 | // 来源：力扣（LeetCode） 12 | // 链接：https://leetcode-cn.com/problems/make-two-arrays-equal-by-reversing-sub-arrays 13 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 14 | 15 | pub fn can_be_equal(target: Vec, arr: Vec) -> bool { 16 | let mut sorted_target = target.clone(); 17 | let mut sorted_arr = arr.clone(); 18 | sorted_target.sort(); 19 | sorted_arr.sort(); 20 | // println!("{:?} {:?}", sorted_target, sorted_arr); 21 | sorted_target == sorted_arr 22 | } 23 | 24 | fn main() { 25 | println!("{:?}", can_be_equal(vec!(3,7,9), vec!(3,7,11))); 26 | } 27 | -------------------------------------------------------------------------------- /1464-maximum-product-of-two-elements-in-an-array.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：nums = [3,4,5,2] 4 | // 输出：12 5 | // 解释：如果选择下标 i=1 和 j=2（下标从 0 开始），则可以获得最大值，(nums[1]-1)*(nums[2]-1) = (4-1)*(5-1) = 3*4 = 12 。 6 | 7 | // 来源：力扣（LeetCode） 8 | // 链接：https://leetcode-cn.com/problems/maximum-product-of-two-elements-in-an-array 9 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 10 | 11 | pub fn max_product(nums: Vec) -> i32 { 12 | let length = nums.len(); 13 | let mut sorted = nums.clone(); 14 | sorted.sort(); 15 | (sorted[length-1]-1) * (sorted[length-2]-1) 16 | } 17 | -------------------------------------------------------------------------------- /1470-shuffle-the-array.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：nums = [2,5,1,3,4,7], n = 3 4 | // 输出：[2,3,5,4,1,7] 5 | // 解释：由于 x1=2, x2=5, x3=1, y1=3, y2=4, y3=7 ，所以答案为 [2,3,5,4,1,7] 6 | 7 | // 来源：力扣（LeetCode） 8 | // 链接：https://leetcode-cn.com/problems/shuffle-the-array 9 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 10 | 11 | fn main() { 12 | let nums = vec!(2,5,1,3,4,7); 13 | let res = shuffle(nums, 3); 14 | println!("{:?}", res); 15 | } 16 | 17 | pub fn shuffle(nums: Vec, n: i32) -> Vec { 18 | let mut res = vec!(); 19 | for i in 0..n { 20 | res.push(nums[i as usize]); 21 | res.push(nums[((i as i32)+n) as usize]); 22 | } 23 | res 24 | } 25 | -------------------------------------------------------------------------------- /1475-final-prices-with-a-special-discount-in-a-shop.rs: -------------------------------------------------------------------------------- 1 | pub fn final_prices(prices: Vec) -> Vec { 2 | let mut ret = vec![]; 3 | 'outer: for (i, n) in prices[0..prices.len()].iter().enumerate() { 4 | for j in (i+1)..prices.len() { 5 | if prices[j] <= *n { 6 | ret.push(n - prices[j]); 7 | continue 'outer; 8 | } 9 | } 10 | ret.push(*n); 11 | } 12 | ret 13 | } 14 | 15 | fn main() { 16 | println!("{:?}", final_prices(vec![8,4,6,2,3])); 17 | println!("{:?}", final_prices(vec![1,2,3,4,5])); 18 | println!("{:?}", final_prices(vec![10,1,1,6])); 19 | } 20 | -------------------------------------------------------------------------------- /1486-xor-operation-in-an-array.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：n = 5, start = 0 4 | // 输出：8 5 | // 解释：数组 nums 为 [0, 2, 4, 6, 8]，其中 (0 ^ 2 ^ 4 ^ 6 ^ 8) = 8 。 6 | // "^" 为按位异或 XOR 运算符。 7 | 8 | // 来源：力扣（LeetCode） 9 | // 链接：https://leetcode-cn.com/problems/xor-operation-in-an-array 10 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 11 | 12 | fn main() { 13 | let n = 5; 14 | let start = 0; 15 | println!("{:?}", xor_operation(n, start)); 16 | } 17 | 18 | pub fn xor_operation(n: i32, start: i32) -> i32 { 19 | let mut res = start; 20 | for i in 1..n { 21 | res ^= start + 2 * i; 22 | } 23 | res 24 | } 25 | -------------------------------------------------------------------------------- /1491-average-salary-excluding-the-minimum-and-maximum-salary.rs: -------------------------------------------------------------------------------- 1 | pub fn average(salary: Vec) -> f64 { 2 | let mut sorted_salary = salary.clone(); 3 | sorted_salary.sort(); 4 | let length = salary.len() - 1; 5 | sorted_salary[1..length].iter().sum::() as f64 / (length - 1) as f64 6 | } 7 | 8 | fn main() { 9 | let salary = vec![8000,9000,2000,3000,6000,1000]; 10 | println!("{:?}", average(salary)); 11 | } 12 | -------------------------------------------------------------------------------- /1502-can-make-arithmetic-progression-from-sequence.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：arr = [3,5,1] 4 | // 输出：true 5 | // 解释：对数组重新排序得到 [1,3,5] 或者 [5,3,1] ，任意相邻两项的差分别为 2 或 -2 ，可以形成等差数列。 6 | 7 | // 来源：力扣（LeetCode） 8 | // 链接：https://leetcode-cn.com/problems/can-make-arithmetic-progression-from-sequence 9 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 10 | 11 | pub fn can_make_arithmetic_progression(arr: Vec) -> bool { 12 | let mut sorted_arr = arr.clone(); 13 | sorted_arr.sort(); 14 | for (i, num) in sorted_arr.iter().enumerate() { 15 | if sorted_arr.get(i+1) != None { 16 | if num - sorted_arr[i+1] != sorted_arr[0] - sorted_arr[1] { 17 | return false; 18 | } 19 | } 20 | } 21 | true 22 | } 23 | 24 | fn main() { 25 | println!("{:?}", can_make_arithmetic_progression(vec![3,5,1])); 26 | } 27 | -------------------------------------------------------------------------------- /1512-number-of-good-pairs.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let nums = vec!(1,2,3); 3 | let res = num_identical_pairs(nums); 4 | println!("{:?}", res); 5 | } 6 | 7 | 8 | // 输入：nums = [1,2,3,1,1,3] 9 | // 输出：4 10 | // 解释：有 4 组好数对，分别是 (0,3), (0,4), (3,4), (2,5) ，下标从 0 开始 11 | 12 | // 来源：力扣（LeetCode） 13 | // 链接：https://leetcode-cn.com/problems/number-of-good-pairs 14 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 15 | // [1,1,1,1] 6 16 | // [1,2,3] 0 17 | 18 | 19 | pub fn num_identical_pairs(nums: Vec) -> i32 { 20 | let mut sum = 0; 21 | let length = &nums.len(); // 这里为什么用& 因为nums(ptr/len/capacity)是immut的 所以只能借用 length是nums.len的借用 22 | for (i, n) in nums.iter().enumerate() { 23 | for num in &nums[i+1..*length] { // 这里为什么用&和* 同理，需要借用nums的slice 并取得length引用的值 24 | if num == n { 25 | sum += 1; 26 | } 27 | } 28 | } 29 | sum 30 | } -------------------------------------------------------------------------------- /1518-water-bottles.rs: -------------------------------------------------------------------------------- 1 | pub fn num_water_bottles(num_bottles: i32, num_exchange: i32) -> i32 { 2 | let mut current_nil_bottles = 0; 3 | let mut num_bottles = num_bottles; 4 | let mut ret = 0; 5 | loop { 6 | ret += num_bottles; 7 | current_nil_bottles += num_bottles; 8 | num_bottles = 0; 9 | let tmp = current_nil_bottles / num_exchange; 10 | if tmp > 0 { 11 | num_bottles += tmp; 12 | current_nil_bottles -= tmp * num_exchange; 13 | } 14 | if num_bottles == 0 && tmp == 0 { break } 15 | } 16 | ret 17 | } 18 | 19 | fn main() { 20 | println!("{:?}", num_water_bottles(15, 4)); 21 | } 22 | -------------------------------------------------------------------------------- /1523-count-odd-numbers-in-an-interval-range.rs: -------------------------------------------------------------------------------- 1 | impl Solution { 2 | pub fn count_odds(low: i32, high: i32) -> i32 { 3 | let mut ret = 0; 4 | 5 | if low % 2 == 1 { ret += 1 } 6 | if high % 2 == 1 { ret += 1 } 7 | 8 | if ret == 2 { 9 | ret += (high - low)/2 - 1 10 | } else { 11 | ret += (high - low)/2 12 | } 13 | ret 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /1528-shuffle-string.rs: -------------------------------------------------------------------------------- 1 | // 输入：s = "codeleet", indices = [4,5,6,7,0,2,1,3] 2 | // 输出："leetcode" 3 | // 解释：如图所示，"codeleet" 重新排列后变为 "leetcode" 。 4 | 5 | // 来源：力扣（LeetCode） 6 | // 链接：https://leetcode-cn.com/problems/shuffle-string 7 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 8 | 9 | pub fn restore_string(s: String, indices: Vec) -> String { 10 | let mut res: Vec = vec!['c'; s.len()]; 11 | for (i, c) in s.chars().enumerate() { 12 | res[indices[i as usize] as usize] = c; 13 | } 14 | res.into_iter().collect() 15 | } 16 | 17 | fn main() { 18 | let s = "codeleet".to_string(); 19 | let indices = vec!(4,5,6,7,0,2,1,3); 20 | println!("{:?}", restore_string(s, indices)); 21 | } 22 | -------------------------------------------------------------------------------- /1529-minimum-suffix-flips.rs: -------------------------------------------------------------------------------- 1 | // 数学归纳法：每次遇到不同数位，结果+1 2 | // 如果target从0开始，结果初始为0，从1，结果初始为1 3 | 4 | pub fn min_flips(target: String) -> i32 { 5 | let mut prev = target.chars().nth(0).unwrap(); 6 | let mut ret = prev as i32 - '0' as i32; 7 | for c in target.chars().collect::>() { 8 | if c != prev { ret += 1 } 9 | prev = c; 10 | } 11 | ret 12 | } 13 | 14 | fn main() { 15 | let target = "10111".to_string(); 16 | println!("{:?}", min_flips(target)); 17 | } 18 | -------------------------------------------------------------------------------- /1534-count-good-triplets.rs: -------------------------------------------------------------------------------- 1 | pub fn count_good_triplets(arr: Vec, a: i32, b: i32, c: i32) -> i32 { 2 | let mut ret = 0; 3 | for i in 0..arr.len() { 4 | for j in (i+1)..arr.len() { 5 | for k in (j+1)..arr.len() { 6 | if (arr[i] - arr[j]).abs() <= a && 7 | (arr[j] - arr[k]).abs() <= b && 8 | (arr[i] - arr[k]).abs() <= c { 9 | ret += 1; 10 | } 11 | } 12 | } 13 | } 14 | ret 15 | } 16 | 17 | fn main() { 18 | let arr = vec![3,0,1,1,9,7]; 19 | let (a, b, c) = (7, 3, 2); 20 | println!("{:?}", count_good_triplets(arr, a, b, c)); 21 | } 22 | -------------------------------------------------------------------------------- /1534-count-operations-to-obtain-zero.rs: -------------------------------------------------------------------------------- 1 | pub fn count_operations(num1: i32, num2: i32) -> i32 { 2 | if num1 == 0 || num2 == 0 { 3 | return 0; 4 | } 5 | let (mut n1, mut n2, mut res) = (num1, num2, 0); 6 | loop { 7 | if n1 == n2 { 8 | break; 9 | } 10 | if n1 >= n2 { 11 | n1 -= n2; 12 | } else { 13 | n2 -= n1; 14 | } 15 | res += 1; 16 | } 17 | res += 1; 18 | res 19 | } 20 | 21 | fn main() { 22 | println!("{:?}", count_operations(0, 1)); 23 | } 24 | -------------------------------------------------------------------------------- /155-min-stack.rs: -------------------------------------------------------------------------------- 1 | struct MinStack { 2 | stk: Vec 3 | } 4 | 5 | impl MinStack { 6 | 7 | fn new() -> Self { 8 | MinStack { 9 | stk: vec!() 10 | } 11 | } 12 | 13 | fn push(&mut self, val: i32) { 14 | self.stk.push(val); 15 | } 16 | 17 | fn pop(&mut self) { 18 | self.stk.pop(); 19 | } 20 | 21 | fn top(&self) -> i32 { 22 | *self.stk.iter().last().unwrap() 23 | } 24 | 25 | fn get_min(&self) -> i32 { 26 | *self.stk.iter().min().unwrap() 27 | } 28 | } 29 | 30 | fn main() { 31 | let mut obj = MinStack::new(); 32 | obj.push(-2); 33 | obj.push(0); 34 | obj.push(-3); 35 | println!("{:?}", obj.get_min()); 36 | println!("{:?}", obj.top()); 37 | obj.pop(); 38 | println!("{:?}", obj.get_min()); 39 | println!("{:?}", obj.top()); 40 | } 41 | -------------------------------------------------------------------------------- /1550-three-consecutive-odds.rs: -------------------------------------------------------------------------------- 1 | pub fn three_consecutive_odds(arr: Vec) -> bool { 2 | pub fn is_odd(num: i32) -> bool { 3 | num % 2 != 0 4 | } 5 | let mut count = 0; 6 | for i in 0..arr.len() { 7 | if is_odd(arr[i]) { 8 | count += 1; 9 | } else { 10 | count = 0; 11 | } 12 | if count == 3 { 13 | return true; 14 | } 15 | } 16 | false 17 | } 18 | 19 | fn main() { 20 | let arr = vec![1,1,1]; 21 | println!("{:?}", three_consecutive_odds(arr)); 22 | } 23 | -------------------------------------------------------------------------------- /1551-minimum-operations-to-make-array-equal.rs: -------------------------------------------------------------------------------- 1 | // 微积分数形结合，斜率为2的三角形移动成长方形，求移动的面积。 2 | pub fn min_operations(n: i32) -> i32 { 3 | n * n / 4 4 | } 5 | -------------------------------------------------------------------------------- /1556-thousand-separator.rs: -------------------------------------------------------------------------------- 1 | pub fn thousand_separator(n: i32) -> String { 2 | let s = n.to_string(); 3 | let mut v: Vec<_> = vec!(); 4 | for i in 0..s.len()/3 { 5 | v.insert(0, &s[s.len()-i*3-3..s.len()-i*3]); 6 | } 7 | let mo = s.len()%3; 8 | if mo != 0 { 9 | v.insert(0, &s[..mo]); 10 | } 11 | v.join(".") 12 | } 13 | 14 | fn main() { 15 | let n = 1234; 16 | println!("{:?}", thousand_separator(n)); 17 | } 18 | -------------------------------------------------------------------------------- /1582-special-positions-in-a-binary-matrix.rs: -------------------------------------------------------------------------------- 1 | pub fn num_special(mat: Vec>) -> i32 { 2 | let mut ret = 0; 3 | let mut ps = vec![]; 4 | for i in 0..mat.len() { 5 | for j in 0..mat[0].len() { 6 | ps.push((i, j)); 7 | } 8 | } 9 | for p in ps { 10 | if mat[p.0][p.1] == 1 { 11 | let mut col_count = 0; 12 | let mut row_count = 0; 13 | for e in &mat[p.0] { 14 | if *e == 1 { row_count += 1 } 15 | } 16 | for i in 0..mat.len() { 17 | if mat[i][p.1] == 1 { col_count += 1 } 18 | } 19 | if col_count == 1 && row_count == 1 { ret += 1 } 20 | } 21 | } 22 | ret 23 | } 24 | 25 | fn main() { 26 | let mat = vec![ 27 | vec![0,0], 28 | vec![0,0], 29 | vec![1,0] 30 | ]; 31 | println!("{:?}", num_special(mat)); 32 | } 33 | -------------------------------------------------------------------------------- /1588-sum-of-all-odd-length-subarrays.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：arr = [1,4,2,5,3] 4 | // 输出：58 5 | // 解释：所有奇数长度子数组和它们的和为： 6 | // [1] = 1 7 | // [4] = 4 8 | // [2] = 2 9 | // [5] = 5 10 | // [3] = 3 11 | // [1,4,2] = 7 12 | // [4,2,5] = 11 13 | // [2,5,3] = 10 14 | // [1,4,2,5,3] = 15 15 | // 我们将所有值求和得到 1 + 4 + 2 + 5 + 3 + 7 + 11 + 10 + 15 = 58 16 | 17 | // 来源：力扣（LeetCode） 18 | // 链接：https://leetcode-cn.com/problems/sum-of-all-odd-length-subarrays 19 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 20 | 21 | 22 | // 移动窗口，窗口为 1 窗口为3 窗口为5 23 | fn main() { 24 | let arr = vec!(1,4,2,5,3); 25 | println!("{:?}", sum_odd_length_subarrays(arr)); 26 | } 27 | 28 | pub fn sum_odd_length_subarrays(arr: Vec) -> i32 { 29 | let n = &arr.len(); 30 | let mut sum = 0; 31 | for i in 0..(n/2+1) { 32 | let window_length = 2*i+1; 33 | for i in 0..*n { 34 | if i+window_length <= *n { 35 | for j in &arr[i..i+window_length] { 36 | sum += j; 37 | } 38 | } 39 | } 40 | } 41 | sum 42 | } 43 | -------------------------------------------------------------------------------- /1598-crawler-log-folder.rs: -------------------------------------------------------------------------------- 1 | pub fn min_operations(logs: Vec) -> i32 { 2 | let mut ret = 0; 3 | for log in logs { 4 | if log.contains("..") { 5 | if ret > 0 { ret -= 1 } 6 | } else if log.contains(".") { 7 | continue 8 | } else { 9 | ret += 1 10 | } 11 | } 12 | ret 13 | } 14 | 15 | fn main() { 16 | let logs: Vec = ["d1/","d2/","../","d21/","./"].iter().map(|e|e.to_string()).collect(); 17 | println!("{:?}", min_operations(logs)); 18 | } 19 | -------------------------------------------------------------------------------- /1603-design-parking-system.rs: -------------------------------------------------------------------------------- 1 | struct ParkingSystem { 2 | current: Vec, 3 | max: Vec 4 | } 5 | 6 | impl ParkingSystem { 7 | fn new(big: i32, medium: i32, small: i32) -> Self { 8 | ParkingSystem { 9 | max: vec!(big, medium, small), 10 | current: vec![0; 3] 11 | } 12 | } 13 | 14 | fn add_car(&mut self, car_type: i32) -> bool { 15 | let car_type = car_type as usize - 1; 16 | if self.current.get(car_type).unwrap() + 1 > *self.max.get(car_type).unwrap() { 17 | false 18 | } else { 19 | *self.current.get_mut(car_type).unwrap() += 1; 20 | true 21 | } 22 | } 23 | } 24 | 25 | fn main() { 26 | let mut obj = ParkingSystem::new(1, 1, 0); 27 | println!("{:?}", obj.add_car(1)); 28 | println!("{:?}", obj.add_car(2)); 29 | println!("{:?}", obj.add_car(3)); 30 | println!("{:?}", obj.add_car(1)); 31 | } 32 | -------------------------------------------------------------------------------- /1608-special-array-with-x-elements-greater-than-or-equal-x.rs: -------------------------------------------------------------------------------- 1 | pub fn special_array(nums: Vec) -> i32 { 2 | for x in 0..=nums.len() { 3 | let x = x as i32; 4 | let mut count = 0; 5 | for num in &nums { 6 | if *num >= x { 7 | count += 1; 8 | } 9 | } 10 | if count == x { 11 | return x; 12 | } 13 | } 14 | -1 15 | } 16 | 17 | fn main() { 18 | let nums = vec![3,5]; 19 | println!("{:?}", special_array(nums)); 20 | } 21 | -------------------------------------------------------------------------------- /1614-maximum-nesting-depth-of-the-parentheses.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：s = "(1+(2*3)+((8)/4))+1" 4 | // 输出：3 5 | // 解释：数字 8 在嵌套的 3 层括号中。 6 | 7 | // 来源：力扣（LeetCode） 8 | // 链接：https://leetcode-cn.com/problems/maximum-nesting-depth-of-the-parentheses 9 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 10 | 11 | fn main() { 12 | println!("{:?}", max_depth("(1+(2*3)+((8)/4))+1".to_string())); 13 | } 14 | 15 | pub fn max_depth(s: String) -> i32 { 16 | let s_chars = s.chars(); 17 | let mut max_depth = 0; 18 | let mut current_depth = 0; 19 | for c in s_chars { 20 | if c == '(' { 21 | current_depth += 1; 22 | } 23 | if c == ')' { 24 | current_depth -= 1; 25 | } 26 | if current_depth > max_depth { 27 | max_depth = current_depth; 28 | } 29 | } 30 | max_depth 31 | } 32 | -------------------------------------------------------------------------------- /1619-mean-of-array-after-removing-some-elements.rs: -------------------------------------------------------------------------------- 1 | pub fn trim_mean(arr: Vec) -> f64 { 2 | let length = arr.len(); 3 | let offset = (length as f64 * 0.05) as usize; 4 | let mut sorted_arr = arr.clone(); 5 | sorted_arr.sort(); 6 | let res = sorted_arr[offset..(length-offset)].iter().sum::() as f64 / (length-offset*2) as f64; 7 | format!("{:.5}", res).parse().unwrap() 8 | } 9 | 10 | fn main() { 11 | let arr = vec![6,0,7,0,7,5,7,8,3,4,0,7,8,1,6,8,1,1,2,4,8,1,9,5,4,3,8,5,10,8,6,6,1,0,6,10,8,2,3,4]; 12 | println!("{:?}", trim_mean(arr)); 13 | } 14 | -------------------------------------------------------------------------------- /1624-largest-substring-between-two-equal-characters.rs: -------------------------------------------------------------------------------- 1 | pub fn max_length_between_equal_characters(s: String) -> i32 { 2 | use std::collections::HashMap; 3 | let mut mmp = HashMap::new(); 4 | let cs: Vec = s.chars().collect(); 5 | for (i, c) in cs.iter().enumerate() { 6 | mmp.entry(c).or_insert(Vec::new()).push(i); 7 | } 8 | mmp.retain(|_, v|v.len()>1); 9 | if mmp.len() > 0 { 10 | let vecs: Vec<_> = mmp.into_values().collect(); 11 | let v: Vec<_> = vecs.iter().map(|e|e.last().unwrap() - e.first().unwrap()).collect(); 12 | *v.iter().max().unwrap() as i32 - 1 13 | } else { 14 | return -1 15 | } 16 | } 17 | 18 | fn main() { 19 | let s = "abcd".to_string(); 20 | println!("{:?}", max_length_between_equal_characters(s)); 21 | } -------------------------------------------------------------------------------- /1636-sort-array-by-increasing-frequency.rs: -------------------------------------------------------------------------------- 1 | pub fn frequency_sort(nums: Vec) -> Vec { 2 | use std::collections::HashMap; 3 | let mut mmp: HashMap> = HashMap::new(); 4 | for i in nums { 5 | mmp.entry(i).or_insert(Vec::new()).push(i); 6 | } 7 | let mut mmp_vec: Vec<_> = mmp.iter().collect(); 8 | mmp_vec.sort_by(|a, b| b.0.cmp(&a.0)); 9 | mmp_vec.sort_by(|a, b| a.1.len().cmp(&b.1.len())); 10 | let mut ret: Vec = vec!(); 11 | for e in mmp_vec { 12 | ret.extend(e.1); 13 | } 14 | ret 15 | } 16 | 17 | fn main() { 18 | let nums = vec![-1,1,-6,4,5,-6,1,4,1]; 19 | println!("{:?}", frequency_sort(nums)); 20 | } 21 | -------------------------------------------------------------------------------- /1640-check-array-formation-through-concatenation.rs: -------------------------------------------------------------------------------- 1 | // 提示：使用Hashmap 2 | 3 | pub fn can_form_array(arr: Vec, pieces: Vec>) -> bool { 4 | use std::collections::HashMap; 5 | let mut mmp: HashMap<_, _> = HashMap::new(); 6 | let mut ret = vec!(); 7 | for piece in pieces { 8 | mmp.entry(piece[0]).or_insert(Vec::new()).push(piece); 9 | } 10 | for e in &arr { 11 | match &mmp.get(&e) { 12 | Some(expr) => { 13 | for el in &expr[0] { 14 | ret.push(*el); 15 | } 16 | }, 17 | None => { 18 | continue; 19 | }, 20 | } 21 | } 22 | arr == ret 23 | } 24 | 25 | fn main() { 26 | let arr = vec![91, 4, 64, 78]; 27 | let pieces = vec![vec![78],vec![4, 64],vec![91]]; 28 | println!("{:?}", can_form_array(arr, pieces)); 29 | } 30 | -------------------------------------------------------------------------------- /1641-count-sorted-vowel-strings.rs: -------------------------------------------------------------------------------- 1 | // 数学，推倒完，公式是 C(n+4, 4) 2 | pub fn count_vowel_strings(n: i32) -> i32 { 3 | (n+4)*(n+3)*(n+2)*(n+1)/24 4 | } 5 | 6 | fn main() { 7 | println!("{:?}", count_vowel_strings(2)); 8 | } 9 | -------------------------------------------------------------------------------- /1662-check-if-two-string-arrays-are-equivalent.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let word1 = vec!("ab".to_string(), "c".to_string()); 3 | let word2 = vec!("a".to_string(), "bc".to_string()); 4 | println!("{:?}", array_strings_are_equal(word1, word2)); 5 | } 6 | 7 | pub fn array_strings_are_equal(word1: Vec, word2: Vec) -> bool { 8 | word1.join("") == word2.join("") 9 | } 10 | -------------------------------------------------------------------------------- /1672-richest-customer-wealth.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let accounts = vec!(vec!(1, 2, 3), vec!(3, 2, 1)); 3 | let a = maximum_wealth(accounts); 4 | println!("{:?}", a); 5 | } 6 | 7 | // 输入：accounts = [[1,2,3],[3,2,1]] 8 | // 输出：6 9 | // 解释： 10 | // 第 1 位客户的资产总量 = 1 + 2 + 3 = 6 11 | // 第 2 位客户的资产总量 = 3 + 2 + 1 = 6 12 | // 两位客户都是最富有的，资产总量都是 6 ，所以返回 6 。 13 | 14 | // 来源：力扣（LeetCode） 15 | // 链接：https://leetcode-cn.com/problems/richest-customer-wealth 16 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 17 | pub fn maximum_wealth(accounts: Vec>) -> i32 { 18 | let mut res = 0; 19 | for account in accounts { 20 | let mut current = 0; 21 | for e in account { 22 | current += e; 23 | } 24 | if current >= res { 25 | res = current 26 | } 27 | } 28 | res 29 | } -------------------------------------------------------------------------------- /1678-goal-parser-interpretation.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：command = "G()(al)" 4 | // 输出："Goal" 5 | // 解释：Goal 解析器解释命令的步骤如下所示： 6 | // G -> G 7 | // () -> o 8 | // (al) -> al 9 | // 最后连接得到的结果是 "Goal" 10 | 11 | // 来源：力扣（LeetCode） 12 | // 链接：https://leetcode-cn.com/problems/goal-parser-interpretation 13 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 14 | 15 | fn main() { 16 | let s = "(al)G(al)()()G".to_string(); 17 | let res = interpret(s); 18 | println!("{:?}", res); 19 | } 20 | 21 | // 100% 100% haha 22 | pub fn interpret(command: String) -> String { 23 | command.replace("(al)", "al").replace("()", "o") 24 | } -------------------------------------------------------------------------------- /1688-count-of-matches-in-tournament.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：n = 7 4 | // 输出：6 5 | // 解释：比赛详情： 6 | // - 第 1 轮：队伍数 = 7 ，配对次数 = 3 ，4 支队伍晋级。 7 | // - 第 2 轮：队伍数 = 4 ，配对次数 = 2 ，2 支队伍晋级。 8 | // - 第 3 轮：队伍数 = 2 ，配对次数 = 1 ，决出 1 支获胜队伍。 9 | // 总配对次数 = 3 + 2 + 1 = 6 10 | 11 | // 来源：力扣（LeetCode） 12 | // 链接：https://leetcode-cn.com/problems/count-of-matches-in-tournament 13 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 14 | 15 | fn main() { 16 | println!("{:?}", number_of_matches(7)); 17 | } 18 | 19 | // 数学归纳法 n-1 20 | pub fn number_of_matches(n: i32) -> i32 { 21 | n - 1 22 | } 23 | -------------------------------------------------------------------------------- /1689-partitioning-into-minimum-number-of-deci-binary-numbers.rs: -------------------------------------------------------------------------------- 1 | pub fn min_partitions(n: String) -> i32 { 2 | n.chars().map(|e|e.to_digit(10)).max().unwrap().unwrap() as i32 3 | } 4 | 5 | fn main() { 6 | let n = "27346209830709182346".to_string(); 7 | println!("{:?}", min_partitions(n)); 8 | } 9 | -------------------------------------------------------------------------------- /1694-reformat-phone-number.rs: -------------------------------------------------------------------------------- 1 | pub fn reformat_number(number: String) -> String { 2 | let tmp = number.replace("-", "").replace(" ", ""); 3 | let mut tmp_arr: Vec<_> = vec!(); 4 | for i in (0..tmp.len()).step_by(3) { 5 | let mut tail = i+3; 6 | if tail > tmp.len() { 7 | tail = tmp.len(); 8 | } 9 | tmp_arr.push(&tmp[i..tail]); 10 | } 11 | let mut tmp_s = String::new(); 12 | if tmp_arr.len() >= 2 && tmp_arr[tmp_arr.len()-1].len() == 1 { 13 | tmp_s.push_str(tmp_arr[tmp_arr.len()-2]); 14 | tmp_s.push_str(tmp_arr[tmp_arr.len()-1]); 15 | tmp_arr.pop(); 16 | tmp_arr.pop(); 17 | tmp_arr.push(&tmp_s[0..2]); 18 | tmp_arr.push(&tmp_s[2..4]); 19 | } 20 | tmp_arr.join("-") 21 | } 22 | 23 | fn main() { 24 | let number = "9964-".to_string(); 25 | println!("{:?}", reformat_number(number)); 26 | } 27 | -------------------------------------------------------------------------------- /1701-average-waiting-time.rs: -------------------------------------------------------------------------------- 1 | pub fn average_waiting_time(customers: Vec>) -> f64 { 2 | let mut time = 0f64; 3 | let mut sum = 0f64; 4 | for customer in &customers { 5 | if customer[0] as f64 >= time { 6 | sum += customer[1] as f64; 7 | time = (customer[0] + customer[1]) as f64; 8 | } else { 9 | sum += time + (customer[1] - customer[0]) as f64; 10 | time += customer[1] as f64; 11 | } 12 | } 13 | sum as f64 / customers.len() as f64 14 | } 15 | 16 | fn main() { 17 | println!("{:?}", average_waiting_time(vec![vec![1,2], vec![2,5], vec![4,3]])); 18 | println!("{:?}", average_waiting_time(vec![vec![5,2], vec![5,4], vec![10,3], vec![20,1]])); 19 | } 20 | -------------------------------------------------------------------------------- /1704-determine-if-string-halves-are-alike.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：s = "book" 4 | // 输出：true 5 | // 解释：a = "bo" 且 b = "ok" 。a 中有 1 个元音, b 也有 1 个元音。所以, a 和 b 相似。 6 | 7 | // 来源：力扣（LeetCode） 8 | // 链接：https://leetcode-cn.com/problems/determine-if-string-halves-are-alike 9 | // 著作权归领扣网络所有。商业转载请联系官方授权, 非商业转载请注明出处。 10 | 11 | pub fn halves_are_alike(s: String) -> bool { 12 | fn count_meta(chars: Vec) -> i32 { 13 | let metas = vec!('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'); 14 | chars.iter().map(|c| 15 | if metas.contains(c) { 16 | 1 17 | } else { 18 | 0 19 | } 20 | ).sum() 21 | } 22 | let mutschars: Vec = s.chars().collect(); 23 | let length = mutschars.len(); 24 | count_meta(mutschars[0..length/2].to_vec()) == count_meta(mutschars[length/2..].to_vec()) 25 | } 26 | 27 | fn main() { 28 | println!("{:?}", halves_are_alike("textbook".to_string())); 29 | } 30 | -------------------------------------------------------------------------------- /1710-maximum-units-on-a-truck.rs: -------------------------------------------------------------------------------- 1 | // box_types.sort{|a, b|b[1]<=>a[1]}.map{|e|[e[1]]*e[0]}.flatten[...truck_size].sum 2 | 3 | pub fn maximum_units(box_types: Vec>, truck_size: i32) -> i32 { 4 | let mut sorted_box_types = box_types.clone(); 5 | sorted_box_types.sort_by(|a, b| b[1].cmp(&a[1])); 6 | let tmp = sorted_box_types.iter().map(|e|vec![e[1]; e[0] as usize]).collect::>>().into_iter().flatten().collect::>(); 7 | let idx = vec![tmp.len(), truck_size as usize].into_iter().min().unwrap(); 8 | tmp[..idx].iter().sum::() 9 | } 10 | 11 | fn main() { 12 | let box_types = [[1,3],[5,5],[2,5],[4,2],[4,1],[3,1],[2,2],[1,3],[2,5],[3,2]].map(|e|e.to_vec()).to_vec(); 13 | let truck_size = 35; 14 | println!("{:?}", maximum_units(box_types, truck_size)); 15 | } -------------------------------------------------------------------------------- /1716-calculate-money-in-leetcode-bank.rs: -------------------------------------------------------------------------------- 1 | // 数学总结归纳法 2 | pub fn total_money(n: i32) -> i32 { 3 | let week = n / 7; 4 | let day = n % 7; 5 | 7*(1+week)*week/2+21*week+(2*(week+1)+day-1)*day/2 6 | } 7 | 8 | fn main() { 9 | let n = 20; 10 | println!("{:?}", total_money(n)); 11 | } 12 | -------------------------------------------------------------------------------- /171_title_to_number.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let str = "FXSHRXW".to_string(); 3 | let a = title_to_number(str); 4 | println!("{:?}", a); 5 | } 6 | 7 | // 171 https://leetcode-cn.com/problems/excel-sheet-column-number/submissions/ 8 | // "FXSHRXW" 2147483647 9 | pub fn title_to_number(column_title: String) -> i32 { 10 | let mut sum = 0; 11 | for (i, c) in column_title.chars().rev().enumerate() { 12 | sum += 26_i32.pow(i as u32) * (c as i32 - 64) 13 | }; 14 | sum 15 | } -------------------------------------------------------------------------------- /1720-decode-xored-array.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：encoded = [1,2,3], first = 1 4 | // 输出：[1,0,2,1] 5 | // 解释：若 arr = [1,0,2,1] ，那么 first = 1 且 encoded = [1 XOR 0, 0 XOR 2, 2 XOR 1] = [1,2,3] 6 | 7 | // 来源：力扣（LeetCode） 8 | // 链接：https://leetcode-cn.com/problems/decode-xored-array 9 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 10 | 11 | fn main() { 12 | println!("{:?}", decode(vec!(1,2,3), 1)); 13 | } 14 | 15 | pub fn decode(encoded: Vec, first: i32) -> Vec { 16 | let mut res = vec!(first); 17 | let mut temp = first; 18 | for num in encoded { 19 | temp = temp ^ num; 20 | res.push(temp); 21 | } 22 | res 23 | } 24 | -------------------------------------------------------------------------------- /1725-number-of-rectangles-that-can-form-the-largest-square.rs: -------------------------------------------------------------------------------- 1 | pub fn count_good_rectangles(rectangles: Vec>) -> i32 { 2 | use std::collections::HashMap; 3 | let mut mmp = HashMap::new(); 4 | for rectangle in rectangles { 5 | let min: i32 = *rectangle.iter().min().unwrap(); 6 | let count = mmp.entry(min).or_insert(0); 7 | *count += 1; 8 | } 9 | let mut count_vec: Vec<_> = mmp.iter().collect(); 10 | count_vec.sort_by(|a, b|a.0.cmp(b.0)); 11 | *count_vec.iter().last().unwrap().1 12 | } 13 | 14 | fn main() { 15 | let rectangles = vec![vec![5,8],vec![3,9],vec![5,12],vec![16,5]]; 16 | println!("{:?}", count_good_rectangles(rectangles)); 17 | } 18 | -------------------------------------------------------------------------------- /1742-maximum-number-of-balls-in-a-box.rs: -------------------------------------------------------------------------------- 1 | pub fn count_balls(low_limit: i32, high_limit: i32) -> i32 { 2 | use std::collections::HashMap; 3 | let mut mmp = HashMap::new(); 4 | for i in low_limit ..= high_limit { 5 | let a = i.to_string().chars().map(|e|e.to_string().parse::().unwrap()).sum::(); 6 | mmp.entry(a).and_modify(|e|*e += 1).or_insert(1); 7 | } 8 | mmp.into_values().into_iter().max().unwrap() 9 | } 10 | 11 | fn main() { 12 | println!("{:?}", count_balls(1, 10)); 13 | println!("{:?}", count_balls(5, 15)); 14 | println!("{:?}", count_balls(19, 28)); 15 | } 16 | -------------------------------------------------------------------------------- /1748-sum-of-unique-elements.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：nums = [1,2,3,2] 4 | // 输出：4 5 | // 解释：唯一元素为 [1,3] ，和为 4 。 6 | 7 | pub fn sum_of_unique(nums: Vec) -> i32 { 8 | use std::collections::HashMap; 9 | let mut kvm = HashMap::new(); 10 | for num in nums { 11 | if !kvm.contains_key(&num) { 12 | kvm.insert(num, 1); 13 | } else { 14 | *kvm.get_mut(&num).unwrap() += 1; 15 | } 16 | } 17 | kvm.retain(|_, v| *v == 1 ); 18 | kvm.keys().sum::() 19 | } 20 | 21 | fn main() { 22 | println!("{:?}", sum_of_unique(vec!(1,2,3,2))); 23 | } 24 | -------------------------------------------------------------------------------- /1752-check-if-array-is-sorted-and-rotated.rs: -------------------------------------------------------------------------------- 1 | 2 | // 统计降序次数 3 | // 最后1位和第一位也要比较，因为是环 4 | // 降序次数不大于1 5 | 6 | pub fn check(nums: Vec) -> bool { 7 | let mut decrease_count = 0; 8 | let mut tmp = -1; 9 | for num in &nums { 10 | if num < &tmp { 11 | decrease_count += 1; 12 | } 13 | tmp = *num; 14 | } 15 | if nums.last().unwrap() > nums.first().unwrap() { 16 | decrease_count += 1; 17 | } 18 | 19 | decrease_count <= 1 20 | } 21 | 22 | fn main() { 23 | let nums = vec![6, 2, 6]; 24 | println!("{:?}", check(nums)); 25 | } 26 | -------------------------------------------------------------------------------- /1758-minimum-changes-to-make-alternating-binary-string.rs: -------------------------------------------------------------------------------- 1 | pub fn min_operations(s: String) -> i32 { 2 | let s_len = s.len(); 3 | let mut final_0 = vec!['0'; s_len]; 4 | let mut final_1 = vec!['1'; s_len]; 5 | let idx: usize; 6 | if s_len % 2 == 0 { idx = s_len / 2 } else { idx = s_len / 2 + 1 } 7 | for i in 0..idx{ 8 | final_0[i * 2] = '1'; 9 | final_1[i * 2] = '0'; 10 | } 11 | let (mut final_0_count, mut final_1_count) = (0, 0); 12 | for (i, c) in s.chars().collect::>().iter().enumerate() { 13 | if final_0[i] != *c { final_0_count += 1 } 14 | if final_1[i] != *c { final_1_count += 1 } 15 | } 16 | *vec![final_1_count, final_0_count].iter().min().unwrap() 17 | } 18 | 19 | fn main() { 20 | let s = "1111".to_string(); 21 | println!("{:?}", min_operations(s)); 22 | } 23 | -------------------------------------------------------------------------------- /1763-longest-nice-substring.rs: -------------------------------------------------------------------------------- 1 | pub fn longest_nice_substring(s: String) -> String { 2 | fn is_nice(s: &str) -> bool { 3 | let mut a = s.to_string().chars().collect::>(); 4 | a.sort_unstable(); 5 | a.dedup(); 6 | println!("{:?}", a); 7 | true 8 | } 9 | for i in 0..s.len()-1 { 10 | for j in i+1..s.len() { 11 | let a = &s[i..j]; 12 | if is_nice(a) { 13 | // println!("{:?}", a); 14 | // return a.to_strin(); 15 | } 16 | } 17 | } 18 | String::new() 19 | } 20 | 21 | fn main() { 22 | let s = "YazaAay".to_string(); 23 | println!("{:?}", longest_nice_substring(s)); 24 | } 25 | -------------------------------------------------------------------------------- /1780-check-if-number-is-a-sum-of-powers-of-three.rs: -------------------------------------------------------------------------------- 1 | // n 转化为3进制，只有0、1 2 | pub fn check_powers_of_three(n: i32) -> bool { 3 | let mut n = n; 4 | while n > 0 { 5 | if n % 3 == 2 { return false } 6 | n /= 3; 7 | } 8 | true 9 | } 10 | 11 | fn main() { 12 | println!("{:?}", check_powers_of_three(12)); 13 | } 14 | -------------------------------------------------------------------------------- /1784-check-if-binary-string-has-at-most-one-segment-of-ones.rs: -------------------------------------------------------------------------------- 1 | pub fn check_ones_segment(s: String) -> bool { 2 | if s == "1".to_string() { return true } 3 | let cs = s.chars().collect::>(); 4 | let mut prev_char = '1'; 5 | let mut change_times = 0; 6 | for c in &cs[1..] { 7 | if *c != prev_char { change_times += 1 } 8 | prev_char = *c; 9 | } 10 | change_times <= 1 11 | } 12 | 13 | fn main() { 14 | println!("{:?}", check_ones_segment("1001".to_string())); // false 15 | println!("{:?}", check_ones_segment("110".to_string())); // true 16 | println!("{:?}", check_ones_segment("1".to_string())); // true 17 | println!("{:?}", check_ones_segment("10".to_string())); // true 18 | } 19 | -------------------------------------------------------------------------------- /1790-check-if-one-string-swap-can-make-strings-equal.rs: -------------------------------------------------------------------------------- 1 | pub fn are_almost_equal(s1: String, s2: String) -> bool { 2 | if s1 == s2 { 3 | return true; 4 | } 5 | let mut diff_idx = vec!(); 6 | let s1_chars = s1.chars().collect::>(); 7 | let s2_chars = s2.chars().collect::>(); 8 | for i in 0..s1.len() { 9 | if s1_chars[i] != s2_chars[i] { 10 | diff_idx.push(i); 11 | } 12 | if diff_idx.len() > 2 { 13 | return false; 14 | } 15 | } 16 | diff_idx.len() == 2 && 17 | s1_chars[diff_idx[0]] == s2_chars[diff_idx[1]] && 18 | s1_chars[diff_idx[1]] == s2_chars[diff_idx[0]] 19 | } 20 | 21 | fn main() { 22 | let s1 = "aa".to_string(); 23 | let s2 = "ac".to_string(); 24 | println!("{:?}", are_almost_equal(s1, s2)); 25 | } 26 | -------------------------------------------------------------------------------- /1791-find-center-of-star-graph.rs: -------------------------------------------------------------------------------- 1 | // 链接：https://leetcode-cn.com/problems/find-center-of-star-graph 2 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。输入：edges = [[1,2],[2,3],[4,2]] 3 | // 输出：2 4 | // 解释：如上图所示，节点 2 与其他每个节点都相连，所以节点 2 是中心节点。 5 | 6 | use std::collections::HashMap; 7 | 8 | fn main() { 9 | let edges = vec!( 10 | vec!(1,2), 11 | vec!(2,3), 12 | vec!(4,2) 13 | ); 14 | println!("{:?}", find_center(edges)); 15 | } 16 | 17 | pub fn find_center(edges: Vec>) -> i32 { 18 | let mut e_map = HashMap::new(); 19 | let mut max = 0; 20 | let mut current_e = 0; 21 | for point in edges { 22 | for e in point { 23 | if !e_map.contains_key(&e) { 24 | e_map.insert(e, 1); 25 | } else { 26 | *e_map.get_mut(&e).unwrap() += 1; 27 | } 28 | if e_map[&e] >= max { 29 | max = e_map[&e]; 30 | current_e = e; 31 | } 32 | } 33 | } 34 | current_e 35 | } 36 | -------------------------------------------------------------------------------- /1800-maximum-ascending-subarray-sum.rs: -------------------------------------------------------------------------------- 1 | pub fn max_ascending_sum(nums: Vec) -> i32 { 2 | let mut arr: Vec = Vec::new(); 3 | let mut tmp_arr = Vec::new(); 4 | let mut pre_num = -1; 5 | for num in nums { 6 | if num > pre_num { 7 | tmp_arr.push(num); 8 | } 9 | if num <= pre_num { 10 | arr.push(tmp_arr.iter().sum()); 11 | tmp_arr = vec!(num); 12 | } 13 | pre_num = num; 14 | } 15 | arr.push(tmp_arr.iter().sum()); 16 | arr.sort(); 17 | *arr.last().unwrap() 18 | } 19 | 20 | fn main() { 21 | println!("{:?}", max_ascending_sum(vec![10,20,30,5,10,50])); 22 | } -------------------------------------------------------------------------------- /1816-truncate-sentence.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：s = "Hello how are you Contestant", k = 4 4 | // 输出："Hello how are you" 5 | // 解释： 6 | // s 中的单词为 ["Hello", "how" "are", "you", "Contestant"] 7 | // 前 4 个单词为 ["Hello", "how", "are", "you"] 8 | // 因此，应当返回 "Hello how are you" 9 | 10 | // 来源：力扣（LeetCode） 11 | // 链接：https://leetcode-cn.com/problems/truncate-sentence 12 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 13 | 14 | pub fn truncate_sentence(s: String, k: i32) -> String { 15 | let words: Vec = s.split(" ").map(|word| word.to_string()).collect(); 16 | words[0..k as usize].join(" ") 17 | } 18 | 19 | fn main() { 20 | println!("{:?}", truncate_sentence("Hello how are you Contestant".to_string(), 4)); 21 | } 22 | -------------------------------------------------------------------------------- /1817-finding-the-users-active-minutes.rs: -------------------------------------------------------------------------------- 1 | pub fn finding_users_active_minutes(logs: Vec>, k: i32) -> Vec { 2 | use std::collections::HashMap; 3 | use std::collections::HashSet; 4 | let mut mmp: HashMap> = HashMap::new(); 5 | for log in logs { 6 | mmp.entry(log[0]).or_insert(HashSet::new()).insert(log[1]); 7 | } 8 | let mut ret = vec![0; k as usize]; 9 | for (_, v) in mmp { 10 | ret[v.len()-1] += 1; 11 | } 12 | ret 13 | } 14 | 15 | fn main() { 16 | let logs: Vec> = vec![[0,5],[1,2],[0,2],[0,5],[1,3]].iter().map(|e|e.to_vec()).collect(); 17 | let k = 5; 18 | println!("{:?}", finding_users_active_minutes(logs, k)); 19 | } 20 | -------------------------------------------------------------------------------- /1822-sign-of-the-product-of-an-array.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：nums = [-1,-2,-3,-4,3,2,1] 4 | // 输出：1 5 | // 解释：数组中所有值的乘积是 144 ，且 signFunc(144) = 1 6 | 7 | // 来源：力扣（LeetCode） 8 | // 链接：https://leetcode-cn.com/problems/sign-of-the-product-of-an-array 9 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 10 | 11 | fn main() { 12 | let nums = vec!(-1,-2,-3,-4,3,2,1); 13 | let res = array_sign(nums); 14 | println!("{:?}", res); 15 | } 16 | // 思路 遍历，如果出现0 返回0，出现正数不变，负数乘以 -1 17 | pub fn array_sign(nums: Vec) -> i32 { 18 | let mut res = 1; 19 | for num in nums { 20 | if num == 0 { 21 | res = 0; 22 | break; 23 | } else if num < 0 { 24 | res *= -1; 25 | } 26 | } 27 | res 28 | } 29 | -------------------------------------------------------------------------------- /1827-minimum-operations-to-make-the-array-increasing.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：nums = [1,1,1] 4 | // 输出：3 5 | // 解释：你可以进行如下操作： 6 | // 1) 增加 nums[2] ，数组变为 [1,1,2] 。 7 | // 2) 增加 nums[1] ，数组变为 [1,2,2] 。 8 | // 3) 增加 nums[2] ，数组变为 [1,2,3] 。 9 | // 示例 2： 10 | 11 | // 输入：nums = [1,5,2,4,1] 12 | // 输出：14 13 | // 示例 3： 14 | 15 | // 输入：nums = [8] 16 | // 输出：0 17 | 18 | // 来源：力扣（LeetCode） 19 | // 链接：https://leetcode-cn.com/problems/minimum-operations-to-make-the-array-increasing 20 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 21 | 22 | fn main() { 23 | let nums = vec!(1,5,2,4,1); 24 | println!("{:?}", min_operations(nums)); 25 | } 26 | 27 | pub fn min_operations(nums: Vec) -> i32 { 28 | let mut temp = 0; 29 | let mut steps = 0; 30 | for num in nums { 31 | if num <= temp { 32 | steps += temp - num; 33 | temp += 1; 34 | } else { 35 | temp = num + 1; 36 | } 37 | } 38 | steps 39 | } 40 | -------------------------------------------------------------------------------- /1828-queries-on-number-of-points-inside-a-circle.rs: -------------------------------------------------------------------------------- 1 | // 计算点到圆心的距离 2 | pub fn count_points(points: Vec>, queries: Vec>) -> Vec { 3 | let mut ret = vec!(); 4 | for q in queries { 5 | let mut count = 0; 6 | for p in &points { 7 | let dis = (((p[0]-q[0]) as f64).powf(2.0) + ((p[1]-q[1]) as f64).powf(2.0)).sqrt(); 8 | if dis <= q[2] as f64 { 9 | count += 1; 10 | } 11 | } 12 | ret.push(count); 13 | } 14 | ret 15 | } 16 | 17 | fn main() { 18 | let points = vec![vec![1,3],vec![3,3],vec![5,3],vec![2,2]]; 19 | let queries = vec![vec![2,3,1],vec![4,3,1],vec![1,1,2]]; 20 | println!("{:?}", count_points(points, queries)); 21 | } 22 | -------------------------------------------------------------------------------- /1829-maximum-xor-for-each-query.rs: -------------------------------------------------------------------------------- 1 | pub fn get_maximum_xor(nums: Vec, maximum_bit: i32) -> Vec { 2 | let max = 2_i32.pow(maximum_bit as u32) - 1; 3 | let mut ret = vec![]; 4 | for i in 0..nums.len() { 5 | let mut tmp = max; 6 | for num in &nums[0..nums.len() - i] { 7 | tmp ^= *num; 8 | } 9 | ret.push(tmp); 10 | } 11 | ret 12 | } 13 | 14 | fn main() { 15 | let nums = vec![2,3,4,7]; 16 | let maximum_bit = 3; 17 | println!("{:?}", get_maximum_xor(nums, maximum_bit)); 18 | } 19 | -------------------------------------------------------------------------------- /1832-check-if-the-sentence-is-pangram.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：sentence = "thequickbrownfoxjumpsoverthelazydog" 4 | // 输出：true 5 | // 解释：sentence 包含英语字母表中每个字母至少一次。 6 | 7 | // 来源：力扣（LeetCode） 8 | // 链接：https://leetcode-cn.com/problems/check-if-the-sentence-is-pangram 9 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 10 | 11 | fn main() { 12 | let sentence = "thequickbrownfoxjumpsoverthelazydog".to_string(); 13 | let res = check_if_pangram(sentence); 14 | println!("{:?}", res); 15 | } 16 | 17 | pub fn check_if_pangram(sentence: String) -> bool { 18 | let mut chars: Vec = sentence.chars().collect(); 19 | chars.sort_unstable(); 20 | chars.dedup(); 21 | let str: String = chars.into_iter().collect(); 22 | str == "abcdefghijklmnopqrstuvwxyz" 23 | } 24 | -------------------------------------------------------------------------------- /1833-maximum-ice-cream-bars.rs: -------------------------------------------------------------------------------- 1 | pub fn max_ice_cream(costs: Vec, coins: i32) -> i32 { 2 | let mut sorted_costs = costs.clone(); 3 | sorted_costs.sort(); 4 | for i in 1..sorted_costs.len() { 5 | sorted_costs[i] += sorted_costs[i-1]; 6 | } 7 | for (i, c) in sorted_costs.iter().enumerate() { 8 | if coins < *c { return i as i32 } 9 | } 10 | sorted_costs.len() as i32 11 | } 12 | 13 | fn main() { 14 | let costs = vec![1,6,3,1,2,5]; 15 | let coins = 20; 16 | println!("{:?}", max_ice_cream(costs, coins)); 17 | println!("{:?}", max_ice_cream(vec![1,3,2,4,1], 7)); 18 | } 19 | -------------------------------------------------------------------------------- /1837-sum-of-digits-in-base-k.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：n = 34, k = 6 4 | // 输出：9 5 | // 解释：34 (10 进制) 在 6 进制下表示为 54 。5 + 4 = 9 。 6 | // 示例 2： 7 | 8 | // 输入：n = 10, k = 10 9 | // 输出：1 10 | // 解释：n 本身就是 10 进制。 1 + 0 = 1 。 11 | 12 | // 来源：力扣（LeetCode） 13 | // 链接：https://leetcode-cn.com/problems/sum-of-digits-in-base-k 14 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 15 | 16 | 17 | // 先分析，因为1 <= n <= 100 所以按2进制算最多7位数 18 | pub fn sum_base(n: i32, k: i32) -> i32 { 19 | let mut res = 0; 20 | let mut temp = n; 21 | for i in (0..7).rev() { 22 | let p = k.pow(i); 23 | let r = temp / p; 24 | res += r; 25 | temp -= r * p; 26 | } 27 | res 28 | } 29 | 30 | fn main() { 31 | println!("{:?}", sum_base(34, 6)); 32 | } 33 | -------------------------------------------------------------------------------- /1844-replace-all-digits-with-characters.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：s = "a1c1e1" 4 | // 输出："abcdef" 5 | // 解释：数字被替换结果如下： 6 | // - s[1] -> shift('a',1) = 'b' 7 | // - s[3] -> shift('c',1) = 'd' 8 | // - s[5] -> shift('e',1) = 'f' 9 | 10 | // 来源：力扣（LeetCode） 11 | // 链接：https://leetcode-cn.com/problems/replace-all-digits-with-characters 12 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 13 | 14 | fn main() { 15 | let s = "a1c1e1".to_string(); 16 | println!("{:?}", replace_digits(s)); 17 | } 18 | 19 | pub fn replace_digits(s: String) -> String { 20 | let chars = s.chars().clone(); 21 | let mut res = "".to_string(); 22 | let mut front_char = 'a'; 23 | for c in chars { 24 | if c.is_digit(10) { 25 | res.push(std::char::from_u32(front_char as u32 + (c as u32 - 0x30)).unwrap()); 26 | } else { 27 | front_char = c; 28 | res.push(c); 29 | } 30 | } 31 | res 32 | } 33 | -------------------------------------------------------------------------------- /1848-minimum-distance-to-the-target-element.rs: -------------------------------------------------------------------------------- 1 | pub fn get_min_distance(nums: Vec, target: i32, start: i32) -> i32 { 2 | let mut ret = 10000; 3 | for (i, e) in nums.iter().enumerate() { 4 | if *e == target { 5 | let tmp = (i as i32-start).abs(); 6 | if tmp < ret { 7 | ret = tmp; 8 | } 9 | } 10 | } 11 | ret 12 | } 13 | 14 | fn main() { 15 | let nums = vec![1,2,3,4,5]; 16 | let target = 5; 17 | let start = 3; 18 | println!("{:?}", get_min_distance(nums, target, start)); 19 | } 20 | -------------------------------------------------------------------------------- /1859-sorting-the-sentence.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：s = "is2 sentence4 This1 a3" 4 | // 输出："This is a sentence" 5 | // 解释：将 s 中的单词按照初始位置排序，得到 "This1 is2 a3 sentence4" ，然后删除数字。 6 | 7 | // 来源：力扣（LeetCode） 8 | // 链接：https://leetcode-cn.com/problems/sorting-the-sentence 9 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 10 | 11 | fn main() { 12 | println!("{:?}", sort_sentence("is2 sentence4 This1 a3".to_string())); 13 | } 14 | 15 | pub fn sort_sentence(s: String) -> String { 16 | let mut arr = s.split(' ').collect::>(); 17 | arr.sort_by(|b, a| b.chars().last().unwrap().cmp(&a.chars().last().unwrap())); // sort 方法必须换行，不能链式调用 18 | let res = arr.join(" "); 19 | res.chars().filter(|c|!c.is_digit(10)).collect::() 20 | } 21 | -------------------------------------------------------------------------------- /1876-substrings-of-size-three-with-distinct-characters.rs: -------------------------------------------------------------------------------- 1 | pub fn count_good_substrings(s: String) -> i32 { 2 | let mut res = 0; 3 | if s.len() >= 3 { 4 | for i in 0..s.len()-2 { 5 | let tmp_str = &s[i..i+3]; 6 | let s_len = tmp_str.len(); 7 | let mut tmp_chars: Vec = tmp_str.chars().collect(); 8 | tmp_chars.sort_unstable(); 9 | tmp_chars.dedup(); 10 | if tmp_chars.len() == s_len { 11 | res += 1; 12 | } 13 | } 14 | } 15 | res 16 | } 17 | 18 | fn main() { 19 | println!("{}", count_good_substrings("x".to_string())); 20 | } 21 | -------------------------------------------------------------------------------- /1880-check-if-word-equals-summation-of-two-words.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：firstWord = "acb", secondWord = "cba", targetWord = "cdb" 4 | // 输出：true 5 | // 解释： 6 | // firstWord 的数值为 "acb" -> "021" -> 21 7 | // secondWord 的数值为 "cba" -> "210" -> 210 8 | // targetWord 的数值为 "cdb" -> "231" -> 231 9 | // 由于 21 + 210 == 231 ，返回 true 10 | 11 | // 来源：力扣（LeetCode） 12 | // 链接：https://leetcode-cn.com/problems/check-if-word-equals-summation-of-two-words 13 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 14 | 15 | pub fn is_sum_equal(first_word: String, second_word: String, target_word: String) -> bool { 16 | fn str_number(s: String) -> i32 { 17 | let char_vec: Vec = s.chars().map(|e|(e as i32 - 'a' as i32).to_string()).collect(); 18 | char_vec.join("").parse().unwrap() 19 | } 20 | str_number(first_word) + str_number(second_word) == str_number(target_word) 21 | } 22 | 23 | fn main() { 24 | println!("{:?}", is_sum_equal("acb".to_string(), "cba".to_string(), "cdb".to_string())); 25 | } 26 | -------------------------------------------------------------------------------- /1887-reduction-operations-to-make-the-array-elements-equal.rs: -------------------------------------------------------------------------------- 1 | pub fn reduction_operations(nums: Vec) -> i32 { 2 | use std::collections::HashMap; 3 | let mut mmp = HashMap::new(); 4 | for num in nums { 5 | mmp.entry(num).and_modify(|e|*e += 1).or_insert(1); 6 | } 7 | let mut mmp_vec: Vec<_> = mmp.iter().collect(); 8 | mmp_vec.sort_by(|a, b|a.0.cmp(&b.0)); 9 | // println!("{:?}", mmp_vec); 10 | let mut ret = 0; 11 | for (i, r) in mmp_vec.iter().enumerate() { 12 | ret += i * r.1 13 | } 14 | ret as i32 15 | } 16 | 17 | fn main() { 18 | println!("{:?}", reduction_operations(vec![5,1,3])); 19 | println!("{:?}", reduction_operations(vec![1,1,1])); 20 | println!("{:?}", reduction_operations(vec![1,1,2,2,3])); 21 | } 22 | -------------------------------------------------------------------------------- /1893-check-if-all-the-integers-in-a-range-are-covered.rs: -------------------------------------------------------------------------------- 1 | pub fn is_covered(ranges: Vec>, left: i32, right: i32) -> bool { 2 | let mut ranges = ranges; 3 | ranges.sort_by(|a, b|a[0].cmp(&b[0])); 4 | let mut stack: Vec = (left..=right).rev().collect(); 5 | let mut current = stack.pop().unwrap(); 6 | for range in &ranges { 7 | while current >= range[0] && current <= range[1] { 8 | if stack.is_empty() { 9 | return true; 10 | } else { 11 | current = stack.pop().unwrap(); 12 | } 13 | } 14 | } 15 | false 16 | } 17 | 18 | fn main() { 19 | let ranges = [[36,50],[14,28],[4,31],[24,37],[13,36],[27,33],[23,32],[23,27],[1,35]].map(|e|e.to_vec()).to_vec(); 20 | let left = 35; 21 | let right = 40; 22 | println!("{:?}", is_covered(ranges, left, right)); 23 | } 24 | -------------------------------------------------------------------------------- /1897-redistribute-characters-to-make-all-strings-equal.rs: -------------------------------------------------------------------------------- 1 | pub fn make_equal(words: Vec) -> bool { 2 | let words_len = words.len(); 3 | if words_len == 1 { return true } 4 | use std::collections::HashMap; 5 | let mut mmp = HashMap::new(); 6 | for word in words { 7 | for c in word.chars().collect::>() { 8 | let count = mmp.entry(c).or_insert(0); 9 | *count += 1; 10 | } 11 | } 12 | mmp.retain(|_, v| *v % words_len != 0); 13 | mmp.is_empty() 14 | } 15 | 16 | fn main() { 17 | let words = ["abc","aabc","bc"].iter().map(|e|e.to_string()).collect::>(); 18 | println!("{:?}", make_equal(words)); 19 | } 20 | -------------------------------------------------------------------------------- /1903-largest-odd-number-in-string.rs: -------------------------------------------------------------------------------- 1 | pub fn largest_odd_number(num: String) -> String { 2 | for (i, c) in num.chars().rev().enumerate() { 3 | if c.to_string().parse::().unwrap() % 2 != 0 { 4 | return num[..(num.len()-i)].to_string(); 5 | } 6 | } 7 | String::new() 8 | } 9 | 10 | fn main() { 11 | let num = "4206".to_string(); 12 | println!("{:?}", largest_odd_number(num)); 13 | } 14 | -------------------------------------------------------------------------------- /1910-remove-all-occurrences-of-a-substring.rs: -------------------------------------------------------------------------------- 1 | // Rust str API: split_once 2 | 3 | pub fn remove_occurrences(s: String, part: String) -> String { 4 | let mut ret = s; 5 | loop { 6 | let parts = ret.split_once(&part); 7 | if parts == None { 8 | break 9 | } else { 10 | let uwparts = parts.unwrap(); 11 | ret = vec![uwparts.0, uwparts.1].join(""); 12 | } 13 | } 14 | ret 15 | } 16 | 17 | fn main() { 18 | let s = "aabababa".to_string(); 19 | let part = "aba".to_string(); 20 | println!("{:?}", remove_occurrences(s, part)); 21 | } 22 | -------------------------------------------------------------------------------- /1913-maximum-product-difference-between-two-pairs.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：nums = [5,6,2,7,4] 4 | // 输出：34 5 | // 解释：可以选出下标为 1 和 3 的元素构成第一个数对 (6, 7) 以及下标 2 和 4 构成第二个数对 (2, 4) 6 | // 乘积差是 (6 * 7) - (2 * 4) = 34 7 | 8 | // 来源：力扣（LeetCode） 9 | // 链接：https://leetcode-cn.com/problems/maximum-product-difference-between-two-pairs 10 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 11 | 12 | fn main() { 13 | let nums = vec!(5,6,2,7,4); 14 | let res = max_product_difference(nums); 15 | println!("{:?}", res); 16 | } 17 | 18 | pub fn max_product_difference(nums: Vec) -> i32 { 19 | let mut sorted_nums = nums.clone(); 20 | sorted_nums.sort(); 21 | let length = nums.len(); 22 | sorted_nums[length-1] * sorted_nums[length-2] - sorted_nums[0] * sorted_nums[1] 23 | } 24 | -------------------------------------------------------------------------------- /1920-build-array-from-permutation.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let nums = vec!(0,2,1,5,3,4); 3 | let res = build_array(nums); 4 | println!("{:?}", res); 5 | } 6 | 7 | // 输入：nums = [0,2,1,5,3,4] 8 | // 输出：[0,1,2,4,5,3] 9 | // 解释：数组 ans 构建如下： 10 | // ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]] 11 | // = [nums[0], nums[2], nums[1], nums[5], nums[3], nums[4]] 12 | // = [0,1,2,4,5,3] 13 | 14 | pub fn build_array(nums: Vec) -> Vec { 15 | nums.clone().into_iter().map(|x| nums[x as usize]).collect() 16 | } -------------------------------------------------------------------------------- /1925-count-square-sum-triples.rs: -------------------------------------------------------------------------------- 1 | pub fn count_triples(n: i32) -> i32 { 2 | let mut counter = 0; 3 | for i in 1..n+1 { 4 | for j in 1..n+1 { 5 | for k in 1..n+1 { 6 | if i * i + j * j == k * k { 7 | counter += 1; 8 | } 9 | } 10 | } 11 | } 12 | counter 13 | } 14 | 15 | fn main() { 16 | println!("{:?}", count_triples(10)); 17 | } 18 | -------------------------------------------------------------------------------- /1929-concatenation-of-array.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let nums = vec!(1, 2, 1); 3 | let a = get_concatenation(nums); 4 | println!("{:?}", a); 5 | } 6 | 7 | // 1929 https://leetcode-cn.com/problems/concatenation-of-array/ 8 | // [1,2,1] [1,2,1,1,2,1] 9 | // 审题，函数输入已经固定是 immut vec，那么结果不能用他返回 10 | // 所以需要declare 2 个mut 的nums 11 | pub fn get_concatenation(nums: Vec) -> Vec { 12 | let mut res_nums = nums.clone(); 13 | let mut clone_nums = nums.clone(); 14 | res_nums.append(&mut clone_nums); // 只能 append mut 的nums 15 | res_nums 16 | } -------------------------------------------------------------------------------- /1935-maximum-number-of-words-you-can-type.rs: -------------------------------------------------------------------------------- 1 | pub fn can_be_typed_words 2 | (text: String, broken_letters: String) -> i32 3 | { 4 | fn have_broken_letters 5 | (word: String, broken_letters: &str) -> bool 6 | { 7 | for c in broken_letters.chars() { 8 | if word.contains(&c.to_string()) { 9 | return true; 10 | } 11 | } 12 | return false; 13 | } 14 | let mut res = 0; 15 | let words: Vec = text.split(" ") 16 | .map(|word|word.to_string()) 17 | .collect(); 18 | 19 | for word in words { 20 | if !have_broken_letters(word, &broken_letters) { 21 | res += 1; 22 | } 23 | } 24 | res 25 | } 26 | 27 | fn main() { 28 | println!("{:?}", can_be_typed_words("hello world".to_string(), "ad".to_string())); 29 | } 30 | -------------------------------------------------------------------------------- /1941-check-if-all-characters-have-equal-number-of-occurrences.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：s = "abacbc" 4 | // 输出：true 5 | // 解释：s 中出现过的字符为 'a'，'b' 和 'c' 。s 中所有字符均出现 2 次。 6 | 7 | fn main() { 8 | let s = "fhojjkontbncdhwxbnexplclvjyexzsvqyyhpfpnvhdskuhkuoihiqgalklqketjikdlgrawhfo".to_string(); 9 | println!("{:?}", are_occurrences_equal(s)); 10 | } 11 | 12 | pub fn are_occurrences_equal(s: String) -> bool { 13 | let mut uniq_chars: Vec = s.chars().collect(); 14 | uniq_chars.sort_unstable(); 15 | uniq_chars.dedup(); 16 | if s.len() % uniq_chars.len() != 0 { 17 | return false; 18 | } 19 | let freq = s.len() / uniq_chars.len(); 20 | for c in uniq_chars { 21 | if s.chars().filter(|&e| e == c).count() != freq { 22 | return false; 23 | } 24 | } 25 | return true; 26 | } 27 | -------------------------------------------------------------------------------- /1945-sum-of-digits-of-string-after-convert.rs: -------------------------------------------------------------------------------- 1 | pub fn get_lucky(s: String, k: i32) -> i32 { 2 | pub fn luck(s: String) -> String { 3 | s.chars().map(|e|e.to_string().parse::().unwrap()).sum::().to_string() 4 | } 5 | let mut ret = s.chars().map(|e|(e as i32 - 'a' as i32 + 1).to_string()).collect::>().join(""); 6 | for _ in 0..k { 7 | ret = luck(ret); 8 | } 9 | ret.parse::().unwrap() 10 | } 11 | 12 | fn main() { 13 | println!("{:?}", get_lucky("iiii".to_string(), 1)); 14 | } 15 | -------------------------------------------------------------------------------- /1952-three-divisors.rs: -------------------------------------------------------------------------------- 1 | pub fn is_three(n: i32) -> bool { 2 | if n < 3 { 3 | return false; 4 | } 5 | let mut count = 0; 6 | for i in 2..n { 7 | if n % i == 0 { 8 | count += 1; 9 | } 10 | if count > 1 { 11 | return false; 12 | } 13 | } 14 | count == 1 15 | } 16 | 17 | fn main() { 18 | println!("{:?}", is_three(4)); 19 | } 20 | -------------------------------------------------------------------------------- /1957-make_fancy_string.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let str = "aab".to_string(); 3 | let a = make_fancy_string(str); 4 | println!("{:?}", a); 5 | } 6 | 7 | // 1957 https://leetcode-cn.com/problems/delete-characters-to-make-fancy-string/ 8 | // leeetcode leetcode 9 | // aaabaaaa aabaa 10 | // aab aab 11 | pub fn make_fancy_string(s: String) -> String { 12 | let mut flag_c = '*'; 13 | let mut counter = 1; 14 | let mut res_str = String::from(""); 15 | for c in s.chars() { 16 | if c != flag_c { 17 | flag_c = c; 18 | counter = 1; 19 | } else { 20 | counter += 1; 21 | } 22 | if counter > 2 { 23 | continue; 24 | } else { 25 | res_str.push(c); 26 | } 27 | } 28 | res_str 29 | } -------------------------------------------------------------------------------- /196-next-greater-element-i.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | impl Solution { 4 | pub fn next_greater_element(nums1: Vec, nums2: Vec) -> Vec { 5 | pub fn next_greater(num: i32, nums2: &[i32]) -> i32 { 6 | let mut flag = false; 7 | for i in nums2 { 8 | if i == &num { 9 | flag = true; 10 | } 11 | if flag == true && i > &num { 12 | return *i; 13 | } 14 | } 15 | return -1; 16 | } 17 | nums1.iter().map(|num|next_greater(*num, &nums2)).collect::>() 18 | } 19 | } 20 | 21 | fn main() { 22 | let nums1 = vec![4, 1, 2]; 23 | let nums2 = vec![1, 3, 4, 2]; 24 | println!("{:?}", Solution::next_greater_element(nums1, nums2)); 25 | } 26 | -------------------------------------------------------------------------------- /1967-number-of-strings-that-appear-as-substrings-in-word.rs: -------------------------------------------------------------------------------- 1 | pub fn num_of_strings(patterns: Vec, word: String) -> i32 { 2 | let mut res = 0; 3 | for p in patterns { 4 | if word.contains(&p) { 5 | res += 1; 6 | } 7 | } 8 | res 9 | } 10 | 11 | fn main() { 12 | let patterns = vec!["a","abc","bc","d"] 13 | .iter().map(|e|e.to_string()).collect(); 14 | let word = "abc".to_string(); 15 | println!("{:?}", num_of_strings(patterns, word)); 16 | } 17 | -------------------------------------------------------------------------------- /1979-find-greatest-common-divisor-of-array.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：nums = [2,5,6,9,10] 4 | // 输出：2 5 | // 解释： 6 | // nums 中最小的数是 2 7 | // nums 中最大的数是 10 8 | // 2 和 10 的最大公约数是 2 9 | 10 | // 来源：力扣（LeetCode） 11 | // 链接：https://leetcode-cn.com/problems/find-greatest-common-divisor-of-array 12 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 13 | 14 | fn main() { 15 | let nums = vec!(2,5,6,9,10); 16 | let res = find_gcd(nums); 17 | println!("{:?}", res); 18 | } 19 | 20 | pub fn find_gcd(nums: Vec) -> i32 { 21 | let min = *nums.iter().min().unwrap(); 22 | let max = *nums.iter().max().unwrap(); 23 | for i in (2..(min+1)).rev() { 24 | if min % i == 0 && max % i == 0 { 25 | return i 26 | } 27 | } 28 | return 1 29 | } -------------------------------------------------------------------------------- /1991-find-the-middle-index-in-array.rs: -------------------------------------------------------------------------------- 1 | pub fn find_middle_index(nums: Vec) -> i32 { 2 | for i in 0..nums.len() { 3 | if nums[0..i].iter().sum::() == nums[i+1..].iter().sum::() { 4 | return i as i32; 5 | } 6 | } 7 | -1 8 | } 9 | 10 | fn main() { 11 | let nums = vec![1]; 12 | println!("{:?}", find_middle_index(nums)); 13 | } 14 | -------------------------------------------------------------------------------- /1995-count-special-quadruplets.rs: -------------------------------------------------------------------------------- 1 | pub fn count_quadruplets(nums: Vec) -> i32 { 2 | let mut ret = 0; 3 | for a in 0..nums.len() { 4 | for b in (a+1)..nums.len() { 5 | for c in (b+1)..nums.len() { 6 | for d in (c+1)..nums.len() { 7 | if nums[a] + nums[b] + nums[c] == nums[d] { 8 | ret += 1; 9 | } 10 | } 11 | } 12 | } 13 | } 14 | ret 15 | } 16 | 17 | fn main() { 18 | let nums = vec![1,1,1,3,5]; 19 | println!("{:?}", count_quadruplets(nums)); 20 | } 21 | -------------------------------------------------------------------------------- /2000-reverse-prefix-of-word.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：word = "abcdefd", ch = "d" 4 | // 输出："dcbaefd" 5 | // 解释："d" 第一次出现在下标 3 。 6 | // 反转从下标 0 到下标 3（含下标 3）的这段字符，结果字符串是 "dcbaefd" 。 7 | 8 | // 来源：力扣（LeetCode） 9 | // 链接：https://leetcode-cn.com/problems/reverse-prefix-of-word 10 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 11 | 12 | fn main() { 13 | let word = "abcdefd".to_string(); 14 | let ch = 'd'; 15 | println!("{:?}", reverse_prefix(word, ch)); 16 | } 17 | 18 | pub fn reverse_prefix(word: String, ch: char) -> String { 19 | let s_index = word.find(ch); 20 | match s_index { 21 | Some(p) => { 22 | let res = word.clone(); 23 | let mut left = res[..p+1].chars().rev().collect::(); 24 | let right: String = res[p+1..].to_string(); 25 | left.push_str(&right); 26 | left 27 | }, 28 | None => word, 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /2006-count-number-of-pairs-with-absolute-difference-k.rs: -------------------------------------------------------------------------------- 1 | // 输入：nums = [3,2,1,5,4], k = 2 2 | // 输出：3 3 | // 解释：差的绝对值为 2 的数对为： 4 | // - 3 1 5 | // - 3 5 6 | // - 2 4 7 | 8 | // 来源：力扣（LeetCode） 9 | // 链接：https://leetcode-cn.com/problems/count-number-of-pairs-with-absolute-difference-k 10 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 11 | 12 | fn main() { 13 | let nums = vec!(3,2,1,5,4); 14 | let k = 2; 15 | let res = count_k_difference(nums, k); 16 | println!("{:?}", res); 17 | } 18 | 19 | pub fn count_k_difference(nums: Vec, k: i32) -> i32 { 20 | let nums_len = &nums.len(); 21 | let mut counter = 0; 22 | for (i, num) in nums.iter().enumerate() { 23 | for n in &nums[i+1..*nums_len] { 24 | if (num - n).abs() == k { 25 | counter += 1; 26 | } 27 | } 28 | } 29 | counter 30 | } 31 | -------------------------------------------------------------------------------- /2011-final-value-of-variable-after-performing-operations.rs: -------------------------------------------------------------------------------- 1 | // 输入：operations = ["--X","X++","X++"] 2 | // 输出：1 3 | // 解释：操作按下述步骤执行： 4 | // 最初，X = 0 5 | // --X：X 减 1 ，X = 0 - 1 = -1 6 | // X++：X 加 1 ，X = -1 + 1 = 0 7 | // X++：X 加 1 ，X = 0 + 1 = 1 8 | 9 | // 来源：力扣（LeetCode） 10 | // 链接：https://leetcode-cn.com/problems/final-value-of-variable-after-performing-operations 11 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 12 | 13 | fn main() { 14 | let operations = ["--X","X++","X++"].iter().map(|&s|s.into()).collect(); 15 | let res = final_value_after_operations(operations); 16 | println!("{:?}", res); 17 | } 18 | 19 | pub fn final_value_after_operations(operations: Vec) -> i32 { 20 | operations.into_iter().map(|s| 21 | if s.contains('+') { 22 | 1 23 | } else { 24 | -1 25 | } 26 | ).sum() // 因为map完，vec里面已经是简单type i32了所以不需要 .collect().iter().sum() 27 | } 28 | -------------------------------------------------------------------------------- /202-happy-number.rs: -------------------------------------------------------------------------------- 1 | use std::collections::HashSet; 2 | 3 | struct Solution; 4 | 5 | impl Solution { 6 | pub fn is_happy(n: i32) -> bool { 7 | let mut set = HashSet::new(); 8 | let mut n = n; 9 | let mut new_n: i32; 10 | while !set.contains(&n) { 11 | set.insert(n); 12 | new_n = 0; 13 | while n > 0 { 14 | new_n += (n % 10).pow(2); 15 | n /= 10; 16 | } 17 | n = new_n; 18 | } 19 | n == 1 20 | } 21 | } 22 | 23 | fn main() { 24 | println!("{:?}", Solution::is_happy(7)); 25 | } 26 | -------------------------------------------------------------------------------- /2023-number-of-pairs-of-strings-with-concatenation-equal-to-target.rs: -------------------------------------------------------------------------------- 1 | pub fn num_of_pairs(nums: Vec, target: String) -> i32 { 2 | let mut res = 0; 3 | for (i, numi) in nums.iter().enumerate() { 4 | for (j, numj) in nums.iter().enumerate() { 5 | if i == j { 6 | continue; 7 | } 8 | let mut tmp = String::new(); 9 | tmp.push_str(numi); 10 | tmp.push_str(numj); 11 | if tmp == target { 12 | res += 1; 13 | } 14 | } 15 | } 16 | res 17 | } 18 | 19 | fn main() { 20 | let nums = vec!["1","1","1"] 21 | .iter().map(|e|e.to_string()).collect(); 22 | let target = "11".to_string(); 23 | println!("{:?}", num_of_pairs(nums, target)); 24 | } 25 | -------------------------------------------------------------------------------- /2027-minimum-moves-to-convert-string.rs: -------------------------------------------------------------------------------- 1 | pub fn minimum_moves(s: String) -> i32 { 2 | let cs = s.chars().collect::>(); 3 | let mut i = 0; 4 | let mut ret = 0; 5 | while i < s.len() { 6 | if cs[i] == 'X' { 7 | i += 3; 8 | ret += 1; 9 | } else { 10 | i += 1; 11 | } 12 | } 13 | ret 14 | } 15 | 16 | fn main() { 17 | let s = "XXOX".to_string(); 18 | println!("{:?}", minimum_moves(s)); 19 | } 20 | -------------------------------------------------------------------------------- /2032-two-out-of-three.rs: -------------------------------------------------------------------------------- 1 | pub fn two_out_of_three(nums1: Vec, nums2: Vec, nums3: Vec) -> Vec { 2 | use std::collections::HashSet; 3 | let mut ret = HashSet::new(); 4 | for i in &nums1 { 5 | for j in &nums2 { 6 | if i == j { 7 | ret.insert(*i); 8 | } 9 | } 10 | for k in &nums3 { 11 | if i == k { 12 | ret.insert(*i); 13 | } 14 | } 15 | } 16 | for i in &nums2 { 17 | for j in &nums3 { 18 | if i == j { 19 | ret.insert(*i); 20 | } 21 | } 22 | } 23 | ret.into_iter().collect::>() 24 | } 25 | 26 | fn main() { 27 | let nums1 = vec![1,1,3,2]; 28 | let nums2 = vec![2,3]; 29 | let nums3 = vec![3]; 30 | println!("{:?}", two_out_of_three(nums1, nums2, nums3)); 31 | } 32 | -------------------------------------------------------------------------------- /2037-minimum-number-of-moves-to-seat-everyone.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：seats = [3,1,5], students = [2,7,4] 4 | // 输出：4 5 | // 解释：学生移动方式如下： 6 | // - 第一位学生从位置 2 移动到位置 1 ，移动 1 次。 7 | // - 第二位学生从位置 7 移动到位置 5 ，移动 2 次。 8 | // - 第三位学生从位置 4 移动到位置 3 ，移动 1 次。 9 | // 总共 1 + 2 + 1 = 4 次移动。 10 | 11 | // 来源：力扣（LeetCode） 12 | // 链接：https://leetcode-cn.com/problems/minimum-number-of-moves-to-seat-everyone 13 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 14 | 15 | fn main() { 16 | let seats = vec!(3,1,5); 17 | let students = vec!(2,7,4); 18 | println!("{:?}", min_moves_to_seat(seats, students)); 19 | } 20 | 21 | pub fn min_moves_to_seat(seats: Vec, students: Vec) -> i32 { 22 | let mut sorted_seats = seats.clone(); 23 | sorted_seats.sort(); 24 | let mut sorted_students = students.clone(); 25 | sorted_students.sort(); 26 | let length = seats.len(); 27 | let mut res = 0; 28 | for i in 0..length { 29 | res += (sorted_seats[i] - sorted_students[i]).abs(); 30 | } 31 | res 32 | } 33 | -------------------------------------------------------------------------------- /2042-check-if-numbers-are-ascending-in-a-sentence.rs: -------------------------------------------------------------------------------- 1 | pub fn are_numbers_ascending(s: String) -> bool { 2 | let mut tmp = 0; 3 | for token in s.split(" ") { 4 | match token.parse() { 5 | Ok(token) => { 6 | if token <= tmp { 7 | return false; 8 | } else { 9 | tmp = token; 10 | } 11 | }, 12 | Err(err) => continue, 13 | }; 14 | } 15 | true 16 | } 17 | 18 | fn main() { 19 | let s = "1 box has 3 blue 4 red 6 green and 12 yellow marbles".to_string(); 20 | println!("{:?}", are_numbers_ascending(s)); 21 | } 22 | -------------------------------------------------------------------------------- /2053-kth-distinct-string-in-an-arra.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | impl Solution { 4 | pub fn kth_distinct(arr: Vec, k: i32) -> String { 5 | use std::collections::HashMap; 6 | let mut mmp = HashMap::new(); 7 | for a in &arr { 8 | let count = mmp.entry(a).or_insert(0); 9 | *count += 1; 10 | } 11 | let mut tmp = 0; 12 | for a in &arr { 13 | if mmp[&a] == 1 { 14 | tmp += 1; 15 | } 16 | if tmp == k { 17 | return a.to_string(); 18 | } 19 | } 20 | String::new() 21 | } 22 | } 23 | 24 | fn main() { 25 | let arr: Vec = vec!["d","b","c","b","c","a"].iter().map(|e|e.to_string()).collect(); 26 | let k = 2; 27 | println!("{:?}", Solution::kth_distinct(arr, k)); 28 | } 29 | -------------------------------------------------------------------------------- /2062-count-vowel-substrings-of-a-string.rs: -------------------------------------------------------------------------------- 1 | pub fn count_vowel_substrings(word: String) -> i32 { 2 | use std::collections::HashMap; 3 | let mut ret = 0; 4 | let vowel = vec!['a', 'e', 'i', 'o', 'u']; 5 | for i in 0..word.len() { 6 | 'middle: for j in i+5..=word.len() { 7 | let mut mmp = HashMap::new(); 8 | let cs = &word[i..j].to_string().clone(); 9 | for c in cs.chars().collect::>() { 10 | if vowel.contains(&c) { 11 | let count = mmp.entry(c).or_insert(0); 12 | *count += 1; 13 | } else { 14 | continue 'middle; 15 | } 16 | } 17 | if mmp.len() == 5 { 18 | ret += 1; 19 | } 20 | } 21 | } 22 | ret 23 | } 24 | 25 | fn main() { 26 | let word = "cuaieuouac".to_string(); 27 | println!("{:?}", count_vowel_substrings(word)); 28 | } 29 | -------------------------------------------------------------------------------- /2073-time-needed-to-buy-tickets.rs: -------------------------------------------------------------------------------- 1 | pub fn time_required_to_buy(tickets: Vec, k: i32) -> i32 { 2 | let mut tickets = tickets; 3 | let mut ret = 0; 4 | while tickets[k as usize] != 0 { 5 | for i in 0..tickets.len() { 6 | if tickets[i] != 0 { 7 | tickets[i] -= 1; 8 | ret += 1; 9 | } 10 | if tickets[k as usize] == 0 { 11 | return ret 12 | } 13 | } 14 | } 15 | ret 16 | } 17 | 18 | fn main() { 19 | println!("{:?}", time_required_to_buy(vec![2,3,2], 2)); 20 | println!("{:?}", time_required_to_buy(vec![84,49,5,24,70,77,87,8], 3)); 21 | } 22 | -------------------------------------------------------------------------------- /2078-two-furthest-houses-with-different-colors.rs: -------------------------------------------------------------------------------- 1 | pub fn max_distance(colors: Vec) -> i32 { 2 | let mut res = 0; 3 | for i in 0..colors.len() { 4 | for j in (i+1)..colors.len() { 5 | let tmp = j - i; 6 | if colors[i] != colors[j] && tmp > res { 7 | res = tmp; 8 | } 9 | } 10 | } 11 | res as i32 12 | } 13 | 14 | fn main() { 15 | let colors = vec![1,1,1,6,1,1,1]; 16 | println!("{:?}", max_distance(colors)); 17 | } 18 | -------------------------------------------------------------------------------- /2089-find-target-indices-after-sorting-array.rs: -------------------------------------------------------------------------------- 1 | pub fn target_indices(nums: Vec, target: i32) -> Vec { 2 | let mut sorted_nums = nums.clone(); 3 | sorted_nums.sort(); 4 | let mut sorted_nums_vec: Vec<_> = sorted_nums.iter().enumerate().collect(); 5 | sorted_nums_vec.retain(|e|*e.1==target); 6 | sorted_nums_vec.iter().map(|e|e.0 as i32).collect() 7 | } 8 | 9 | fn main() { 10 | let nums = vec![1,2,5,2,3]; 11 | let target = 3; 12 | println!("{:?}", target_indices(nums, target)); 13 | } 14 | -------------------------------------------------------------------------------- /2108-find-first-palindromic-string-in-the-array.rs: -------------------------------------------------------------------------------- 1 | pub fn first_palindrome(words: Vec) -> String { 2 | fn is_palindrome(word: &String) -> bool { 3 | let word_chars: Vec = word.clone().chars().collect(); 4 | let word_chars_rev: Vec = word.chars().rev().collect(); 5 | word_chars == word_chars_rev 6 | } 7 | for word in words { 8 | if is_palindrome(&word) { 9 | return word; 10 | } 11 | } 12 | "".to_string() 13 | } 14 | 15 | fn main() { 16 | let words = vec!["notapalindrome".to_string(), "racescar".to_string()]; 17 | println!("{:?}", first_palindrome(words)); 18 | } 19 | -------------------------------------------------------------------------------- /2109-adding-spaces-to-a-string.rs: -------------------------------------------------------------------------------- 1 | pub fn add_spaces(s: String, spaces: Vec) -> String { 2 | let mut s = s; 3 | let mut z = 0; 4 | for space in spaces { 5 | let idx = space + z; 6 | s.insert(idx as usize, ' '); 7 | z += 1; 8 | } 9 | s 10 | } 11 | 12 | fn main() { 13 | let s = "LeetcodeHelpsMeLearn".to_string(); 14 | let spaces = vec![8,13,15]; 15 | println!("{:?}", add_spaces(s, spaces)); 16 | } 17 | -------------------------------------------------------------------------------- /2114-maximum-number-of-words-found-in-sentences.rs: -------------------------------------------------------------------------------- 1 | pub fn most_words_found(sentences: Vec) -> i32 { 2 | let arr: Vec = sentences.iter().map(|e|e.split(" ").count()).collect(); 3 | *arr.iter().max().unwrap() as i32 4 | } 5 | 6 | fn main() { 7 | let sentences: Vec = ["alice and bob love leetcode", "i think so too", "this is great thanks very much"] 8 | .iter().map(|e|e.to_string()).collect(); 9 | println!("{:?}", most_words_found(sentences)); 10 | } 11 | -------------------------------------------------------------------------------- /2119-a-number-after-a-double-reversal.rs: -------------------------------------------------------------------------------- 1 | pub fn is_same_after_reversals(num: i32) -> bool { 2 | if num == 0 { 3 | return true; 4 | } 5 | num % 10 != 0 6 | } 7 | 8 | fn main() { 9 | println!("{:?}", is_same_after_reversals()); 10 | } 11 | -------------------------------------------------------------------------------- /2124-check-if-all-as-appears-before-all-bs.rs: -------------------------------------------------------------------------------- 1 | pub fn check_string(s: String) -> bool { 2 | let s_chars: Vec = s.chars().collect(); 3 | let mut sorted: Vec = s_chars.clone(); 4 | sorted.sort(); 5 | sorted == s_chars 6 | } 7 | 8 | fn main() { 9 | let s = "aaaa".to_string(); 10 | println!("{:?}", check_string(s)); 11 | } 12 | -------------------------------------------------------------------------------- /2125-number-of-laser-beams-in-a-bank.rs: -------------------------------------------------------------------------------- 1 | pub fn number_of_beams(bank: Vec) -> i32 { 2 | let mut count_arr = vec!(); 3 | for e in bank { 4 | let count = e.matches("1").count(); 5 | if count != 0 { 6 | count_arr.push(count); 7 | } 8 | } 9 | if count_arr.iter().count() < 2 { 10 | 0 11 | } else { 12 | let mut res = 0; 13 | let index = count_arr.len() - 1; 14 | for i in 0..index { 15 | res += count_arr[i] * count_arr[i+1]; 16 | } 17 | res as i32 18 | } 19 | } 20 | 21 | fn main() { 22 | let bank: Vec = vec!["011001","000000","010100","001000"] 23 | .iter().map(|e|e.to_string()).collect(); 24 | println!("{:?}", number_of_beams(bank)); 25 | } 26 | -------------------------------------------------------------------------------- /2129-capitalize-the-title.rs: -------------------------------------------------------------------------------- 1 | // to_lowercase() 和 to_ascii_uppercase()的区别，一个是针对字符串，一个是针对字符。 2 | pub fn capitalize_title(title: String) -> String { 3 | let mut ret_arr: Vec = vec![]; 4 | for word in title.split_ascii_whitespace() { 5 | if word.len() < 3 { 6 | ret_arr.push(word.to_lowercase()); 7 | } else { 8 | let mut tmp: Vec = word.to_lowercase().chars().collect(); 9 | tmp[0] = tmp[0].to_ascii_uppercase(); 10 | ret_arr.push(tmp.iter().collect::()); 11 | } 12 | } 13 | ret_arr.join(" ") 14 | } 15 | 16 | fn main() { 17 | let title = "capiTalIze OF titLe".to_string(); 18 | println!("{:?}", capitalize_title(title)); 19 | } 20 | -------------------------------------------------------------------------------- /2133-check-if-every-row-and-column-contains-all-numbers.rs: -------------------------------------------------------------------------------- 1 | // using HashSet 2 | pub fn check_valid(matrix: Vec>) -> bool { 3 | use std::collections::HashSet; 4 | let mut set = HashSet::new(); 5 | for i in 0..matrix.len() { 6 | set.clear(); 7 | for j in 0..matrix.len() { 8 | if !set.insert(matrix[i][j]) { 9 | return false; 10 | } 11 | } 12 | } 13 | for i in 0..matrix.len() { 14 | set.clear(); 15 | for j in 0..matrix.len() { 16 | if !set.insert(matrix[j][i]) { 17 | return false; 18 | } 19 | } 20 | } 21 | true 22 | } 23 | 24 | fn main() { 25 | let matrix = vec![vec![1,2,3],vec![3,1,2],vec![2,3,1]]; 26 | println!("{:?}", check_valid(matrix)); 27 | } 28 | -------------------------------------------------------------------------------- /2138-divide-a-string-into-groups-of-size-k.rs: -------------------------------------------------------------------------------- 1 | pub fn divide_string(s: String, k: i32, fill: char) -> Vec { 2 | let mut ret = s.chars() 3 | .collect::>().chunks(k as usize) 4 | .collect::>().iter().map(|v|v.into_iter().collect::()) 5 | .collect::>(); 6 | let last_len = ret.last().unwrap().len(); 7 | let l = ret.len(); 8 | if last_len != k as usize { 9 | for _ in 0..k as usize - last_len { 10 | ret[l-1].push(fill); 11 | } 12 | } 13 | ret 14 | } 15 | 16 | fn main() { 17 | let s = "abcdefghij".to_string(); 18 | let k = 3; 19 | let fill = 'x'; 20 | println!("{:?}", divide_string(s, k, fill)); 21 | } 22 | -------------------------------------------------------------------------------- /2144-minimum-cost-of-buying-candies-with-discount.rs: -------------------------------------------------------------------------------- 1 | pub fn minimum_cost(cost: Vec) -> i32 { 2 | let mut sorted = cost.clone(); 3 | sorted.sort_by(|a, b|b.cmp(&a)); 4 | let mut ret = 0; 5 | for (i, e) in sorted.iter().enumerate() { 6 | if i % 3 == 2 { continue } 7 | ret += e; 8 | } 9 | ret 10 | } 11 | 12 | fn main() { 13 | let cost = vec![6, 5, 7, 9, 2, 2]; 14 | println!("{:?}", minimum_cost(cost)); 15 | } 16 | -------------------------------------------------------------------------------- /2148-count-elements-with-strictly-smaller-and-greater-elements.rs: -------------------------------------------------------------------------------- 1 | pub fn count_elements(nums: Vec) -> i32 { 2 | let min = *nums.iter().min().unwrap(); 3 | let max = *nums.iter().max().unwrap(); 4 | let mut ret = 0; 5 | for num in nums { 6 | if num == min { continue } 7 | if num == max { continue } 8 | ret += 1; 9 | } 10 | ret 11 | } 12 | 13 | fn main() { 14 | let nums = vec![-65,-65,50,-65,50,-55,-65,-65]; 15 | println!("{:?}", count_elements(nums)); 16 | } 17 | -------------------------------------------------------------------------------- /2149-rearrange-array-elements-by-sign.rs: -------------------------------------------------------------------------------- 1 | pub fn rearrange_array(nums: Vec) -> Vec { 2 | let mut ret = vec!(0; nums.len()); 3 | let mut tmp_pos_index = 0; 4 | let mut tmp_neg_index = 0; 5 | for n in nums { 6 | if n > 0 { 7 | ret[tmp_pos_index*2] = n; 8 | tmp_pos_index += 1; 9 | } else { 10 | ret[tmp_neg_index*2+1] = n; 11 | tmp_neg_index += 1; 12 | } 13 | } 14 | ret 15 | } 16 | 17 | fn main() { 18 | let nums = vec![3,1,-2,-5,2,-4]; 19 | println!("{:?}", rearrange_array(nums)); 20 | } 21 | -------------------------------------------------------------------------------- /2150-find-all-lonely-numbers-in-the-array.rs: -------------------------------------------------------------------------------- 1 | pub fn find_lonely(nums: Vec) -> Vec { 2 | use std::collections::HashMap; 3 | let mut mmp = HashMap::new(); 4 | for n in nums { 5 | let count = mmp.entry(n).or_insert(0); 6 | *count += 1; 7 | } 8 | let mut ret = vec!(); 9 | for (k, v) in &mmp { 10 | if *v != 1 { continue } 11 | if mmp.get(&(k-1)) != None { continue } 12 | if mmp.get(&(k+1)) != None { continue } 13 | ret.push(*k); 14 | } 15 | ret 16 | } 17 | 18 | fn main() { 19 | let nums = vec![10,6,5,8]; 20 | println!("{:?}", find_lonely(nums)); 21 | } 22 | -------------------------------------------------------------------------------- /2154-keep-multiplying-found-values-by-two.rs: -------------------------------------------------------------------------------- 1 | pub fn find_final_value(nums: Vec, original: i32) -> i32 { 2 | let mut tmp = original; 3 | loop { 4 | if nums.iter().any(|x|*x==tmp) { 5 | tmp *= 2; 6 | continue; 7 | } else { 8 | break; 9 | } 10 | } 11 | tmp 12 | } 13 | 14 | fn main() { 15 | let nums = vec![5,3,6,1,12]; 16 | let original = 3; 17 | println!("{:?}", find_final_value(nums, original)); 18 | } 19 | -------------------------------------------------------------------------------- /216-combination-sum-iii.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | // 回溯 = 递归 + 循环 4 | impl Solution { 5 | pub fn backtrace(n: i32, k: usize, start_index: i32, path: &mut Vec, ret: &mut Vec>, sum: i32) { 6 | if path.len() == k && path.iter().sum::() == sum { 7 | ret.push(path.to_vec()); 8 | return; 9 | } 10 | for i in start_index..=n { 11 | path.push(i); 12 | Self::backtrace(n, k, i+1, path, ret, sum); 13 | path.pop(); 14 | } 15 | } 16 | 17 | pub fn combination_sum3(k: i32, n: i32) -> Vec> { 18 | let mut path = vec![]; 19 | let mut ret = vec![]; 20 | Self::backtrace(9, k as usize, 1, &mut path, &mut ret, n); 21 | ret 22 | } 23 | } 24 | 25 | fn main() { 26 | println!("{:?}", Solution::combination_sum3(3, 9)); 27 | } 28 | -------------------------------------------------------------------------------- /2160-minimum-sum-of-four-digit-number-after-splitting-digits.rs: -------------------------------------------------------------------------------- 1 | pub fn minimum_sum(num: i32) -> i32 { 2 | let mut sorted_num_chars: Vec = num.to_string().chars().collect(); 3 | sorted_num_chars.sort(); 4 | let mut new1 = String::new(); 5 | let mut new2 = String::new(); 6 | println!("{:?}", sorted_num_chars); 7 | for (i, e) in sorted_num_chars.iter().enumerate() { 8 | if i % 2 == 0 { 9 | new1.push(*e); 10 | } else { 11 | new2.push(*e); 12 | } 13 | } 14 | let new1_num: i32 = new1.parse().unwrap(); 15 | let new2_num: i32 = new2.parse().unwrap(); 16 | new1_num + new2_num 17 | } 18 | 19 | fn main() { 20 | let num = 2932; 21 | println!("{:?}", minimum_sum(num)); 22 | } 23 | -------------------------------------------------------------------------------- /2164-sort-even-and-odd-indices-independently.rs: -------------------------------------------------------------------------------- 1 | pub fn sort_even_odd(nums: Vec) -> Vec { 2 | let mut odd_arr = vec!(); 3 | let mut even_arr = vec!(); 4 | let mut ret = vec!(); 5 | let half_len = nums.len() / 2 + 1; 6 | for i in 0..half_len { 7 | if nums.get(2*i).is_some() { 8 | even_arr.push(*nums.get(2*i).unwrap()); 9 | } 10 | if nums.get(2*i+1).is_some() { 11 | odd_arr.push(*nums.get(2*i+1).unwrap()); 12 | } 13 | } 14 | odd_arr.sort_by(|a, b|b.cmp(a)); 15 | even_arr.sort(); 16 | // println!("{:?} {:?}", odd_arr, even_arr); 17 | for i in 0..half_len { 18 | if even_arr.get(i).is_some() { 19 | ret.push(*even_arr.get(i).unwrap()); 20 | } 21 | if odd_arr.get(i).is_some() { 22 | ret.push(*odd_arr.get(i).unwrap()); 23 | } 24 | } 25 | ret 26 | } 27 | 28 | fn main() { 29 | let nums = vec![5,39,33,5,12,27,20,45,14,25,32,33,30,30,9,14,44,15,21] 30 | ; 31 | println!("{:?}", sort_even_odd(nums)); 32 | } 33 | -------------------------------------------------------------------------------- /2177-find-three-consecutive-integers-that-sum-to-a-given-number.rs: -------------------------------------------------------------------------------- 1 | pub fn sum_of_three(num: i64) -> Vec { 2 | if num % 3 == 0 { 3 | let middle = num / 3; 4 | vec![middle - 1, middle, middle + 1] 5 | } else { 6 | vec![] 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /2180-count-integers-with-even-digit-sum.rs: -------------------------------------------------------------------------------- 1 | // (2..num).select{|e|e.to_s.chars.map(&:to_i).sum % 2 == 0}.count 2 | 3 | pub fn count_even(num: i32) -> i32 { 4 | let mut ret = 0; 5 | for i in 2..=num { 6 | if i.to_string().chars().map(|e|e.to_string().parse::().unwrap()).sum::() % 2 == 0 { 7 | ret += 1; 8 | } 9 | } 10 | ret 11 | } 12 | 13 | fn main() { 14 | println!("{:?}", count_even(30)); 15 | } 16 | -------------------------------------------------------------------------------- /2185-counting-words-with-a-given-prefix.rs: -------------------------------------------------------------------------------- 1 | pub fn prefix_count(words: Vec, pref: String) -> i32 { 2 | let mut counter = 0; 3 | for word in words { 4 | if word.starts_with(&pref) { 5 | counter += 1; 6 | } 7 | } 8 | counter 9 | } 10 | 11 | fn main() { 12 | let words = vec!["pay","attention","practice","attend"].iter().map(|e|e.to_string()).collect(); 13 | let pref = "at".to_string(); 14 | println!("{:?}", prefix_count(words, pref)); 15 | } 16 | -------------------------------------------------------------------------------- /2194-cells-in-a-range-on-an-excel-sheet.rs: -------------------------------------------------------------------------------- 1 | pub fn cells_in_range(s: String) -> Vec { 2 | let a: Vec<_> = s.split(":").collect(); 3 | let start_alpha = a[0].chars().nth(0).unwrap(); 4 | let start_num = a[0].chars().nth(1).unwrap(); 5 | let end_alpha = a[1].chars().nth(0).unwrap(); 6 | let end_num = a[1].chars().nth(1).unwrap(); 7 | let mut ret: Vec = vec!(); 8 | for a in start_alpha..=end_alpha { 9 | for n in start_num..=end_num { 10 | let mut tmp = String::new(); 11 | tmp.push(a); 12 | tmp.push(n); 13 | ret.push(tmp); 14 | } 15 | } 16 | ret 17 | } 18 | 19 | fn main() { 20 | let s = "A1:F1".to_string(); 21 | println!("{:?}", cells_in_range(s)); 22 | } 23 | -------------------------------------------------------------------------------- /2215-find-the-difference-of-two-arrays.rs: -------------------------------------------------------------------------------- 1 | pub fn find_difference(nums1: Vec, nums2: Vec) -> Vec> { 2 | let mut nums1_uniq = nums1.clone(); 3 | let mut nums2_uniq = nums2.clone(); 4 | nums1_uniq.sort_unstable(); 5 | nums1_uniq.dedup(); 6 | nums2_uniq.sort_unstable(); 7 | nums2_uniq.dedup(); 8 | let mut ret = vec!(); 9 | nums2_uniq.retain(|x|!nums1.contains(x)); 10 | nums1_uniq.retain(|x|!nums2.contains(x)); 11 | ret.push(nums1_uniq); 12 | ret.push(nums2_uniq); 13 | ret 14 | } 15 | 16 | fn main() { 17 | let nums1 = vec![1,2,3]; 18 | let nums2 = vec![2,4,6]; 19 | println!("{:?}", find_difference(nums1, nums2)); 20 | } 21 | -------------------------------------------------------------------------------- /2243-calculate-digit-sum-of-a-string.rs: -------------------------------------------------------------------------------- 1 | pub fn digit_sum(s: String, k: i32) -> String { 2 | let mut ret = s.clone(); 3 | while ret.len() > k as usize { 4 | let mut tmp = String::new(); 5 | for ch in ret.chars().collect::>().chunks(k as usize) { 6 | let mut sum = 0; 7 | for c in ch { 8 | sum += c.to_string().parse::().unwrap(); 9 | } 10 | tmp.push_str(&sum.to_string()); 11 | } 12 | ret = tmp; 13 | } 14 | ret 15 | } 16 | 17 | fn main() { 18 | println!("{:?}", digit_sum("11111222223".to_string(), 3)); 19 | println!("{:?}", digit_sum("00000000".to_string(), 3)); 20 | } 21 | -------------------------------------------------------------------------------- /2248-intersection-of-multiple-arrays.rs: -------------------------------------------------------------------------------- 1 | pub fn intersection(nums: Vec>) -> Vec { 2 | use std::collections::HashSet; 3 | let mut ret: HashSet = HashSet::new(); 4 | for i in &nums[0] { 5 | ret.insert(*i); 6 | } 7 | for a in &nums[1..] { 8 | let mut tmp: HashSet = HashSet::new(); 9 | for i in a { 10 | tmp.insert(*i); 11 | } 12 | let mut t: HashSet = HashSet::new(); 13 | for x in ret.intersection(&tmp) { 14 | t.insert(*x); 15 | } 16 | ret = t; 17 | } 18 | let mut ret = ret.into_iter().collect::>(); 19 | ret.sort(); 20 | ret 21 | } 22 | 23 | fn main() { 24 | let nums = vec![vec![3,1,2,4,5], vec![1,2,3,4], vec![3,4,5,6]]; 25 | println!("{:?}", intersection(nums)); 26 | } 27 | -------------------------------------------------------------------------------- /225-implement-stack-using-queues.rs: -------------------------------------------------------------------------------- 1 | struct MyStack { 2 | stack_box: Vec 3 | } 4 | 5 | impl MyStack { 6 | fn new() -> Self { 7 | MyStack { 8 | stack_box: vec!() 9 | } 10 | } 11 | 12 | fn push(&mut self, x: i32) { 13 | self.stack_box.push(x); 14 | } 15 | 16 | fn pop(&mut self) -> i32 { 17 | let index = self.stack_box.len()-1; 18 | let ret = self.stack_box[index]; 19 | self.stack_box.remove(index); 20 | ret 21 | } 22 | 23 | fn top(&self) -> i32 { 24 | *self.stack_box.last().unwrap() 25 | } 26 | 27 | fn empty(&self) -> bool { 28 | self.stack_box.len() == 0 29 | } 30 | } 31 | 32 | fn main() { 33 | let mut obj = MyStack::new(); 34 | obj.push(1); 35 | obj.push(2); 36 | obj.push(3); 37 | let ret_2: i32 = obj.pop(); 38 | let ret_3: i32 = obj.top(); 39 | let ret_4: bool = obj.empty(); 40 | println!("{:?} {:?} {:?}", ret_2, ret_3, ret_4); 41 | } 42 | -------------------------------------------------------------------------------- /2264-largest-3-same-digit-number-in-string.rs: -------------------------------------------------------------------------------- 1 | pub fn largest_good_integer(num: String) -> String { 2 | pub fn is_good(s: &str) -> bool { 3 | let mut tmp = vec!(); 4 | for c in s.chars() { 5 | tmp.push(c); 6 | } 7 | tmp.sort_unstable(); 8 | tmp.dedup(); 9 | tmp.len() == 1 10 | } 11 | let mut sta = -1; 12 | let mut ret = String::new(); 13 | for i in 0..num.len()-2 { 14 | let tmp = &num[i..i+3]; 15 | let n = tmp.parse::().unwrap(); 16 | if is_good(tmp) && n > sta { 17 | sta = n; 18 | ret = tmp.to_string(); 19 | } 20 | } 21 | ret 22 | } 23 | 24 | fn main() { 25 | let num = "2300019".to_string(); 26 | println!("{:?}", largest_good_integer(num)); 27 | } 28 | -------------------------------------------------------------------------------- /2278-percentage-of-letter-in-string.rs: -------------------------------------------------------------------------------- 1 | pub fn percentage_letter(s: String, letter: char) -> i32 { 2 | let mut counter = 0; 3 | for c in s.chars().collect::>() { 4 | if c == letter { 5 | counter += 1 6 | } 7 | } 8 | (100.0 * counter as f64 / s.len() as f64) as i32 9 | } 10 | 11 | fn main() { 12 | println!("{:?}", percentage_letter("foobar".to_string(), 'o')); 13 | } 14 | -------------------------------------------------------------------------------- /228-summary-ranges.rs: -------------------------------------------------------------------------------- 1 | pub fn summary_ranges(nums: Vec) -> Vec { 2 | let mut ret = vec!(); 3 | if nums.len() == 0 { 4 | return ret; 5 | } 6 | pub fn assemble(current: Vec) -> String { 7 | if current.len() == 1 { 8 | current[0].to_string() 9 | } else { 10 | let f = current.first().unwrap().to_string(); 11 | let l = current.last().unwrap().to_string(); 12 | vec!(f, "->".to_string(), l).join("") 13 | } 14 | } 15 | let mut prev = nums[0]; 16 | let mut current = vec!(prev); 17 | for num in &nums[1..] { 18 | if num - prev != 1 { 19 | ret.push(assemble(current)); 20 | current = vec!(*num); 21 | } else { 22 | current.push(*num); 23 | } 24 | prev = *num; 25 | } 26 | ret.push(assemble(current)); 27 | ret 28 | } 29 | 30 | fn main() { 31 | let nums = vec![]; 32 | println!("{:?}", summary_ranges(nums)); 33 | } 34 | -------------------------------------------------------------------------------- /2287-rearrange-characters-to-make-target-string.rs: -------------------------------------------------------------------------------- 1 | pub fn rearrange_characters(s: String, target: String) -> i32 { 2 | use std::collections::HashMap; 3 | let mut s_mmp = HashMap::new(); 4 | let mut target_mmp = HashMap::new(); 5 | for c in s.chars() { 6 | let count = s_mmp.entry(c).or_insert(0); 7 | *count += 1; 8 | } 9 | for c in target.chars() { 10 | let count = target_mmp.entry(c).or_insert(0); 11 | *count += 1; 12 | } 13 | let mut arr = vec!(); 14 | for (k, v) in target_mmp { 15 | let tmp = s_mmp.get(&k); 16 | if tmp.is_some() { 17 | arr.push(tmp.unwrap()/v); 18 | } else { 19 | arr.push(0); 20 | } 21 | } 22 | *arr.iter().min().unwrap() 23 | } 24 | 25 | fn main() { 26 | let s = "abcd".to_string(); 27 | let target = "abcd".to_string(); 28 | println!("{:?}", rearrange_characters(s, target)); 29 | } 30 | -------------------------------------------------------------------------------- /2293-min-max-game.rs: -------------------------------------------------------------------------------- 1 | pub fn min_max_game(nums: Vec) -> i32 { 2 | let mut nums = nums.clone(); 3 | while nums.len() > 1 { 4 | let nums_chunks = nums.chunks(2); 5 | let mut tmp = vec!(); 6 | for (i, chunk) in nums_chunks.enumerate() { 7 | if i % 2 == 0 { 8 | tmp.push(*chunk.iter().min().unwrap()); 9 | } else { 10 | tmp.push(*chunk.iter().max().unwrap()); 11 | } 12 | } 13 | nums = tmp; 14 | } 15 | nums[0] 16 | } 17 | 18 | fn main() { 19 | let nums = vec![1,3,5,2,4,8,2,2]; 20 | println!("{:?}", min_max_game(nums)); 21 | } 22 | -------------------------------------------------------------------------------- /2294-partition-array-such-that-maximum-difference-is-k.rs: -------------------------------------------------------------------------------- 1 | pub fn partition_array(nums: Vec, k: i32) -> i32 { 2 | let mut sorted_nums = nums.clone(); 3 | sorted_nums.sort(); 4 | let mut ret = 1; 5 | let mut tmp = vec![sorted_nums[0]]; 6 | for num in &sorted_nums[1..] { 7 | if num - tmp[0] > k { 8 | tmp = vec![*num]; 9 | ret += 1; 10 | } else { 11 | tmp.push(*num); 12 | } 13 | } 14 | ret 15 | } 16 | 17 | fn main() { 18 | println!("{:?}", partition_array(vec![3, 6, 1, 2, 5], 2)); 19 | println!("{:?}", partition_array(vec![1, 2, 3], 1)); 20 | println!("{:?}", partition_array(vec![2, 2, 4, 5], 0)); 21 | } 22 | -------------------------------------------------------------------------------- /2303-calculate-amount-paid-in-taxes.rs: -------------------------------------------------------------------------------- 1 | pub fn calculate_tax(brackets: Vec>, income: i32) -> f64 { 2 | let mut ret = 0.0_f64; 3 | let mut prev = 0.0_f64; 4 | let mut left_income: f64 = income.into(); 5 | for b in brackets { 6 | if left_income <= 0.0 { break } 7 | if left_income > b[0] as f64 - prev { 8 | ret += ( b[0] as f64 - prev ) * b[1] as f64/ 100.0_f64; 9 | left_income -= b[0] as f64 - prev; 10 | prev = b[0] as f64; 11 | } else { 12 | ret += left_income * b[1] as f64 / 100.0_f64; 13 | break; 14 | } 15 | } 16 | ret 17 | } 18 | 19 | fn main() { 20 | let brackets = vec![vec![3,50], vec![7,10], vec![12,25]]; 21 | let income = 10; 22 | println!("{:?}", calculate_tax(brackets, income)); 23 | } 24 | -------------------------------------------------------------------------------- /2309-greatest-english-letter-in-upper-and-lower-case.rs: -------------------------------------------------------------------------------- 1 | pub fn greatest_letter(s: String) -> String { 2 | use std::collections::HashMap; 3 | let mut s_chars = s.chars().collect::>(); 4 | s_chars.sort_unstable(); 5 | s_chars.dedup(); 6 | let mut mmp = HashMap::new(); 7 | let mut ret = '0'; 8 | for c in s_chars { 9 | let cu = c.to_ascii_uppercase(); 10 | let count = mmp.entry(cu).or_insert(0); 11 | *count += 1; 12 | if *count > 1 && cu > ret { ret = cu } 13 | } 14 | if ret == '0' { return String::new() } 15 | ret.to_string() 16 | } 17 | 18 | fn main() { 19 | println!("{:?}", greatest_letter("AbCdEfGhIjK".to_string())); 20 | } 21 | -------------------------------------------------------------------------------- /2315-count-asterisks.rs: -------------------------------------------------------------------------------- 1 | pub fn count_asterisks(s: String) -> i32 { 2 | let mut outside = true; 3 | let mut tmp_s = String::new(); 4 | for c in s.chars() { 5 | if outside { 6 | if c != '|' { 7 | tmp_s.push(c); 8 | } else { 9 | outside = false; 10 | } 11 | } else { 12 | if c == '|' { 13 | outside = true; 14 | } 15 | } 16 | } 17 | tmp_s.matches(|c|c=='*').count() as i32 18 | } 19 | 20 | fn main() { 21 | println!("{:?}",count_asterisks("yo|uar|e**|b|e***au|tifu|l".to_string())); 22 | } 23 | -------------------------------------------------------------------------------- /232-implement-queue-using-stacks.rs: -------------------------------------------------------------------------------- 1 | struct MyQueue { 2 | v: Vec 3 | } 4 | 5 | impl MyQueue { 6 | 7 | fn new() -> Self { 8 | MyQueue { 9 | v: vec!() 10 | } 11 | } 12 | 13 | fn push(&mut self, x: i32) { 14 | self.v.push(x); 15 | } 16 | 17 | fn pop(&mut self) -> i32 { 18 | let ret = self.v[0]; 19 | self.v.remove(0); 20 | ret 21 | } 22 | 23 | fn peek(&self) -> i32 { 24 | self.v[0] 25 | } 26 | 27 | fn empty(&self) -> bool { 28 | self.v.len() == 0 29 | } 30 | } 31 | 32 | fn main() { 33 | let mut obj = MyQueue::new(); 34 | obj.push(1); 35 | obj.push(2); 36 | let ret_2: i32 = obj.pop(); 37 | let ret_3: i32 = obj.peek(); 38 | let ret_4: bool = obj.empty(); 39 | println!(" {:?} {:?} {:?}", ret_2, ret_3, ret_4); 40 | } 41 | -------------------------------------------------------------------------------- /23350-minimum-amount-of-time-to-fill-cups.rs: -------------------------------------------------------------------------------- 1 | pub fn fill_cups(amount: Vec) -> i32 { 2 | let mut sort_am = amount.clone(); 3 | sort_am.sort(); 4 | if sort_am[2] >= sort_am[0] + sort_am[1] { 5 | // return amount[0] + amount[1] + amount[2] - (amount[0] + amount[1]) 6 | sort_am[2] 7 | } else { 8 | let mut ret = sort_am[2]; 9 | let left = sort_am[0] + sort_am[1] - sort_am[2]; 10 | if left % 2 == 0 { 11 | ret += left / 2 12 | } else { 13 | ret += left / 2 + 1 14 | } 15 | ret 16 | } 17 | } 18 | 19 | fn main() { 20 | println!("{:?}", fill_cups(vec![1,4,2])); 21 | println!("{:?}", fill_cups(vec![5,4,4])); 22 | println!("{:?}", fill_cups(vec![3,4,5])); 23 | println!("{:?}", fill_cups(vec![5,0,0])); 24 | } 25 | -------------------------------------------------------------------------------- /2341-maximum-number-of-pairs-in-array.rs: -------------------------------------------------------------------------------- 1 | pub fn number_of_pairs(nums: Vec) -> Vec { 2 | use std::collections::HashMap; 3 | let mut mmp = HashMap::new(); 4 | let nums_len = nums.len(); 5 | for n in nums { 6 | mmp.entry(n).and_modify(|e|*e += 1).or_insert(1); 7 | } 8 | let mut a = 0; 9 | for (_, v) in mmp { 10 | a += v % 2; 11 | } 12 | vec!((nums_len as i32 - a) / 2, a) 13 | } 14 | 15 | fn main() { 16 | println!("{:?}", number_of_pairs(vec![1,3,2,1,3,2,2])); 17 | println!("{:?}", number_of_pairs(vec![1,1])); 18 | println!("{:?}", number_of_pairs(vec![0])); 19 | } 20 | -------------------------------------------------------------------------------- /238-product-of-array-except-self.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | impl Solution { 4 | pub fn product_except_self(nums: Vec) -> Vec { 5 | let mut ret = vec!(0; nums.len()); 6 | let mut left = vec!(0; nums.len()); 7 | let mut right = vec!(0; nums.len()); 8 | left[0] = 1; 9 | right[nums.len()-1] = 1; 10 | for i in 1..nums.len() { 11 | left[i] = nums[i-1] * left[i-1]; 12 | } 13 | println!("{:?}", left); 14 | for j in (0..(nums.len()-1)).rev() { 15 | right[j] = nums[j+1] * right[j+1]; 16 | } 17 | println!("{:?}", right); 18 | for i in 0..nums.len() { 19 | ret[i] = left[i] * right[i]; 20 | } 21 | ret 22 | } 23 | } 24 | 25 | fn main() { 26 | let nums = vec![1,2,3,4]; 27 | println!("{:?}", Solution::product_except_self(nums)); 28 | } 29 | -------------------------------------------------------------------------------- /2389-longest-subsequence-with-limited-sum.rs: -------------------------------------------------------------------------------- 1 | pub fn answer_queries(nums: Vec, queries: Vec) -> Vec { 2 | fn cal(q: i32, sorted_nums: &[i32]) -> i32 { 3 | let mut sum = 0; 4 | for (i, n) in sorted_nums.iter().enumerate() { 5 | sum += n; 6 | if sum > q { 7 | return i as i32 8 | } 9 | } 10 | sorted_nums.len() as i32 11 | } 12 | let mut sorted_nums = nums.clone(); 13 | sorted_nums.sort(); 14 | queries.iter().map(|e|cal(*e, &sorted_nums)).collect() 15 | } 16 | 17 | fn main() { 18 | let nums = vec![4,5,2,1]; 19 | let queries = vec![3,10,21]; 20 | println!("{:?}", answer_queries(nums, queries)); 21 | } 22 | -------------------------------------------------------------------------------- /2390-removing-stars-from-a-string.rs: -------------------------------------------------------------------------------- 1 | pub fn remove_stars(s: String) -> String { 2 | let mut ret = String::new(); 3 | for c in s.chars().collect::>() { 4 | if c == '*' { ret.pop(); } else { ret.push(c); } 5 | } 6 | ret 7 | } 8 | 9 | fn main() { 10 | println!("{:?}", remove_stars("leet**cod*e".to_string())); 11 | } 12 | -------------------------------------------------------------------------------- /242-valid-anagram.rs: -------------------------------------------------------------------------------- 1 | pub fn is_anagram(s: String, t: String) -> bool { 2 | let mut a = s.chars().collect::>(); 3 | let mut b = t.chars().collect::>(); 4 | a.sort(); 5 | b.sort(); 6 | a == b 7 | } 8 | 9 | fn main() { 10 | let s = "rat".to_string(); 11 | let t = "car".to_string(); 12 | println!("{:?}", is_anagram(s, t)); 13 | } 14 | -------------------------------------------------------------------------------- /2455-average-value-of-even-numbers-that-are-divisible-by-three.rs: -------------------------------------------------------------------------------- 1 | pub fn average_value(nums: Vec) -> i32 { 2 | let mut nums = nums; 3 | nums.retain(|num| { num % 6 == 0 }); 4 | (nums.iter().sum::() as f64 / nums.len() as f64).floor() as i32 5 | } 6 | 7 | fn main() { 8 | println!("{:?}", average_value(vec![1,3,6,10,12,15])); 9 | println!("{:?}", average_value(vec![1,2,4,7,10])); 10 | } 11 | -------------------------------------------------------------------------------- /2460-apply-operations-to-an-array.rs: -------------------------------------------------------------------------------- 1 | pub fn apply_operations(nums: Vec) -> Vec { 2 | let mut none_zero = vec![]; 3 | let mut zero = vec![]; 4 | let mut nums_clone = nums.clone(); 5 | for i in 0 .. nums.len() { 6 | if nums_clone[i] == 0 { 7 | zero.push(0); 8 | continue 9 | } 10 | if i + 1 < nums.len() && nums[i] == nums[i + 1] { 11 | nums_clone[i] *= 2; 12 | nums_clone[i + 1] = 0 13 | } 14 | none_zero.push(nums_clone[i]); 15 | } 16 | [none_zero, zero].concat() 17 | } 18 | 19 | fn main() { 20 | println!("{:?}", apply_operations(vec![1, 2, 2, 1, 1, 0])); 21 | println!("{:?}", apply_operations(vec![847,847,0,0,0,399,416,416,879,879,206,206,206,272])); 22 | println!("{:?}", apply_operations(vec![0, 1])); 23 | 24 | } 25 | -------------------------------------------------------------------------------- /2490-circular-sentence.rs: -------------------------------------------------------------------------------- 1 | pub fn is_circular_sentence(sentence: String) -> bool { 2 | if sentence.chars().nth(0).unwrap() != 3 | sentence.chars().nth(sentence.len() - 1).unwrap() { 4 | return false 5 | } 6 | let mut count = 0; 7 | let mut prev_char: char = '?'; 8 | for word in sentence.split_ascii_whitespace() { 9 | if count == 0 { 10 | prev_char = word.chars().last().unwrap() 11 | } else { 12 | let curr_char = word.chars().nth(0).unwrap(); 13 | if curr_char != prev_char { return false } 14 | prev_char = word.chars().last().unwrap(); 15 | } 16 | count += 1 17 | } 18 | true 19 | } 20 | 21 | fn main() { 22 | let sentence = "leetcode exercises sound delightful".to_string(); 23 | println!("{:?}", is_circular_sentence(sentence)); 24 | let sentence = "eetcode".to_string(); 25 | println!("{:?}", is_circular_sentence(sentence)); 26 | } 27 | -------------------------------------------------------------------------------- /258-add-digits.rs: -------------------------------------------------------------------------------- 1 | pub fn add_digits(num: i32) -> i32 { 2 | let mut sum = num; 3 | while sum >= 10 { 4 | let arr: Vec = sum.to_string().chars().collect(); 5 | sum = arr.iter().map(|e|*e as i32 - '0' as i32).sum(); 6 | } 7 | sum 8 | } 9 | 10 | fn main() { 11 | println!("{:?}", add_digits(38)); 12 | } 13 | -------------------------------------------------------------------------------- /260-single-number-iii.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | impl Solution { 4 | pub fn single_number(nums: Vec) -> Vec { 5 | use std::collections::HashMap; 6 | let mut mmp = HashMap::new(); 7 | for num in nums { 8 | let count = mmp.entry(num).or_insert(0); 9 | *count += 1; 10 | } 11 | mmp.retain(|_, v|*v==1); 12 | mmp.into_keys().collect::>() 13 | } 14 | } 15 | 16 | fn main() { 17 | let nums = vec![1,2,1,3,2,5]; 18 | println!("{:?}", Solution::single_number(nums)); 19 | } 20 | -------------------------------------------------------------------------------- /268-missing-number.rs: -------------------------------------------------------------------------------- 1 | pub fn missing_number(nums: Vec) -> i32 { 2 | let mut n: Vec<_> = (0..=nums.len()).map(usize::from).collect(); 3 | n.retain(|e|!nums.contains(&(*e as i32))); 4 | *n.first().unwrap() as i32 5 | } 6 | 7 | fn main() { 8 | let nums = vec![3,0,1]; 9 | println!("{:?}", missing_number(nums)); 10 | } 11 | -------------------------------------------------------------------------------- /283-move-zeroes.rs: -------------------------------------------------------------------------------- 1 | // 跟紧接着不为0的数字互换 2 | pub fn move_zeroes(nums: &mut Vec) { 3 | for i in 0..nums.len() { 4 | for j in i..nums.len() { 5 | if nums[i] == 0 && nums[j] != 0 { nums.swap(i, j) } 6 | } 7 | } 8 | } 9 | 10 | fn main() { 11 | let mut nums = vec![1, 0, 0, 4, 3, 12]; 12 | move_zeroes(&mut nums); 13 | println!("{:?}", nums); 14 | let mut nums = vec![1, 0, 0, 0, 1]; 15 | move_zeroes(&mut nums); 16 | println!("{:?}", nums); 17 | } 18 | -------------------------------------------------------------------------------- /29-divide-two-integers.rs: -------------------------------------------------------------------------------- 1 | struct Solution { 2 | 3 | } 4 | 5 | impl Solution { 6 | pub fn divide(dividend: i32, divisor: i32) -> i32 { 7 | if dividend == -2147483648 && divisor == -1 { 8 | 2147483647 9 | } else { 10 | dividend / divisor 11 | } 12 | } 13 | } 14 | 15 | fn main() { 16 | println!("{:?}", Solution::divide(10, 3)); 17 | } 18 | -------------------------------------------------------------------------------- /338-counting-bits.rs: -------------------------------------------------------------------------------- 1 | // 示例 2： 2 | 3 | // 输入：n = 5 4 | // 输出：[0,1,1,2,1,2] 5 | // 解释： 6 | // 0 --> 0 7 | // 1 --> 1 8 | // 2 --> 10 9 | // 3 --> 11 10 | // 4 --> 100 11 | // 5 --> 101 12 | 13 | // 来源：力扣（LeetCode） 14 | // 链接：https://leetcode-cn.com/problems/counting-bits 15 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 16 | 17 | pub fn count_bits(n: i32) -> Vec { 18 | (0..n+1).map(|i|{ 19 | let b_vec: Vec = format!("{:b}", i).chars().collect(); 20 | b_vec.iter().filter(|e|**e=='1').count() as i32 21 | }).collect() 22 | } 23 | 24 | fn main() { 25 | println!("{:?}", count_bits(5)); 26 | } 27 | -------------------------------------------------------------------------------- /345-reverse-vowels-of-a-string.rs: -------------------------------------------------------------------------------- 1 | pub fn reverse_vowels(s: String) -> String { 2 | let cs = s.chars().collect::>(); 3 | let mut cs_clone = cs.clone(); 4 | let vowels = vec!('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'); 5 | let mut vowels_idx = vec!(); 6 | let mut vowels_rev = vec!(); 7 | for (i, c) in cs.iter().enumerate() { 8 | if vowels.contains(&c) { 9 | vowels_idx.push(i); 10 | vowels_rev.push(c); 11 | } 12 | } 13 | vowels_rev.reverse(); 14 | for (i, c) in vowels_rev.iter().enumerate() { 15 | cs_clone[vowels_idx[i]] = **c; 16 | } 17 | cs_clone.iter().collect() 18 | } 19 | 20 | fn main() { 21 | println!("{:?}", reverse_vowels("leetcode".to_string())); 22 | println!("{:?}", reverse_vowels("hello".to_string())); 23 | } 24 | -------------------------------------------------------------------------------- /347-top-k-frequent-elements.rs: -------------------------------------------------------------------------------- 1 | pub fn top_k_frequent(nums: Vec, k: i32) -> Vec { 2 | use std::collections::HashMap; 3 | let mut mmp = HashMap::new(); 4 | for num in nums { 5 | let count = mmp.entry(num).or_insert(0); 6 | *count += 1; 7 | } 8 | let mut mv = mmp.iter().collect::>(); 9 | mv.sort_by(|a, b|b.1.cmp(&a.1)); 10 | mv[0..k as usize].into_iter().map(|e|*e.0).collect() 11 | } 12 | 13 | fn main() { 14 | let nums = vec![1, 1, 1, 2, 2, 3]; 15 | let k = 2; 16 | println!("{:?}", top_k_frequent(nums, k)); 17 | println!("{:?}", top_k_frequent(vec![4,1,-1,2,-1,2,3], 2)); 18 | } 19 | -------------------------------------------------------------------------------- /352-data-stream-as-disjoint-intervals.rs: -------------------------------------------------------------------------------- 1 | use std::cmp; 2 | struct SummaryRanges { 3 | set: std::collections::BTreeSet<(i32, i32)>, 4 | } 5 | 6 | impl SummaryRanges { 7 | 8 | fn new() -> Self { 9 | SummaryRanges { 10 | set: std::collections::BTreeSet::new(), 11 | } 12 | } 13 | 14 | fn add_num(&mut self, val: i32) { 15 | let mut new = (val, val); 16 | let l = *self.set.range(..(val, val)).last().unwrap_or(&new); 17 | let r= *self.set.range((val, val)..).next().unwrap_or(&new); 18 | if l.1 >= val - 1 { 19 | new = (l.0, cmp::max(val, l.1)); 20 | self.set.remove(&l); 21 | } 22 | if r.0 <= val + 1 && new.1 < r.1 { 23 | new.1 = r.1; 24 | self.set.remove(&r); 25 | } 26 | self.set.insert(new); 27 | } 28 | 29 | fn get_intervals(&self) -> Vec> { 30 | self.set.iter().map(|(l, r)| vec![*l, *r]).collect() 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /384-shuffle-an-array.rs: -------------------------------------------------------------------------------- 1 | use std::time::{SystemTime, UNIX_EPOCH}; 2 | struct Solution { 3 | nums: Vec 4 | } 5 | impl Solution { 6 | fn new(nums: Vec) -> Self { 7 | Self { nums } 8 | } 9 | fn reset(&self) -> Vec { 10 | self.nums.clone() 11 | } 12 | fn shuffle(&self) -> Vec { 13 | let mut nums = self.nums.clone(); 14 | let mut n = nums.len() as u128; 15 | while n > 1 { 16 | let m = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos() % n; 17 | nums.swap(m as usize, n as usize - 1); 18 | n -= 1; 19 | } 20 | nums 21 | } 22 | } 23 | 24 | fn main() { 25 | let nums = vec![1, 2, 3]; 26 | let obj = Solution::new(nums); 27 | let ret_1: Vec = obj.reset(); 28 | println!("{:?}", ret_1); 29 | let ret_2: Vec = obj.shuffle(); 30 | println!("{:?}", ret_2); 31 | let ret_3: Vec = obj.reset(); 32 | println!("{:?}", ret_3); 33 | } 34 | -------------------------------------------------------------------------------- /387-first-unique-character-in-a-string.rs: -------------------------------------------------------------------------------- 1 | pub fn first_uniq_char(s: String) -> i32 { 2 | use std::collections::HashMap; 3 | let mut mmp = HashMap::new(); 4 | for (i, c) in s.chars().enumerate() { 5 | mmp.entry(c).or_insert(Vec::new()).push(i); 6 | } 7 | mmp.retain(|_, v|v.len() == 1); 8 | if mmp.len() > 0 { 9 | mmp.into_values().map(|e|e[0]).min().unwrap() as i32 10 | } else { 11 | -1 12 | } 13 | } 14 | 15 | fn main() { 16 | println!("{:?}", first_uniq_char("ccbb".to_string())); 17 | } 18 | -------------------------------------------------------------------------------- /389-find-the-difference.rs: -------------------------------------------------------------------------------- 1 | pub fn find_the_difference(s: String, t: String) -> char { 2 | use std::collections::HashMap; 3 | let mut chars_map = HashMap::new(); 4 | for c in s.chars() { 5 | let counter = chars_map.entry(c).or_insert(0); 6 | *counter += 1; 7 | } 8 | for c in t.chars() { 9 | let counter = chars_map.entry(c).or_insert(0); 10 | *counter -= 1; 11 | } 12 | chars_map.retain(|_, v| v == &-1); 13 | *chars_map.keys().nth(0).unwrap() 14 | } 15 | 16 | fn main() { 17 | let s = "abcd".to_string(); 18 | let t = "abcde".to_string(); 19 | println!("{:?}", find_the_difference(s, t)); 20 | } 21 | -------------------------------------------------------------------------------- /412-fizz-buzz.rs: -------------------------------------------------------------------------------- 1 | // 给你一个整数 n ，找出从 1 到 n 各个整数的 Fizz Buzz 表示，并用字符串数组 answer（下标从 1 开始）返回结果，其中： 2 | 3 | // answer[i] == "FizzBuzz" 如果 i 同时是 3 和 5 的倍数。 4 | // answer[i] == "Fizz" 如果 i 是 3 的倍数。 5 | // answer[i] == "Buzz" 如果 i 是 5 的倍数。 6 | // answer[i] == i 如果上述条件全不满足。 7 | //   8 | 9 | // 示例 1： 10 | 11 | // 输入：n = 3 12 | // 输出：["1","2","Fizz"] 13 | 14 | // 来源：力扣（LeetCode） 15 | // 链接：https://leetcode-cn.com/problems/fizz-buzz 16 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 17 | 18 | fn main() { 19 | println!("{:?}", fizz_buzz(3)); 20 | } 21 | 22 | pub fn fizz_buzz(n: i32) -> Vec { 23 | let mut res = vec!(); 24 | for i in 1..n+1 { 25 | if i % 15 == 0 { 26 | res.push("FizzBuzz".to_string()); 27 | } else if i % 3 == 0 { 28 | res.push("Fizz".to_string()); 29 | } else if i % 5 == 0 { 30 | res.push("Buzz".to_string()); 31 | } else { 32 | res.push(i.to_string()); 33 | } 34 | } 35 | res 36 | } 37 | -------------------------------------------------------------------------------- /413-arithmetic-slices.rs: -------------------------------------------------------------------------------- 1 | pub fn number_of_arithmetic_slices(nums: Vec) -> i32 { 2 | if nums.len() < 3 { return 0; } 3 | pub fn is_arithmetic(nums: &[i32]) -> bool { 4 | let minus = nums[1] - nums[0]; 5 | for i in 2..nums.len() { 6 | if nums[i] - nums[i-1] != minus { return false; } 7 | } 8 | true 9 | } 10 | let mut ret = 0; 11 | for length in 3..=nums.len() { 12 | for i in 0..=nums.len() - length { 13 | if is_arithmetic(&nums[i..i+length]) { ret += 1; } 14 | } 15 | } 16 | ret 17 | } 18 | 19 | fn main() { 20 | println!("{:?}", number_of_arithmetic_slices(vec![1, 2, 3, 4])); 21 | } 22 | -------------------------------------------------------------------------------- /434-number-of-segments-in-a-string.rs: -------------------------------------------------------------------------------- 1 | pub fn count_segments(s: String) -> i32 { 2 | s.split_ascii_whitespace().count() as i32 3 | } 4 | 5 | fn main() { 6 | println!("{:?}", count_segments("s Hello, my name is John".to_string())); 7 | } 8 | -------------------------------------------------------------------------------- /442-find-all-duplicates-in-an-array.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | impl Solution { 4 | pub fn find_duplicates(nums: Vec) -> Vec { 5 | use std::collections::HashMap; 6 | let mut mmp = HashMap::new(); 7 | for num in nums { 8 | let count = mmp.entry(num).or_insert(0); 9 | *count += 1; 10 | } 11 | mmp.retain(|_, v|v > &mut 1); 12 | mmp.into_keys().collect::>() 13 | } 14 | } 15 | 16 | fn main() { 17 | let nums = vec![4,3,2,7,8,2,3,1]; 18 | println!("{:?}", Solution::find_duplicates(nums)); 19 | } 20 | -------------------------------------------------------------------------------- /448-find-all-numbers-disappeared-in-an-array.rs: -------------------------------------------------------------------------------- 1 | pub fn find_disappeared_numbers(nums: Vec) -> Vec { 2 | use std::collections::HashMap; 3 | let mut mmp = HashMap::new(); 4 | for i in 1..=nums.len() { 5 | mmp.entry(i as i32).or_insert(0); 6 | } 7 | for i in nums { 8 | let count = mmp.entry(i).or_insert(0); 9 | *count += 1; 10 | } 11 | mmp.retain(|_, v|*v==0); 12 | mmp.into_keys().collect::>() 13 | } 14 | 15 | fn main() { 16 | let nums = vec![4,3,2,7,8,2,3,1]; 17 | println!("{:?}", find_disappeared_numbers(nums)); 18 | } 19 | -------------------------------------------------------------------------------- /451-sort-characters-by-frequency.rs: -------------------------------------------------------------------------------- 1 | pub fn frequency_sort(s: String) -> String { 2 | use std::collections::HashMap; 3 | let mut count_map: HashMap> = HashMap::new(); 4 | for c in s.chars() { 5 | count_map.entry(c).or_insert(Vec::new()).push(c); 6 | } 7 | let mut count_vec: Vec<_> = count_map.iter().collect(); 8 | count_vec.sort_by(|b, a|a.1.len().cmp(&b.1.len())); 9 | let mut res = String::new(); 10 | for e in count_vec { 11 | for c in e.1 { 12 | res.push(*c); 13 | } 14 | } 15 | res 16 | } 17 | 18 | fn main() { 19 | let s = "Aabb".to_string(); 20 | println!("{:?}", frequency_sort(s)); 21 | } 22 | -------------------------------------------------------------------------------- /46-permutations.rs: -------------------------------------------------------------------------------- 1 | // backtrace 公式 2 | // result = [] 3 | // def backtrack(路径, 选择列表): 4 | // if 满足结束条件: 5 | // result.add(路径) 6 | // return 7 | 8 | // for 选择 in 选择列表: 9 | // 做选择 10 | // backtrack(路径, 选择列表) 11 | // 撤销选择 12 | 13 | struct Solution; 14 | 15 | impl Solution { 16 | pub fn permute(mut path: Vec) -> Vec> { 17 | let mut ret = vec![]; 18 | Self::backtrack(&mut path, &mut ret, 0); 19 | ret 20 | } 21 | 22 | fn backtrack(path: &mut Vec, ans: &mut Vec>, begin: usize) { 23 | if begin == path.len() { 24 | ans.push(path.to_vec()); 25 | return; 26 | } 27 | 28 | for i in begin..path.len() { 29 | path.swap(i, begin); 30 | Self::backtrack(path, ans, begin + 1); 31 | path.swap(i, begin); 32 | } 33 | } 34 | } 35 | 36 | fn main() { 37 | let nums = vec![1, 2, 3]; 38 | println!("{:?}", Solution::permute(nums)); 39 | } 40 | -------------------------------------------------------------------------------- /461-hamming-distance.rs: -------------------------------------------------------------------------------- 1 | // 两个整数之间的 汉明距离 指的是这两个数字对应二进制位不同的位置的数目。 2 | 3 | // 给你两个整数 x 和 y，计算并返回它们之间的汉明距离。 4 | 5 | // 示例 1： 6 | 7 | // 输入：x = 1, y = 4 8 | // 输出：2 9 | // 解释： 10 | // 1 (0 0 0 1) 11 | // 4 (0 1 0 0) 12 | // ↑ ↑ 13 | // 上面的箭头指出了对应二进制位不同的位置。 14 | 15 | // 来源：力扣（LeetCode） 16 | // 链接：https://leetcode-cn.com/problems/hamming-distance 17 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 18 | 19 | fn main() { 20 | println!("{:?}", hamming_distance(1, 3)); 21 | } 22 | 23 | pub fn hamming_distance(x: i32, y: i32) -> i32 { 24 | let x = format!("{:#064b}", x); 25 | let y = format!("{:#064b}", y); 26 | let x_chars: Vec = x.chars().collect(); // i32 转 2进制string 转 Vec 才好处理 27 | let y_chars: Vec = y.chars().collect(); 28 | let mut counter = 0; 29 | for i in 0..64 { 30 | if x_chars[i] != y_chars[i] { 31 | counter += 1; 32 | } 33 | } 34 | counter 35 | } 36 | -------------------------------------------------------------------------------- /476-number-complement.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：num = 5 4 | // 输出：2 5 | // 解释：5 的二进制表示为 101（没有前导零位），其补数为 010。所以你需要输出 2 。 6 | 7 | pub fn find_complement(num: i32) -> i32 { 8 | let mut binary_str: String = format!("{:b}", num); 9 | binary_str = binary_str.replace("0", "-"); 10 | binary_str = binary_str.replace("1", "0"); 11 | binary_str = binary_str.replace("-", "1"); 12 | isize::from_str_radix(&binary_str, 2).unwrap() as i32 13 | } 14 | 15 | fn main() { 16 | println!("{:?}", find_complement(5)); 17 | } 18 | -------------------------------------------------------------------------------- /485-max-consecutive-ones.rs: -------------------------------------------------------------------------------- 1 | pub fn find_max_consecutive_ones(nums: Vec) -> i32 { 2 | nums.split(|e|*e == 0).map(|a|a.len()).max().unwrap() as i32 3 | } 4 | 5 | fn main() { 6 | let nums = vec![1,1,0,1,1,1]; 7 | println!("{:?}", find_max_consecutive_ones(nums)); 8 | } 9 | -------------------------------------------------------------------------------- /492-construct-the-rectangle.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | impl Solution { 4 | pub fn construct_rectangle(area: i32) -> Vec { 5 | let mut ret = vec!(0; 2); 6 | let mut cha = 10000000; 7 | for i in 1..=area/2+1 { 8 | if area % i == 0 { 9 | let tmp = area / i; 10 | let abs = (tmp - i).abs(); 11 | if abs > cha { 12 | continue; 13 | } 14 | cha = abs; 15 | if tmp > i { 16 | ret[0] = tmp; 17 | ret[1] = i; 18 | } else { 19 | ret[0] = i; 20 | ret[1] = tmp; 21 | } 22 | } 23 | } 24 | ret 25 | } 26 | } 27 | 28 | fn main() { 29 | // println!("{:?}", Solution::construct_rectangle(4)); 30 | // println!("{:?}", Solution::construct_rectangle(37)); 31 | println!("{:?}", Solution::construct_rectangle(9999998)); 32 | } 33 | -------------------------------------------------------------------------------- /495-teemo-attacking.rs: -------------------------------------------------------------------------------- 1 | // (1...time_series.length).map{|i|[duration, (time_series[i]-time_series[i-1])].min}.sum+duration 2 | 3 | pub fn find_poisoned_duration(time_series: Vec, duration: i32) -> i32 { 4 | (1..time_series.len()).map(|i|vec![duration, (time_series[i]-time_series[i-1])].into_iter().min().unwrap()).sum::()+duration 5 | } 6 | 7 | fn main() { 8 | let time_series = vec![1,4]; 9 | let duration = 2; 10 | println!("{:?}", find_poisoned_duration(time_series, duration)); 11 | } 12 | -------------------------------------------------------------------------------- /503-next-greater-element-ii.rs: -------------------------------------------------------------------------------- 1 | pub fn next_greater_elements(nums: Vec) -> Vec { 2 | let mut ret = vec![]; 3 | let nums_len = nums.len(); 4 | 'outer: for i in 0..nums_len { 5 | for j in i+1..nums_len { 6 | if nums[j] > nums[i] { 7 | ret.push(nums[j]); 8 | continue 'outer; 9 | } 10 | } 11 | for k in 0..i { 12 | if nums[k] > nums[i] { 13 | ret.push(nums[k]); 14 | continue 'outer; 15 | } 16 | } 17 | ret.push(-1); 18 | } 19 | ret 20 | } 21 | 22 | fn main() { 23 | let nums = vec![1, 2, 1]; 24 | println!("{:?}", next_greater_elements(nums)); 25 | } 26 | -------------------------------------------------------------------------------- /506-relative-ranks.rs: -------------------------------------------------------------------------------- 1 | pub fn find_relative_ranks(score: Vec) -> Vec { 2 | let mut sorted_score = score.clone(); 3 | sorted_score.sort_by(|a, b|b.cmp(a)); 4 | use std::collections::HashMap; 5 | let mut mmp = HashMap::new(); 6 | for (i, s) in sorted_score.iter().enumerate() { 7 | let v: String; 8 | let j = i + 1; 9 | if j == 1 { 10 | v = "Gold Medal".to_string(); 11 | } else if j == 2 { 12 | v = "Silver Medal".to_string(); 13 | } else if j == 3 { 14 | v = "Bronze Medal".to_string(); 15 | } else { 16 | v = j.to_string(); 17 | } 18 | mmp.insert(s, v); 19 | } 20 | let res: Vec = score.into_iter().map(|e|mmp[&e].clone()).collect(); 21 | res 22 | } 23 | 24 | fn main() { 25 | let score = vec![5,4,3,2,1]; 26 | println!("{:?}", find_relative_ranks(score)); 27 | } -------------------------------------------------------------------------------- /509-fibonacci-number.rs: -------------------------------------------------------------------------------- 1 | // 经典递归（两个条件：） 2 | // 1. 有出口 n=1 n=2 3 | // 2. 有公式 fib(n) = fib(n-1) + fib(n-2) 4 | 5 | struct Solution; 6 | 7 | impl Solution { 8 | pub fn fib(n: i32) -> i32 { 9 | if n == 0 { 10 | 0 11 | } else if n == 1 { 12 | 1 13 | } else { 14 | Self::fib(n-1) + Self::fib(n-2) 15 | } 16 | } 17 | 18 | pub fn fib_dp(n: i32) -> i32 { 19 | let mut dp = vec![0; 31]; 20 | dp[1] = 1; 21 | for i in 2..=30 { 22 | dp[i] = dp[i-1] + dp[i-2]; 23 | } 24 | dp[n as usize] 25 | } 26 | } 27 | 28 | fn main() { 29 | println!("{:?}", Solution::fib(6)); 30 | println!("{:?}", Solution::fib_dp(6)); 31 | } 32 | -------------------------------------------------------------------------------- /520-detect-capital.rs: -------------------------------------------------------------------------------- 1 | pub fn detect_capital_use(word: String) -> bool { 2 | let word_len = word.len(); 3 | let mut count = vec![0, 0]; 4 | let chars = word.chars().collect::>(); 5 | let first_char = chars[0]; 6 | for c in chars { 7 | if c.is_uppercase() { 8 | count[0] += 1 9 | } else { 10 | count[1] += 1 11 | } 12 | } 13 | if count[0] == 0 { 14 | true 15 | } else { 16 | if count[1] == 0 { 17 | true 18 | } else { 19 | count[1] == word_len - 1 && first_char.is_uppercase() 20 | } 21 | } 22 | } 23 | 24 | fn main() { 25 | println!("{:?}", detect_capital_use("USA".to_string())); 26 | println!("{:?}", detect_capital_use("leetcode".to_string())); 27 | println!("{:?}", detect_capital_use("Google".to_string())); 28 | println!("{:?}", detect_capital_use("FlaG".to_string())); 29 | println!("{:?}", detect_capital_use("ffffffffffffffffffffF".to_string())); 30 | } 31 | -------------------------------------------------------------------------------- /537-complex-number-multiplication.rs: -------------------------------------------------------------------------------- 1 | pub fn complex_number_multiply(num1: String, num2: String) -> String { 2 | let a = num1.split("+").collect::>(); 3 | let x1: i32 = a[0].parse().unwrap(); 4 | let y1: i32 = a[1].replace("i", "").parse().unwrap(); 5 | let b = num2.split("+").collect::>(); 6 | let x2: i32 = b[0].parse().unwrap(); 7 | let y2: i32 = b[1].replace("i", "").parse().unwrap(); 8 | // println!("{:?} {:?} {:?} {:?}", x1, y1, x2, y2); 9 | let real = x1 * x2 - y1 * y2; 10 | let blural = x1 * y2 + y1 * x2; 11 | format!("{:?}+{:?}i", real, blural) 12 | } 13 | 14 | fn main() { 15 | let num1 = "1+-1i".to_string(); 16 | let num2 = "1+-1i".to_string(); 17 | println!("{:?}", complex_number_multiply(num1, num2)); 18 | } 19 | -------------------------------------------------------------------------------- /539-minimum-time-difference.rs: -------------------------------------------------------------------------------- 1 | pub fn find_min_difference(time_points: Vec) -> i32 { 2 | let mut mmp = vec![]; 3 | for p in time_points { 4 | let arr = p.split(":").map(|e|e.parse::().unwrap()).collect::>(); 5 | mmp.push(arr[0]*60+arr[1]); 6 | mmp.push((arr[0]+24)*60+arr[1]); 7 | } 8 | mmp.sort(); 9 | let mut ret = 24 * 60; 10 | for i in 1..mmp.len() { 11 | let tmp = mmp[i] - mmp[i-1]; 12 | if tmp < ret { ret = tmp } 13 | } 14 | ret 15 | } 16 | 17 | fn main() { 18 | println!("{:?}", find_min_difference(vec!["00:00".to_string(),"23:59".to_string(),"00:00".to_string()])); 19 | } 20 | -------------------------------------------------------------------------------- /541-reverse-string-ii.rs: -------------------------------------------------------------------------------- 1 | // good，练习chunk的使用。 2 | pub fn reverse_str(s: String, k: i32) -> String { 3 | let mut ret_c = s.chars().collect::>(); 4 | let mut idx = 0; 5 | for chunk in ret_c.chunks_mut(k as usize) { 6 | if idx % 2 == 0 { 7 | let mut tmp = chunk.to_vec(); 8 | tmp.reverse(); 9 | for (i, elem) in chunk.iter_mut().enumerate() { 10 | *elem = tmp[i]; 11 | } 12 | } 13 | idx += 1; 14 | } 15 | ret_c.iter().collect() 16 | } 17 | 18 | fn main() { 19 | let s = "abcd".to_string(); 20 | let k = 2; 21 | println!("{:?}", reverse_str(s, k)); 22 | } 23 | -------------------------------------------------------------------------------- /557-reverse-words-in-a-string-iii.rs: -------------------------------------------------------------------------------- 1 | // 示例： 2 | 3 | // 输入："Let's take LeetCode contest" 4 | // 输出："s'teL ekat edoCteeL tsetnoc" 5 | 6 | pub fn reverse_words(s: String) -> String { 7 | s.split(" ").map(|word|word.to_string().chars().rev().collect()).collect::>().join(" ") 8 | } 9 | 10 | fn main() { 11 | println!("{:?}", reverse_words("Let's take LeetCode contest".to_string())); 12 | } 13 | -------------------------------------------------------------------------------- /561-array-partition-i.rs: -------------------------------------------------------------------------------- 1 | pub fn array_pair_sum(nums: Vec) -> i32 { 2 | let mut sorted_nums = nums.clone(); 3 | sorted_nums.sort(); 4 | let mut res = 0; 5 | for (i, n) in sorted_nums.iter().enumerate() { 6 | if i % 2 == 0 { 7 | res += n; 8 | } 9 | } 10 | res 11 | } 12 | 13 | fn main() { 14 | let nums = vec![1,4,3,2]; 15 | println!("{:?}", array_pair_sum(nums)); 16 | } 17 | -------------------------------------------------------------------------------- /566-reshape-the-matrix.rs: -------------------------------------------------------------------------------- 1 | pub fn matrix_reshape(mat: Vec>, r: i32, c: i32) -> Vec> { 2 | let mut flattened = mat.clone().into_iter().flatten().collect::>(); 3 | if flattened.len() != (r * c) as usize { return mat } 4 | let mut ret = vec![]; 5 | for _ in 0..r { 6 | let mut tmp = vec![]; 7 | for _ in 0..c { 8 | tmp.push(flattened.remove(0)); 9 | } 10 | ret.push(tmp); 11 | } 12 | ret 13 | } 14 | 15 | fn main() { 16 | let mat = vec![vec![1,2], vec![3,4]]; 17 | let r = 1; 18 | let c = 4; 19 | println!("{:?}", matrix_reshape(mat, r, c)); 20 | } 21 | -------------------------------------------------------------------------------- /599-minimum-index-sum-of-two-lists.rs: -------------------------------------------------------------------------------- 1 | pub fn find_restaurant(list1: Vec, list2: Vec) -> Vec { 2 | let mut ret_idx = vec![2000; list1.len()]; 3 | let mut ret = vec!(); 4 | for (i, s) in list1.iter().enumerate() { 5 | let tmp = list2.iter().position(|x|x == s); 6 | if tmp.is_some() { 7 | ret_idx[i] = tmp.unwrap()+i; 8 | } 9 | } 10 | let min = ret_idx.iter().min().unwrap(); 11 | for (i, idx) in ret_idx.iter().enumerate() { 12 | if idx == min { 13 | ret.push(list1[i].clone()); 14 | } 15 | } 16 | ret 17 | } 18 | 19 | fn main() { 20 | let list2 = vec!["vacag","KFC"] 21 | .iter().map(|e|e.to_string()).collect::>(); 22 | let list1 = vec!["fvo","xrljq","jrl","KFC"] 23 | .iter().map(|e|e.to_string()).collect::>(); 24 | println!("{:?}", find_restaurant(list1, list2)); 25 | } 26 | -------------------------------------------------------------------------------- /6124-first-letter-to-appear-twice.rs: -------------------------------------------------------------------------------- 1 | pub fn repeated_character(s: String) -> char { 2 | use std::collections::HashMap; 3 | let mut mp = HashMap::new(); 4 | let mut ret = '!'; 5 | for c in s.chars().collect::>() { 6 | let count = mp.entry(c).or_insert(0); 7 | *count += 1; 8 | if *count == 2 { 9 | ret = c; 10 | break; 11 | } 12 | } 13 | ret 14 | } 15 | 16 | fn main() { 17 | println!("{:?}", repeated_character("abccbaacz".to_string())); 18 | } 19 | -------------------------------------------------------------------------------- /647-palindromic-substrings.rs: -------------------------------------------------------------------------------- 1 | pub fn count_substrings(s: String) -> i32 { 2 | pub fn is_palindromic(cs: &[char]) -> bool { 3 | // println!("{:?}", cs.clone().to_vec()); 4 | let tmp = cs.clone().to_vec(); 5 | let mut tmp_rev = cs.clone().to_vec(); 6 | tmp_rev.reverse(); 7 | tmp == tmp_rev 8 | } 9 | let cs = s.chars().collect::>(); 10 | let mut ret = 0; 11 | for i in 1 ..= s.len() { 12 | for j in 0 ..= (s.len() - i) { 13 | if is_palindromic(&cs[j..j+i]) { ret += 1 } 14 | } 15 | } 16 | ret 17 | } 18 | 19 | fn main() { 20 | println!("{:?}", count_substrings("abc".to_string())); 21 | println!("{:?}", count_substrings("aaa".to_string())); 22 | } 23 | -------------------------------------------------------------------------------- /648-replace-words.rs: -------------------------------------------------------------------------------- 1 | pub fn replace_words(dictionary: Vec, sentence: String) -> String { 2 | let mut dictionary = dictionary; 3 | dictionary.sort_by(|a, b|a.len().cmp(&b.len())); 4 | let mut ret_vec = vec![]; 5 | 'outer: for word in sentence.split_ascii_whitespace() { 6 | for prefix in &dictionary { 7 | if word.starts_with(prefix) { 8 | ret_vec.push(prefix.clone()); 9 | continue 'outer; 10 | } 11 | } 12 | ret_vec.push(word.to_string()) 13 | } 14 | ret_vec.join(" ") 15 | } 16 | 17 | fn main() { 18 | let dictionary = vec!["catt".to_string(), "cat".to_string(), "bat".to_string(), "rat".to_string()]; 19 | let sentence = "the cattle was rattled by the battery".to_string(); 20 | println!("{:?}", replace_words(dictionary, sentence)); 21 | } 22 | -------------------------------------------------------------------------------- /657-robot-return-to-origin.rs: -------------------------------------------------------------------------------- 1 | pub fn judge_circle(moves: String) -> bool { 2 | let (mut x, mut y) = (0, 0); 3 | for c in moves.chars() { 4 | match c { 5 | 'U' => x += 1, 6 | 'D' => x -= 1, 7 | 'L' => y += 1, 8 | 'R' => y -= 1, 9 | _ => {}, 10 | } 11 | } 12 | x == 0 && y == 0 13 | } 14 | 15 | fn main() { 16 | let moves = "UD".to_string(); 17 | println!("{:?}", judge_circle(moves)); 18 | } 19 | -------------------------------------------------------------------------------- /682-baseball-game.rs: -------------------------------------------------------------------------------- 1 | pub fn cal_points(ops: Vec) -> i32 { 2 | let mut arr = vec!(); 3 | for e in ops { 4 | if e == "C".to_string() { 5 | arr.pop(); 6 | } else if e == "D".to_string() { 7 | let tmp = arr.iter().last().unwrap() * 2; 8 | arr.push(tmp); 9 | } else if e == "+".to_string() { 10 | let start = &arr.len() - 2; 11 | arr.push(arr[start..].iter().sum::()); 12 | } else { 13 | let num: i32 = e.parse().unwrap(); 14 | arr.push(num); 15 | } 16 | } 17 | arr.iter().sum() 18 | } 19 | 20 | fn main() { 21 | let ops = vec!["5","-2","4","C","D","9","+","+"].iter().map(|e|e.to_string()).collect(); 22 | println!("{:?}", cal_points(ops)); 23 | } 24 | -------------------------------------------------------------------------------- /693-binary-number-with-alternating-bits.rs: -------------------------------------------------------------------------------- 1 | // 给定一个正整数，检查它的二进制表示是否总是 0、1 交替出现：换句话说，就是二进制表示中相邻两位的数字永不相同。 2 | 3 | // 示例 1： 4 | 5 | // 输入：n = 5 6 | // 输出：true 7 | // 解释：5 的二进制表示是：101 8 | 9 | // 来源：力扣（LeetCode） 10 | // 链接：https://leetcode-cn.com/problems/binary-number-with-alternating-bits 11 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 12 | 13 | pub fn has_alternating_bits(n: i32) -> bool { 14 | let bin_str = format!("{:b}", n); 15 | !bin_str.contains("00") && !bin_str.contains("11") 16 | } 17 | 18 | fn main() { 19 | println!("{:?}", has_alternating_bits(7)); 20 | } 21 | -------------------------------------------------------------------------------- /696-count-binary-substrings.rs: -------------------------------------------------------------------------------- 1 | // 先统计连续的0和1分别有多少个 2 | // 如：111100011000，得到4323 3 | // 在4323中的任意相邻两个数字， 4 | // 取小的一个加起来，就是3+2+2 = 7 5 | 6 | pub fn count_binary_substrings(s: String) -> i32 { 7 | let mut cur_char = 'w'; 8 | let mut tmp_count = 0; 9 | let mut arr = vec!(); 10 | for c in s.chars() { 11 | if c == cur_char { 12 | tmp_count += 1; 13 | } else { 14 | if tmp_count != 0 { 15 | arr.push(tmp_count); 16 | } 17 | cur_char = c; 18 | tmp_count = 1; 19 | } 20 | } 21 | arr.push(tmp_count); 22 | let mut res = 0; 23 | for i in 0..(&arr.len()-1) { 24 | if arr[i] < arr[i+1] { 25 | res += arr[i]; 26 | } else { 27 | res += arr[i+1]; 28 | } 29 | } 30 | res 31 | } 32 | 33 | fn main() { 34 | let s = "00110011".to_string(); 35 | println!("{:?}", count_binary_substrings(s)); 36 | } -------------------------------------------------------------------------------- /697-degree-of-an-array.rs: -------------------------------------------------------------------------------- 1 | pub fn find_shortest_sub_array(nums: Vec) -> i32 { 2 | let mut res = Vec::new(); 3 | use std::collections::HashMap; 4 | let mut counter_map = HashMap::new(); 5 | for num in &nums { 6 | let count = counter_map.entry(num).or_insert(0); 7 | *count += 1; 8 | } 9 | let mut counter_vec: Vec<_> = counter_map.iter().collect(); 10 | counter_vec.sort_by(|b, a|a.1.cmp(b.1)); 11 | let du = counter_vec[0].1; 12 | counter_vec.retain(|e|e.1 == du); 13 | for pair in counter_vec { 14 | let key_element = pair.0; 15 | let index_0 = nums.iter().position(|&r|r == **key_element).unwrap(); 16 | let index_1 = nums.iter().rev().position(|&r|r == **key_element).unwrap(); 17 | let tmp = (&nums.len() - index_1 - index_0) as i32; 18 | res.push(tmp); 19 | } 20 | *res.iter().min().unwrap() 21 | } 22 | 23 | fn main() { 24 | let nums = vec![1,2,2,3,1]; 25 | println!("{:?}", find_shortest_sub_array(nums)); 26 | } 27 | -------------------------------------------------------------------------------- /704-binary-search.rs: -------------------------------------------------------------------------------- 1 | pub fn search(nums: Vec, target: i32) -> i32 { 2 | let mut left = 0; 3 | let mut right = nums.len() - 1; 4 | while left <= right { 5 | let mid = left + ( right - left ) / 2; // 游标是left作为起点，右侧总长除2，就是右边的中间。 6 | if nums[mid] == target { 7 | return mid as i32; 8 | } 9 | if nums[mid] > target { 10 | right = mid - 1; // 如果在左区间，要左移1位，作为开始 11 | } 12 | if nums[mid] < target { 13 | left = mid + 1; // 如果在右区间，要右移1位，作为开始 14 | } 15 | } 16 | -1 17 | } 18 | 19 | fn main() { 20 | let nums = vec![-1,0,3,5,9,12]; 21 | let target = 9; 22 | println!("{:?}", search(nums, target)); 23 | } 24 | -------------------------------------------------------------------------------- /705-design-hashset.rs: -------------------------------------------------------------------------------- 1 | use std::collections::HashSet; 2 | struct MyHashSet { 3 | set: HashSet 4 | } 5 | 6 | 7 | /** 8 | * `&self` means the method takes an immutable reference. 9 | * If you need a mutable reference, change it to `&mut self` instead. 10 | */ 11 | impl MyHashSet { 12 | 13 | fn new() -> Self { 14 | MyHashSet {set: HashSet::new()} 15 | } 16 | 17 | fn add(&mut self, key: i32) { 18 | self.set.insert(key); 19 | } 20 | 21 | fn remove(&mut self, key: i32) { 22 | self.set.remove(&key); 23 | } 24 | 25 | fn contains(&self, key: i32) -> bool { 26 | self.set.contains(&key) 27 | } 28 | } 29 | 30 | fn main() { 31 | let mut obj = MyHashSet::new(); 32 | obj.add(1); 33 | obj.remove(1); 34 | let ret_3: bool = obj.contains(1); 35 | } 36 | -------------------------------------------------------------------------------- /717-1-bit-and-2-bit-characters.rs: -------------------------------------------------------------------------------- 1 | pub fn is_one_bit_character(bits: Vec) -> bool { 2 | let bits_strs: Vec = bits.into_iter().map(|b|b.to_string()).collect::>(); 3 | let bits_str = bits_strs.join(""); 4 | if bits_str == "0".to_string() || bits_str == "00".to_string() { 5 | true 6 | } else { 7 | bits_str.ends_with("100") || 8 | bits_str.ends_with("000") || 9 | ( bits_str.ends_with("110") && !bits_str.ends_with("1110")) || 10 | ( bits_str.ends_with("11110") && !bits_str.ends_with("111110")) 11 | } 12 | } 13 | 14 | fn main() { 15 | let bits = vec![1,1,1,1,0]; 16 | println!("{:?}", is_one_bit_character(bits)); 17 | } 18 | -------------------------------------------------------------------------------- /724-find-pivot-index.rs: -------------------------------------------------------------------------------- 1 | pub fn pivot_index(nums: Vec) -> i32 { 2 | let mindex = nums.len(); 3 | for i in 0..mindex { 4 | if &nums[0..i].iter().sum::() == &nums[(i+1)..].iter().sum::() { 5 | return i as i32; 6 | } 7 | } 8 | -1 9 | } 10 | 11 | fn main() { 12 | let nums = vec![2,1,-1]; 13 | println!("{:?}", pivot_index(nums)); 14 | } 15 | -------------------------------------------------------------------------------- /728-self-dividing-numbers.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入： 4 | // 上边界left = 1, 下边界right = 22 5 | // 输出： [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22] 6 | 7 | // 来源：力扣（LeetCode） 8 | // 链接：https://leetcode-cn.com/problems/self-dividing-numbers 9 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 10 | 11 | pub fn self_dividing_numbers(left: i32, right: i32) -> Vec { 12 | let mut res = vec!(); 13 | for number in left..right+1 { 14 | let digit_chars: Vec = number.to_string().chars().collect(); 15 | if digit_chars.contains(&'0') { 16 | continue; 17 | } 18 | let mut flag = true; 19 | for c in digit_chars { 20 | if number % c.to_digit(10).unwrap() as i32 != 0 { 21 | flag = false; 22 | break; 23 | } 24 | } 25 | if flag { 26 | res.push(number); 27 | } 28 | } 29 | res 30 | } 31 | 32 | fn main() { 33 | println!("{:?}", self_dividing_numbers(1, 22)); 34 | } 35 | -------------------------------------------------------------------------------- /739-daily-temperatures.rs: -------------------------------------------------------------------------------- 1 | pub fn daily_temperatures(temperatures: Vec) -> Vec { 2 | let mut ret = vec!(); 3 | 'outer: for (i, t) in temperatures.iter().enumerate() { 4 | for (j, e) in temperatures[i+1..].iter().enumerate() { 5 | if *e > *t { 6 | ret.push(j as i32 + 1); 7 | continue 'outer; 8 | } 9 | } 10 | ret.push(0); 11 | } 12 | ret 13 | } 14 | 15 | fn main() { 16 | let temperatures = vec![73,74,75,71,69,72,76,73]; 17 | println!("{:?}", daily_temperatures(temperatures)); 18 | } 19 | -------------------------------------------------------------------------------- /744-find-smallest-letter-greater-than-target.rs: -------------------------------------------------------------------------------- 1 | pub fn next_greatest_letter(letters: Vec, target: char) -> char { 2 | for letter in &letters { 3 | if letter > &target { 4 | return *letter; 5 | } 6 | } 7 | *letters.iter().nth(0).unwrap() 8 | } 9 | 10 | fn main() { 11 | let letters = vec!['c', 'f', 'j']; 12 | let target = 'j'; 13 | println!("{:?}", next_greatest_letter(letters, target)); 14 | } 15 | -------------------------------------------------------------------------------- /747-largest-number-at-least-twice-of-others.rs: -------------------------------------------------------------------------------- 1 | pub fn dominant_index(nums: Vec) -> i32 { 2 | if nums == vec![1] { 3 | return 0; 4 | } 5 | let mut sorted_nums: Vec<_> = nums.clone().into_iter().enumerate().collect(); 6 | sorted_nums.sort_by(|a, b|a.1.cmp(&b.1)); 7 | let length = &nums.len(); 8 | if sorted_nums[length-1].1 < sorted_nums[length-2].1 * 2 { 9 | -1 10 | } else { 11 | sorted_nums[length-1].0 as i32 12 | } 13 | } 14 | 15 | fn main() { 16 | let nums = vec![1]; 17 | println!("{:?}", dominant_index(nums)); 18 | } 19 | -------------------------------------------------------------------------------- /75-sort-colors.rs: -------------------------------------------------------------------------------- 1 | pub fn sort_colors(nums: &mut Vec) { 2 | let lst_idx = nums.len() - 1; 3 | for i in 0..lst_idx { 4 | for j in 0..lst_idx-i { 5 | if nums[j] > nums[j+1] { 6 | let tmp = nums[j]; 7 | nums[j] = nums[j+1]; 8 | nums[j+1] = tmp; 9 | } 10 | } 11 | } 12 | } 13 | 14 | fn main() { 15 | let mut nums = vec![2,0,2,1,1,0]; 16 | sort_colors(&mut nums); 17 | println!("{:?}", nums); 18 | } 19 | -------------------------------------------------------------------------------- /762-prime-number-of-set-bits-in-binary-representation.rs: -------------------------------------------------------------------------------- 1 | pub fn count_prime_set_bits(left: i32, right: i32) -> i32 { 2 | pub fn is_prime(num: usize) -> bool { 3 | if num < 2 { 4 | return false; 5 | } 6 | for i in 2..num { 7 | if num % i == 0 { 8 | return false; 9 | } 10 | } 11 | return true; 12 | } 13 | let mut ret = 0; 14 | for num in left..=right { 15 | let num_binary: Vec = format!("{:b}", num).chars().collect(); 16 | let count_binary = num_binary.iter().filter(|&n|*n=='1').count(); 17 | if is_prime(count_binary) { 18 | ret += 1; 19 | } 20 | } 21 | ret 22 | } 23 | 24 | fn main() { 25 | let (left, right) = (10, 15); 26 | println!("{:?}", count_prime_set_bits(left, right)); 27 | } 28 | -------------------------------------------------------------------------------- /766-toeplitz-matrix.rs: -------------------------------------------------------------------------------- 1 | pub fn is_toeplitz_matrix(matrix: Vec>) -> bool { 2 | let (m, n) = (matrix[0].len(), matrix.len()); 3 | // 00 11 22 4 | // 01 12 23 5 | // 02 13 6 | // 03 7 | for y in 0..m { 8 | let mut i = 0; 9 | let mut j = y; 10 | let prev = matrix[i][j]; 11 | while j < m && i < n { 12 | if matrix[i][j] != prev { return false; } 13 | i += 1; 14 | j += 1; 15 | } 16 | } 17 | // 00 11 22 18 | // 10 21 19 | // 20 20 | for x in 0..n { 21 | let mut i = x; 22 | let mut j = 0; 23 | let prev = matrix[i][j]; 24 | while j < m && i < n { 25 | if matrix[i][j] != prev { return false; } 26 | i += 1; 27 | j += 1; 28 | } 29 | } 30 | true 31 | } 32 | 33 | fn main() { 34 | let matrix = vec![vec![1,2,3,4], vec![5,1,2,3], vec![9,5,1,2]]; 35 | println!("{:?}", is_toeplitz_matrix(matrix)); 36 | } 37 | -------------------------------------------------------------------------------- /77-combinations.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | // 回溯 = 递归 + 循环 4 | impl Solution { 5 | pub fn backtrace(n: i32, k: usize, start_index: i32, path: &mut Vec, ret: &mut Vec>) { 6 | if path.len() == k { 7 | ret.push(path.to_vec()); 8 | return; 9 | } 10 | for i in start_index..=n { 11 | path.push(i); 12 | Self::backtrace(n, k, i+1, path, ret); 13 | path.pop(); 14 | } 15 | } 16 | 17 | pub fn combine(n: i32, k: i32) -> Vec> { 18 | let mut path = vec![]; 19 | let mut ret = vec![]; 20 | Self::backtrace(n, k as usize, 1, &mut path, &mut ret); 21 | ret 22 | } 23 | } 24 | 25 | fn main() { 26 | println!("{:?}", Solution::combine(4, 2)); 27 | } 28 | -------------------------------------------------------------------------------- /78-subsets.rs: -------------------------------------------------------------------------------- 1 | // 这个题蛮有意思的，可以直接从后遍历，遇到一个数就把所有子集加上该数组成新的子集，遍历完毕即是所有子集 2 | pub fn subsets(nums: Vec) -> Vec> { 3 | let mut res: Vec> = vec!(vec!()); 4 | for num in nums { 5 | for i in 0..res.len() { // 这里只能用index，因为res在循环里面变化 6 | let mut tmp = res[i].clone(); 7 | tmp.push(num); 8 | res.push(tmp); 9 | } 10 | } 11 | res 12 | } 13 | 14 | fn main() { 15 | let nums = vec![1,2,3]; 16 | println!("{:?}", subsets(nums)); 17 | } 18 | -------------------------------------------------------------------------------- /788-rotated-digits.rs: -------------------------------------------------------------------------------- 1 | pub fn rotated_digits(n: i32) -> i32 { 2 | pub fn is_good(e: i32) -> bool { 3 | let digit_chars = e.to_string().chars().collect::>(); 4 | let mut count = 0; 5 | for digit_char in digit_chars { 6 | if digit_char == '3' || digit_char == '4' 7 | || digit_char == '7' { 8 | return false 9 | } 10 | if digit_char == '2' || digit_char == '5' 11 | || digit_char == '6' || digit_char == '9' { 12 | count += 1 13 | } 14 | } 15 | count > 0 16 | } 17 | let mut nums = (1..=n).collect::>(); 18 | nums.retain(|e|is_good(*e)); 19 | nums.len() as i32 20 | } 21 | 22 | fn main() { 23 | println!("{:?}", rotated_digits(10)); 24 | } 25 | -------------------------------------------------------------------------------- /789-escape-the-ghosts.rs: -------------------------------------------------------------------------------- 1 | // 这题考阅读理解和题意转化能力，其实问的就是有没鬼能比你更快到达终点(转) 2 | pub fn escape_ghosts(ghosts: Vec>, target: Vec) -> bool { 3 | let dis = target[0].abs() + target[1].abs(); 4 | for g in ghosts { 5 | if (g[0] - target[0]).abs() + (g[1] - target[1]).abs() <= dis { 6 | return false 7 | } 8 | } 9 | true 10 | } 11 | 12 | fn main() { 13 | println!("{:?}", escape_ghosts(vec![vec![1,0], vec![0,3]], vec![0,1])); 14 | println!("{:?}", escape_ghosts(vec![vec![2,0]], vec![1,0])); 15 | println!("{:?}", escape_ghosts(vec![vec![2,0]], vec![1,0])); 16 | } 17 | -------------------------------------------------------------------------------- /796-rotate-string.rs: -------------------------------------------------------------------------------- 1 | pub fn rotate_string(s: String, goal: String) -> bool { 2 | if s == goal { 3 | return true; 4 | } 5 | let mut s_chars: Vec = s.chars().collect(); 6 | let goal_chars: Vec = goal.chars().collect(); 7 | for _i in 0..s.len() { 8 | s_chars.rotate_left(1); 9 | if s_chars == goal_chars { 10 | return true; 11 | } 12 | } 13 | return false; 14 | } 15 | 16 | fn main() { 17 | let s = "abcde".to_string(); 18 | let goal = "cdaeb".to_string(); 19 | println!("{:?}", rotate_string(s, goal)); 20 | } 21 | -------------------------------------------------------------------------------- /807-max-increase-to-keep-city-skyline.rs: -------------------------------------------------------------------------------- 1 | pub fn max_increase_keeping_skyline(grid: Vec>) -> i32 { 2 | let mut res = 0; 3 | let mut cols_max = vec!(); 4 | let index = grid.len(); 5 | for i in 0..index { 6 | let mut tmp = vec!(); 7 | for j in 0..index { 8 | tmp.push(grid[j][i]); 9 | } 10 | let col_max = tmp.into_iter().max().unwrap(); 11 | cols_max.push(col_max); 12 | } 13 | for row in grid { 14 | let row_max = row.iter().max().unwrap(); 15 | let mut added: i32; 16 | for (i, e) in row.iter().enumerate() { 17 | if cols_max[i] < *row_max { 18 | added = cols_max[i] - e; 19 | } else { 20 | added = row_max - e; 21 | } 22 | res += added; 23 | } 24 | } 25 | res 26 | } 27 | 28 | fn main() { 29 | let grid = vec![vec![3,0,8,4],vec![2,4,5,7],vec![9,2,6,3],vec![0,3,1,0]]; 30 | println!("{:?}", max_increase_keeping_skyline(grid)); 31 | } 32 | -------------------------------------------------------------------------------- /812-largest-triangle-area.rs: -------------------------------------------------------------------------------- 1 | pub fn largest_triangle_area(points: Vec>) -> f64 { 2 | let mut areas = vec!(); 3 | for x in points.clone() { 4 | for y in points.clone() { 5 | for z in points.clone() { 6 | let area = 0.5 * ((x[0]*y[1] + y[0]*z[1] + z[0]*x[1] - x[0]*z[1] - y[0]*x[1] - z[0]*y[1]) as f64); 7 | areas.push(area); 8 | } 9 | } 10 | } 11 | areas.into_iter().max_by(|a, b| a.partial_cmp(b).unwrap()).unwrap() 12 | } 13 | 14 | fn main() { 15 | let points = vec![vec![0,0],vec![0,1],vec![1,0],vec![0,2],vec![2,0]]; 16 | println!("{:?}", largest_triangle_area(points)); 17 | } 18 | -------------------------------------------------------------------------------- /821-shortest-distance-to-a-character.rs: -------------------------------------------------------------------------------- 1 | pub fn shortest_to_char(s: String, c: char) -> Vec { 2 | let mut ch_indices = vec!(); 3 | for (i, ch) in s.chars().enumerate() { 4 | if c == ch { 5 | ch_indices.push(i as i32); 6 | } 7 | } 8 | let mut ret: Vec = vec!(); 9 | for (i, ch) in s.chars().enumerate() { 10 | if c == ch { 11 | ret.push(0); 12 | } else { 13 | ret.push(ch_indices.iter().map(|e|(e-i as i32).abs()).min().unwrap()); 14 | } 15 | } 16 | ret 17 | } 18 | 19 | fn main() { 20 | let s = "loveleetcode".to_string(); 21 | let c = 'e'; 22 | println!("{:?}", shortest_to_char(s, c)); 23 | } 24 | -------------------------------------------------------------------------------- /830-positions-of-large-groups.rs: -------------------------------------------------------------------------------- 1 | pub fn large_group_positions(s: String) -> Vec> { 2 | let chars = s.chars().collect::>(); 3 | let mut prev_char = chars[0]; 4 | let mut count = 1; 5 | let mut arr = vec!(); 6 | for c in &chars[1..] { 7 | if *c == prev_char { 8 | count += 1; 9 | } else { 10 | arr.push(count); 11 | count = 1; 12 | } 13 | prev_char = *c; 14 | } 15 | arr.push(count); 16 | let mut ret = vec!(); 17 | let mut sum = 0; 18 | for cc in arr { 19 | if cc > 2 { 20 | ret.push(vec![sum, sum + cc - 1]); 21 | } 22 | sum += cc; 23 | } 24 | ret 25 | } 26 | 27 | fn main() { 28 | let s = "abcdddeeeeaabbbcd".to_string(); 29 | println!("{:?}", large_group_positions(s)); 30 | } 31 | -------------------------------------------------------------------------------- /832-flipping-an-image.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：[[1,1,0],[1,0,1],[0,0,0]] 4 | // 输出：[[1,0,0],[0,1,0],[1,1,1]] 5 | // 解释：首先翻转每一行: [[0,1,1],[1,0,1],[0,0,0]]； 6 | // 然后反转图片: [[1,0,0],[0,1,0],[1,1,1]] 7 | 8 | // 来源：力扣（LeetCode） 9 | // 链接：https://leetcode-cn.com/problems/flipping-an-image 10 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 11 | 12 | fn main() { 13 | let image = vec!( 14 | vec!(1,1,0), 15 | vec!(1,0,1), 16 | vec!(0,0,0) 17 | ); 18 | let res = flip_and_invert_image(image); 19 | println!("{:?}", res); 20 | } 21 | 22 | pub fn flip_and_invert_image(image: Vec>) -> Vec> { 23 | image.into_iter().map(|row|row.into_iter().rev().map(|pixel|pixel ^ 1).collect()).collect() 24 | } // into_iter map collect 3人成组出现 25 | -------------------------------------------------------------------------------- /841-keys-and-rooms.rs: -------------------------------------------------------------------------------- 1 | pub fn can_visit_all_rooms(rooms: Vec>) -> bool { 2 | use std::collections::HashSet; 3 | let mut mmp: HashSet = HashSet::new(); 4 | pub fn dfs(mmp: &mut HashSet, rooms: &Vec>, key: i32) { 5 | let keys = rooms.get(key as usize); 6 | if keys == None { return } 7 | for key in keys.unwrap() { 8 | let tmp = mmp.get(key); 9 | if tmp.is_some() { continue } 10 | mmp.insert(*key); 11 | dfs(mmp, rooms, *key); 12 | } 13 | } 14 | dfs(&mut mmp, &rooms, 0); 15 | let mut mmp = mmp.into_iter().collect::>(); 16 | mmp.sort(); 17 | (1..rooms.len() as i32).collect::>() == mmp 18 | } 19 | 20 | fn main() { 21 | println!("{:?}", can_visit_all_rooms(vec![vec![1], vec![2], vec![3], vec![]])); 22 | println!("{:?}", can_visit_all_rooms(vec![vec![1,3], vec![3,0,1], vec![2], vec![0]])); 23 | } 24 | -------------------------------------------------------------------------------- /844-backspace-string-compare.rs: -------------------------------------------------------------------------------- 1 | pub fn backspace_compare(s: String, t: String) -> bool { 2 | fn get_chars(s: String) -> Vec { 3 | let s_chars: Vec = s.chars().collect(); 4 | let mut cs = vec!(); 5 | for c in s_chars { 6 | if c != '#' { 7 | cs.push(c); 8 | } else { 9 | cs.pop(); 10 | } 11 | } 12 | cs 13 | } 14 | get_chars(s) == get_chars(t) 15 | } 16 | 17 | fn main() { 18 | let s = "ab##".to_string(); 19 | let t = "c#d#".to_string(); 20 | println!("{:?}", backspace_compare(s, t)); 21 | } 22 | -------------------------------------------------------------------------------- /852-peak-index-in-a-mountain-array.rs: -------------------------------------------------------------------------------- 1 | // binary search 2 | pub fn peak_index_in_mountain_array(arr: Vec) -> i32 { 3 | let mut left = 0; 4 | let mut right = arr.len() -1; 5 | let mut mid = 0; 6 | while left < right { 7 | mid = left+(right-left)/2; 8 | if arr[mid-1] < arr[mid] && arr[mid] > arr[mid+1] { 9 | break; 10 | } 11 | if arr[mid] < arr[mid+1] { 12 | left = mid; 13 | } 14 | if arr[mid] > arr[mid+1] { 15 | right = mid; 16 | } 17 | } 18 | mid as i32 19 | } 20 | 21 | fn main() { 22 | let arr = vec![18,29,38,59,98,100,99,98,90]; 23 | println!("{:?}", peak_index_in_mountain_array(arr)); 24 | } 25 | -------------------------------------------------------------------------------- /867-transpose-matrix.rs: -------------------------------------------------------------------------------- 1 | pub fn transpose(matrix: Vec>) -> Vec> { 2 | let times = matrix[0].len(); 3 | let mut res = vec!(); 4 | for i in 0..times { 5 | let mut tmp = vec!(); 6 | for e in &matrix { 7 | tmp.push(e[i]); 8 | } 9 | res.push(tmp); 10 | } 11 | res 12 | } 13 | 14 | fn main() { 15 | let matrix = vec![vec![1,2,3],vec![4,5,6]]; 16 | println!("{:?}", transpose(matrix)); 17 | } 18 | -------------------------------------------------------------------------------- /868-binary-gap.rs: -------------------------------------------------------------------------------- 1 | pub fn binary_gap(n: i32) -> i32 { 2 | let bin_chars: Vec = format!("{:b}", n).chars().collect(); 3 | let mut one_arr = vec!(); 4 | for (i, c) in bin_chars.iter().enumerate() { 5 | if c == &'1' { 6 | one_arr.push(i); 7 | } 8 | } 9 | if &one_arr.len() < &2 { 10 | 0 11 | } else { 12 | let mut minus_arr = vec!(); 13 | for i in 1..one_arr.len() { 14 | minus_arr.push(one_arr[i] - one_arr[i-1]); 15 | } 16 | *minus_arr.iter().max().unwrap() as i32 17 | } 18 | } 19 | 20 | fn main() { 21 | println!("{:?}", binary_gap(22)); 22 | } 23 | -------------------------------------------------------------------------------- /869-reordered-power-of-2.rs: -------------------------------------------------------------------------------- 1 | // Enumerate numbers with same length 2 | 3 | pub fn reordered_power_of2(n: i32) -> bool { 4 | let mut candidate_numbers = vec![]; 5 | let n_len = n.to_string().len(); 6 | let mut power = 0; 7 | loop { 8 | let tmp = 2_i32.pow(power); 9 | if tmp.to_string().len() == n_len { 10 | candidate_numbers.push(tmp); 11 | } 12 | if tmp.to_string().len() > n_len { 13 | break; 14 | } 15 | power += 1 16 | } 17 | let mut sorted_nums = n.to_string().chars().collect::>(); 18 | sorted_nums.sort(); 19 | for number in &candidate_numbers { 20 | let mut sorted_tmp = number.to_string().chars().collect::>(); 21 | sorted_tmp.sort(); 22 | if sorted_tmp == sorted_nums { 23 | return true; 24 | } 25 | } 26 | false 27 | } 28 | 29 | fn main() { 30 | println!("{:?}", reordered_power_of2(10)); 31 | } 32 | -------------------------------------------------------------------------------- /884-uncommon-words-from-two-sentences.rs: -------------------------------------------------------------------------------- 1 | pub fn uncommon_from_sentences(s1: String, s2: String) -> Vec { 2 | use std::collections::HashMap; 3 | let mut mmp = HashMap::new(); 4 | for w in s1.split_whitespace() { 5 | let count = mmp.entry(w).or_insert(0); 6 | *count += 1; 7 | } 8 | for w in s2.split_whitespace() { 9 | let count = mmp.entry(w).or_insert(0); 10 | *count += 1; 11 | } 12 | mmp.retain(|_, v| *v == 1); 13 | mmp.into_keys() 14 | .collect::>() 15 | .iter() 16 | .map(|e|e.to_string()) 17 | .collect() 18 | } 19 | 20 | fn main() { 21 | let s1 = "this apple is sweet".to_string(); 22 | let s2 = "this apple is sour".to_string(); 23 | println!("{:?}", uncommon_from_sentences(s1, s2)); 24 | } 25 | -------------------------------------------------------------------------------- /888-fair-candy-swap.rs: -------------------------------------------------------------------------------- 1 | pub fn fair_candy_swap(alice_sizes: Vec, bob_sizes: Vec) -> Vec { 2 | let diff: i32 = alice_sizes.iter().sum::() - bob_sizes.iter().sum::(); 3 | let abs_diff = diff / 2; 4 | let mut ret = vec![]; 5 | 'o: for i in &alice_sizes { 6 | for j in &bob_sizes { 7 | if abs_diff == *i - *j { 8 | ret = vec![*i, *j]; 9 | break 'o 10 | } 11 | } 12 | } 13 | ret 14 | } 15 | 16 | fn main() { 17 | println!("{:?}", fair_candy_swap(vec![1, 1], vec![2, 2])); 18 | println!("{:?}", fair_candy_swap(vec![1, 2], vec![2, 3])); 19 | println!("{:?}", fair_candy_swap(vec![2], vec![1, 3])); 20 | println!("{:?}", fair_candy_swap(vec![1, 2, 5], vec![2, 4])); 21 | } 22 | -------------------------------------------------------------------------------- /892-surface-area-of-3d-shapes.rs: -------------------------------------------------------------------------------- 1 | pub fn surface_area(grid: Vec>) -> i32 { 2 | let mut ret = 0; 3 | for j in 0..grid.len() { 4 | for i in 0..grid.len() { 5 | // 去掉0 6 | if grid[i][j] == 0 { continue } 7 | ret += grid[i][j] * 4 + 2; 8 | // 减去上下左右的紧贴面积 9 | if i > 0 { ret -= vec![grid[i-1][j], grid[i][j]].iter().min().unwrap() } 10 | if i+1 < grid.len() { ret -= vec![grid[i+1][j], grid[i][j]].iter().min().unwrap() } 11 | if j > 0 { ret -= vec![grid[i][j-1], grid[i][j]].iter().min().unwrap() } 12 | if j+1 < grid.len() { ret -= vec![grid[i][j+1], grid[i][j]].iter().min().unwrap() } 13 | // println!("{:?}", ret); 14 | } 15 | } 16 | ret 17 | } 18 | 19 | fn main() { 20 | // let grid = vec![vec![1,2],vec![3,4]]; 21 | // println!("{:?}", surface_area(grid)); 22 | let grid = vec![vec![1,1,1],vec![1,0,1],vec![1,1,1]]; 23 | println!("{:?}", surface_area(grid)); 24 | } 25 | -------------------------------------------------------------------------------- /896-monotonic-array.rs: -------------------------------------------------------------------------------- 1 | pub fn is_monotonic(nums: Vec) -> bool { 2 | let mut sorted_nums = nums.clone(); 3 | sorted_nums.sort(); 4 | if nums == sorted_nums { 5 | true 6 | } else { 7 | sorted_nums.reverse(); 8 | nums == sorted_nums 9 | } 10 | } 11 | 12 | fn main() { 13 | let nums = vec![1,2,2,3]; 14 | println!("{:?}", is_monotonic(nums)); 15 | } 16 | -------------------------------------------------------------------------------- /905-sort_array_by_parity.rs: -------------------------------------------------------------------------------- 1 | pub fn sort_array_by_parity(nums: Vec) -> Vec { 2 | let mut res = Vec::new(); 3 | let mut vec = nums.clone(); 4 | vec.retain(|&x| x % 2 == 0); 5 | res.append(&mut vec); 6 | let mut vec = nums.clone(); 7 | vec.retain(|&x| x % 2 != 0); 8 | res.append(&mut vec); 9 | res 10 | } 11 | 12 | fn main() { 13 | println!("{:?}", sort_array_by_parity(vec![3,1,2,4])); 14 | } 15 | -------------------------------------------------------------------------------- /917-reverse-only-letters.rs: -------------------------------------------------------------------------------- 1 | pub fn reverse_only_letters(s: String) -> String { 2 | let mut idxs: Vec = vec!(); 3 | let mut tmp = String::new(); 4 | for (i, c) in s.chars().enumerate() { 5 | if c.is_alphabetic() { 6 | idxs.push(i); 7 | tmp.push(c); 8 | } 9 | } 10 | let mut s = s; 11 | unsafe { 12 | let vec = s.as_mut_vec(); 13 | let tmp_vec = tmp.as_mut_vec(); 14 | tmp_vec.reverse(); 15 | for (i, c) in tmp_vec.iter().enumerate() { 16 | vec[idxs[i]] = *c; 17 | } 18 | } 19 | s 20 | } 21 | 22 | fn main() { 23 | let s = "Test1ng-Leet=code-Q!".to_string(); 24 | println!("{:?}", reverse_only_letters(s)); 25 | } 26 | -------------------------------------------------------------------------------- /929-unique-email-addresses.rs: -------------------------------------------------------------------------------- 1 | // def num_unique_emails(emails) 2 | // emails.map do |e| 3 | // ear = e.split("@") 4 | // ear[0].split("+")[0].gsub(".", "") + "@" + ear[1] 5 | // end.uniq.count 6 | // end 7 | 8 | pub fn num_unique_emails(emails: Vec) -> i32 { 9 | use std::collections::HashSet; 10 | let mut mms: HashSet = HashSet::new(); 11 | for email in emails { 12 | let strs: Vec<&str> = email.split("@").collect(); 13 | let ss: Vec<&str> = strs[0].split("+").collect(); 14 | let mut tmp = ss[0].replace(".", ""); 15 | tmp.push_str("@"); 16 | tmp.push_str(strs[1]); 17 | mms.insert(tmp); 18 | } 19 | mms.len() as i32 20 | } 21 | 22 | fn main() { 23 | let emails: Vec = vec!["test.email+alex@leetcode.com","test.e.mail+bob.cathy@leetcode.com","testemail+david@lee.tcode.com"] 24 | .iter().map(|e|e.to_string()).collect(); 25 | println!("{:?}", num_unique_emails(emails)); 26 | } -------------------------------------------------------------------------------- /942-di-string-match.rs: -------------------------------------------------------------------------------- 1 | pub fn di_string_match(s: String) -> Vec { 2 | let s_len = s.len(); 3 | let mut arr: Vec = (0..s_len+1).map(|e|e as i32).collect(); 4 | let mut res: Vec = vec!(); 5 | for c in s.chars() { 6 | let op_index; 7 | if c == 'I' { 8 | op_index = 0; 9 | } else { 10 | op_index = arr.len()-1; 11 | } 12 | res.push(arr[op_index]); 13 | arr.remove(op_index); 14 | } 15 | res.push(*arr.last().unwrap()); 16 | res 17 | } 18 | 19 | fn main() { 20 | println!("{:?}", di_string_match("IDID".to_string())); 21 | } 22 | -------------------------------------------------------------------------------- /944-delete-columns-to-make-sorted.rs: -------------------------------------------------------------------------------- 1 | pub fn min_deletion_size(strs: Vec) -> i32 { 2 | let index = strs.get(0).unwrap().len(); 3 | let mut ret = 0; 4 | 'outer: for i in 0..index { 5 | let mut c = ' '; 6 | for s in &strs { 7 | let cc = s.chars().nth(i).unwrap(); 8 | if c > cc { 9 | ret += 1; 10 | continue 'outer; 11 | } 12 | c = cc; 13 | } 14 | } 15 | ret 16 | } 17 | 18 | fn main() { 19 | let strs = vec!["zyx","wvu","tsr"] 20 | .iter().map(|e|e.to_string()).collect(); 21 | println!("{:?}", min_deletion_size(strs)); 22 | } 23 | -------------------------------------------------------------------------------- /946-validate-stack-sequences.rs: -------------------------------------------------------------------------------- 1 | pub fn validate_stack_sequences(pushed: Vec, popped: Vec) -> bool { 2 | let mut stack: Vec = vec![]; 3 | let mut pushed = pushed; 4 | let mut popped = popped; 5 | while pushed.len() > 0 { 6 | let tmp = pushed.remove(0); 7 | stack.push(tmp); 8 | if tmp == popped[0] { 9 | // 这里应该持续出栈 10 | while stack.iter().last().is_some() && *stack.iter().last().unwrap() == popped[0] { 11 | stack.pop(); 12 | popped.remove(0); 13 | } 14 | } 15 | } 16 | if stack.len() == 0 { return true } 17 | stack.reverse(); 18 | stack == popped 19 | } 20 | 21 | fn main() { 22 | println!("{:?}", validate_stack_sequences(vec![1,2,3,4,5], vec![4,5,3,2,1])); 23 | println!("{:?}", validate_stack_sequences(vec![2,1,0], vec![1,2,0])); 24 | } 25 | -------------------------------------------------------------------------------- /961-n-repeated-element-in-size-2n-array.rs: -------------------------------------------------------------------------------- 1 | // solution 1 2 | // pub fn repeated_n_times(nums: Vec) -> i32 { 3 | // use std::collections::HashMap; 4 | // let mut mmp = HashMap::new(); 5 | // let half_len = nums.len() / 2; 6 | // let mut ret = 0; 7 | // for num in nums { 8 | // let count = mmp.entry(num).or_insert(0); 9 | // *count += 1; 10 | // if *count == half_len { 11 | // ret = num; 12 | // break; 13 | // } 14 | // } 15 | // ret 16 | // } 17 | 18 | // solution 2 19 | pub fn repeated_n_times(nums: Vec) -> i32 { 20 | let mut sorted_nums = nums.clone(); 21 | sorted_nums.sort(); 22 | let half_len = nums.len() / 2; 23 | if sorted_nums[half_len] == sorted_nums[half_len+1] { sorted_nums[half_len+1] } else { sorted_nums[half_len-1] } 24 | } 25 | 26 | fn main() { 27 | let nums = vec![3,3,5,9]; 28 | println!("{:?}", repeated_n_times(nums)); 29 | } 30 | -------------------------------------------------------------------------------- /977-squares-of-a-sorted-array.rs: -------------------------------------------------------------------------------- 1 | pub fn sorted_squares(nums: Vec) -> Vec { 2 | let mut res: Vec = nums.iter().map(|e|e*e).collect(); 3 | res.sort(); 4 | res 5 | } 6 | 7 | fn main() { 8 | let nums = vec![-4,-1,0,3,10]; 9 | println!("{:?}", sorted_squares(nums)); 10 | } 11 | -------------------------------------------------------------------------------- /985-sum-of-even-numbers-after-queries.rs: -------------------------------------------------------------------------------- 1 | pub fn sum_even_after_queries(nums: Vec, queries: Vec>) -> Vec { 2 | let mut ret = vec![]; 3 | let mut nums = nums.clone(); 4 | for i in 0 .. nums.len() { 5 | let val = queries[i][0]; 6 | let index = queries[i][1]; 7 | nums[index as usize] += val; 8 | let mut tmp = 0; 9 | for j in 0 .. nums.len() { 10 | if nums[j] % 2 == 0 { tmp += nums[j] } 11 | } 12 | ret.push(tmp) 13 | } 14 | ret 15 | } 16 | 17 | fn main() { 18 | let nums = vec![1,2,3,4]; 19 | let queries = vec![vec![1,0], vec![-3,1], vec![-4,0], vec![2,3]]; 20 | println!("{:?}", sum_even_after_queries(nums, queries)); 21 | } 22 | -------------------------------------------------------------------------------- /README.txt: -------------------------------------------------------------------------------- 1 | leetcode_rust 2 | 3 | Rush leetcode(https://leetcode-cn.com) by rust-lang 4 | 5 | 6 | -------------------------------------------------------------------------------- /commit.sh: -------------------------------------------------------------------------------- 1 | FILE=`git status --porcelain | sed s/^...//` 2 | git add $FILE 3 | git commit -m "Upsert $FILE" 4 | https_proxy=localhost:1088 git push 5 | -------------------------------------------------------------------------------- /lcp-50-WHnhjV.rs: -------------------------------------------------------------------------------- 1 | pub fn give_gem(gem: Vec, operations: Vec>) -> i32 { 2 | let mut gem = gem.clone(); 3 | for op in operations { 4 | let minus = (gem[op[0] as usize] as f64 / 2.0_f64).floor() as i32; 5 | gem[op[0] as usize] -= minus; 6 | gem[op[1] as usize] += minus; 7 | } 8 | *gem.iter().max().unwrap() - *gem.iter().min().unwrap() 9 | } 10 | 11 | fn main() { 12 | let gem = vec![3,1,2]; 13 | let operations = vec![vec![0,2],vec![2,1],vec![2,0]]; 14 | println!("{:?}", give_gem(gem, operations)); 15 | } 16 | -------------------------------------------------------------------------------- /lcp06-na-ying-bi.rs: -------------------------------------------------------------------------------- 1 | // 示例 1： 2 | 3 | // 输入：[4,2,1] 4 | 5 | // 输出：4 6 | 7 | // 解释：第一堆力扣币最少需要拿 2 次，第二堆最少需要拿 1 次，第三堆最少需要拿 1 次，总共 4 次即可拿完。 8 | 9 | // 来源：力扣（LeetCode） 10 | // 链接：https://leetcode-cn.com/problems/na-ying-bi 11 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 12 | 13 | fn main() { 14 | let coins = vec!(4,2,1); 15 | let res = min_count(coins); 16 | println!("{:?}", res); 17 | } 18 | 19 | pub fn min_count(coins: Vec) -> i32 { 20 | coins.into_iter().map(|e|e/2+e%2).sum() 21 | } 22 | -------------------------------------------------------------------------------- /lcp17-nGK0Fy.rs: -------------------------------------------------------------------------------- 1 | // 小扣在秋日市集发现了一款速算机器人。店家对机器人说出两个数字（记作 x 和 y），请小扣说出计算指令： 2 | 3 | // "A" 运算：使 x = 2 * x + y； 4 | // "B" 运算：使 y = 2 * y + x。 5 | // 在本次游戏中，店家说出的数字为 x = 1 和 y = 0，小扣说出的计算指令记作仅由大写字母 A、B 组成的字符串 s，字符串中字符的顺序表示计算顺序，请返回最终 x 与 y 的和为多少。 6 | 7 | // 示例 1： 8 | 9 | // 输入：s = "AB" 10 | 11 | // 输出：4 12 | 13 | // 解释： 14 | // 经过一次 A 运算后，x = 2, y = 0。 15 | // 再经过一次 B 运算，x = 2, y = 2。 16 | // 最终 x 与 y 之和为 4。 17 | 18 | // 来源：力扣（LeetCode） 19 | // 链接：https://leetcode-cn.com/problems/nGK0Fy 20 | // 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 21 | 22 | 23 | fn main() { 24 | println!("{:?}", calculate("AB".to_string())); 25 | } 26 | 27 | pub fn calculate(s: String) -> i32 { 28 | let mut x = 1; 29 | let mut y = 0; 30 | for c in s.chars() { 31 | if c == 'A' { 32 | x = 2 * x + y; 33 | } else { 34 | y = 2 * y + x 35 | } 36 | } 37 | x + y 38 | } 39 | -------------------------------------------------------------------------------- /lcp55-PTXy4P.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | impl Solution { 4 | pub fn get_minimum_time(time: Vec, fruits: Vec>, limit: i32) -> i32 { 5 | // tranlate from Ruby to Rust code 6 | // fruits.map{|e|time[e[0]]*(e[1]/limit.to_f).ceil}.sum 7 | fruits.iter().map(|e|time[e[0] as usize]*(e[1] as f64 / limit as f64).ceil() as i32).sum() 8 | } 9 | } 10 | 11 | fn main() { 12 | let time = vec![2,3,2]; 13 | let fruits = vec![vec![0,2], vec![1,4], vec![2,1]]; 14 | let limit = 3; 15 | println!("{:?}", Solution::get_minimum_time(time, fruits, limit)); 16 | } 17 | -------------------------------------------------------------------------------- /lcs-WqXACV.rs: -------------------------------------------------------------------------------- 1 | pub fn half_questions(questions: Vec) -> i32 { 2 | let n = questions.len() / 2; 3 | use std::collections::HashMap; 4 | let mut mmp = HashMap::new(); 5 | for i in questions { *mmp.entry(i).or_insert(0) += 1 } 6 | let mut mmp_vec: Vec<_> = mmp.iter().collect(); 7 | mmp_vec.sort_by(|b, a|a.1.cmp(&b.1)); 8 | let mut ret = 0; 9 | let mut current = 0; 10 | for e in mmp_vec { 11 | ret += 1; 12 | current += e.1; 13 | if current >= n { break } 14 | } 15 | ret 16 | } 17 | 18 | fn main() { 19 | println!("{:?}", half_questions(vec![13,8,3,7,5,6,11,12,3,6,6,11])); 20 | println!("{:?}", half_questions(vec![2,1,6,2])); 21 | println!("{:?}", half_questions(vec![1,5,1,3,4,5,2,5,3,3,8,6])); 22 | } 23 | --------------------------------------------------------------------------------