In this HackerRank Mini Max Sum (1 Week preparation kit) problem solution, we have Given five positive integers, and find the minimum and maximum values that can be calculated by summing exactly four of the five integers. Then print the respective minimum and maximum values as a single line of two space-separated long integers.
Problem solution in Python.
#!/bin/python3
import math
import os
import random
import re
import sys
#
# Complete the 'miniMaxSum' function below.
#
# The function accepts INTEGER_ARRAY arr as parameter.
#
def miniMaxSum(arr):
# Write your code here
if len(arr) == 0:
print("0 0")
num_sum = 0
num_max = arr[0]
num_min = arr[0]
for i in range(len(arr)):
num_sum = num_sum + arr[i]
if arr[i] > num_max:
num_max = arr[i]
elif arr[i] < num_min:
num_min = arr[i]
print(str(num_sum - num_max) + " " + str(num_sum - num_min))
if __name__ == '__main__':
arr = list(map(int, input().rstrip().split()))
miniMaxSum(arr)
Problem solution in Java.
import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.function.*;
import java.util.regex.*;
import java.util.stream.*;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;
class Result {
/*
* Complete the 'miniMaxSum' function below.
*
* The function accepts INTEGER_ARRAY arr as parameter.
*/
public static void miniMaxSum(List<Integer> arr) {
// Write your code here
int n=arr.size();
long[] myList = new long[n];
for(int i=0;i<n;i++){
myList[i] = (long)arr.get(i);
}
for(int p=0;p<=n-1;p++){
for(int q=p+1;q<=n-1;q++){
long temp=0;
if(myList[p]>myList[q]){
temp=myList[p];
myList[p]=myList[q];
myList[q]=temp;
}
}
}
long sum=0;
for(int i=0;i<=n-1;i++){
sum+=myList[i];
}
long h=sum-myList[0];
long l=sum-myList[n-1];
System.out.println(l+" "+h);
}
}
public class Solution {
public static void main(String[] args) throws IOException {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
List<Integer> arr = Stream.of(bufferedReader.readLine().replaceAll("\\s+$", "").split(" "))
.map(Integer::parseInt)
.collect(toList());
Result.miniMaxSum(arr);
bufferedReader.close();
}
}
Problem solution in C++.
#include <bits/stdc++.h>
#include <algorithm>
using namespace std;
string ltrim(const string &);
string rtrim(const string &);
vector<string> split(const string &);
void miniMaxSum(vector<int> arr) {
long int max = 0, min = 0;
sort(arr.rbegin(), arr.rend());
for (int i = 0; i < arr.size() - 1; i++){
max = max + arr[i];
}
for (int i = 1; i < arr.size(); i++){
min = min + arr[i];
}
cout << min << " " << max;
}
int main()
{
string arr_temp_temp;
getline(cin, arr_temp_temp);
vector<string> arr_temp = split(rtrim(arr_temp_temp));
vector<int> arr(5);
for (int i = 0; i < 5; i++) {
int arr_item = stoi(arr_temp[i]);
arr[i] = arr_item;
}
miniMaxSum(arr);
return 0;
}
string ltrim(const string &str) {
string s(str);
s.erase(
s.begin(),
find_if(s.begin(), s.end(), not1(ptr_fun<int, int>(isspace)))
);
return s;
}
string rtrim(const string &str) {
string s(str);
s.erase(
find_if(s.rbegin(), s.rend(), not1(ptr_fun<int, int>(isspace))).base(),
s.end()
);
return s;
}
vector<string> split(const string &str) {
vector<string> tokens;
string::size_type start = 0;
string::size_type end = 0;
while ((end = str.find(" ", start)) != string::npos) {
tokens.push_back(str.substr(start, end - start));
start = end + 1;
}
tokens.push_back(str.substr(start));
return tokens;
}
Problem solution in C.
#include <assert.h>
#include <ctype.h>
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char* readline();
char* ltrim(char*);
char* rtrim(char*);
char** split_string(char*);
int parse_int(char*);
int cmpfunc (const void * a, const void * b) {
return ( *(int*)a - *(int*)b );
}
/*
* Complete the 'miniMaxSum' function below.
*
* The function accepts INTEGER_ARRAY arr as parameter.
*/
void miniMaxSum(int arr_count, int* arr) {
qsort(arr,arr_count, sizeof(int), cmpfunc);
long long int min = 0;
long long int max = 0;
for (int i = 0 ; i< arr_count-1;i++){
min += arr[i];
}
for (int i = 1 ; i< arr_count;i++){
max += arr[i];
}
printf("%lld %lld\n", min, max);
}
int main()
{
char** arr_temp = split_string(rtrim(readline()));
int* arr = malloc(5 * sizeof(int));
for (int i = 0; i < 5; i++) {
int arr_item = parse_int(*(arr_temp + i));
*(arr + i) = arr_item;
}
miniMaxSum(5, arr);
return 0;
}
char* readline() {
size_t alloc_length = 1024;
size_t data_length = 0;
char* data = malloc(alloc_length);
while (true) {
char* cursor = data + data_length;
char* line = fgets(cursor, alloc_length - data_length, stdin);
if (!line) {
break;
}
data_length += strlen(cursor);
if (data_length < alloc_length - 1 || data[data_length - 1] == '\n') {
break;
}
alloc_length <<= 1;
data = realloc(data, alloc_length);
if (!data) {
data = '\0';
break;
}
}
if (data[data_length - 1] == '\n') {
data[data_length - 1] = '\0';
data = realloc(data, data_length);
if (!data) {
data = '\0';
}
} else {
data = realloc(data, data_length + 1);
if (!data) {
data = '\0';
} else {
data[data_length] = '\0';
}
}
return data;
}
char* ltrim(char* str) {
if (!str) {
return '\0';
}
if (!*str) {
return str;
}
while (*str != '\0' && isspace(*str)) {
str++;
}
return str;
}
char* rtrim(char* str) {
if (!str) {
return '\0';
}
if (!*str) {
return str;
}
char* end = str + strlen(str) - 1;
while (end >= str && isspace(*end)) {
end--;
}
*(end + 1) = '\0';
return str;
}
char** split_string(char* str) {
char** splits = NULL;
char* token = strtok(str, " ");
int spaces = 0;
while (token) {
splits = realloc(splits, sizeof(char*) * ++spaces);
if (!splits) {
return splits;
}
splits[spaces - 1] = token;
token = strtok(NULL, " ");
}
return splits;
}
int parse_int(char* str) {
char* endptr;
int value = strtol(str, &endptr, 10);
if (endptr == str || *endptr != '\0') {
exit(EXIT_FAILURE);
}
return value;
}
0 Comments