Hackerrank - Flowers - Pavol Pidanič

Problem Statement
A description of the problem can be found on Hackerrank.

Solution
Sort all prices descending.
The formula for calculating the flower i in prices:
$$total = \sum_{i=0}^{n-1}((i / k + 1) * price_{i})$$

I created solution in:

Java
JavaScript
Ruby
Scala

All solutions are also available on my GitHub.

Java

import java.util.*;

public class Flowers {

    private static class Descending implements Comparator<Integer> {
        @Override
        public int compare(Integer i, Integer j) {
            return j - i;
        }
    }

    public static void main(String[] args) {
        Scanner stdin = new Scanner(System.in);
        int n = stdin.nextInt();
        int k = stdin.nextInt();
        Integer[] prices = new Integer[n];
        for(int i = 0; i < n; i++) {
            prices[i] = stdin.nextInt();
        }
        Arrays.sort(prices, new Descending());
        int sum = 0;
        for(int i = 0; i < n; i++) {
            int factor = i / k;
            sum += prices[i] * (factor + 1);
        }
        System.out.println(sum);
        stdin.close();
    }
}

import java.util.*;

public class Flowers {

private static class Descending implements Comparator<Integer> {

@Override

public int compare(Integer i, Integer j) {

return j - i;

}

public static void main(String[] args) {

Scanner stdin = new Scanner(System.in);

int n = stdin.nextInt();

int k = stdin.nextInt();

Integer[] prices = new Integer[n];

for(int i = 0; i < n; i++) {

prices[i] = stdin.nextInt();

}

Arrays.sort(prices, new Descending());

int sum = 0;

for(int i = 0; i < n; i++) {

int factor = i / k;

sum += prices[i] * (factor + 1);

}

System.out.println(sum);

stdin.close();

}

JavaScript

'use strict';

const processData = input => {
    let lines = input.split('\n');
    let definition = lines[0].split(' ').map(i => parseInt(i));
    let n = definition[0];
    let k = definition[1];
    let prices = lines[1].split(" ").map(i => parseInt(i));
    let descendingPrices = prices.sort((i, j) => j - i);
    let totalPrice = 0;
    for(let i = 0; i < n; i++) {
        let factor = parseInt(i / k);
        totalPrice += (factor + 1) * descendingPrices[i];
    }
    console.log(totalPrice);

};

process.stdin.resume();
process.stdin.setEncoding("ascii");

var _input = "";
process.stdin.on("data", input => _input += input);
process.stdin.on("end", () => processData(_input));

'use strict';

const processData = input => {

let lines = input.split('\n');

let definition = lines[0].split(' ').map(i => parseInt(i));

let n = definition[0];

let k = definition[1];

let prices = lines[1].split(" ").map(i => parseInt(i));

let descendingPrices = prices.sort((i, j) => j - i);

let totalPrice = 0;

for(let i = 0; i < n; i++) {

let factor = parseInt(i / k);

totalPrice += (factor + 1) * descendingPrices[i];

}

console.log(totalPrice);

};

process.stdin.resume();

process.stdin.setEncoding("ascii");

var _input = "";

process.stdin.on("data", input => _input += input);

process.stdin.on("end", () => processData(_input));

Ruby

(n, k) = gets.chomp.split.map { |e| e.to_i }
prices = gets.chomp.split.map { |e| e.to_i }

prices.sort! { |i,j| j <=> i }
result = 0
n.times do |i|
  factor = i / k
  result += (factor + 1) * prices[i]
end
puts result

(n, k) = gets.chomp.split.map { |e| e.to_i }

prices = gets.chomp.split.map { |e| e.to_i }

prices.sort! { |i,j| j <=> i }

result = 0

n.times do |i|

factor = i / k

result += (factor + 1) * prices[i]

end

puts result

Scala

import scala.io.Source

object Flowers extends App {
  val lines = Source.stdin.getLines().toList
  val definition = lines(0).split(" ").map(_.toInt)
  val n = definition(0)
  val k = definition(1)
  val prices = lines(1).split(" ").map(_.toInt)
  val descendingPrices = prices.sortWith((i, j) => i > j)
  val total = descendingPrices.indices.map(totalPrice).sum
  println(total)

  def totalPrice(index: Int): Int = {
    val factor = index / k
    (factor + 1) * descendingPrices(index)
  }
}

import scala.io.Source

object Flowers extends App {

val lines = Source.stdin.getLines().toList

val definition = lines(0).split(" ").map(_.toInt)

val n = definition(0)

val k = definition(1)

val prices = lines(1).split(" ").map(_.toInt)

val descendingPrices = prices.sortWith((i, j) => i > j)

val total = descendingPrices.indices.map(totalPrice).sum

println(total)

def totalPrice(index: Int): Int = {

val factor = index / k

(factor + 1) * descendingPrices(index)

}

Pavol Pidanič

I can count to 1023 with 10 fingers

Hackerrank – Flowers