🚀 18-Nov-2020

Author: sureshmangs

Diff for: competitive programming/codeforces/1440A -Buy the String.cpp

@@ -0,0 +1,159 @@
+/*
+You are given four integers n, c0, c1 and h and a binary string s of length n.
+
+A binary string is a string consisting of characters 0 and 1.
+
+You can change any character of the string s (the string should be still binary after the change). You should pay h coins for each change.
+
+After some changes (possibly zero) you want to buy the string. To buy the string you should buy all its characters. To buy the character 0 you should pay c0 coins, to buy the character 1 you should pay c1 coins.
+
+Find the minimum number of coins needed to buy the string.
+
+Input
+The first line contains a single integer t (1≤t≤10) — the number of test cases. Next 2t lines contain descriptions of test cases.
+
+The first line of the description of each test case contains four integers n, c0, c1, h (1≤n,c0,c1,h≤1000).
+
+The second line of the description of each test case contains the binary string s of length n.
+
+Output
+For each test case print a single integer — the minimum number of coins needed to buy the string.
+
+Example
+inputCopy
+6
+3 1 1 1
+100
+5 10 100 1
+01010
+5 10 1 1
+11111
+5 1 10 1
+11111
+12 2 1 10
+101110110101
+2 100 1 10
+00
+outputCopy
+3
+52
+5
+10
+16
+22
+Note
+In the first test case, you can buy all characters and pay 3 coins, because both characters 0 and 1 costs 1 coin.
+
+In the second test case, you can firstly change 2-nd and 4-th symbols of the string from 1 to 0 and pay 2 coins for that.
+Your string will be 00000. After that, you can buy the string and pay 5⋅10=50 coins for that. The total number of coins paid will be 2+50=52.
+*/
+
+
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int main()
+{
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+
+    int t;
+    cin>>t;
+    while(t--){
+        int n, c0, c1, h;
+        cin>>n>>c0>>c1>>h;
+        string s;
+        cin>>s;
+
+        long long sum=0;
+
+        for(auto &ch: s){
+            if(ch=='0') sum+=min(c0, h+c1);
+            else sum+=min(c1, h+c0);
+        }
+
+        cout<<sum<<endl;
+    }
+
+
+return 0;
+}
+
+
+
+
+
+
+/* Less Efficient
+#include<bits/stdc++.h>
+using namespace std;
+
+int main()
+{
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+
+    int t;
+    cin>>t;
+    while(t--){
+        int n, c0, c1, h;
+        cin>>n>>c0>>c1>>h;
+        string s;
+        cin>>s;
+
+        long long sum=0;
+
+        if(c0==c1){
+            sum+=n*c0;
+            } else if(c0 > c1){
+                if(h<c0){
+                    for(int i=0;i<n;i++){
+                        if(s[i]=='0'){
+                           // s[i]='1';
+                            sum+=h;
+                        }
+                    }
+                    sum+=n*c1;
+                } else {
+                    for(int i=0;i<n;i++){
+                        if(s[i]=='0') sum+=c0;
+                        else sum+=c1;
+                    }
+                }
+            } else {
+                if(h<c1){
+                    for(int i=0;i<n;i++){
+                        if(s[i]=='1'){
+                           // s[i]='0';
+                            sum+=h;
+                        }
+                    }
+                    sum+=n*c0;
+                } else {
+                    for(int i=0;i<n;i++){
+                        if(s[i]=='0') sum+=c0;
+                        else sum+=c1;
+                    }
+                }
+            }
+
+            long long nc=0;
+
+            for(int i=0;i<n;i++){
+                if(s[i]=='0') nc+=c0;
+                else nc+=c1;
+            }
+
+            sum=min(sum, nc);
+
+            cout<<sum<<endl;
+    }
+
+
+return 0;
+}
+*/

Diff for: competitive programming/codeforces/1440B - Sum of Medians.cpp

@@ -0,0 +1,112 @@
+/*
+A median of an array of integers of length n is the number standing on the ⌈n2⌉ (rounding up) position in the non-decreasing ordering of its elements. Positions are numbered starting with 1. For example, a median of the array [2,6,4,1,3,5] is equal to 3. There exist some other definitions of the median, but in this problem, we will use the described one.
+
+Given two integers n and k and non-decreasing array of nk integers. Divide all numbers into k arrays of size n, such that each number belongs to exactly one array.
+
+You want the sum of medians of all k arrays to be the maximum possible. Find this maximum possible sum.
+
+Input
+The first line contains a single integer t (1≤t≤100) — the number of test cases. The next 2t lines contain descriptions of test cases.
+
+The first line of the description of each test case contains two integers n, k (1≤n,k≤1000).
+
+The second line of the description of each test case contains nk integers a1,a2,…,ank (0≤ai≤109) — given array. It is guaranteed that the array is non-decreasing: a1≤a2≤…≤ank.
+
+It is guaranteed that the sum of nk for all test cases does not exceed 2⋅105.
+
+Output
+For each test case print a single integer — the maximum possible sum of medians of all k arrays.
+
+Example
+inputCopy
+6
+2 4
+0 24 34 58 62 64 69 78
+2 2
+27 61 81 91
+4 3
+2 4 16 18 21 27 36 53 82 91 92 95
+3 4
+3 11 12 22 33 35 38 67 69 71 94 99
+2 1
+11 41
+3 3
+1 1 1 1 1 1 1 1 1
+outputCopy
+165
+108
+145
+234
+11
+3
+Note
+The examples of possible divisions into arrays for all test cases of the first test:
+
+Test case 1: [0,24],[34,58],[62,64],[69,78]. The medians are 0,34,62,69. Their sum is 165.
+
+Test case 2: [27,61],[81,91]. The medians are 27,81. Their sum is 108.
+
+Test case 3: [2,91,92,95],[4,36,53,82],[16,18,21,27]. The medians are 91,36,18. Their sum is 145.
+
+Test case 4: [3,33,35],[11,94,99],[12,38,67],[22,69,71]. The medians are 33,94,38,69. Their sum is 234.
+
+Test case 5: [11,41]. The median is 11. The sum of the only median is 11.
+
+Test case 6: [1,1,1],[1,1,1],[1,1,1]. The medians are 1,1,1. Their sum is 3.
+*/
+
+
+
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int main()
+{
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+
+    int t;
+    cin>>t;
+
+    while(t--){
+        int n, k;
+        cin>>n>>k;
+
+        vector<int> v(n*k);
+
+        for(int i=0;i<n*k;i++) cin>>v[i];
+
+        int mid=ceil(n/2.0);
+
+        int start=0, last=n*k-1;
+
+        long long sum=0;
+
+        vector<int> a(n);
+        while(k--){
+                int i=0, j=n-1;
+            while(i<mid-1){
+                a[i]=v[start];
+                start++;
+                i++;
+            }
+            while(j>=mid-1){
+                a[j]=v[last];
+                last--;
+                j--;
+            }
+
+            sum+=a[mid-1];
+        }
+
+        cout<<sum<<endl;
+    }
+
+
+return 0;
+}
+

Diff for: competitive programming/leetcode/1446. Consecutive Characters.cpp

@@ -56,3 +56,21 @@ class Solution {
         return maxi;
     }
 };
+
+
+
+
+class Solution {
+public:
+    int maxPower(string s) {
+        int n=s.length();
+        int maxi=0, cnt=0;
+        for(int i=0;i<n-1;i++){
+            if(s[i]==s[i+1]){
+                cnt++;
+                maxi=max(maxi, cnt);
+            } else cnt=0;
+        }
+        return maxi+1;
+    }
+};

Diff for: competitive programming/leetcode/147. Insertion Sort List.cpp

@@ -0,0 +1,63 @@
+Sort a linked list using insertion sort.
+
+
+A graphical example of insertion sort. The partial sorted list (black) initially contains only the first element in the list.
+With each iteration one element (red) is removed from the input data and inserted in-place into the sorted list
+
+
+Algorithm of Insertion Sort:
+
+Insertion sort iterates, consuming one input element each repetition, and growing a sorted output list.
+At each iteration, insertion sort removes one element from the input data, finds the location it belongs within the sorted list, and inserts it there.
+It repeats until no input elements remain.
+
+Example 1:
+
+Input: 4->2->1->3
+Output: 1->2->3->4
+Example 2:
+
+Input: -1->5->3->4->0
+Output: -1->0->3->4->5
+
+
+
+
+
+
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* insertionSortList(ListNode* head) {
+        if(!head) return head;
+
+        ListNode *it=head;
+
+        while(it!=NULL){
+            ListNode *curr=it;
+            int small=it->val;
+            ListNode *smallNode=it;
+            while(curr!=NULL){
+              if(curr->val<small){
+                  small=curr->val;
+                  smallNode=curr;
+              }
+                curr=curr->next;
+            }
+
+            swap(it->val, smallNode->val);
+            it=it->next;
+        }
+        return head;
+    }
+};