Vectors

C++, Rust, Python, Go(No semicolons), C

C++ Rust Python (List []) Go (Slice []) C
Access 
    
v[i]
            
    
v[i as usize]
            
    
v[i]
            
    
v[i]
            
    
v[i]
Back 
    
vector v;
v.back();
            
    
let mut v:Vec = Vec::new();
v.push(1);
v.push(2);
if let Some(l) = v.last() {
    prinln!("last=", l);
}
clear 
                               
v.clear();
            
                               
v.clear();
Create/Initialize
1D 

//vector v(size, init_value);
v.assign(3,10);//10 10 10
2D 

using vvI = vector<vector<int>>;
vvI vec = {
    {1,2,3},
    {4,5,6}
};
OR
//vec[row][col]
vvI v(row, vector<int>(col,0));
1D 
let mut v:Vec <String> = Vec::new();
let mut v:Vec <i32> = vec![];
Initialize 
let v2: Vec <i32> = vec![1,2,3];
let mut v = vec![0; 5]; //size=5, init value=0
let v: Vec <i32> = [1,2,3].to_vec();
2D 

let mut 2d_vec: Vec<Vec<i32>> = Vec::new();

// rows x cols matrix
let mut 2d_vec: Vec<Vec<i32>> = 
vec![vec![0; cols]; rows];

/*
    0 1 0 0
    1 1 1 0
*/
let v: Vec> = vec![
    vec![0, 1, 0, 0],
    vec![1, 1, 1, 0],
];
                        
                   
######### 1 D
a = []              #Empty
a = [False] * (5)   #Filled

######### 2 D
out = []
or
out = [[0 for _ in range(cols)] for _ in range(rows)]
range() 
                       
////// 1D
package main
import (
    "fmt"
)
func main() {
    a := make([]int, 5)
    for i:=0;i <5; i++ {
        a[i] = i+3
    }

    for index, val := range(a) {
        fmt.Println (index, val)
    }
}
$ go build test.go
$ ./test
index   value
0        3
1        4
2        5
3        6
4        7

/////// 2D
a := make([][]uint8, cols)
for i := range a {
    a[i] = make([]uint8, rows)
}
1D 
int a[10];

OR

int* a = (int*) malloc(sizeof(int)*10);
memset(a, 0, sizeof(int)*10));
free(a);
2D 
int a[3][4];

OR

//Using pointer to a pointer
int r=3, c=4;
int** arr = (int**)malloc(r * sizeof(int*));
for (int i=0;i<r;i++)
arr[i] = (int*)malloc(c * sizeof(int));

for (int i = 0; i < r; i++)
    free(arr[i]);
free(arr);
Delete
  • 1 element v.erase(v.begin()+position-1);
  • Range v.erase(v.begin()+position1, v.begin()position2);
  • All v.clear();
 
//pop(&mut self) -> Option
if let Some(a) = vec.pop() {
    
}
Last Element element = list.pop()
Find 

string word = "abcde";  char ch = 'd';
auto it = find(word.begin(), word.end(), ch);
                

// Find returns a index(usize)
let index = match word.find(ch) {
    Some (a)=>a,
    None => {
        0
    }
};
Max INT_MAX 
       
let max_int: i32 = i32::MAX;
let min_int: i32 = i32::MIN;
let maxi = std::cmp::max(a,b);
            
import sys
sys.max_int     //INT_MAX
min_int = -sys.maxsize - 1
pop Back. Remove last 
       
vec.pop_back();                
            
       
// Pop removes and returns last
if let Some(last) = st.pop() {
    println!("last element", last);
}
push_back() 
//push_back(): allocates element
//somewhere else then insert
//into vector at back.
v.push_back(11)

//emplace():also inserts at back
//it But constructs elements inside the stl only.
//Adv: Does in place insertion
//avoids unneccessary copy
v.emplace_back(11)
vec.push(str.clone()) list.append(4)
Insert vec.insert(v.begin() + 2, 7) vec[i] = ele
Iterate, Traverse 
   
vector<int> v;
for_each(v.begin(),v.end(),[&](int ele){
});

// next element
for (auto it=v.begin(); it!=v.end()-1; ++it) {
    auto next = std::next(it);
    out = (*it)*(*next);
}

// Reversing the string
void reverseString(vector& s) {
    for (auto it=s.begin(),itr = s.end() - 1; //Multiple Initializations
        it < itr;                            //Check
        ++it, --itr                         //Multiple inc,dec
        )
        swap(*it, *itr);
}
            
   
fun(nums: Vec<i32>) {
    for i in nums.iter().skip(1) {//skip 1st 2 element
        println!("{}", *i);
    }
}
for i in 1..10 {
    
}
// Closure or Lambda
let s:String = "010101";
s.chars().for_each(|ele| {
    if ele == '1' {

    }
});
            
   
for c in s[1:-1]:
  print(c)

j=1
#range(start, stop, step)
for i in range(0,n):
  print(vec[i][j])

# Reverse Iterate
for i in range(len(list) - 1,
 -1, -1):
  print(list[i])
            
        
for i := 0; i < len(nums)-1; i++ {
    sum += int64(nums[i])
}
OR
for index, n := range nums {
    sum += int64(n)
}
Last element vec.back() if Some(l) = vec.last()
Reverse 

reverse(str.begin(), str.end());
            
    
fn reverse_string_till_index(text: &str, index: usize) -> String {
    // Take characters up to index
    let mut chars: Vec = text.chars().take(index + 1).collect();

    // Reverse the characters
    chars.reverse();

    // Convert the reversed characters back into a string
    chars.into_iter().collect()
}
Slice last 3 print(a[-3:])
1st to last list[1:]
Size vec.size() vec.len() len(vec) len(arr)
Sort 
       
sort(a.begin(), a.end())
            
vec.sort();
Simple 
list.sort()
Custom 
def fun(s):
    return s[1] 
sorted(list, key=fun)
                        
   
v := []int
sort.Ints(v)

// sort [][]
v = :[][]
sort.Slice(v, func(i, j int) bool {
    return v[i][0] < v[j][0]
})                      
            
       
int cmpfunc(const void * a, const void * b) {
    return (*(int*)a - *(int*)b);
}
qsort(nums, numsSize, sizeof(int), cmpfunc);
Swap swap(arr[i], arr[j]) std::mem::swap(&mut a, &mut b); lst[i], lst[j] = lst[j], lst[i] a,b = b,a
Sum 
for(auto&i:v)
    sum += i;
OR
// C++17
sum = std::accumulate(v.begin(), v.end());
Ternary Operator 
int a = (x == '0') ? 1 : 0;
            
a = 1 if x == '0' else 0