Putting all the Long Contests inside the correct year folder in the Long Contest Folder

Author: MathProgrammer

Contests/Long Challenge/2017/06 June JUNE17/Explanation/A Good Set Explanation.txt

@@ -0,0 +1,13 @@
+A set of integers is called good if there does not exist three distinct elements a, b, c in it such that a + b = c.
+
+Your task is simple. Just output any good set of n integers. All the elements in this set should be distinct and should lie between 1 and 500, both inclusive.
+
+----------------------------------------------------------------------------
+
+The sum of two odd numbers is even. Odd numbers are not closed with respect to addition.
+
+    for(i = 1; i <= size_of_set; i++)
+    {
+        printf("%d ", (2*i - 1));
+    }
+    printf("\n");

Contests/Long Challenge/2017/06 June JUNE17/Programs/A Good Set.c

@@ -0,0 +1,23 @@
+#include <stdio.h>
+
+void solve()
+{
+    int size_of_set, i;
+    scanf("%d", &size_of_set);
+
+    for(i = 1; i <= size_of_set; i++)
+    {
+        printf("%d ", (2*i - 1));
+    }
+    printf("\n");
+}
+
+int main()
+{
+    int no_of_test_cases;
+    scanf("%d", &no_of_test_cases);
+    while(no_of_test_cases-- != 0)
+        solve();
+
+    return 0;
+}

Contests/Long Challenge/2017/07 July JULY17/Explanation/Chef and Sign Sequence Explanation.txt

@@ -0,0 +1,55 @@
+Chef found a strange string yesterday - a string of signs s, where each sign is either a '<', '=' or a '>'. Let N be the length of this string. 
+Chef wants to insert N + 1 positive integers into this sequence and make it valid. 
+A valid sequence is a sequence where every sign is preceded and followed by an integer, and the signs are correct. 
+That is, if a sign '<' is preceded by the integer a and followed by an integer b, then a should be less than b. Likewise for the other two signs as well. 
+Chef can take some positive integers in the range [1, P] and use a number in the range as many times as he wants.
+Help Chef find the minimum possible P with which he can create a valid sequence.
+
+--------------------------------------------------------------
+
+Notice that if there was a sequence of equal to and greater than signs like,
+
+< = < = = < ... The number of distinct numbers must be equal to at least 1 more than the number of < signs. Because each of these signs cause an inequality.
+
+----------------------------------------
+
+My idea was to go through the string ... Go through every run of < and =, and > and =, keeping track of the maximum number of < and > occuring in any run.
+
+P = 1 + max.
+
+I got a WA at first because I only considered the greater case and didn't consider that case of > and = signs. Fortunately, I was able to catch the mistake myself.
+I solved it in contest environment so no access to other solutions or editorials. It felt great to see the green tick after solving a problem on your own !
+
+Also got strange results when the second loop was starting from i... The second loop always starts from where the first one ends.
+We know the entire extent of the first loop has no < signs. This ensures that the complexity is linear.
+
+---------------------------------------
+
+void solve()
+{
+    char sequence[MAX_LENGTH];
+    scanf("%s", sequence);
+
+    int maximum_sign_run = 0, length = strlen(sequence), i, j;
+
+    for(i = 0; i < length; i = j)
+    {
+        int no_of_greater_than = 0;
+        for(j = i; sequence[j] == '<' || sequence[j] == '='; j++)
+        {
+            no_of_greater_than += (sequence[j] == '<');
+        }
+
+        int no_of_less_than = 0;
+        for(; sequence[j] == '>' || sequence[j] == '='; j++) //Pick off from where the previous loop ended.
+        {
+            no_of_less_than += (sequence[j] == '>');
+        }
+
+        maximum_sign_run = max(maximum_sign_run, max(no_of_greater_than, no_of_less_than));
+
+    }
+    printf("%d\n", maximum_sign_run + 1);
+
+}
+

Contests/Long Challenge/2017/07 July JULY17/Explanation/Whats in a Name Explanation.txt

@@ -0,0 +1,19 @@
+Nitika was once reading a history book and wanted to analyze it. So she asked her brother to create a list of names of the various famous personalities in the book. 
+Her brother gave Nitika the list. Nitika was furious when she saw the list. The names of the people were not properly formatted. 
+She doesn't like this and would like to properly format it.
+A name can have at most three parts: first name, middle name and last name. It will have at least one part. The last name is always present. 
+The rules of formatting a name are very simple: 
+Only the first letter of each part of the name should be capital.
+All the parts of the name except the last part should be represented by only two characters. The first character should be the first letter of the part and should be 
+capitalized. The second character should be ".".
+
+Let us look at some examples of formatting according to these rules:
+gandhi -> Gandhi 
+mahatma gandhI -> M. Gandhi 
+Mohndas KaramChand ganDhi -> M. K. Gandhi 
+
+-----------------------------------------
+
+Surprisingly, this problem challenged me a lot more than I thought ... Ultimately, I didn't get full AC because I didn't put a space in between the names. I realised
+that because I only cleared the first subtask. That was a good way of informing by CodeChef. Then, I looked at the sample cases closer and saw that there was a space
+in between two parts of the name. Then, I scored full AC and 100 points. 

Contests/Long Challenge/2017/07 July JULY17/Programs/Chef and Sign Sequence.cpp

@@ -0,0 +1,44 @@
+#include <cstdio>
+#include <cstring>
+
+#define max(a, b) (a > b ? a : b)
+#define MAX_LENGTH 100000 + 1
+
+void solve()
+{
+    char sequence[MAX_LENGTH];
+    scanf("%s", sequence);
+
+    int maximum_sign_run = 0, length = strlen(sequence), i, j;
+
+    for(i = 0; i < length; i = j)
+    {
+        int no_of_greater_than = 0;
+        for(j = i; sequence[j] == '<' || sequence[j] == '='; j++)
+        {
+            no_of_greater_than += (sequence[j] == '<');
+        }
+
+        int no_of_less_than = 0;
+        for(; sequence[j] == '>' || sequence[j] == '='; j++) //Pick off from where the previous loop ended.
+        {
+            no_of_less_than += (sequence[j] == '>');
+        }
+
+        maximum_sign_run = max(maximum_sign_run, max(no_of_greater_than, no_of_less_than));
+
+    }
+    printf("%d\n", maximum_sign_run + 1);
+
+}
+
+int main()
+{
+    int no_of_test_cases;
+    scanf("%d", &no_of_test_cases);
+
+    while(no_of_test_cases--)
+        solve();
+
+    return 0;
+}

Contests/Long Challenge/2017/07 July JULY17/Programs/Whats in the Name.cpp

@@ -0,0 +1,65 @@
+#include <cstdio>
+#include <iostream>
+#include <vector>
+#include <string>
+#include <string.h>
+#include <algorithm>
+
+#define all(v) (v).begin(), (v).end()
+#define MAX_LENGTH 50 + 1
+
+using namespace std;
+
+void solve()
+{
+    int i, space = 0;
+    char name[MAX_LENGTH];
+
+    string formatted_name;
+    fgets(name, MAX_LENGTH, stdin);
+
+    if(name[0] == '\n') return;
+
+    for(i = strlen(name) - 2; name[i] != ' ' && i > 0; i--)
+    {
+         formatted_name += tolower(name[i]);
+    }
+
+    while(i >= 0)
+    {
+        if(name[i] == ' ')
+        {
+            space++;
+
+            if(space > 1)
+                formatted_name += name[i + 1];
+
+            char last_char = formatted_name[formatted_name.length() - 1]; //Make first letter of name capital
+            formatted_name[formatted_name.length() - 1] = toupper(last_char);
+
+            formatted_name += " .";
+
+        }
+         i--;
+    }
+
+    char first_letter = name[0];
+    formatted_name += toupper(first_letter);
+
+    reverse(all(formatted_name));
+
+    cout << formatted_name << "\n";
+}
+
+int main()
+{
+    int no_of_test_cases;
+    scanf("%d", &no_of_test_cases);
+
+    no_of_test_cases++; //fgets reads the first new line as a test case.
+
+    while(no_of_test_cases--)
+        solve();
+
+    return 0;
+}

Contests/Long Challenge/2017/09 September SEPT17/Explanations/Chef and Pick Digit Explanation.txt

@@ -0,0 +1,74 @@
+
+-----------------------------------------
+
+Maintain a frequency vector of each digit in the number. This can be done in O(n) time.
+
+Now for each character of the alphabet check if it can be made. This can be done in O(t), where t is the number of alphabets.
+
+As t <<< n ... Complexity is O(n) overall.
+
+Probably, looping through all 26 alphabets and checking if the digits of it's ASCII representation are present using binary search will not work.
+
+That would be O(nlog n + t log n)  ... First for sorting and then t queries for each alphabet.
+
+I'm not sure. It might still pass.... But, this approach is nicer except I couldn't think of a better way to write it than put all of the ASCII representations of
+all alphabets inside a big switch-case.
+
+-------------------------------------------------
+
+int possible_to_make(char ch, vector <int> &frequency)
+{
+    switch(ch)
+    {
+        case 'A' : return (frequency[6] >= 1 && frequency[5] >= 1);
+        case 'B' : return (frequency[6] >= 2);
+        case 'C' : return (frequency[6] >= 1 && frequency[7] >= 1);
+        case 'D' : return (frequency[6] >= 1 && frequency[8] >= 1);
+        case 'E' : return (frequency[6] >= 1 && frequency[9] >= 1);
+        case 'F' : return (frequency[7] >= 1 && frequency[0] >= 1);
+        case 'G' : return (frequency[7] >= 1 && frequency[1] >= 1);
+        case 'H' : return (frequency[7] >= 1 && frequency[2] >= 1);
+        case 'I' : return (frequency[7] >= 1 && frequency[3] >= 1);
+        case 'J' : return (frequency[7] >= 1 && frequency[4] >= 1);
+        case 'K' : return (frequency[7] >= 1 && frequency[5] >= 1);
+        case 'L' : return (frequency[7] >= 1 && frequency[6] >= 1);
+        case 'M' : return (frequency[7] >= 2);
+        case 'N' : return (frequency[7] >= 1 && frequency[8] >= 1);
+        case 'O' : return (frequency[7] >= 1 && frequency[9] >= 1);
+        case 'P' : return (frequency[8] >= 1 && frequency[0] >= 1);
+        case 'Q' : return (frequency[8] >= 1 && frequency[1] >= 1);
+        case 'R' : return (frequency[8] >= 1 && frequency[2] >= 1);
+        case 'S' : return (frequency[8] >= 1 && frequency[3] >= 1);
+        case 'T' : return (frequency[8] >= 1 && frequency[4] >= 1);
+        case 'U' : return (frequency[8] >= 1 && frequency[5] >= 1);
+        case 'V' : return (frequency[8] >= 1 && frequency[6] >= 1);
+        case 'W' : return (frequency[8] >= 1 && frequency[7] >= 1);
+        case 'X' : return (frequency[8] >= 2);
+        case 'Y' : return (frequency[8] >= 1 && frequency[9] >= 1);
+        case 'Z' : return (frequency[9] >= 1 && frequency[0] >= 1);
+    }
+    return false;
+}
+
+void solve()
+{
+    const int no_of_alphabets = 26;
+    vector <int> frequency(no_of_alphabets, 0);
+
+    char number[MAX_SIZE];
+    scanf("%s", number);
+
+    for(int i = 0; number[i] != '\0'; i++)
+    {
+        frequency[number[i] - '0']++;
+    }
+
+    for(char current_char = 'A'; current_char <= 'Z'; current_char++)
+        if(possible_to_make(current_char, frequency))
+            putchar(current_char);
+
+    printf("\n");
+}
+
+-------------------------------
+

Contests/Long Challenge/2017/09 September SEPT17/Explanations/Little Chef and Sums Explanation.txt

@@ -0,0 +1,29 @@
+-------------------------------------------
+
+Prefix(i) + Suffix(i) = Sum(entire array) + A[i]
+
+, because A[i] is counted twice.
+
+To find the i that minimises Prefix(i) + Suffix(i) is the same as finding the i for which A[i] is minimum.
+
+The smallest such i is needed in case of a tie.
+
+----------------------------------------------
+
+void solve()
+{
+    int no_of_elements;
+    scanf("%d", &no_of_elements);
+
+    int minimum_element_index = 0, minimum_element = 1e9;
+    for(int i = 1; i <= no_of_elements; i++)
+    {
+        int element_i;
+        scanf("%d", &element_i);
+
+        if(element_i < minimum_element)
+            minimum_element_index = i, minimum_element = element_i;
+    }
+
+    printf("%d\n", minimum_element_index);
+}