AI STICKER

Problem

Some people are standing in a row in a park. There are trees between them which cannot be moved. Your task is to rearrange the people by their heights in a non-descending order without moving the trees.

Example

For a = [-1, 150, 190, 170, -1, -1, 160, 180], the output should be
sortByHeight(a) = [-1, 150, 160, 170, -1, -1, 180, 190].

Input/Output

• [input] array.integer a

  If a[i] = -1, then the ith position is occupied by a tree. Otherwise a[i] is the height of a person standing in the ith position.

  Guaranteed constraints:
  5 ≤ a.length ≤ 15,
  -1 ≤ a[i] ≤ 200.

• [output] array.integer

  Sorted array a with all the trees untouched.

def sortByHeight(a):
lst = sorted([i for i in a if i > 0])
err_lst = [i for i in range(len(a)) if a[i] == -1]

for i in err_lst:
lst.insert(i, -1)

return lst

*lst : Input 리스트의 값 중 0 이상인 값들을 정렬한 리스트를 저장한 변수입니다.

*err_lst : Input 리스트의 값이 -1인 값들의 인덱스 값을 저장한 변수입니다.

-1을 제외한 나머지 숫자들만 정렬하는 문제입니다.

-1을 제외한 숫자들을 sort() 함수를 통해 정렬하고, -1에 해당하는 인덱스 값을 나중에 삽입하는 방식으로 문제 해결이 가능합니다. 

Problem

Ticket numbers usually consist of an even number of digits. A ticket number is considered lucky if the sum of the first half of the digits is equal to the sum of the second half.

Given a ticket number n, determine if it's lucky or not.

Example

• For n = 1230, the output should be
  isLucky(n) = true;
• For n = 239017, the output should be
  isLucky(n) = false.

Input/Output

• [input] integer n

  A ticket number represented as a positive integer with an even number of digits.

  Guaranteed constraints:
  10 ≤ n < 106.

• [output] boolean

  true if n is a lucky ticket number, false otherwise.

def isLucky(n):
number = str(n)

sh = number[:int(len(number)/2)]
he = number[int(len(number)/2):]

return sum([int(i) for i in sh]) == sum([int(i) for i in he])

*number : 인덱스 슬라이싱을 하기 위해 integer로 들어오는 입력 값을 string으로 변환한 값을 저장하는 변수입니다.

*sh : start to half, 처음부터 중간까지 문자열을 저장하는 변수입니다.

*he : half to end : 중간부터 끝까지 문자열을 저장하는 변수입니다.

Input 값으로 입력된 숫자의 절반과 나머지의 합이 같은지를 판단하는 문제입니다.

인덱스 슬라이싱을 위해 Input값을 String으로 변환하고, 변환한 상태에서 절반씩 나누어 변수에 저장해주었습니다.

for문을 사용하여 각각의 숫자 값을 integer로 변환 후 리스트로 반환하고, 반환한 리스트를 더한 값을 서로 비교하여 문제를 해결할 수 있습니다.

Problem

Given two strings, find the number of common characters between them.

Example

For s1 = "aabcc" and s2 = "adcaa", the output should be
commonCharacterCount(s1, s2) = 3.

Strings have 3 common characters - 2"a"s and 1 "c".

Input/Output

• [input] string s1

  A string consisting of lowercase latin letters a-z.

  Guaranteed constraints:
  1 ≤ s1.length ≤ 15.

• [input] string s2

  A string consisting of lowercase latin letters a-z.

  Guaranteed constraints:
  1 ≤ s2.length ≤ 15.

• [output] integer

def commonCharacterCount(s1, s2):
return sum([min(s1.count(i), s2.count(i)) for i in set(s1)])

두 개의 입력 문자열 중 공통된 문자열을 취하여 개수를 반환하는 형태입니다.

만약 s1이 문자 'a'를 2개, s2가 1개를 가지고 있는 형태라면, 최소값인 s2의 개수가 선택됩니다.

위와 같은 개념을 활용하면 문제를 해결할 수 있습니다.

Problem

Given an array of strings, return another array containing all of its longest strings.

Example

For inputArray = ["aba", "aa", "ad", "vcd", "aba"], the output should be
allLongestStrings(inputArray) = ["aba", "vcd", "aba"].

Input/Output

• [input] array.string inputArray

  A non-empty array.

  Guaranteed constraints:
  1 ≤ inputArray.length ≤ 10,
  1 ≤ inputArray[i].length ≤ 10.

• [output] array.string

  Array of the longest strings, stored in the same order as in the inputArray.

Solution

def allLongestStrings(inputArray):
length = max([len(i) for i in inputArray])
return [i for i in inputArray if len(i) == length]

*length : string으로 구성된 inputArray 속의 문자열들에 대한 길이의 최대값을 저장하는 변수입니다.

최종적으로 length에 저장된 길이와 같은 문자열들을 반환하여 문제를 해결할 수 있습니다.

Problem

After they became famous, the CodeBots all decided to move to a new building and live together. The building is represented by a rectangular matrix of rooms. Each cell in the matrix contains an integer that represents the price of the room. Some rooms are free (their cost is 0), but that's probably because they are haunted, so all the bots are afraid of them. That is why any room that is free or is located anywhere below a free room in the same column is not considered suitable for the bots to live in.

Help the bots calculate the total price of all the rooms that are suitable for them.

Example

• For

matrix = [[0, 1, 1, 2], 
          [0, 5, 0, 0], 
          [2, 0, 3, 3]]

the output should be
matrixElementsSum(matrix) = 9.

Here's the rooms matrix with unsuitable rooms marked with 'x':

[[x, 1, 1, 2], 
 [x, 5, x, x], 
 [x, x, x, x]]

Thus, the answer is 1 + 5 + 1 + 2 = 9.

• For

matrix = [[1, 1, 1, 0], 
          [0, 5, 0, 1], 
          [2, 1, 3, 10]]

the output should be
matrixElementsSum(matrix) = 9.

Here's the rooms matrix with unsuitable rooms marked with 'x':

[[1, 1, 1, x], 
 [x, 5, x, x], 
 [x, 1, x, x]]

Note that the free room in the first row make the full column unsuitable for bots.

Thus, the answer is 1 + 1 + 1 + 5 + 1 = 9.

Input/Output

• [input] array.array.integer matrix

  A 2-dimensional array of integers representing a rectangular matrix of the building.

  Guaranteed constraints:
  1 ≤ matrix.length ≤ 5,
  1 ≤ matrix[i].length ≤ 5,
  0 ≤ matrix[i][j] ≤ 10.

• [output] integer

  The total price of all the rooms that are suitable for the CodeBots to live in.

Solution

def matrixElementsSum(matrix):
for i in range(len(matrix) - 1):
for j in range(len(matrix[0])):
if matrix[i][j] == 0:
matrix[i+1][j] = 0

return sum([sum(matrix[i]) for i in range(len(matrix))])

2차원 배열의 탐색을 위해 중첩 for문을 사용하였습니다. 

만약 [i][j]의 값이 0이라면, 그 아래에 위치하는 값을 0으로 바꾸는 방식으로 진행하였습니다.

Problem

Given a sequence of integers as an array, determine whether it is possible to obtain a strictly increasing sequence by removing no more than one element from the array.

Example

• For sequence = [1, 3, 2, 1], the output should be
  almostIncreasingSequence(sequence) = false;

  There is no one element in this array that can be removed in order to get a strictly increasing sequence.

• For sequence = [1, 3, 2], the output should be
  almostIncreasingSequence(sequence) = true.

  You can remove 3 from the array to get the strictly increasing sequence [1, 2]. Alternately, you can remove 2 to get the strictly increasing sequence [1, 3].

Input/Output

• [input] array.integer sequence

  Guaranteed constraints:
  2 ≤ sequence.length ≤ 105,
  -105 ≤ sequence[i] ≤ 105.

• [output] boolean

  Return true if it is possible to remove one element from the array in order to get a strictly increasing sequence, otherwise return false.

def almostIncreasingSequence(sequence):
count_decreasing_sq = 0

for i in range(len(sequence) - 1):
if count_decreasing_sq > 1:
return False
elif sequence[i] > sequence[i+1]:
count_decreasing_sq += 1
if i >= 1 and sequence[i+1] <= sequence[i-1]:
if len(sequence) - 2 > i and sequence[i+2] <= sequence[i]:
count_decreasing_sq += 1

return count_decreasing_sq <= 1

*count_decreasing_sq : 내림차순으로 이어지는 흐름의 개수를 저장하는 변수입니다. 이 변수를 통해 정상적인 흐름으로 진행하고 있는지를 판단합니다.

문제에서 하나의 수는 제거할 수 있다고 했으므로, 한 번의 비정상적은 흐름은 감수합니다. 만약 비정상적인 흐름이 2번 이상 발견된다면 False를 반환합니다.

Problem

Ratiorg got statues of different sizes as a present from CodeMaster for his birthday, each statue having an non-negative integer size. Since he likes to make things perfect, he wants to arrange them from smallest to largest so that each statue will be bigger than the previous one exactly by 1. He may need some additional statues to be able to accomplish that. Help him figure out the minimum number of additional statues needed.

Example

For statues = [6, 2, 3, 8], the output should be
makeArrayConsecutive2(statues) = 3.

Ratiorg needs statues of sizes 4, 5 and 7.

Input/Output

• [input] array.integer statues

  An array of distinct non-negative integers.

  Guaranteed constraints:
  1 ≤ statues.length ≤ 10,
  0 ≤ statues[i] ≤ 20.

• [output] integer

  The minimal number of statues that need to be added to existing statues such that it contains every integer size from an interval [L, R](for some L, R) and no other sizes.

Solution

def makeArrayConsecutive2(statues):
return max(statues) - min(statues) - len(statues) + 1

Problem

Below we will define an n-interesting polygon. Your task is to find the area of a polygon for a given n.

A 1-interesting polygon is just a square with a side of length 1. An n-interesting polygon is obtained by taking the n - 1-interesting polygon and appending 1-interesting polygons to its rim, side by side. You can see the 1-, 2-, 3- and 4-interesting polygons in the picture below.

Example

• For n = 2, the output should be
  shapeArea(n) = 5;
• For n = 3, the output should be
  shapeArea(n) = 13.

Input/Output

• [input] integer n

  Guaranteed constraints:
  1 ≤ n < 104.

• [output] integer

  The area of the n-interesting polygon.

def shapeArea(n):
return n ** 2 + (n-1) ** 2

위의 그림과 같이 변화하는 도형의 개수를 예측하는 알고리즘 문제입니다.

이번 문제는 해당 알고리즘의 규칙만 찾으면 되는 단순한 문제입니다.

도형을 구성하는 사각형의 개수가 1개, 5개, 13개, 25개 ··· 와 같이 증가하고 있습니다.

이를 수식으로 표현하면 n의 제곱 + (n-1)의 제곱으로 표현할 수 있습니다.

Problem

Given an array of integers, find the pair of adjacent elements that has the largest product and return that product.

Example

For inputArray = [3, 6, -2, -5, 7, 3], the output should be
adjacentElementsProduct(inputArray) = 21.

7 and 3 produce the largest product.

Input/Output

• [input] array.integer inputArray

  An array of integers containing at least two elements.

  Guaranteed constraints:
  2 ≤ inputArray.length ≤ 10,
  -1000 ≤ inputArray[i] ≤ 1000.

• [output] integer

  The largest product of adjacent elements.

Solution

def adjacentElementsProduct(inputArray):
    return max([inputArray[i] * inputArray[i + 1] for i in range(len(inputArray) - 1)])

     *Point : List Comprehension

Step 1. integer 로 구성된 배열을 0부터 배열의 길이 -1 까지 for문을 활용하여 탐색합니다. (Index Error를 방지하기 위해 -1까지 탐색)

Step 2. i 번 째와 i+1 번 째를 곱한 값을 리스트에 저장합니다.

Step 3. max() 함수를 활용하여 반환된 리스트에서의 최대값을 추출합니다.

Problem

Given the string, check if it is a palindrome. (* palindrome은 어느 방향으로 읽어도 동일한 문장을 의미합니다.)

Example

• For inputString = "aabaa", the output should be
  checkPalindrome(inputString) = true;
• For inputString = "abac", the output should be
  checkPalindrome(inputString) = false;
• For inputString = "a", the output should be
  checkPalindrome(inputString) = true.
  
  

Input/Output

• [input] string inputString

  A non-empty string consisting of lowercase characters.

  Guaranteed constraints:
  1 ≤ inputString.length ≤ 105.

• [output] boolean

  true if inputString is a palindrome, false otherwise.

Solution

def checkPalindrome(inputString):
return inputString == inputString[::-1]

'리스트 슬라이싱' 을 활용하여 간단하게 문제해결 가능합니다.

inputString[::-1] 은 해당 문자열을 뒤에서 부터 순서대로 출력합니다.

inputString과 해당 문자열을 거꾸로 출력한 것을 비교한 값을 Boolean 값으로 반환하여 문제를 해결합니다.