Posts published in August 2018

花花酱 LeetCode 888. Uncommon Words from Two Sentences

By zxi on August 12, 2018

Problem

We are given two sentences A and B. (A sentence is a string of space separated words. Each word consists only of lowercase letters.)

A word is uncommon if it appears exactly once in one of the sentences, and does not appear in the other sentence.

Return a list of all uncommon words.

You may return the list in any order.

Example 1:

Input: A = "this apple is sweet", B = "this apple is sour"
Output: ["sweet","sour"]

Example 2:

Input: A = "apple apple", B = "banana"
Output: ["banana"]

Note:

0 <= A.length <= 200
0 <= B.length <= 200
A and B both contain only spaces and lowercase letters.

Solution: HashTable

Time complexity: O(m+n)

Space complexity: O(m+n)

C++

class Solution {

public:

vector<string> uncommonFromSentences(string A, string B) {

istringstream ss(A + " " + B);

unordered_map<string, int> counts;

string s;

while (ss >> s) ++counts[s];

vector<string> ans;

for (const auto& p : counts)

if (p.second == 1)

ans.push_back(p.first);

return ans;

}

};

花花酱 LeetCode 707. Design Linked List

By zxi on August 9, 2018

Problem

Design your implementation of the linked list. You can choose to use the singly linked list or the doubly linked list. A node in a singly linked list should have two attributes: val and next. val is the value of the current node, and next is a pointer/reference to the next node. If you want to use the doubly linked list, you will need one more attribute prev to indicate the previous node in the linked list. Assume all nodes in the linked list are 0-indexed.

Implement these functions in your linked list class:

get(index) : Get the value of the index-th node in the linked list. If the index is invalid, return -1.
addAtHead(val) : Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list.
addAtTail(val) : Append a node of value val to the last element of the linked list.
addAtIndex(index, val) : Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted.
deleteAtIndex(index) : Delete the index-th node in the linked list, if the index is valid.

Example:

MyLinkedList linkedList = new MyLinkedList();

linkedList.addAtHead(1);

linkedList.addAtTail(3);

linkedList.addAtIndex(1, 2); // linked list becomes 1->2->3

linkedList.get(1); // returns 2

linkedList.deleteAtIndex(1); // now the linked list is 1->3

linkedList.get(1); // returns 3

Note:

All values will be in the range of [1, 1000].
The number of operations will be in the range of [1, 1000].
Please do not use the built-in LinkedList library.

Solution: Single linked list

Keep tracking head and tail of the list.

Time Complexity:

addAtHead, addAtTail O(1)

addAtIndex O(index)

deleteAtIndex O(index)

Space complexity: O(1)

C++

Tracking head/tail and size of the list.

// Author: Huahua

// Running time: 24 ms

class MyLinkedList {

public:

MyLinkedList(): head_(nullptr), tail_(nullptr), size_(0) {}

~MyLinkedList() {

Node* node = head_;

while (node) {

Node* cur = node;

node = node->next;

delete cur;

}

head_ = nullptr;

tail_ = nullptr;

}

int get(int index) {

if (index < 0 || index >= size_) return -1;

auto node = head_;

while (index--)

node = node->next;

return node->val;

}

void addAtHead(int val) {

head_ = new Node(val, head_);

if (size_++ == 0)

tail_ = head_;

}

void addAtTail(int val) {

auto node = new Node(val);

if (size_++ == 0) {

head_ = tail_ = node;

} else {

tail_->next = node;

tail_ = tail_->next;

}

void addAtIndex(int index, int val) {

if (index < 0 || index > size_) return;

if (index == 0) return addAtHead(val);

if (index == size_) return addAtTail(val);

Node dummy(0, head_);

Node* prev = &dummy;

while (index--) prev = prev->next;

prev->next = new Node(val, prev->next);

++size_;

}

void deleteAtIndex(int index) {

if (index < 0 || index >= size_) return;

Node dummy(0, head_);

Node* prev = &dummy;

for (int i = 0; i < index; ++i)

prev = prev->next;

Node* node_to_delete = prev->next;

prev->next = prev->next->next;

if (index == 0) head_ = prev->next;

if (index == size_ - 1) tail_ = prev;

delete node_to_delete;

--size_;

}

private:

struct Node {

int val;

Node* next;

Node(int _val): Node(_val, nullptr) {}

Node(int _val, Node* _next): val(_val), next(_next) {}

};

Node* head_;

Node* tail_;

int size_;

};

// Author: Huahua

// Running time: 28 ms

class MyLinkedList {

public:

MyLinkedList(): head_(nullptr), tail_(nullptr), dummy_(0), size_(0) {}

~MyLinkedList() {

Node* node = head_;

while (node) {

Node* cur = node;

node = node->next;

delete cur;

}

head_ = nullptr;

tail_ = nullptr;

}

int get(int index) {

if (index < 0 || index >= size_) return -1;

return getNode(index)->val;

}

void addAtHead(int val) {

head_ = new Node(val, head_);

if (size_++ == 0)

tail_ = head_;

}

void addAtTail(int val) {

auto node = new Node(val);

if (size_++ == 0) {

head_ = tail_ = node;

} else {

tail_->next = node;

tail_ = tail_->next;

}

void addAtIndex(int index, int val) {

if (index < 0 || index > size_) return;

if (index == 0) return addAtHead(val);

if (index == size_) return addAtTail(val);

Node* prev = getNode(index - 1);

prev->next = new Node(val, prev->next);

++size_;

}

void deleteAtIndex(int index) {

if (index < 0 || index >= size_) return;

Node* prev = getNode(index - 1);

Node* node_to_delete = prev->next;

prev->next = node_to_delete->next;

if (index == 0) head_ = prev->next;

if (index == size_ - 1) tail_ = prev;

delete node_to_delete;

--size_;

}

private:

struct Node {

int val;

Node* next;

Node(int _val): Node(_val, nullptr) {}

Node(int _val, Node* _next): val(_val), next(_next) {}

};

Node* head_; // Does not own

Node* tail_; // Does not own

Node dummy_;

int size_;

Node* getNode(int index) {

dummy_.next = head_;

Node* n = &dummy_;

for (int i = 0; i <= index; ++i)

n = n->next;

return n;

}

};

Python3

"""

Author: Huahua

Running time: 132 ms

"""

class Node:

def __init__(self, val, _next=None):

self.val = val

self.next = _next

class MyLinkedList:

def __init__(self):

self.head = self.tail = None

self.size = 0

def getNode(self, index):

n = Node(0, self.head)

for i in range(index + 1):

n = n.next

return n

def get(self, index):

if index < 0 or index >= self.size: return -1

return self.getNode(index).val

def addAtHead(self, val):

n = Node(val, self.head)

self.head = n

if self.size == 0:

self.tail = n

self.size += 1

def addAtTail(self, val):

n = Node(val)

if self.size == 0:

self.head = self.tail = n

else:

self.tail.next = n

self.tail = n

self.size += 1

def addAtIndex(self, index, val):

if index < 0 or index > self.size: return

if index == 0: return self.addAtHead(val)

if index == self.size: return self.addAtTail(val)

prev = self.getNode(index - 1)

n = Node(val, prev.next)

prev.next = n

self.size += 1

def deleteAtIndex(self, index):

if index < 0 or index >= self.size: return

prev = self.getNode(index - 1)

prev.next = prev.next.next

if index == 0: self.head = prev.next

if index == self.size - 1: self.tail = prev

self.size -= 1

Java

// Author: Huahua

// Running time: 74 ms

class MyLinkedList {

class Node {

public int val;

public Node next;

public Node(int val) { this.val = val; this.next = null; }

public Node(int val, Node next) { this.val = val; this.next = next; }

}

private Node head;

private Node tail;

private int size;

public MyLinkedList() {

this.head = this.tail = null;

this.size = 0;

}

private Node getNode(int index) {

Node n = new Node(0, this.head);

while (index-- >= 0) {

n = n.next;

}

return n;

}

public int get(int index) {

if (index < 0 || index >= size) return -1;

return getNode(index).val;

}

public void addAtHead(int val) {

this.head = new Node(val, this.head);

if (this.size++ == 0)

this.tail = this.head;

}

public void addAtTail(int val) {

Node n = new Node(val);

if (this.size++ == 0)

this.head = this.tail = n;

else

this.tail = this.tail.next = n;

}

public void addAtIndex(int index, int val) {

if (index < 0 || index > this.size) return;

if (index == 0) { this.addAtHead(val); return; }

if (index == size) { this.addAtTail(val); return; }

Node prev = this.getNode(index - 1);

prev.next = new Node(val, prev.next);

++this.size;

}

public void deleteAtIndex(int index) {

if (index < 0 || index >= this.size) return;

Node prev = this.getNode(index - 1);

prev.next = prev.next.next;

if (index == 0) this.head = prev.next;

if (index == this.size - 1) this.tail = prev;

--this.size;

}

TIOBE Index History (2001-2018)

By zxi on August 8, 2018

Data Source: https://www.tiobe.com/tiobe-index/

Preprocessing: Sublime + Python

Visualization: https://github.com/Jannchie/Historical-ranking-data-visualization-based-on-d3.js

花花酱 LeetCode 638. Shopping Offers

By zxi on August 6, 2018

Problem

In LeetCode Store, there are some kinds of items to sell. Each item has a price.

However, there are some special offers, and a special offer consists of one or more different kinds of items with a sale price.

You are given the each item’s price, a set of special offers, and the number we need to buy for each item. The job is to output the lowest price you have to pay for exactly certain items as given, where you could make optimal use of the special offers.

Each special offer is represented in the form of an array, the last number represents the price you need to pay for this special offer, other numbers represents how many specific items you could get if you buy this offer.

You could use any of special offers as many times as you want.

Example 1:

Input: [2,5], [[3,0,5],[1,2,10]], [3,2]
Output: 14
Explanation: 
There are two kinds of items, A and B. Their prices are $2 and $5 respectively. 
In special offer 1, you can pay $5 for 3A and 0B
In special offer 2, you can pay $10 for 1A and 2B. 
You need to buy 3A and 2B, so you may pay $10 for 1A and 2B (special offer #2), and $4 for 2A.

Example 2:

Input: [2,3,4], [[1,1,0,4],[2,2,1,9]], [1,2,1]
Output: 11
Explanation: 
The price of A is $2, and $3 for B, $4 for C. 
You may pay $4 for 1A and 1B, and $9 for 2A ,2B and 1C. 
You need to buy 1A ,2B and 1C, so you may pay $4 for 1A and 1B (special offer #1), and $3 for 1B, $4 for 1C. 
You cannot add more items, though only $9 for 2A ,2B and 1C.

Note:

There are at most 6 kinds of items, 100 special offers.
For each item, you need to buy at most 6 of them.
You are not allowed to buy more items than you want, even if that would lower the overall price.

Solution: Search

Try all combinations.

// Author: Huahua

// Running time: 4 ms

class Solution {

public:

int shoppingOffers(vector<int>& price, vector<vector<int>>& special, vector<int>& needs) {

int with_offer = INT_MAX;

for (const auto& offer : special) {

vector<int> new_needs(needs);

bool valid_offer = true;

for (int i = 0; i < price.size(); ++i)

if (!(valid_offer &= ((new_needs[i] -= offer[i]) >= 0)))

break;

if (!valid_offer) continue;

with_offer = min(with_offer, shoppingOffers(price, special, new_needs) + offer.back());

}

int without_offer = inner_product(begin(price), end(price), begin(needs), 0);

return min(with_offer, without_offer);

}

};

花花酱 LeetCode 592. Fraction Addition and Subtraction

By zxi on August 6, 2018

Problem

Given a string representing an expression of fraction addition and subtraction, you need to return the calculation result in string format. The final result should be irreducible fraction. If your final result is an integer, say 2, you need to change it to the format of fraction that has denominator 1. So in this case, 2 should be converted to 2/1.

Example 1:

Input:"-1/2+1/2"
Output: "0/1"

Example 2:

Input:"-1/2+1/2+1/3"
Output: "1/3"

Example 3:

Input:"1/3-1/2"
Output: "-1/6"

Example 4:

Input:"5/3+1/3"
Output: "2/1"

Note:

The input string only contains '0' to '9', '/', '+' and '-'. So does the output.
Each fraction (input and output) has format ±numerator/denominator. If the first input fraction or the output is positive, then '+' will be omitted.
The input only contains valid irreducible fractions, where the numerator and denominator of each fraction will always be in the range [1,10]. If the denominator is 1, it means this fraction is actually an integer in a fraction format defined above.
The number of given fractions will be in the range [1,10].
The numerator and denominator of the final result are guaranteed to be valid and in the range of 32-bit int.

Solution: Math

a/b+c/d = (a*d + b * c) / (b * d)

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

string fractionAddition(string expression) {

int a = 0;

int b = 1;

int c;

int d;

char slash;

istringstream in(expression);

while (in >> c >> slash >> d) {

a = a * d + b * c;

b *= d;

int gcd = abs(__gcd(a, b));

a /= gcd;

b /= gcd;

}

return to_string(a) + "/" + to_string(b);

}

};

C++/class

// Author: Huahua

// Running time: 0 ms

class Fraction {

public:

Fraction(int a, int b): a_(a), b_(b) {}

Fraction& operator+=(const Fraction& f) {

a_ = a_ * f.b_ + b_ * f.a_;

b_ = b_ * f.b_;

int d = abs(__gcd(a_, b_));

a_ /= d;

b_ /= d;

return *this;

}

string toString() {

return to_string(a_) + "/" + to_string(b_);

}

private:

int a_; // hold the sign, e.g. can be +-.

int b_; // always > 0.

};

class Solution {

public:

string fractionAddition(string expression) {

Fraction f(0, 1);

int a;

int b;

char op;

istringstream in(expression);

while (in >> a >> op >> b)

f += Fraction(a, b);

return f.toString();

}

};