# Get Lowest Free - CodeChef

### Problem Statement :

```Chef goes to the supermarket to buy some items. Luckily there's a sale going on under which Chef gets the following offer:

If Chef buys 3 items then he gets the item (out of those 3 items) having the lowest price as free.
For e.g. if Chef bought 3 items with the cost 6, 2 and 4, then he would get the item with cost 2 as free. So he would only have to pay the cost of the other two items which will be 6+4=10.

Chef buys 3 items having prices A, B and C respectively. What is the amount of money Chef needs to pay?

Input Format

The first line will contain an integer T - number of test cases. Then the test cases follow.
The first and only line of each test case contains three integers A,B,C - the prices of the items bought by Chef.

Output Format

For each test case, output the price paid by Chef.

Constraints

1≤T≤100
1≤A,B,C≤10
Sample Input 1

3
6 2 4
3 3 3
8 4 4

Sample Output 1

10
6
12```

### Solution :

```                        ```Solution in C++ :

#include <iostream>
#include <cstdio>
#include <string>
#include <set>
#include <map>
#include <stack>
#include <unordered_set>
#include <vector>
#include <algorithm>
#include <sys/time.h>
#include <climits>
#include <cmath>
#include <unordered_map>
#include <list>
#include <functional>
#include <cassert>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
#define FOR(i, s, e, t) for ((i) = (s); (i) < (e); (i) += (t))
#define REP(i, e) for (int i = 0; i < (e); ++i)
#define REP1(i, s, e) for (int i = (s); i < (e); ++i)
#define RREP(i, e) for (int i = (e); i >= 0; --i)
#define RREP1(i, e, s) for (int i = (e); i >= (s); --i)
ll inf = 1e18;
int __FAST_IO__ = []() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
std::cout.tie(0);
return 0;
}();

int main() {
int t;
cin >> t;
while (t--) {
int A, B, C;
cin >> A >> B >> C;
printf("%d\n", A + B + C - min({A, B, C}));
}

return 0;
}```
```

```                        ```Solution in Java :

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

public class Main {

static long startTime = System.currentTimeMillis();

// for global initializations and methods starts here

// global initialisations and methods end here

static void run() {
boolean tc = true;

try (OutputStream out = new BufferedOutputStream(System.out)) {

//long startTime = System.currentTimeMillis();

int testcases = tc ? r.ni() : 1;
int tcCounter = 1;
// Hold Here Sparky------------------->>>
// Solution Starts Here

start:
while (testcases-- > 0) {
int n = 3;
long sum = al.stream().mapToInt(a -> a).sum();
out.write((sum - Collections.min(al) + " ").getBytes());
out.write(("\n").getBytes());
}
// Solution Ends Here
} catch (IOException e) {
e.printStackTrace();
}
}

final private int BUFFER_SIZE = 1 << 16;
private final DataInputStream din;
private final byte[] buffer;
public StringTokenizer st;

din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
}

public AdityaFastIO(String file_name) throws IOException {
din = new DataInputStream(new FileInputStream(file_name));
buffer = new byte[BUFFER_SIZE];
}

public String word() {
while (st == null || !st.hasMoreElements()) {
try {
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}

public String line() {
String str = "";
try {
} catch (IOException e) {
e.printStackTrace();
}
return str;
}

public String readLine() throws IOException {
byte[] buf = new byte; // line length
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == '\n') break;
buf[cnt++] = (byte) c;
}
return new String(buf, 0, cnt);
}

public int ni() throws IOException {
int ret = 0;
while (c <= ' ') c = read();
boolean neg = (c == '-');
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (neg) return -ret;
return ret;
}

public long nl() throws IOException {
long ret = 0;
while (c <= ' ') c = read();
boolean neg = (c == '-');
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (neg) return -ret;
return ret;
}

public double nd() throws IOException {
double ret = 0, div = 1;
while (c <= ' ') c = read();
boolean neg = (c == '-');
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (c == '.') while ((c = read()) >= '0' && c <= '9') ret += (c - '0') / (div *= 10);
if (neg) return -ret;
return ret;
}

private void fillBuffer() throws IOException {
if (bytesRead == -1) buffer = -1;
}

private byte read() throws IOException {
return buffer[bufferPointer++];
}

public void close() throws IOException {
if (din == null) return;
din.close();
}
}

public static void main(String[] args) throws Exception {
run();
}

int[] arr = new int[n];
for (int i = 0; i < n; i++) arr[i] = r.ni();
return arr;
}

long[] arr = new long[n];
for (int i = 0; i < n; i++) arr[i] = r.nl();
return arr;
}

List<Integer> al = new ArrayList<>();
for (int i = 0; i < n; i++) al.add(r.ni());
return al;
}

List<Long> al = new ArrayList<>();
for (int i = 0; i < n; i++) al.add(r.nl());
return al;
}

static long mod = 998244353;

static long modInv(long base, long e) {
long result = 1;
base %= mod;
while (e > 0) {
if ((e & 1) > 0) result = result * base % mod;
base = base * base % mod;
e >>= 1;
}
return result;
}

StringTokenizer st;

}

String word() {
while (st == null || !st.hasMoreElements()) {
try {
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}

String line() {
String str = "";
try {
} catch (IOException e) {
e.printStackTrace();
}
return str;
}

int ni() {
return Integer.parseInt(word());
}

long nl() {
return Long.parseLong(word());
}

double nd() {
return Double.parseDouble(word());
}
}

static int MOD = (int) (1e9 + 7);

static long powerLL(long x, long n) {
long result = 1;
while (n > 0) {
if (n % 2 == 1) result = result * x % MOD;
n = n / 2;
x = x * x % MOD;
}
return result;
}

static long powerStrings(int i1, int i2) {
String sa = String.valueOf(i1);
String sb = String.valueOf(i2);
long a = 0, b = 0;
for (int i = 0; i < sa.length(); i++) a = (a * 10 + (sa.charAt(i) - '0')) % MOD;
for (int i = 0; i < sb.length(); i++) b = (b * 10 + (sb.charAt(i) - '0')) % (MOD - 1);
return powerLL(a, b);
}

static long gcd(long a, long b) {
if (a == 0) return b;
else return gcd(b % a, a);
}

static long lcm(long a, long b) {
return (a * b) / gcd(a, b);
}

static long lower_bound(int[] arr, int x) {
int l = -1, r = arr.length;
while (l + 1 < r) {
int m = (l + r) >>> 1;
if (arr[m] >= x) r = m;
else l = m;
}
return r;
}

static int upper_bound(int[] arr, int x) {
int l = -1, r = arr.length;
while (l + 1 < r) {
int m = (l + r) >>> 1;
if (arr[m] <= x) l = m;
else r = m;
}
return l + 1;
}

static void addEdge(ArrayList<ArrayList<Integer>> graph, int edge1, int edge2) {
}

public static class Pair implements Comparable<Pair> {
int first;
int second;

public Pair(int first, int second) {
this.first = first;
this.second = second;
}

public String toString() {
return "(" + first + "," + second + ")";
}

public int compareTo(Pair o) {
// TODO Auto-generated method stub
if (this.first != o.first)
return (int) (this.first - o.first);
else return (int) (this.second - o.second);
}
}

public static class PairC<X, Y> implements Comparable<PairC> {
X first;
Y second;

public PairC(X first, Y second) {
this.first = first;
this.second = second;
}

public String toString() {
return "(" + first + "," + second + ")";
}

public int compareTo(PairC o) {
// TODO Auto-generated method stub
return o.compareTo((PairC) first);
}
}

static boolean isCollectionsSorted(List<Long> list) {
if (list.size() == 0 || list.size() == 1) return true;
for (int i = 1; i < list.size(); i++) if (list.get(i) <= list.get(i - 1)) return false;
return true;
}

static boolean isCollectionsSortedReverseOrder(List<Long> list) {
if (list.size() == 0 || list.size() == 1) return true;
for (int i = 1; i < list.size(); i++) if (list.get(i) >= list.get(i - 1)) return false;
return true;
}

}```
```

```                        ```Solution in Python :

t=int(input())
for _ in range(t):
a,b,c=map(int,input().split())
print(a+b+c-min([a,b,c]))```
```

## Down to Zero II

You are given Q queries. Each query consists of a single number N. You can perform any of the 2 operations N on in each move: 1: If we take 2 integers a and b where , N = a * b , then we can change N = max( a, b ) 2: Decrease the value of N by 1. Determine the minimum number of moves required to reduce the value of N to 0. Input Format The first line contains the integer Q.

## Truck Tour

Suppose there is a circle. There are N petrol pumps on that circle. Petrol pumps are numbered 0 to (N-1) (both inclusive). You have two pieces of information corresponding to each of the petrol pump: (1) the amount of petrol that particular petrol pump will give, and (2) the distance from that petrol pump to the next petrol pump. Initially, you have a tank of infinite capacity carrying no petr

## Queries with Fixed Length

Consider an -integer sequence, . We perform a query on by using an integer, , to calculate the result of the following expression: In other words, if we let , then you need to calculate . Given and queries, return a list of answers to each query. Example The first query uses all of the subarrays of length : . The maxima of the subarrays are . The minimum of these is . The secon

## QHEAP1

This question is designed to help you get a better understanding of basic heap operations. You will be given queries of types: " 1 v " - Add an element to the heap. " 2 v " - Delete the element from the heap. "3" - Print the minimum of all the elements in the heap. NOTE: It is guaranteed that the element to be deleted will be there in the heap. Also, at any instant, only distinct element