why can't i see ur code on the link u posted??

It is NOT a cpp solution, it is C solution! Here is a cpp one:

https://www.hackerrank.com/challenges/cut-the-sticks/submissions/code/12786708

include

using namespace std; int MIN(int a[],int length) { int min; for(int j=0;jmax) max=a[k];} return max; } int main() { int N; cin>>N; int a[N]; for(int i=0;i>a[i];

}
while(MAX(a,N)!=0)
{
    int dem=0;
    for(int i=0;i<N;i++)
    {
        if(a[i]!=0) dem++;
    }
    cout<<dem<<endl;
    int x=MIN(a,N);
    for(int i=0;i<N;i++)
    {
        if(a[i]!=0) a[i]=a[i]-x;
    }
}
return 0;

}

I like what you did with if (Array[i] != Array[i+1]), that was a clever way of checking for both uniqueness and that it is non-zero. Mine was similar (in python3), using a list to store the unique lengths.

https://www.hackerrank.com/challenges/cut-the-sticks/submissions/code/16760136

My C++ solution with C++11 style. https://www.hackerrank.com/challenges/cut-the-sticks/submissions/code/18237551

#include <vector>
#include <iostream>
#include <algorithm>

int main() {
    using namespace std;
    
    int N;
    auto less_then_1 = [](int n)->bool{ return n < 1;};
    
    cin >> N;
    vector<int> arr(N);
    for (int i = 0; i < N; ++i) cin >> arr[i];

    int prev_size = arr.size();
    while (!arr.empty()) {
        cout << prev_size << endl;
        int minim = *min_element(arr.begin(), arr.end()); 
        for (int& n : arr) { n = n - minim; }
        // Remove elements which are less then 1
        arr.erase(remove_if(arr.begin(), arr.end(), less_then_1), arr.end());
        prev_size = arr.size(); // Update the count of elements
    }
}

not such complex just check this out :- https://www.hackerrank.com/challenges/cut-the-sticks/submissions/code/20861396

Yup, each cut will eliminate only one stick with the exception of when the the size of the stick you are cutting is not unique.

wow.. It's brilliant.

well i did something similar as your's but ur code is better

import java.io.*;
import java.util.*;

public class Solution {

    public static void main(String[] args) {
        /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int arr[] = new int[n];
        for(int i =0; i<n;i++){
            arr[i] = sc.nextInt();
        }
        Arrays.sort(arr);
        int min = arr[0];
        for(int i =0; i<n;){
            System.out.println(arr.length-i);
            i++;
            while(arr[i]==min){
                i++;
            }
            min = arr[i];
        }
        
    }
}

Similar approach. Here is my solution https://www.hackerrank.com/challenges/cut-the-sticks/submissions/code/47822881

sort(Array, Array + N); How this works? anyone explain pls..!

JAVA O(N) Simple solution :)

Approach:

1. i make array of 1001(1-1000) element and count occurence of each digit in given input.
2. then i print the first row of output which always going to be same as value of n
3. then i again start loop(0-1000) and whenever elemnt of array found non-zero(which is occurence of smallest element), i substract it from n and assign result to n again and print value as result.

According to me there is no need to substract lowest value from remaining sticks because whether you substract or not, overall effect on elements is going to be null!!....

    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    int[] arr = new int[1001];
    for(int i=0;i<n;i++)
    {
        int x = sc.nextInt();
        arr[x]++;
    }
    System.out.println(n);
    for(int j=1;j<=1000;j++)
    {
        if(arr[j]!=0)
        {
            n=n-arr[j];
            if(n!=0)
                System.out.println(n);                
        }
    }   

I made my solution using a minHeap Idea.

vector <int> cutTheSticks(const vector <int> &arr) {
    priority_queue <int, vector<int>, greater<int> > minHeap;
    
    for(int x: arr){
        minHeap.push(x);
    }
    
    int nStickCutted = arr.size();
    int cuttedSize = 0;
    vector<int> ans;
    int counter = 0;
    while(!minHeap.empty()){
        if((minHeap.top() - cuttedSize) == 0){
            ans.push_back(nStickCutted);
            
            while(((minHeap.top() - cuttedSize) == 0) && !minHeap.empty() ){
                --nStickCutted;
                minHeap.pop();
            }
        }
        else{
            cuttedSize = minHeap.top();
        }
    }

    return ans;
}

Yea exactly sorting and done in one more loop. Here's my cpp solution https://www.hackerrank.com/challenges/cut-the-sticks/submissions/code/15104424

i exactly did it and it is one of best way ;) still couldnot get all test cases correct

I don't understand why everyone sorts the input... you don't need to here is my O(n) solution without sorting

int main(){
    int n, len; 
    scanf("%d",&n);
    int *arr = (int*)calloc(1001, sizeof(int));
    int min = 0, max = 0;
    for(int arr_i = 0; arr_i < n; arr_i++){
        scanf("%d",&len);
        if(!min || min > len) 
            min = len;
        if(max < len)
            max = len;
        arr[len]++;
    }
    for(int i = min; i <= max; i++) {
        if(arr[i]) {
            printf("%d\n", n);
            n -= arr[i];
        }
    }
    return 0;
}

I did the same...

Very nice

that's why i love ruby

I couldnot understand the last loop .please reply

Please check if the check al.get(0)==0 should be replaced by al.get(0)<=0 as while subtracting the value can be less than 0.

This is my java implementation. The idea is to clasify the input in groups of duplicates. I'm acomplish this using a TreeMap whos acces time is O(log n) and keeps the natural ordering of the groups (for Integers is lowest to greatest).

After we have finished to read the input, we have something like this in our TreeMap.

{ (2, 2), (4, 2), (5, 1), (8, 1) }

Where each (k, v) tuple is the input and the number of times it was duplicated.

Then all we have to do is travel the TreeMap and sustract to N the lenght of each block while N > 0 and print the answer.

public static void main(String[] args) {
	Scanner scanner = new Scanner( System.in );		
	int n = scanner.nextInt();
	scanner.nextLine();
		
	Map<Integer, Integer> blocks = new TreeMap<Integer, Integer>();
	Arrays.asList( scanner.nextLine().split( " " ) )
		.stream()
		.map( Integer::new )
		.forEach( x -> {
			if( blocks.get( x ) != null )
				blocks.put( x, blocks.get( x ) + 1 );
			else 
				blocks.put( x, 1 );
		});
		
	Iterator< Entry< Integer, Integer > > iterator = blocks.entrySet().iterator();
	while( n > 0 ){
		System.out.println( n );
		n  -= iterator.next().getValue();			
	}
		
}

nice

I love your code...but can you please explain the logic behind it once

In 3 lines

n = int(input().strip())
arr = [int(arr_temp) for arr_temp in input().strip().split(' ')]


while(len(arr)):
    print(len(arr))
    arr = [x - min(arr) for x in arr if x - min(arr)>0]

O(n^2)...

Good job on this!! I pretty much had the same thought process as you did to solve this. I just needed a little fine tuning in reference to local variables. Thank you for posting!!

thanks mate. the problem with my code was initialising min and your idea of init with upper bound totally solved it since my min was taking the value of 0 during subsequent iterations. cheers mate!!

impressive (y)

this puts all the others to shame

Good idea

brilliant