Codechef: Easy Problems

Author: OmkarPathak

CompetitiveProgramming/CodeChef/P01_CIELAB.py

@@ -0,0 +1,47 @@
+# In Ciel's restaurant, a waiter is training. Since the waiter isn't good at arithmetic,
+# sometimes he gives guests wrong change. Ciel gives him a simple problem. What is A-B (A minus B) ?
+#
+# Surprisingly, his answer is wrong. To be more precise, his answer has exactly one wrong digit.
+# Can you imagine this? Can you make the same mistake in this problem?
+#
+# Input
+# An input contains 2 integers A and B.
+#
+# Output
+# Print a wrong answer of A-B. Your answer must be a positive integer containing the same number of digits
+# as the correct answer, and exactly one digit must differ from the correct answer. Leading zeros are not
+# allowed. If there are multiple answers satisfying the above conditions, anyone will do.
+#
+# Constraints
+# 1 ≤ B < A ≤ 10000
+#
+# Sample Input
+# 5858 1234
+#
+# Sample Output
+# 1624
+#
+# Output details
+# The correct answer of 5858-1234 is 4624. So, for instance, 2624, 4324, 4623, 4604 and 4629 will be accepted,
+# but 0624, 624, 5858, 4624 and 04624 will be rejected.
+
+# MY SOLUTION:
+
+## This solution gives error in codechef as this consumes more memory
+
+# A, B = input().split()
+# result = list(str(int(A) - int(B)))
+# result[random.randint(0, 3)] = str(random.randint(0, 9))
+# print(int(''.join(result)))
+
+A, B = map(int, input().split())
+C = A - B
+if C % 10 == 9:
+    C = C - 1
+else:
+    C = C + 1
+print(C)
+
+# Output For above solution:
+# 5858 1234
+# 4625

CompetitiveProgramming/CodeChef/P02_HORSES.py

@@ -0,0 +1,47 @@
+# There are N horses in the stable. The skill of the horse i is represented by an integer S[i].
+# The Chef needs to pick 2 horses for the race such that the difference in their skills is minimum.
+# This way, he would be able to host a very interesting race. Your task is to help him do this and
+# report the minimum difference that is possible between 2 horses in the race.
+#
+# Input:
+# First line of the input file contains a single integer T, the number of test cases.
+# Every test case starts with a line containing the integer N.
+# The next line contains N space separated integers where the i-th integer is S[i].
+#
+# Output:
+# For each test case, output a single line containing the minimum difference that is possible.
+#
+# Constraints:
+# 1 ≤ T ≤ 10
+# 2 ≤ N ≤ 5000
+# 1 ≤ S[i] ≤ 1000000000
+#
+# Example:
+#
+# Input:
+# 1
+# 5
+# 4 9 1 32 13
+#
+# Output:
+# 3
+
+# MY SOLUTION:
+
+testCase = int(input())
+for i in range(0, testCase):
+    n = int(input())
+    userInput = input().split()
+    userInput = sorted([int(i) for i in userInput])
+    mdif = (userInput[1] - userInput[0])            # Check difference
+    for i in range(0, n-1):
+        dif = userInput[i+1] - userInput[i]
+        if dif < mdif:
+            mdif = dif
+    print(mdif)
+
+# OUTPUT for above solution:
+# 1
+# 5
+# 4 9 1 32 13
+# 3

CompetitiveProgramming/CodeChef/P03_JOHNY.py

@@ -0,0 +1,55 @@
+# Vlad enjoys listening to music. He lives in Sam's Town. A few days ago he had a birthday, so his parents
+# gave him a gift: MP3-player! Vlad was the happiest man in the world! Now he can listen his favorite songs
+# whenever he wants!
+# Vlad built up his own playlist. The playlist consists of N songs, each has a unique positive integer length.
+# Vlad likes all the songs from his playlist, but there is a song, which he likes more than the others.
+# It's named "Uncle Johny".
+# After creation of the playlist, Vlad decided to sort the songs in increasing order of their lengths.
+# For example, if the lengths of the songs in playlist was {1, 3, 5, 2, 4} after sorting it becomes
+# {1, 2, 3, 4, 5}. Before the sorting, "Uncle Johny" was on A-th position (1-indexing is assumed for the
+# playlist) in the playlist.
+# Vlad needs your help! He gives you all the information of his playlist.
+# Your task is to find the position of "Uncle Johny" in the sorted playlist.
+#
+# Input
+# The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
+# The first line of each test case contains one integer N denoting the number of songs in Vlad's playlist.
+# The second line contains N space-separated integers A1, A2, ..., AN denoting the lenghts of Vlad's songs.
+# The third line contains the only integer A - the position of "Uncle Johny" in the initial playlist.
+#
+# Output
+# For each test case, output a single line containing the position of "Uncle Johny" in the sorted playlist.
+#
+# Constraints
+# 1 ≤ T ≤ 1000
+# 1 ≤ A ≤ N ≤ 100
+# 1 ≤ ki ≤ 100
+#
+# Example
+# Input:
+# 3
+# 4
+# 1 3 4 2
+# 2
+# 5
+# 1 2 3 9 4
+# 5
+# 5
+# 1 2 3 9 4
+# 1
+#
+# Output:
+# 3
+# 4
+# 1
+
+testCases = int(input())
+for i in range(0, testCases):
+    N = input()
+    A = list(map(int,input().split()))
+    K = int(input())
+    result = A[K - 1]
+    A = sorted(A)
+    for i in range(0, len(A)):
+        if (A[i]== result):
+            print (i + 1)

CompetitiveProgramming/CodeChef/P04_CONFLIP.py

@@ -0,0 +1,62 @@
+# In this game the player will use N coins numbered from 1 to N, and all the coins will be facing in
+# "Same direction" (Either Head or Tail),which will be decided by the player before starting of the game.
+#
+# The player needs to play N rounds.In the k-th round the player will flip the face of the all coins whose
+# number is less than or equal to k. That is, the face of coin i will be reversed, from Head to Tail, or,
+# from Tail to Head, for i ≤ k.
+#
+# Elephant needs to guess the total number of coins showing a particular face after playing N rounds.
+# Elephant really becomes quite fond of this game COIN FLIP, so Elephant plays G times. Please help the
+# Elephant to find out the answer.
+#
+# Input
+# The first line of input contains an integer T, denoting the number of test cases.
+# Then T test cases follow.
+#
+# The first line of each test contains an integer G, denoting the number of games played by Elephant.
+# Each of the following G lines denotes a single game, and contains 3 space separeted integers I, N, Q,
+# where I denotes the initial state of the coins, N denotes the number of coins and rounds, and Q, which
+# is either 1, or 2 as explained below.
+#
+# Here I=1 means all coins are showing Head in the start of the game, and I=2 means all coins are showing
+# Tail in the start of the game. Q=1 means Elephant needs to guess the total number of coins showing Head
+# in the end of the game, and Q=2 means Elephant needs to guess the total number of coins showing Tail in
+# the end of the game.
+#
+# Output
+# For each game, output one integer denoting the total number of coins showing the particular face in the
+# end of the game.
+#
+# Constraints
+# 1 ≤ T ≤ 10
+# 1 ≤ G ≤ 20000
+# 1 ≤ N ≤ 109
+# 1 ≤ I ≤ 2
+# 1 ≤ Q ≤ 2
+# Example
+#
+# Input:
+# 1
+# 2
+# 1 5 1
+# 1 5 2
+#
+# Output:
+# 2
+# 3
+
+# MY SOLUTION:
+testCases = int(input())
+while testCases:
+    testCases -= 1
+    G = int(input())
+    while G:
+        G -= 1
+        I, N, Q = map(int, input().split())
+        if N % 2 == 0:
+            print(N // 2)
+        else:
+            if I == Q:
+                print(N // 2)
+            else:
+                print((N // 2) + 1)

CompetitiveProgramming/CodeChef/P05_CARVANS.py

@@ -0,0 +1,44 @@
+# Input
+# The first line of the input contains a single integer T denoting the number of test cases to follow.
+# Description of each test case contains 2 lines. The first of these lines contain a single integer N,
+# the number of cars. The second line contains N space separated integers, denoting the maximum speed of
+# the cars in the order they entered the long straight segment.
+#
+# Output
+# For each test case, output a single line containing the number of cars which were moving at their maximum
+# speed on the segment.
+#
+# Example
+# Input:
+# 3
+# 1
+# 10
+# 3
+# 8 3 6
+# 5
+# 4 5 1 2 3
+#
+# Output:
+# 1
+# 2
+# 2
+#
+# Constraints
+# 1 ≤ T ≤ 100
+# 1 ≤ N ≤ 10,000
+# All speeds are distinct positive integers that fit in a 32 bit signed integer.
+
+testCases = int(input())
+while testCases:
+    testCases -= 1
+    N = int(input())
+    speeds = [int(i) for i in input().split()]
+    maximum = speeds[0]
+    count = 0
+    for i in range(1, len(speeds)):
+        if speeds[i] > maximum:
+            count += 1
+        else:
+            maximum = speeds[i]
+
+    print(N - count)

CompetitiveProgramming/CodeChef/P06_LAPIN.py

@@ -0,0 +1,52 @@
+# Lapindrome is defined as a string which when split in the middle, gives two halves having the same
+# characters and same frequency of each character. If there are odd number of characters in the string,
+# we ignore the middle character and check for lapindrome. For example gaga is a lapindrome, since the
+# two halves ga and ga have the same characters with same frequency. Also, abccab, rotor and xyzxy are a
+# few examples of lapindromes. Note that abbaab is NOT a lapindrome. The two halves contain the same
+# characters but their frequencies do not match.
+# Your task is simple. Given a string, you need to tell if it is a lapindrome.
+#
+# Input:
+# First line of input contains a single integer T, the number of test cases.
+# Each test is a single line containing a string S composed of only lowercase English alphabet.
+#
+# Output:
+# For each test case, output on a separate line: "YES" if the string is a lapindrome and "NO" if it is not.
+#
+# Constraints:
+# 1 ≤ T ≤ 100
+# 2 ≤ |S| ≤ 1000, where |S| denotes the length of S
+#
+# Example:
+# Input:
+# 6
+# gaga
+# abcde
+# rotor
+# xyzxy
+# abbaab
+# ababc
+#
+# Output:
+# YES
+# NO
+# YES
+# YES
+# NO
+# NO
+
+testCases = int(input())
+while testCases:
+    testCases -= 1
+    string = input()        # input is already in string format so no need to type-cast
+    halve = len(string) // 2
+    if len(string) % 2 == 0:
+        if sorted(string[:halve]) == sorted(string[halve:]):
+            print('YES')
+        else:
+            print('NO')
+    else:
+        if sorted(string[:halve]) == sorted(string[halve + 1:]):
+            print('YES')
+        else:
+            print('NO')

CompetitiveProgramming/CodeChef/P07_BUYING2.py

@@ -0,0 +1,59 @@
+# Customers in Strangeland are strange. A customer points at some kind of sweets and gives several banknotes
+# to the seller. This means that he wants to buy a positive number of sweets of that kind. He doesn't tell
+# the exact number of sweets he wants to buy. The only thing Ann knows is: an 'adequate' customer won't give
+# any extra banknotes. It means that if you throw away any banknote, the resulting amount of money won't be
+# enough to buy the wanted number of sweets.
+#
+# Ann has to determine the number of sweets the customer wants. Help Ann write a program which determines
+# this number or tells that it's impossible.
+#
+# Input
+# The first line of the input contains a single integer T, the number of test cases (no more than 20).
+# T test cases follow. Each test case consists of two lines. The first of these lines contains two integers
+# N and X (1 ≤ N, X ≤ 100) separated by a single space. N is the number of banknotes given by the customer.
+# X is the cost of a single sweet of the chosen kind. The second of these lines contains N space-separated
+# integers Ai (1 ≤ Ai ≤ 100), the values of the banknotes.
+#
+# Output
+# For each test case output exactly one line containing a single integer:
+#
+# -1 if the customer is inadequate and has given extra banknotes, or
+# K, the number of sweets the customer wants to buy. If there are several possible answers, output the
+# largest of them.
+#
+# Example
+# Input:
+# 3
+# 4 7
+# 10 4 8 5
+# 1 10
+# 12
+# 2 10
+# 20 50
+#
+# Output:
+# -1
+# 1
+# 7
+#
+# Explanation
+# In the first test case, the total amount of money received from the customer is 27. He can't buy more than
+# 3 sweets with this amount. If you throw away the banknote of value 5 (or of value 4), it will still be
+# possible to buy 3 sweets. Hence the customer is inadequate.
+#
+# In the second test case, it's clear that he wants to buy just one sweet (note that this number should be
+# positive).
+#
+# In the third test case, the total amount of money received is 70, which is enough for 7 sweets. The
+# customer might want to buy only 6 sweets, but we are interested in the largest possible answer.
+testCases = int(input())
+while testCases:
+    testCases -= 1
+    N, X = map(int, input().split())
+    bankNotes = [int(i) for i in input().split()]
+    bankNotes = sum(bankNotes)
+    if (N * X) <= bankNotes:
+        result = bankNotes // X
+        print(int(result))
+    else:
+        print(int('-1'))