jabba_lib/
jvec.rs

1//! vector
2
3/// Returns `true` if the array / vector is sorted.
4///
5/// # Examples
6///
7/// ```
8/// let vec_yes = vec![1, 2, 3, 4];
9/// let vec_no = vec![1, 4, 3, 2];
10/// let array_yes = [1, 4, 8, 8];
11///
12/// assert_eq!(jabba_lib::jvec::is_sorted(&vec_yes), true);
13/// assert_eq!(jabba_lib::jvec::is_sorted(&vec_no), false);
14/// assert_eq!(jabba_lib::jvec::is_sorted(&array_yes), true);
15/// ```
16pub fn is_sorted<T: PartialOrd>(v: &[T]) -> bool {
17    if v.is_empty() {
18        return true;
19    }
20
21    for i in 0..v.len() - 1 {
22        if v[i] > v[i + 1] {
23            return false;
24        }
25    }
26    true
27}
28
29/// Returns a sorted vector (of references) of the input array / vector.
30///
31/// The returned vector contains references.
32///
33/// # Examples
34///
35/// ```
36/// let array = [8, 2, 9, 3];
37/// assert_eq!(jabba_lib::jvec::sorted_ref(&array), vec![&2, &3, &8, &9]);
38///
39/// let v = vec![8, 2, 9, 3];
40/// assert_eq!(jabba_lib::jvec::sorted_ref(&v), vec![&2, &3, &8, &9]);
41/// ```
42pub fn sorted_ref<T: Ord>(v: &[T]) -> Vec<&T> {
43    let mut copy = v.iter().collect::<Vec<_>>();
44    copy.sort();
45    copy
46}
47
48/// Returns a sorted copy (a vector) of the input array / vector.
49///
50/// The returned vector contains copies.
51///
52/// # Examples
53///
54/// ```
55/// let array = [8, 2, 9, 3];
56/// assert_eq!(jabba_lib::jvec::sorted_copy(&array), vec![2, 3, 8, 9]);
57///
58/// let v = vec![8, 2, 9, 3];
59/// assert_eq!(jabba_lib::jvec::sorted_copy(&v), vec![2, 3, 8, 9]);
60///
61/// let mut v = vec![6, 1, 9, 2, 0];
62/// let sorted = jabba_lib::jvec::sorted_copy(&v);
63/// v[0] = 99;
64/// assert_eq!(v, vec![99, 1, 9, 2, 0]);
65/// assert_eq!(sorted, vec![0, 1, 2, 6, 9]);
66/// ```
67pub fn sorted_copy<T: Ord + Clone>(v: &[T]) -> Vec<T> {
68    let mut copy: Vec<T> = v.iter().map(|x| (*x).clone()).collect();
69    copy.sort();
70    copy
71}
72
73/// Returns `true` if the array / vector is palindrome.
74///
75/// # Examples
76///
77/// ```
78/// let array1 = [8, 2, 2, 8];
79/// assert_eq!(jabba_lib::jvec::is_palindrome(&array1), true);
80///
81/// let array2 = [2, 0, 2, 2];
82/// assert_eq!(jabba_lib::jvec::is_palindrome(&array2), false);
83///
84/// let v = vec!["aa", "bb", "aa"];
85/// assert_eq!(jabba_lib::jvec::is_palindrome(&v), true);
86///
87/// ```
88pub fn is_palindrome<T: PartialEq>(v: &[T]) -> bool {
89    if v.len() < 2 {
90        return true;
91    }
92    // else
93    let mut i = 0;
94    let mut j = v.len() - 1;
95    while i < j {
96        if v[i] != v[j] {
97            return false;
98        }
99        i += 1;
100        j -= 1;
101    }
102    true
103}
104
105// ==========================================================================
106
107#[cfg(test)]
108mod tests {
109    use super::*;
110
111    #[test]
112    fn is_sorted_test1() {
113        assert!(is_sorted(&Vec::<i32>::new()));
114        assert!(is_sorted(&vec![1]));
115        assert!(is_sorted(&vec![1, 1]));
116        assert!(is_sorted(&vec![1, 2, 3]));
117        assert!(is_sorted(&vec![1, 2, 3, 3]));
118        assert!(is_sorted(&vec![1, 2, 3, 4, 5]));
119        assert!(is_sorted(&vec![1, 2, 3, 4, 5, 5, 5, 5]));
120    }
121
122    #[test]
123    fn is_sorted_test2() {
124        assert_eq!(is_sorted(&vec![2, 1]), false);
125        assert_eq!(is_sorted(&vec![1, 2, 3, 4, 3]), false);
126        assert_eq!(is_sorted(&vec![1, 2, 3, 2, 5]), false);
127        assert_eq!(is_sorted(&vec![1, 2, 1, 4, 5]), false);
128        assert_eq!(is_sorted(&vec![1, 0, 3, 4, 5]), false);
129        assert_eq!(is_sorted(&vec![3, 2, 3, 4, 5]), false);
130    }
131
132    #[test]
133    fn is_sorted_test3() {
134        assert!(is_sorted(&Vec::<&str>::new()));
135        assert!(is_sorted(&vec!["aa"]));
136        assert!(is_sorted(&vec!["aa", "aa"]));
137        assert!(is_sorted(&vec!["aa", "bb", "cc"]));
138        //
139        assert_eq!(is_sorted(&vec!["aa", "cc", "bb"]), false);
140        assert_eq!(is_sorted(&vec!["aa", "bb", "cc", "bb"]), false);
141    }
142
143    #[test]
144    fn sorted_ref_test1() {
145        let array = [8, 2, 9, 3];
146        assert_eq!(sorted_ref(&array), vec![&2, &3, &8, &9]);
147
148        let v = Vec::<i32>::new();
149        assert_eq!(sorted_ref(&v), Vec::<&i32>::new());
150
151        let v = ["bb", "cc", "aa"];
152        assert_eq!(sorted_ref(&v), vec![&"aa", &"bb", &"cc"]);
153    }
154
155    #[test]
156    fn sorted_copy_test1() {
157        let mut v = vec![6, 1, 9, 2, 0];
158        let sorted = sorted_copy(&v);
159        v[0] = 99;
160        assert_eq!(v, vec![99, 1, 9, 2, 0]);
161        assert_eq!(sorted, vec![0, 1, 2, 6, 9]);
162
163        let array = [8, 2, 9, 3];
164        assert_eq!(sorted_copy(&array), vec![2, 3, 8, 9]);
165
166        let v = ["bb", "cc", "aa"];
167        assert_eq!(sorted_copy(&v), vec!["aa", "bb", "cc"]);
168    }
169
170    #[test]
171    fn is_palindrome_test() {
172        assert_eq!(is_palindrome(&Vec::<i32>::new()), true);
173        assert_eq!(is_palindrome(&[0]), true);
174        assert_eq!(is_palindrome(&[0, 1]), false);
175        assert_eq!(is_palindrome(&[1, 1]), true);
176        assert_eq!(is_palindrome(&[1, 0, 1]), true);
177        //
178        assert_eq!(is_palindrome(&[1, 9, 7, 7]), false);
179        assert_eq!(is_palindrome(&[2, 0, 2, 2]), false);
180        assert_eq!(is_palindrome(&vec![1, 9, 9, 1]), true);
181    }
182}
jabba_lib/jvec.rs

jabba_lib/
jvec.rs
