Posts tagged as “simulation”

花花酱 LeetCode 944. Delete Columns to Make Sorted

By zxi on November 18, 2018

Problem

We are given an array A of N lowercase letter strings, all of the same length.

Now, we may choose any set of deletion indices, and for each string, we delete all the characters in those indices.

For example, if we have a string "abcdef" and deletion indices {0, 2, 3}, then the final string after deletion is "bef".

Suppose we chose a set of deletion indices D such that after deletions, each remaining column in A is in non-decreasing sorted order.

Formally, the c-th column is [A[0][c], A[1][c], ..., A[A.length-1][c]]

Return the minimum possible value of D.length.

Example 1:

Input: ["cba","daf","ghi"]
Output: 1

Example 2:

Input: ["a","b"]
Output: 0

Example 3:

Input: ["zyx","wvu","tsr"]
Output: 3

Note:

1 <= A.length <= 100
1 <= A[i].length <= 1000

Solution: Simulation

Check descending case column by column.

Time complexity: O(NL)

Space complexity: O(1)

C++

// Author: Huahua, 64 ms

class Solution {

public:

int minDeletionSize(vector<string>& A) {

int ans = 0;

for (int c = 0; c < A[0].size(); ++c)

for (int r = 1; r < A.size(); ++r) {

if (A[r][c] < A[r - 1][c]) {

++ans;

break;

}

return ans;

}

};

花花酱 LeetCode 12. Integer to Roman

By zxi on September 12, 2018

Problem

Roman numerals are represented by seven different symbols: I, V, X, L, C, D and M.

Symbol       Value
I             1
V             5
X             10
L             50
C             100
D             500
M             1000

For example, two is written as II in Roman numeral, just two one’s added together. Twelve is written as, XII, which is simply X + II. The number twenty seven is written as XXVII, which is XX + V + II.

Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not IIII. Instead, the number four is written as IV. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as IX. There are six instances where subtraction is used:

I can be placed before V (5) and X (10) to make 4 and 9.
X can be placed before L (50) and C (100) to make 40 and 90.
C can be placed before D (500) and M (1000) to make 400 and 900.

Given an integer, convert it to a roman numeral. Input is guaranteed to be within the range from 1 to 3999.

Example 1:

Input: 3
Output: "III"

Example 2:

Input: 4
Output: "IV"

Example 3:

Input: 9
Output: "IX"

Example 4:

Input: 58
Output: "LVIII"
Explanation: C = 100, L = 50, XXX = 30 and III = 3.

Example 5:

Input: 1994
Output: "MCMXCIV"
Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.

Solution: HashTable + Simulation

Map integer 1,4,5,9,10,40,50,90, …, 1000 to Romain

Start from the largest number y,

if x >= y:
ans += Roman[y]
x -= y

Time complexity: O(x)

Space complexity: O(x)

C++

// Author: Huahua

class Solution {

public:

string intToRoman(int num) {

vector<pair<int,string>> v{{1000, "M"}, {900, "CM"}, {500, "D"}, {400, "CD"},

{ 100, "C"}, { 90, "XC"}, { 50, "L"}, { 40, "XL"},

{ 10, "X"}, { 9, "IX"}, { 5, "V"}, { 4, "IV"},

{ 1, "I"}};

string ans;

auto it = cbegin(v);

while (num) {

if (num >= it->first) {

num -= it->first;

ans += it->second;

} else {

++it;

}

return ans;

}

};

Python3

# Author: Huahua

class Solution:

def intToRoman(self, num):

m = [[1000, "M"], [900, "CM"], [500, "D"], [400, "CD"],

[ 100, "C"], [ 90, "XC"], [ 50, "L"], [ 40, "XL"],

[ 10, "X"], [ 9, "IX"], [ 5, "V"], [ 4, "IV"],

[ 1, "I"]]

index = 0

ans = ''

while num > 0:

if num >= m[index][0]:

ans += m[index][1]

num -= m[index][0]

else:

index += 1

return ans

花花酱 LeetCode 7. Reverse Integer

By zxi on September 12, 2018

Problem

Given a 32-bit signed integer, reverse digits of an integer.

Example 1:

Input: 123
Output: 321

Example 2:

Input: -123
Output: -321

Example 3:

Input: 120
Output: 21

Note:
Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−2³¹, 2³¹− 1]. For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows.

Solution: Simulation

Reverse digit by digit. Be careful about the overflow and negative numbers (especially in Python)

Time complexity: O(log(x)) ~ O(1)

Space complexity: O(log(x)) ~ O(1)

C++

// Author: Huahua

class Solution {

public:

int reverse(int x) {

int ans = 0;

while (x != 0) {

int r = x % 10;

if (ans > INT_MAX / 10 || ans < INT_MIN / 10) return 0;

ans = ans * 10 + r;

x /= 10;

}

return ans;

}

};

Java

class Solution {

public int reverse(int x) {

int ans = 0;

while (x != 0) {

int r = x % 10;

if (ans > Integer.MAX_VALUE / 10 || ans < Integer.MIN_VALUE / 10) return 0;

ans = ans * 10 + r;

x /= 10;

}

return ans;

}

Python3

class Solution:

def reverse(self, x):

min_val = -(2**31);

max_val = 2**31 - 1;

sign = -1 if x < 0 else 1

x = abs(x)

ans = 0

while x != 0:

ans = ans * 10 + (x % 10)

x //= 10

ans *= sign

if ans > max_val or ans < min_val: return 0

return ans

花花酱 LeetCode 504. Base 7

By zxi on August 17, 2018

Problem

Given an integer, return its base 7 string representation.

Example 1:

Input: 100
Output: "202"

Example 2:

Input: -7
Output: "-10"

Note: The input will be in range of [-1e7, 1e7].

Solution: Simulation

Time complexity: O(logn)

Space complexity: O(logn)

// Author: Huahua

// Running time: 4 ms

class Solution {

public:

string convertToBase7(int num) {

bool is_nagetive = num<0;

num = abs(num);

string ans;

do {

ans += ('0' + (num % 7));

num /= 7;

} while (num > 0);

if (is_nagetive)

ans += "-";

reverse(begin(ans), end(ans));

return ans;

}

};

花花酱 LeetCode 551. Student Attendance Record I

By zxi on August 17, 2018

Problem

You are given a string representing an attendance record for a student. The record only contains the following three characters:

‘A’ : Absent.
‘L’ : Late.
‘P’ : Present.

A student could be rewarded if his attendance record doesn’t contain more than one ‘A’ (absent) or more than two continuous ‘L’ (late).

You need to return whether the student could be rewarded according to his attendance record.

Example 1:

Input: "PPALLP"
Output: True

Example 2:

Input: "PPALLL"
Output: False

Solution1: Simulation

Time complexity: O(n)

Space complexity: O(1)

// Author: Huahua

// Running time: 3 ms

class Solution {

public:

bool checkRecord(string s) {

int a{0};

int l{0};

for(char c: s) {

if (c == 'A') ++a;

if (c == 'L') ++l;

else l=0;

if (a > 1 || l > 2) return false;

}

return true;

}

};

Solution 2: Regex

// Author: Huahua

// Running time: 6 ms

class Solution {

public:

bool checkRecord(string s) {

return !std::regex_search(s, std::regex("A.*A|LLL"));

}

};