Common functions implementation

substring

#![allow(unused)]
fn main() {
pub fn sub_string(s: String, start: usize, end: usize) -> String {
s.get(start..=end).unwrap().to_string()
}
}

convert hexadecimal to decimal

/*
十六进制转换为十进制
*/
fn hexadecimal_to_decimal(h: &str) -> i32 {
let mut result = 0;
for c in h.get(2..).unwrap().to_string().chars() {
match c.to_digit(16) {
Some(d) => result = result * 16 + d as i32,
None => return -1,
}
}
result
}
fn main(){
let re = hexadecimal_to_decimal("0xA0");
println!("{}", re);//160
}

parse string to i32

fn parse_to_int(b: &str) -> Option<i32> {
if b.len() == 0 {
return None;
}
let mut res = 0;
for c in b.chars() {
res *= 10;
res += c as i32 - 48;
}
return Some(res);
}
fn main(){
let re = parse_to_int("1014565115");
println!("{:?}", re);
}

binary to decimal

/*
二进制转换为十进制
*/
fn binary_to_decimal(num: &str) -> Option<i64> {
if num.len() == 0 {
return None;
}
let mut sum = 0;
let vec = num
.chars()
.map(|x| i64::from(x.to_digit(10).unwrap()))
.collect::<Vec<i64>>();
for (index, item) in vec.iter().rev().enumerate() {
sum += i64::pow(2, index as u32) * item;
}
Some(sum)
}
fn main(){
let re = binary_to_decimal("101");
println!("{:?}", re);
}

all prime factors

/*
数的所有质数因子
*/
fn all_prime_factors(n: usize) -> Vec<usize> {
let mut n = n as usize;
let mut factors: Vec<usize> = vec![];
for i in 2..n * n {
while n % i == 0 {
factors.push(i);
n /= i;
}
}
factors
}
fn main(){
let re = all_prime_factors(40);
println!("{:?}", re); //[2,2,2,5]
}

round

/*
四舍五入
*/
fn round(f: f64) -> i64 {
(f + 0.5).floor() as i64
}
fn main() {
let re = round(10.4);
assert_eq!(10, re);
}

input from terminal

pub fn input_string() -> String {
let mut input = String::new();
std::io::stdin().read_line(&mut input).unwrap();
input.trim().to_string()
}
pub fn input_num<T>() -> T
where
<T as std::str::FromStr>::Err: std::fmt::Debug,
T: std::str::FromStr,
{
let mut input = String::new();
std::io::stdin().read_line(&mut input).unwrap();
input.trim().to_string().parse::<T>().unwrap()
}
pub fn input_vec_string(split_by: &str) -> Vec<String> {
let mut input = String::new();
std::io::stdin().read_line(&mut input).unwrap();
input
.trim()
.split(split_by)
.filter(|s| !s.is_empty())
.map(|s| s.trim().to_string())
.map(|s| s.to_string())
.collect::<Vec<String>>()
}
pub fn input_vec_num<T>(split_by: &str) -> Vec<T>
where
<T as std::str::FromStr>::Err: std::fmt::Debug,
T: std::str::FromStr,
{
let mut input = String::new();
std::io::stdin().read_line(&mut input).unwrap();
input
.trim()
.split(split_by)
.filter(|s| !s.is_empty())
.map(|s| s.trim().to_string())
.map(|s| s.parse::<T>().unwrap())
.collect::<Vec<T>>()
}
fn input_loop() -> std::io::Lines<std::io::StdinLock<'static>> {
use std::io::{self, *};
let stdin = io::stdin();
stdin.lock().lines()
}
fn main() {
for line in input_loop() {
println!("{}", line.unwrap());
}
}

padding和对齐

#![allow(unused)]
fn main() {
// 右对齐，不足左边补空格
println!("|{:6}|", 21);//|    21|
println!("|{:>6}|", 21);//|    21|
// 右对齐，不足左边补0
println!("{:06}", 21);//000021
println!("{:>06}", 21);//000021
println!("{:0>6}", 21);//000021
// 右对齐，左边补-
println!("{:->6}", 21);//----21
// 居中对齐
println!("|{:^6}|", 21);//|  21  |
// 左对齐，右边补-
println!("|{:-<6}|", 21);//|21----|
}

数组去重

#![allow(unused)]
fn main() {
pub fn huawei_2016_17() {
let s = vec![1, 0, 1, 0, 0, 0, 1];
fn remove_repeat(v: Vec<i32>) -> Vec<i32> {
let mut res = vec![];
for i in 0..v.len() {
if res.contains(&v[i]) {
continue;
} else {
res.push(v[i]);
}
}
res
}
let res = remove_repeat(s);
println!("{:?}", res);//[1,0]
}
}

vertor 中的邻居

#![allow(unused)]
fn main() {
pub fn huawei_2016_18() {
let v = Vec::from("zankxnsk1515-5151xsx45");
let digits = v
.iter()
.enumerate()
.filter(|(i, c)| (**c as char).is_digit(10))
.map(|(i, c)| (i, *c, *c as char))
.collect::<Vec<_>>();
println!("{:?}", digits);
let mut d_iter = digits.iter();
let mut v = vec![];
while let Some(d) = d_iter.next() {
if let Some(d1) = d_iter.next() {
v.push([d.2, d1.2]);
}
}
// [['1', '5'], ['1', '5'], ['5', '1'], ['5', '1'], ['4', '5']]
println!("{:?}", v);
}
}

排序的Vec去重 并return重复的元素数量

fn remove_duplicates_from_sorted_vec(nums: Vec<i32>) -> usize {
if nums.len() < 1 {
return 0;
};
let n = nums.len();
let mut nums = nums.clone();
let mut j = 0;
for i in 0..n {
if nums[j] != nums[i] {
j += 1;
nums[j] = nums[i];
}
}
let (unique, duplicate) = nums.split_at(j + 1);
println!("{:?}", unique); // unique vec
println!("{:?}", duplicate); // duplicate vec
// [0, 1, 2, 3, 4]
// [2, 2, 3, 3, 4]
// 5
return j + 1; //重复的元素数
}
fn main() {
let res = remove_duplicates_from_sorted_vec(vec![0, 0, 1, 1, 1, 2, 2, 3, 3, 4]);
println!("{}", res);
}

判断链表是否有环

public boolean hasCycle(ListNode head) {
if (head == null || head.next == null) {
return false;
}
ListNode slow = head;
ListNode fast = head.next;
while (slow != fast) {
if (fast == null || fast.next == null) {
return false;
}
slow = slow.next;
fast = fast.next.next;
}
return true;
}

字符串中找出数字 find all digit in string

pub fn findall_digit(s: &str) -> Vec<i64> {
let mut s = s.chars().collect::<Vec<_>>();
let ss = s.clone();
for (i, c) in ss.iter().enumerate() {
if !c.is_digit(10) && i < ss.len() {
s[i] = ' ';
}
}
let s_digit = s.iter().map(|s| s.to_string()).collect::<Vec<_>>().join("");
s_digit
.split(" ")
.filter(|s| !s.is_empty())
.map(|s| s.trim().to_string())
.map(|s| s.parse::<i64>().unwrap())
.collect::<Vec<i64>>()
}
fn main(){
let res = findall_digit("xsxsx54xsxs45x4sx");
println!("{:?}", res); //[54, 45, 4]
}

String 全排列 (full arrangement)

#![allow(unused)]
fn main() {
fn full_arrangement(s: String) -> Vec<String> {
let s_string = s.to_string();
let mut out_vec = Vec::new();
for i in 0..s.len() + 1 {
for j in i + 1..s.len() + 1 {
out_vec.push(s_string.get(i..j).unwrap().to_string());
}
}
out_vec
}
println!("{:?}", full_arrangement("123".to_string())); //["1", "12", "123", "2", "23", "3"]
}

Vec 全排列 (full arrangement)

#![allow(unused)]
fn main() {
fn full_arrangement(s: Vec<i32>) -> Vec<Vec<i32>> {
let mut out_vec = Vec::new();
for i in 0..s.len() + 1 {
for j in i + 1..s.len() + 1 {
out_vec.push(s.get(i..j).unwrap().to_owned());
}
}
out_vec
}
println!("{:?}", full_arrangement(vec![1, 2, 3])); //[[1], [1, 2], [1, 2, 3], [2], [2, 3], [3]]
}

Vec 排序

#![allow(unused)]
fn main() {
pub fn permute(nums: Vec<i32>) -> Vec<Vec<i32>> {
if nums.len() <= 1 { return vec![nums]; };
let mut ret = vec![];
for i in 0..nums.len() {
let mut iter_ret = vec![];
let mut cloned_nums = nums.clone();
let index_item = cloned_nums.remove(i);
iter_ret.push(index_item);
for x in Solution::permute(cloned_nums) {
let mut cloned_iter_ret = iter_ret.clone();
cloned_iter_ret.extend(x);
ret.push(cloned_iter_ret);
}
}
ret
}
let ret = vec![
vec![1, 2, 3],
vec![1, 3, 2],
vec![2, 1, 3],
vec![2, 3, 1],
vec![3, 1, 2],
vec![3, 2, 1]
];
assert_eq!(ret, permute(vec![1, 2, 3]));//全排序
}

Vec 组合 (combinations)

pub fn combinations() {
// 组合 Combination
pub struct Combinations<T>
where
T: Ord + Clone,
{
original: Vec<T>,
possition: Vec<usize>,
len: usize,
started: bool,
}
impl<T> Combinations<T>
where
T: Ord + Clone,
{
//new
pub fn new(mut original: Vec<T>, len: usize) -> Self {
if original.len() > len && len >= 1 {
original.sort_unstable();
Self {
original,
possition: (0..len).collect(),
len,
started: false,
}
} else {
panic!("the length has to be smaller then the datasets len");
}
}
//insert
fn insert(&self, col: &mut Vec<T>) {
col.clear();
self.possition
.iter()
.enumerate()
.for_each(|(p, n)| col.insert(p, self.original[*n].clone()))
}
//next
pub fn next_combination(&mut self, mut comb: &mut Vec<T>) -> bool {
if !self.started {
// first pass throught
self.started = true;
self.insert(&mut comb);
true
} else {
let org_len = self.original.len();
// check if we cant bump the back number
if self.original[self.possition[self.len - 1]] == self.original[org_len - 1] {
// locate the number closest behind that needs to be bumped
for i in 2..=self.len {
if self.original[self.possition[self.len - i]]
< self.original[org_len - i]
{
//find the value of the
let lastpos = self.possition[self.len - i];
let val = &self.original[lastpos];
for j in lastpos + 1..org_len {
if *val < self.original[j] {
for k in 0..i {
self.possition[self.len - i + k] = j + k;
}
self.insert(&mut comb);
return true;
}
}
}
}
false
} else {
let mut i = self.possition[self.len - 1];
let current = &self.original[i];
let mut next = current;
while current == next {
i += 1;
next = &self.original[i];
}
self.possition[self.len - 1] = i;
self.insert(&mut comb);
true
}
}
}
}
impl<T> Iterator for Combinations<T>
where
T: Ord + Clone,
{
type Item = Vec<T>;
fn next(&mut self) -> Option<Self::Item> {
let mut vals = Vec::with_capacity(self.len);
if self.next_combination(&mut vals) {
Some(vals)
} else {
None
}
}
}
let mut comb = Combinations::new(vec![1, 2, 3, 4], 3).collect::<Vec<_>>();
println!("{:?}", comb); //[[1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4]]
}
fn main(){
combinations();
}

二分查找 (binary search)

#![allow(unused)]
fn main() {
let binary_search = |f: Vec<i32>, target: i32| {
let mut low = 0;
let mut high = f.len() - 1;
while low < high {
let mid = f64::floor((high - low) as f64 / 2.) as usize + low;
if f[mid] < target {
low = mid + 1;
} else {
high = mid;
}
}
return low;
};
assert_eq!(binary_search(vec![2, 5, 8], 8),2);
}

HJ4 字符串分割

•输入一个字符串，请按长度为8拆分每个输入字符串并进行输出； •长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。 输入描述： 连续输入字符串(每个字符串长度小于等于100) 输出描述： 依次输出所有分割后的长度为8的新字符串

示例1
输入：
abc
复制
输出：
abc00000

use std::io::{self, *};
fn main() {
let stdin = io::stdin();
unsafe {
for line in stdin.lock().lines() {
let mut ll = line.unwrap();
if ll.len()==8{
println!("{}",ll);
}
else if ll.len()<8{
let z = 8-ll.len();
for i in 0..z{
ll.push('0');
}
println!("{}",ll);
}
else{
let l_vec = ll.split("").filter(|s|!s.is_empty()).map(|s|s.to_string()).collect::<Vec<_>>();
let ll_vec = l_vec.chunks(8).collect::<Vec<_>>();
for ll in ll_vec{
if ll.len()==8{
println!("{}",ll.join(""));
}
else if ll.len()<8{
let mut lll = ll.to_vec();
let z = 8-ll.len();
for i in 0..z{
lll.push("0".to_string());
}
println!("{}",lll.join(""));
}
}
}
}
}
}

chunks windows

#![allow(unused)]
fn main() {
pub fn chunk_windows() {
let a = vec![1, 2, 3];
let a_chunks = a
.iter()
.as_slice()
.chunks(2)
.map(|s| s.to_vec())
.collect::<Vec<_>>();
let a_windows = a
.iter()
.as_slice()
.windows(2)
.map(|s| s.to_vec())
.collect::<Vec<_>>();
println!("{:?}", a_chunks);
println!("{:?}", a_windows);
// [[1, 2], [3]]
// [[1, 2], [2, 3]]
}
}

字母出现次数统计 (count letters)

#![allow(unused)]
fn main() {
//是否有效的字母异位词
pub fn is_anagram(s: String, t: String) -> bool {
//字母出现次数统计
fn count_letter(s: String) -> std::collections::BTreeMap<char, i32> {
use std::collections::BTreeMap;
let mut map: BTreeMap<char, i32> = BTreeMap::new();
for c in s.chars() {
if !map.contains_key(&c) {
map.insert(c, 0);
} else {
*map.get_mut(&c).unwrap() += 1;
}
}
map
}
count_letter(s) == count_letter(t)
}
}