Scribbling

[C++] LRU Cache

focalpoint — Sat, 5 Oct 2024 13:31:29 +0900

https://leetcode.com/problems/lru-cache/description/

#include <iostream>
#include <list>
#include <map>


using namespace std;


class Node {
public:
    int key;
    int val;

    Node() {}
    Node(int key=-1, int val=-1) : key(key), val(val) {}
    ~Node() {}
};


class LRUCache {
public:
    list<Node> ll;
    map<int,list<Node>::iterator> dict;
    int capacity;
    int cnt;

    LRUCache(int capacity) : capacity(capacity), cnt(0) {}

    int get(int key) {
        if (dict.find(key) != dict.end()) {
            auto it = dict[key];
            Node node(*it);
            ll.erase(it);
            ll.push_back(node);
            dict[key] = prev(ll.end());
            return node.val;
        }
        else {
            return -1;
        }
    }

    void put(int key, int value) {
        if (dict.find(key) != dict.end()) {
            auto it = dict[key];
            Node node = Node(*it);
            node.val = value;
            ll.erase(it);
            ll.push_back(node);
            dict[key] = prev(ll.end());
        }
        else {
            if (cnt == capacity) {
                Node popped = ll.front();
                dict.erase(popped.key);
                ll.pop_front();
                Node node = Node(key, value);
                ll.push_back(node);
                dict[key] = prev(ll.end());
            }
            else {
                Node node = Node(key, value);
                ll.push_back(node);
                dict[key] = prev(ll.end());
                cnt++;
            }
        }
    }
};




int main() {
    LRUCache lru(2);
    lru.put(2, 1);
    lru.put(1, 1);
    lru.get(2);
}

[C++] Interface

focalpoint — Wed, 2 Oct 2024 02:46:56 +0900

#include <iostream>


using namespace std;

class Printable {
	friend ostream& operator<<(ostream& os, const Printable& obj);
public:
	virtual void print(ostream& os) const = 0;
	virtual ~Printable() {}
};

ostream& operator<<(ostream& os, const Printable& obj) {
	obj.print(os);
	return os;
}

class class1 : public Printable {
public:
	virtual void print(ostream& os) const override {
		os << "class1" << endl;
	}
};

class class2 : public Printable {
public:
	virtual void print(ostream& os) const override {
		os << "class2" << endl;
	}
};

int main() {
	class1 cls1;
	class2 cls2;
	cout << cls1 << endl;
	cout << cls2 << endl;
}

[C++] Object Oriented Programming

focalpoint — Tue, 1 Oct 2024 08:09:51 +0900

https://leetcode.com/problems/implement-trie-prefix-tree/description/

Trie.h

#pragma once
#include <string>


class TrieNode
{
private:
	char ch;
	bool isWord;
	TrieNode* children[26] {nullptr};

public:
	TrieNode(char ch, bool isWord=false);
	TrieNode(const TrieNode& node);
	TrieNode(TrieNode&& node);
	TrieNode& operator=(const TrieNode& rhs);
	TrieNode& operator=(TrieNode&& rhs);
	
	char getCh() const;
	bool getIsWord() const;
	void setIsWord(bool isWord);
	TrieNode* getChild(int idx) const;
	void setChild(int idx, TrieNode* node);
	
	~TrieNode();
};


class Trie 
{
private:
	TrieNode* root;
	
public:
	Trie();
	Trie(const Trie& trie);
	Trie(Trie&& trie);
	Trie& operator=(const Trie& rhs);
	Trie& operator=(Trie&& rhs);
	
	TrieNode* getRoot() const;
	void setRoot(TrieNode* node);
	void insert(std::string word);
	bool search(std::string word);
	bool startsWith(std::string prefix);
	
	~Trie();
	
	friend void displayTrie(Trie& trie);
};


void displayTrie(Trie& trie);

Trie.cpp

#include <string>
#include <vector>
#include <iostream>

#include "Trie.h"


TrieNode::TrieNode(char ch, bool isWord) : ch(ch), isWord(isWord) {}

TrieNode::TrieNode(const TrieNode& node) : ch(node.getCh()), isWord(node.getIsWord()) {
	for (int i = 0; i < 26; i++) {
		if (node.getChild(i) != nullptr) {
			children[i] = new TrieNode(*(node.getChild(i)));
		}	
		else {
			children[i] = nullptr;
		}
	}
}

TrieNode::TrieNode(TrieNode&& node) : ch(node.getCh()), isWord(node.getIsWord()) {
	for (int i = 0; i < 26; i++) {
		children[i] = node.getChild(i);
        node.setChild(i, nullptr);
	}
}

TrieNode& TrieNode::operator=(const TrieNode& rhs) {
	if(this == &rhs) return *this;
	this->ch = rhs.getCh();
	this->isWord = rhs.getIsWord();
	for (int i = 0; i < 26; i++) {
		if(rhs.getChild(i) != nullptr) {
			children[i] = new TrieNode(*rhs.getChild(i));
		} else {
			children[i] = nullptr;
		}
	}
	return *this;
}

TrieNode& TrieNode::operator=(TrieNode&& rhs) {
	if(this == &rhs) return *this;
	this->ch = rhs.getCh();
	this->isWord = rhs.getIsWord();
	for (int i = 0; i < 26; i++) {
		children[i] = rhs.getChild(i);
        rhs.setChild(i, nullptr);
	}
	return *this;
}

char TrieNode::getCh() const {
	return ch;
}

bool TrieNode::getIsWord() const {
	return isWord;
}

void TrieNode::setIsWord(bool isWord) {
	this->isWord = isWord;
}

TrieNode* TrieNode::getChild(int idx) const {
	return children[idx];
}

void TrieNode::setChild(int idx, TrieNode* node) {
	children[idx] = node;
}

TrieNode::~TrieNode() {
	for (int i = 0; i < 26; i++) {
		if (children[i] != nullptr) {
			delete children[i];
		}
	}
}

Trie::Trie() {
	root = new TrieNode('R');
}

Trie::Trie(const Trie& trie) {
	root = new TrieNode(*trie.getRoot());
}

Trie::Trie(Trie&& trie) {
	root = trie.getRoot();
	trie.setRoot(nullptr);
}

Trie& Trie::operator=(const Trie& rhs) {
	if (this == &rhs) return *this;
	root = new TrieNode(*rhs.getRoot());
	return *this;
}

Trie& Trie::operator=(Trie&& rhs) {
	if (this == &rhs) return *this;
	root = rhs.getRoot();
	rhs.setRoot(nullptr);
	return *this;
}

TrieNode* Trie::getRoot() const {
	return root;
}

void Trie::setRoot(TrieNode* node) {
	root = node;
}

void Trie::insert(std::string word) {
	TrieNode* cur = getRoot();
	for (char c : word) {
		int idx = c - 'a';
		if (cur->getChild(idx) == nullptr) {
			TrieNode* node = new TrieNode(c);
			cur->setChild(idx, node);
		}
		cur = cur->getChild(idx);
	}
	cur->setIsWord(true);
}

bool Trie::search(std::string word) {
	TrieNode* cur = getRoot();
	for (char c : word) {
		int idx = c - 'a';
		if (cur->getChild(idx) == nullptr) {
			return false;
		}
		cur = cur->getChild(idx);
	}
	return cur->getIsWord();
}

bool Trie::startsWith(std::string prefix) {
	TrieNode* cur = getRoot();
	for (char c : prefix) {
		int idx = c - 'a';
		if (cur->getChild(idx) == nullptr) {
			return false;
		}
		cur = cur->getChild(idx);
	}
	return true;
}

Trie::~Trie() {
	if (root != nullptr) delete root;
}

void displayTrieHelper(std::vector<std::string>& words, TrieNode& node, std::string word) {
	std::string cur = word + node.getCh();
	if (node.getIsWord() == true) {
		words.push_back(cur);
	}
	for (int i = 0; i < 26; i++) {
		TrieNode* child = node.getChild(i);
		if (child != nullptr) {
			displayTrieHelper(words, *child, cur);
		}
	}
}

void displayTrie(Trie& trie) {
	std::vector<std::string> words;
	TrieNode* root = trie.getRoot();
	for (int i = 0; i < 26; i++) {
		TrieNode* child = root->getChild(i);
		if (child != nullptr) {
			displayTrieHelper(words, *child, "");
		}
	}
	for (std::string word : words) {
		std::cout << word << std::endl;
	}
}

main.cpp

#include <iostream>
#include <string>
#include <vector>
#include "Trie.h"


using namespace std;


int main() {
	Trie trie1;
	trie1.insert("apple");
	cout << trie1.search("apple") << endl;   // return True
	cout << trie1.search("app") << endl;     // return False
	cout << trie1.startsWith("app") << endl; // return True
	trie1.insert("app");
	cout << trie1.search("app") << endl;   // return True
	
	Trie trie2(trie1);
	cout << trie2.search("apple") << endl;   // return True
	cout << trie2.search("app") << endl;     // return True
	cout << trie2.startsWith("app") << endl; // return True
	cout << trie2.search("app") << endl;   // return True
	
	vector<Trie> vec;
	vec.push_back(trie2);
	cout << vec[0].search("apple") << endl;
	
	displayTrie(trie1);
	
	Trie trie3;
	trie3 = trie1;
	displayTrie(trie3);
	
}

[C++] Strings

focalpoint — Mon, 30 Sep 2024 11:59:10 +0900

https://www.hackerrank.com/challenges/attribute-parser/problem?isFullScreen=true

Attribute Parser | HackerRank

Parse the values within various tags.

www.hackerrank.com

#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
#include <map>
#include <sstream>

using namespace std;


int main() {
    /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
    int n, q;
    cin >> n >> q;
    cin.ignore();
    
    // tag1.tag2~attr : val
    map<string, string> parsed;
    string tags, attr;
    // parse n lines of hrml
    for (int i=0; i<n; i++) {
        string line;
        getline(cin, line);
        line = line.substr(1, line.size() - 2);
        // opening tag
        if (line[0] != '/') {
            stringstream ss(line);
            string tag;
            getline(ss, tag, ' ');
            if (tags.empty()) {
                tags = tag;
            }
            else {
                tags += "." + tag;
            }
            string word;
            while (getline(ss, word, ' ')) {
                if (word[0] == '=') {
                    continue;
                }
                // value
                else if (word[0] == '"') {
                    parsed[tags + "~" + attr] = word.substr(1, word.size()-2);
                }
                // attr
                else {
                    attr = word;
                }
            }            
        }
        // closing tag
        else {
            line = line.substr(1, line.size() - 1);
            string tag(line);
            int idx = tags.find("." + tag);
            if (idx != string::npos) {
                tags = tags.substr(0, idx);
            }
            else {
                tags = "";
            }
        }
    }
    
    // for (auto e : parsed) {
    //     cout << e.first << endl;
    //     cout << e.second << endl;
    // }
    
    // queries
    for (int i=0; i<q; i++) {
        string line;
        getline(cin, line);
        if (parsed.find(line) == parsed.end()) {
            cout << "Not Found!" << endl;
        }
        else {
            cout << parsed[line] << endl;
        }
    }
    
}

[C++] Abstract Class, Polymorphism

focalpoint — Sat, 28 Sep 2024 09:48:34 +0900

https://www.hackerrank.com/challenges/abstract-classes-polymorphism/problem?isFullScreen=true

Abstract Classes - Polymorphism | HackerRank

Given an abstract class Cache, write a class LRUCache which extends the class Cache and implement an LRU cache.

www.hackerrank.com

#include <iostream>
#include <vector>
#include <map>
#include <string>
#include <algorithm>
#include <set>
#include <cassert>
using namespace std;

struct Node{
   Node* next;
   Node* prev;
   int value;
   int key;
   Node(Node* p, Node* n, int k, int val):prev(p),next(n),key(k),value(val){};
   Node(int k, int val):prev(NULL),next(NULL),key(k),value(val){};
};

class Cache{
   
   protected: 
   map<int,Node*> mp; //map the key to the node in the linked list
   int cp;  //capacity
   Node* tail; // double linked list tail pointer
   Node* head; // double linked list head pointer
   virtual void set(int, int) = 0; //set function
   virtual int get(int) = 0; //get function

};

class LinkedList {
private:
    int cnt;
    Node* head;
    Node* tail;
    
public:
    LinkedList() : cnt(0), head(nullptr), tail(nullptr) {
        head = new Node(-1, -1);
        tail = new Node(-1, -1);
        head->next = tail;
        tail->prev = head;
    }
    
    void insertNodeToTail(Node* node) {
        Node* prev = tail->prev;
        prev->next = node;
        node->prev = prev;
        node->next = tail;
        tail->prev = node;
        cnt++;
    }
    
    int popHead() {
        Node* node = head->next;
        Node* next = node->next;
        next->prev = head;
        head->next = next;
        int key = node->key;
        delete node;
        cnt--;
        return key;
    }
    
    void removeNode(Node* node) {
        Node* prev = node->prev;
        Node* next = node->next;
        prev->next = next;
        next->prev = prev;
        delete node;
        cnt--;
    }
    
    int getCnt() {
        return cnt;
    }
    
    Node* getHead() {
        return head;
    }
    
    Node* getTail() {
        return tail;
    }
    
    ~LinkedList() {
        if (head != nullptr) delete head;
        if (tail != nullptr) delete tail;
    }
};

class LRUCache : public Cache {
protected:
    int cnt;
    LinkedList ll;
public:
    LRUCache(int capacity): Cache(), cnt(0) {
        this->cp = capacity;
        tail = ll.getTail();
        head = ll.getHead();
    }
    
    void set(int key, int val) {
        if (mp.find(key) != mp.end()) {
            Node* node = mp[key];
            mp.erase(key);
            Node* newNode = new Node(key, val);
            mp[key] = newNode;
            ll.removeNode(node);
            ll.insertNodeToTail(newNode);
        } 
        else {
            // at max capacity
            if (cnt == cp) {
                int deletedKey = ll.popHead();
                mp.erase(deletedKey);
                Node* node = new Node(key, val);
                mp[key] = node;
                ll.insertNodeToTail(node);
            }
            else {
                Node* node = new Node(key, val);
                mp[key] = node;
                ll.insertNodeToTail(node);
                cnt++;
            }
        }
    }
    
    int get(int key) {
        // cache miss
        if (mp.find(key) == mp.end()) {
            return -1;
        } 
        // cache hit
        else {
            Node* node = mp[key];
            mp.erase(key);
            int val = node->value;
            Node* newNode = new Node(key, val);
            mp[key] = newNode;
            ll.removeNode(node);
            ll.insertNodeToTail(newNode);
            return val;
        }
    }
};

int main() {
   int n, capacity,i;
   cin >> n >> capacity;
   LRUCache l(capacity);
   for(i=0;i<n;i++) {
      string command;
      cin >> command;
      if(command == "get") {
         int key;
         cin >> key;
         cout << l.get(key) << endl;
      } 
      else if(command == "set") {
         int key, value;
         cin >> key >> value;
         l.set(key,value);
      }
   }
   return 0;
}

[C++] Virtual Functions

focalpoint — Sat, 28 Sep 2024 04:34:04 +0900

https://www.hackerrank.com/challenges/virtual-functions/problem?isFullScreen=true

Virtual Functions | HackerRank

Learn how to use virtual functions and solve the given problem.

www.hackerrank.com

#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;


class Person {
public:
    string name;
    int age;
    
    Person() {}
    virtual void getdata() {};
    virtual void putdata() {};
    virtual ~Person() {}
};


class Professor : public Person {
public:
    static int id;
    int cur_id;
    int publications;
    
    Professor() : Person() {
        Professor::id++;
        cur_id = Professor::id;
    }
    virtual void getdata() override {
        string _name;
        int _publications;
        int _age;
        cin >> _name;
        cin >> _publications;
        cin >> _age;
        this->name = _name;
        this->publications = _publications;
        this->age = _age;
    }
    virtual void putdata() override {
        cout << this->name << " ";
        cout << this->publications << " ";
        cout << this->age << " ";
        cout << this->cur_id << endl;
    }
    
};


class Student : public Person {
public:
    static int id;
    int cur_id;
    int marks[6];
    int marks_total {0};
    
    Student() : Person() {
        Student::id++;
        cur_id = Student::id;
    }
    virtual void getdata() override {
        string _name;
        int _age;
        cin >> _name;
        cin >> _age;
        this->name = _name;
        this->age = _age;
        for (int i=0; i<6; i++) {
            cin >> marks[i];
            marks_total += marks[i];
        }
    }
    virtual void putdata() override {
        cout << this->name << " ";
        cout << this->age << " ";
        cout << this->marks_total << " ";
        cout << this->cur_id << endl;
    }
};


int Professor::id {0};
int Student::id {0};


int main(){

    int n, val;
    cin>>n; //The number of objects that is going to be created.
    Person *per[n];

    for(int i = 0;i < n;i++){

        cin>>val;
        if(val == 1){
            // If val is 1 current object is of type Professor
            per[i] = new Professor;

        }
        else per[i] = new Student; // Else the current object is of type Student

        per[i]->getdata(); // Get the data from the user.

    }

    for(int i=0;i<n;i++)
        per[i]->putdata(); // Print the required output for each object.

    return 0;

}

[C++] Regular Expression Matching

focalpoint — Thu, 26 Sep 2024 07:34:24 +0900

C++ Regular Expressions Library

https://en.cppreference.com/w/cpp/regex

Regular expressions library (since C++11) - cppreference.com

Regular expressions library The regular expressions library provides a class that represents regular expressions, which are a kind of mini-language used to perform pattern matching within strings. Almost all operations with regexes can be characterized by

en.cppreference.com

8. String to Integer (atoi)

https://leetcode.com/problems/string-to-integer-atoi/description/

#include <iostream>
#include <regex>
#include <stdexcept>
#include <climits>

class Solution {
public:
    int myAtoi(string s) {
        const std::regex pat("^ *([+-]?)([0-9]+)");
		std::smatch match;
		std::regex_search(s, match, pat);
		if (match.size() == 0) return 0;
		string sign = match.str(1);
		int parsed;
		try {
			parsed = stoi(match.str(2));
		} catch (std::out_of_range& e) {
			if (!sign.empty() and sign == "-")
                return INT_MIN;
            return INT_MAX;
		} 
		if (!sign.empty() and sign == "-") 
			return -parsed;
		return parsed;
    }
};

[Programmers] 택배 배달과 수거하기

focalpoint — Sat, 20 Jul 2024 06:52:37 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/150369

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

The key is to eliminate the farthest houses.

To identify the farthest ones, we may use max heaps.

1. Python

import heapq
def solution(cap, n, deliveries, pickups):
    h1 = []
    h2 = []
    for i, d in enumerate(deliveries):
        if d > 0:
            heapq.heappush(h1, (-i-1, d))
    for i, p in enumerate(pickups):
        if p > 0:
            heapq.heappush(h2, (-i-1, p))
    ret = 0
    while h1 or h2:
        if not h1:
            ret += 2 * -h2[0][0]
        elif not h2:
            ret += 2 * -h1[0][0]
        else:
            ret += 2 * max(-h1[0][0], -h2[0][0])
        c1 = cap
        while h1 and c1 > 0:
            i, d = heapq.heappop(h1)
            if d > c1:
                heapq.heappush(h1, (i, d - c1))
                c1 = 0
            elif d == c1:
                break
            else:
                c1 -= d
        c2 = cap
        while h2 and c2 > 0:
            i, d = heapq.heappop(h2)
            if d > c2:
                heapq.heappush(h2, (i, d - c2))
                c2 = 0
            elif d == c2:
                break
            else:
                c2 -= d
    return ret

2. C++

struct comparator {
	bool operator()(pair<int, int> p1, pair<int, int> p2) {
		return p1.first < p2.first;
	}
};


long long solution(int cap, int n, vector<int> deliveries, vector<int> pickups) {
	auto comp = [](pair<int, int> p1, pair<int, int> p2) {
		return p1.first < p2.first;
	};
	//priority_queue <pair<int, int>, vector<pair<int, int>>, decltype(comp)> pq1;
	//priority_queue <pair<int, int>, vector<pair<int, int>>, decltype(comp)> pq2;
	priority_queue <pair<int, int>, vector<pair<int, int>>, comparator> pq1;
	priority_queue <pair<int, int>, vector<pair<int, int>>, comparator> pq2;
	for (int i = 0; i < deliveries.size(); i++) {
		if (deliveries[i] > 0) {
			pq1.push({ i + 1, deliveries[i] });
		}
	}
	for (int i = 0; i < pickups.size(); i++) {
		if (pickups[i] > 0) {
			pq2.push({ i + 1, pickups[i] });
		}
	}
	long long ret = 0;
	while (!pq1.empty() or !pq2.empty()) {
		if (pq1.empty())
			ret += 2 * pq2.top().first;
		else if (pq2.empty())
			ret += 2 * pq1.top().first;
		else
			ret += 2 * max(pq1.top().first, pq2.top().first);
		int c1 = cap, c2 = cap;
		while (!pq1.empty() and c1 > 0) {
			auto[i, d] = pq1.top();
			pq1.pop();
			if (d > c1) {
				pq1.push({ i, d - c1 });
				c1 = 0;
			}
			else if (d == c1) {
				break;
			}
			else {
				c1 -= d;
			}
		}
		while (!pq2.empty() and c2 > 0) {
			auto [i, d] = pq2.top();
			pq2.pop();
			if (d > c2) {
				pq2.push({ i, d - c2 });
				c2 = 0;
			}
			else if (d == c2) {
				break;
			}
			else {
				c2 -= d;
			}
		}
	}
	return ret;
}

[LeetCode] 2781. Length of the Longest Valid Substring

focalpoint — Wed, 10 Jul 2024 03:03:54 +0900

https://leetcode.com/problems/length-of-the-longest-valid-substring/description/

The main idea is to use Trie data structure.

1. Python

class Solution:
    def longestValidSubstring(self, word: str, forbidden: List[str]) -> int:
        ret = 0
        trie = {}
        for f in forbidden:
            f = f[::-1]
            t = trie
            for c in f:
                if c not in t:
                    t[c] = {}
                t = t[c]
            t['#'] = len(f)
        j = 0
        for i in range(len(word)):
            valid = True
            nxtJ = None
            t = trie
            for k in range(i, j - 1, -1):
                c = word[k]
                if c not in t:
                    break
                t = t[c]
                if '#' in t:
                    valid = False
                    nxtJ = i - t['#'] + 2
                    break
            if valid is True:
                ret = max(ret, i - j + 1)
            else:
                j = nxtJ
        return ret

2. C++

class TrieNode {
	public:
		char ch;
		bool isWord;
		int length;
		TrieNode* children[26] {nullptr};
		
		TrieNode() {}
		
		TrieNode(char ch, bool isWord=false, int length=0): ch(ch), isWord(isWord), length(length) {}
		
		~TrieNode() {}
};


class Trie {
	public:
		TrieNode* root = new TrieNode();
		
		Trie () {}
		
		void insert(string word) {
			TrieNode* cur = root;
			for (char c : word) {
				int idx = c - 'a';
				if (cur->children[idx] == nullptr) {
					cur->children[idx] = new TrieNode(c);
				}
				cur = cur->children[idx];
			}
			cur->isWord = true;
			cur->length = word.size();
		}
		
		~Trie() {
			delete root;
		}		
};


class Solution {
public:
    int longestValidSubstring(string word, vector<string>& forbidden) {
        int ret = 0;
		Trie trie = Trie();
		for (string& word : forbidden) {
            reverse(word.begin(), word.end());
			trie.insert(word);
		}
		int j = 0;
		for (int i=0; i<word.size(); i++) {
			bool valid = true;
			int nxtJ = -1;
			TrieNode node = *trie.root;
			for (int k=i; k>j-1; k--) {
				char c = word[k];
				int idx = c - 'a';
				if (node.children[idx] == nullptr) {
					break;
				}
				node = *node.children[idx];
				if (node.isWord) {
					valid = false;
					nxtJ = i - node.length + 2;
					break;
				}
			}
			if (valid) {
				ret = max(ret, i - j + 1);
			} else {
				j = nxtJ;
			}
		}
		return ret;
    }
};

[LeetCode] 2340. Minimum Adjacent Swaps to Make a Valid Array

focalpoint — Tue, 2 Jul 2024 16:19:26 +0900

https://leetcode.com/problems/minimum-adjacent-swaps-to-make-a-valid-array/description/

1. Python

class Solution:
    def minimumSwaps(self, nums: List[int]) -> int:
        if len(nums) <= 1:
            return 0

        minVal = min(nums)
        maxVal = max(nums)

        for i in range(len(nums)):
            if nums[i] == minVal:
                minIdx = i
                break

        for i in range(len(nums)-1, -1, -1):
            if nums[i] == maxVal:
                maxIdx = i
                break

        if minIdx == maxIdx:
            return 0
        elif minIdx < maxIdx:
            return minIdx + len(nums) - maxIdx - 1
        else:
            return minIdx + len(nums) - maxIdx - 2

2. C++

class Solution {
public:
    int minimumSwaps(vector<int>& nums) {
        if (nums.size() <= 1) return 0;
		int minVal = *min_element(nums.begin(), nums.end());
		int maxVal = *max_element(nums.begin(), nums.end());
		int minIdx, maxIdx;
		for (int i=0; i<nums.size(); i++) {
			if (nums[i] == minVal) {
				minIdx = i;
				break;
			}
		}
		for (int i=nums.size()-1; i>=0; i--) {
			if (nums[i] == maxVal) {
				maxIdx = i;
				break;
			}
		}
		if (minIdx == maxIdx) return 0;
		else if (minIdx < maxIdx) return minIdx + nums.size() - maxIdx - 1;
		else return minIdx + nums.size() - maxIdx - 2;
    }
};