The only bad thing about this is that it required two iterations. It's nice and concise though.

How do you come up with such solutions. I wrote a long ass code using if statements, but when i see your answer it is easy but it doesn't come to the mind when i am trying to look for a solution. I am a beginner, does it come with practise?

2 lines in python:

nums = [int(x) for x in input().strip().split(' ')]
print(sum(nums) - max(nums), sum(nums) - min(nums))

How do we write it in python3? because raw_input is python2

This is very crisp code!

Well done, better than mine I guess

arr = list(map(int, input().strip().split(' ')))
min_a = sum([x for i, x in enumerate(arr) if i != arr.index(max(arr))])
max_a = sum([x for i, x in enumerate(arr) if i != arr.index(min(arr))])
print(min_a, max_a)

Thanks for your submission. I was wondering if the point of algorithms is to avoid using libraries if possible. Even tho it is a trivial example, shouldn't the sum of numbers be like

for(int i = 0; i < array.length; i++){ sum += array[i]; }

as opposed to "sum(array)"

Cheers

amazing approach! my code was of more than 10 lines

import sys
from functools import reduce

arr = list(map(int, input().strip().split(' ')))
arr.sort()
barr = arr.copy()
barr.remove(arr[0])
d = reduce(lambda x,y:x+y,barr)
arr.remove(arr[len(arr)-1])
c = reduce(lambda x, y: x + y, arr)
print(c,d)

Did it in C. Is there a way to make it shorter?

int main() {
    int *arr = malloc(sizeof(int) * 5);
    for(int arr_i = 0; arr_i < 5; arr_i++){
       scanf("%d",&arr[arr_i]);
    }
    
    long sum = 0; 
    for(int i = 0; i < 5; i++)
    {
        sum = arr[i] + sum;
    }
    
    long lowest = sum, new_lowest = 0, highest = 0;
    for(int j = 0; j < 5; j++)
    {
        long a = sum - arr[j];
        
        if(a < lowest)
        {
            lowest = a;
            new_lowest = a;
        }
        if(a > highest) 
        {
            highest = a;
        }
    }
    
    printf("%ld %ld", new_lowest, highest);
    return 0;
}

Great solution! Slightly different way of doing it below too:

from functools import reduce

arr = list(map(int, input().strip().split(' ')))

min = reduce((lambda x, y: x + y), sorted(arr)[:-1])
max = reduce((lambda x, y: x + y), sorted(arr)[1:])

print(str(min) + " " + str(max))

Meh. Way too much pointless stuff. You don't need the strip, the split parameter, and so many parentheses.

arr = map(int, raw_input().split())
s = sum(arr)
print s - max(arr), s - min(arr)

Another one:

a = sorted(map(int, input().split()))
print(sum(a[:-1]), sum(a[1:]))

Man that's pretty cool.

This code is brilliant! i am so silly that i literally add every 4 numbers together and see the sum.

My version:

def miniMaxSum(arr):
    arr.sort()
    print(sum(arr[:4]),sum(arr[1:]))

my code in python but your code is more efficient: def miniMaxSum(arr): l=[] l.append(arr[1]+arr[2]+arr[3]+arr[4]) l.append(arr[0]+arr[2]+arr[3]+arr[4]) l.append(arr[1]+arr[0]+arr[3]+arr[4]) l.append(arr[1]+arr[2]+arr[0]+arr[4]) l.append(arr[1]+arr[2]+arr[3]+arr[0]) print(min(l),end=' ') print(max(l))

Yeah that looks sexy :-)

here's mine :D arrx = [] for i,x in enumerate(arr): b = arr[0:] b.pop(i) arrx.append(sum(b)) sarrx = sorted(arrx) print (sarrx[0], sarrx[-1])

You can avoid the array

public static void main(String[] args) { Scanner in = new Scanner(System.in);

    long max, min, sum;
    sum = max = min = in.nextLong();

    for(int i=1; i<5;i++){
        long temp = in.nextLong();
        sum += temp;
        if(max>temp){
            if(min > temp) {
                min = temp;
            }
        } else {
            max = temp;
        }
    }

    System.out.print((sum -max) + " " + (sum - min));
}

Oh! I did not think to change the scanning code to read longs... I was trying to do it with int array, and failing test 4. :) Thank you. Great discussions here.

    Scanner in = new Scanner(System.in);

    List<Long> a = new ArrayList<>();

    for(int i = 0; i < 5; i++)
        a.add(new Long(in.nextLong()));

    long min = a.stream().mapToLong(f -> f).min().getAsLong();
    long max = a.stream().mapToLong(f -> f).max().getAsLong();
    long sum = a.stream().mapToLong(f -> f).sum();

    System.out.println((sum - max) + " " + (sum - min));

import java.util.*; // for beginner guyes

Thanks, I was coming up with a more complicated procedure

This works under the assumption that are inputs are non-negative. It would become erroneous when negative integers are introduced.

Simplest Java solution

public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        long[] arr = new long[5];
        for(int arr_i=0; arr_i < 5; arr_i++){
            arr[arr_i] = in.nextLong();
        }
        Arrays.sort(arr);
        System.out.println(arr[0] + arr[1] + arr[2] + arr[3] + " " + (arr[1] + arr[2] + arr[3] + arr[4]));
    }

Ele ffing gant !! Beautiful code.

Based on your solution, I do this. Thanks!

import java.util.Scanner;

public class Solution4 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        long sum = 0;
        long min = 2147483647;
        long max = 0;
        long tmp = 0;

        for (int i = 0; i < 5; i++) {
            tmp  = in.nextInt();
            max  = tmp > max ? tmp : max;
            min  = tmp < min ? tmp : min;
            sum += tmp;
        }

        // System.out.println("Max: " + max + "\nMin: " + min);
        System.out.println((sum - max) + " " + (sum - min));
        in.close();
    }
}

nice one

thanx..

Exactly my solution, though I did it in c

#include <stdio.h>
#include <limits.h>

int main(){
  int inp,largest=0,smallest=INT_MAX;
  unsigned sum=0;
  
  for(int i = 0; i < 5; i++){
    scanf("%d",&inp);
    if(inp>largest) largest = inp;
    if(inp<smallest) smallest = inp;
    sum+=inp;
  }
  
  printf("%u %u\n",sum-largest,sum-smallest); 
}

why sorting? just add all nums in first input loop and in next loop find min and max

what you actually mean i+1 ? i mean how you know the index number i+1 will be max?

this is actually excellent, been coding it myself before looking at the discussion :D

I like this a lot, I had 2 for loops to get min and max separately but this is much simpler.

you don't even need a for loop in C#, here is my solution:

static void Main(String[] args) {
            string[] arr_temp = Console.ReadLine().Split(' ');
            long[] arr = Array.ConvertAll(arr_temp, Int64.Parse);
            long minSum = arr.Sum() - arr.Max();
            long maxSum = arr.Sum() - arr.Min();
            Console.WriteLine("{0} {1}",minSum, maxSum);
        }

Nice solution but you loop through the array 3 times here: min() and max() methods loop through entire array to find those values - you could do the whole thing in your for loop with a bit of tweaking ;) but kudos none the less

You dont need two result longs:

long sum = 0;
        long min = arr.Min();
        long max = arr.Max();
        for (int i = 0; i<arr.Length; i++){
            sum = sum + arr[i];
        }
        Console.WriteLine("{0} {1}",sum-max,sum-min);

That's actually an interesting way to go about it.

That is interesting. However I think the time complexity for this would still be the same as sorting, O(NlogN), since you are performing an insertion into the tree for each element and each insertion takes logN time.

why would you use sortedset? if after adding you could search for maximum amongst them?

SortedSet sortedSet = new TreeSet(); why did u use capital L in long rather than data type

public static void main(String[] args) { Scanner in = new Scanner(System.in); long a = in.nextLong(); long b = in.nextLong(); long c = in.nextLong(); long d = in.nextLong(); long e = in.nextLong(); SortedSet p = new TreeSet(); p.add(b+c+d+e); p.add(a+c+d+e); p.add(a+b+d+e); p.add(a+b+c+d); System.out.println(p.first() +" " +p.last()); }

this code is not working 2,6,8,9,11
can anyone help me out?

I do not think this is right way as if there are many numbers.

Thats why java is my favourite...

arr = [a,b,c,d,e] arr.sort() print(sum(arr[:4]),sum(arr[1:])) `

I often overthink these algorithms. It makes sense that the numbers from index 0 - 4 would be less than 1 - 5!

here is my approach

let output = [];
for (var i = 0; i < 2; i++) {
    output[i] = input.sort((a, b) => a > b).slice(0 + i, 4 + i).reduce((prev, next) => prev + next)
}
console.log(output[0], output[1])

Here is my approach.

arr.sort((a,b) => a-b);
    console.log(String(arr.slice(0,4).reduce((a,b)=>a+b)) + ' ' + String(arr.slice(1,5).reduce((a,b)=>a+b)));

nice one 👏👏

can you explain this code ? the second for loop does not take the last element in consideration right ? so how come the sum are different