CareerCup

This is how I'd solve that, considering arrays a and b to merge to c

check one element from a and b and add the min to c until one of the arrays runs out of elements

add remaining elements from a or b to c

fun main() {
    val a = arrayOf(1, 3, 5, 7, 8, 9)
    val b = arrayOf(2, 4, 6)
    print("A = ${a.asList()}")
    print("B = ${b.asList()}")
    
    val c = Array(a.size + b.size) { 0 }
    
    var i = 0
    var j = 0
    var k = 0
    // find the min of a[j],b[j] and add it at c[k]
    // until one of the arrays(a or b) is empty
    while (i < a.size && j < b.size) {
        if (a[i] < b[j]) {
            c[k] = a[i]
            i++
            k++
        } else {
            c[k] = b[j]
            j++
            k++
        }
    }
    
    // add remaining elements to c
    while (i < a.size) {
        c[k] = a[i]
        i++
        k++
    }
    while (j < b.size) {
        c[k] = b[j]
        j++
        k++
    }
    
    print("C = ${c.asList()}")
}

note: i contains position of current element in A similarly j for B and k for C

most operating systems are written in c/c++, and also pointers are used in c/c++ not in java. pointers allows one to be able to directly play around with addresses and not have them behind an abstraction like in java. potentially if written right c/c++ programs should always be faster than in java

based on what programming language it was written in you could try some decompiler and bring back the source code though the code may sometime not so readable(variable names, functions, classes), but most of the logic should be visible

The answer is quite simple..
You just need to find the count of misplaced even and odd numbers and output the min of those two numbers
if the count of misplaced even and odd are not equal it just means that there are a few numbers that cannot be sorted to even/odd places If you need the program approach reply to this comment

This is the best solution I could come up with

1. from 2 to n-1 add one number to set

2. for each new added number find sum with existing from set

note: step two is important if you want to maximise a+b=c triplets

public static void main(String[] args) {
    ArrayList<Integer> set = new ArrayList<>();
    Scanner in = new Scanner(System.in);
    
    System.out.print("Enter limit n : ");
    int n = in.nextInt();
    System.out.print("Enter limit m : ");
    int m = in.nextInt();
    
    outer:
    for (int i = 2; i < n && set.size() < m; i++) {
        int size = set.size();
        if (set.contains(i)) continue;
        set.add(i);
        inner:
        for (int j = size; j < set.size(); j++) {
            for (int k = 0; k < j; k++) {
                int sum = set.get(j) + set.get(k);
                if (sum >= n) continue inner;
                if (set.contains(sum)) continue;
                if (set.size() < m)
                    set.add(sum);
                else break outer;
            }
        }
    }
    
    System.out.println("the set is " + set.toString());
}

the check num>=n checks if the num has exceeded the n limit

to ensure a num is added only once we check for set contains num

I understand I read the question as Shouldn't produce number in set..

wouldn't it be easier if you just pick the last m integers from n-1,n-2...etc

like in case of n=20 m=5

[19, 18, 17, 16, 15]

the question isn't complete, links don't work so, type in the whole question here

if the sub tree has zero coins in the node that means we have to bring one coin to that node essentially meaning deficit of (i.e. -1 of) coins be it deficit or surplus the coin needs to be moved so -1 requires 1 move

something like this should be ok

public static void main(String[] args) {
    var input = new Scanner(System.in);
    System.out.print("Enter number <0 to exit> : ");
    var n = input.nextInt();
    while (n != 0) {
        System.out.println(isHappy(n) ? 1 : 0);
        System.out.print("Enter number <0 to exit> : ");
        n = input.nextInt();
    }
}

private static boolean isHappy(int n) {
    var set = new HashSet<Integer>();
    int computed;
    do {
        computed = 0;
        set.add(n);
        while (n > 0) {
            computed += square(n % 10);
            n /= 10;
        }
        if (set.contains(computed)) break;
        n = computed;
    } while (computed != 1);
    return computed == 1;
}

private static int square(int i) { return i * i; }

Ok mate seems like this is what you are looking for

int main(int argc, char const *argv[])
{
    int n = 0;

    printf("Enter Size N : ");
    scanf("%d", &n);

    int a[n][n];

    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
        {
            printf("Enter A[%2d][%2d] : ", i + 1, j + 1);
            scanf("%d", &a[i][j]);
        }

    int si = 0, sj = 0, ei = n - 1, ej = n - 1;
    int direction = 0;
    while (si < ei || sj < ej)
    {
        switch (direction % 4)
        {
        case 0: sj++; break;
        case 1: ei--; break;
        case 2: ej--; break;
        case 3: si++; break;
        }
        direction++;
    }

    printf("the last element is %d", a[si][sj]);

    return 0;
}

based on the direction it keeps removing one row or column to get to the central element

do you want something like this?

-1--2--3--4
          |
 5--6--7  8
 |     |  |
 9 10-11 12
 |        |
13-14-15-16

where the last number is 10?

This is how I'd do it, inspiration leetcode 459

private static String FindPattern(String input) throws NoSuchObjectException {
    int repeatPos=(input+input).indexOf(input,1);
    if (repeatPos==-1) 
        throw new NoSuchObjectException("Pattern not found!!!");
    else 
        return input.substring(0,repeatPos);
}

In c

#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <stdbool.h>

char set[10];
int end;

void combinations(char *num, char *pre, int curr, int lvl)
{
    if (curr < strlen(num))
    {
        if (num[curr] >= '0' && num[curr] <= '9')
        {
            pre[lvl] = num[curr];
            combinations(num, pre, curr + 1, lvl + 1);
        }
        else if (num[curr] == '$')
            for (int i = 0; i < end; i++)
            {
                pre[lvl] = set[i];
                combinations(num, pre, curr + 1, lvl + 1);
            }
        else
            combinations(num, pre, curr + 1, lvl);
    }
    else
    {
        pre[lvl] = '\0';
        printf("%s\n", pre);
    }
}

int main(int argc, char const *argv[])
{
    char num[20], pre[20];
    printf("Enter Number String : ");
    scanf("%s", num);

    end = 0;
    for (int i = 0; i < strlen(num); i++)
        if (num[i] >= '0' && num[i] <= '9')
        {
            bool flag = true;

            for (int j = 0; j < end; j++)
                if (set[j] == num[i])
                    flag = false;

            if (flag == true)
                set[end++] = num[i];
        }

    combinations(num, pre, 0, 0);

    return 0;
}

rewrote in c check that answer

this how I'd solve the problem

class Scratch {
    
    private static ArrayList<Character> num;
    
    public static void main(String[] args) {
        System.out.print("Enter he number string : ");
        String input = (new Scanner(System.in)).next();
        num = new ArrayList<>();
        
        for (char c : input.toCharArray())
            if (c >= '0' && c <= '9') num.add(c);
        
        combinations(input, "", 0);
    }
    
    private static void combinations(String input, String pre, int i) {
        if (i < input.length()) {
            char c = input.charAt(i);
            
            if (c >= '0' && c <= '9')
                combinations(input, pre + c, i + 1);
            
            if (c == '$')
                for (char t : num)
                    combinations(input, pre + t, i + 1);
        }
        else System.out.println(pre);
    }
}

something like this would be sufficient

while (retry < MAX_RETRY) {
    if (istream.hasNext()) {
        // read stream
        retry = 0;
    } else {
        sleep(1000);
        retry++;
    }
}

your logic for checking if the input is present might be different
but the general concept should be similar

I kinda did it using Kotlin, but Java should be really similar,
order the countries in descending by no of players
for K slots fill each country in one slot where the min total players is the lowest
(when the no of total players in slot clashes no of countries in the slot must be lowest)
this should give us minimum difference between the slots and the max number of teams is the min total of the slots

import java.util.*
import kotlin.collections.ArrayList

private val input = Scanner(System.`in`)

fun main(args: Array<String>) {
    
    print("Enter no of countries N : ")
    val n = input.nextInt()
    
    val arr = ArrayList<Int>()
    repeat(n) { i ->
        print("Enter count of Players of Country[${i + 1}] : ")
        arr.add(input.nextInt())
    }
    arr.sortDescending()
    
    print("Enter size of Team K : ")
    val k = input.nextInt()
    
    val slots = ArrayList<Slots>()
    repeat(k) { slots.add(Slots()) }
    
    arr.forEach {
        slots.sortedBy { it.sArr.size }
            .sortedByDescending { it.total }
            .minBy { it.total }?.apply {
                total += it
                sArr.add(it)
            }
    }
    
    print("Max possible No of teams is ${slots.minBy { it.total }?.total}")
    
}

class Slots(var total: Int = 0, val sArr: ArrayList<Int> = ArrayList())

This is how I'd do it for Node with val and kids
if t1.val == t2.val match t2.kids in t1.kids is even one not found return false
else match t2 in t1.kids

boolean match(Node t1, Node t2) {
    boolean ret = false;
    if (t1.val == t2.val) {
        ret = true; // true if no kids for t1 and t2
        for (Node item : t2.kids) {
            ret = false; // false if t2 has kids but t1 doesn't have one of t2.kids
            for (Node other : t1.kids)
                ret |= match(other, item);
            if (!ret) break;
        }
        return ret;
    }
    for (Node other : t1.kids)
        ret |= match(other, t2);
    return ret;
}

I couldn't test it, so do post if this works for you

its an (n log(n)) solution assumes 2 things
1 need to use up all the money
2 can come back to the beginning of the shops if there is a balance of money

but to my knowledge this might be the optimal solution

Something like this would go well,(Java)

private static int calculate(int amount, int[] q, int[] c) {
    int ret = 0;
    int bal = 0;
    for (int i = 0; i < n; i++) {
        int n = amount / c[i];
        int quantity = q[i] * n;
        if (quantity > ret) {
            ret = quantity;
            bal = amount % c[i];
        }
    }
    
    if (ret!=0&&bal!=0) ret+=calculate(bal,q,c);
    
    return ret;
}

the root function does the same as s**1/2or3or4(python) in java there is no direct function to do so had to implement it in code

if we need to include for all solutions in 0 to s then we need to add not just 1 per a we find, we need to add 1 for each 0 to a for every a we find i.e. a+1 to count.

the only place were this might be false is when a>10000 in that case we need to add 10001 to count
the modified code will be this

if (a > -1) {
    System.out.println("a=0to" + a + " b=" + b + " c=" + c + " d=" + d);
    count += Math.min(a + 1, 10001);
}

i redid the solution please check the other answer

I redid the solution... now the O(n^3)
Optimizations
1 like that of @hrabryi found the limits for c, b, d dynamically (improvement in best case Ω and average case Θ, but not in worst case O, still O(n^4))
2 did away with looping a from 0 to 10000 since we can assume that a from calculating

a = s-(b^2 + c^3 + d^4)

and we can check if for given b, c, d inferred a is in 0 to 10000
this gives us O(n^3) the solution is as follows

public static void main(String[] args) {
    System.out.print("Enter the value s (0<=s<=10^15) : ");
    long s = (new Scanner(System.in)).nextLong();
    System.out.println("The count of integrals is " + countOfIntegrals(s));
}

private static long countOfIntegrals(long s) {
    long count = 0;
    long lb, lc, ld, cp3, dp4;
    ld = Math.min(root(s, 4), 10000);
    for (int d = 0; d <= ld; d++) {
        dp4 = pow(d, 4);
        lc = Math.min(root(s - dp4, 3), 10000);
        for (int c = 0; c <= lc; c++) {
            cp3 = pow(c, 3);
            lb = Math.min(root(s - dp4 - cp3, 2), 10000);
            for (int b = 0; b <= lb; b++) {
                long a = s - (pow(b, 2) + cp3 + dp4);
                if (a < 10001 && a > -1) {
                    System.out.println(a + " " + b + " " + c + " " + d);
                    count++;
                }
            }
        }
    }
    return count;
}

private static long pow(int n, int p) {
    return p > 1 ? n * pow(n, p - 1) : n;
}

private static long root(long s, int pow) {
    return (long) Math.floor(Math.exp(Math.log(s) / pow)) + 1;
}

other smaller optimizations only to adjust working code for java

four for loops is being used and so the complexity is still O(n^4)...

something like this should work but note that the time complexity is O(n^4)

public static void main(String[] args) {
    System.out.print("Enter the value s (0<=s<=10^15) : ");
    long s = (new Scanner(System.in)).nextLong();
    System.out.println("The count of integrals is " + countOfIntegrals(s));
}

private static long countOfIntegrals(long s) {
    long count = 0, pb2, pc3;
    int a, b, c, d;
    for (a = 0; a <= s && a < 10001; a++)
        for (b = 0, pb2 = a + pow(b, 2); pb2 <= s && b < 10001; pb2 = a + pow(++b, 2))
            for (c = 0, pc3 = pb2 + pow(c, 3); pc3 <= s && c < 10001; pc3 = pb2 + pow(++c, 3))
                for (d = 0; d < 10001; d++)
                    if (pc3 + pow(d, 4) == s) {
                        System.out.println(a + " " + b + " " + c + " " + d);
                        count++;
                        break;
                    }
    return count;
}

private static long pow(int n, int p) {
    return p > 1 ? n * pow(n, p - 1) : n;
}

I'd do something like this,

class Node {
    int num;
    HashSet<Node> next = new HashSet<>();
}

boolean allPathsConnect(Node curr, HashSet<Node> visited, Node end) {
    if (curr == end) return true;
    if (visited.contains(curr)) return true;
    else if (curr.next.isEmpty()) return false;
    else {
        visited.add(curr);
        for (Node i : curr.next) {
            if (!allPathsConnect(i, visited, end)) return false;
        }
        return true;
    }
}

Pass the result variable to the function?
like this

void mul(int *a, int *b, int *ans)
{
    *ans = *a * *b;
}

int main(int argc, char const *argv[])
{
    int a = 5;
    int b = 4;
    int ans;
    mul(&a, &b, &ans);
    printf("%d * %d = %d\n", a, b, ans);
    return 0;
}

I'd do something like this

int n=0xDA;
int filter = 0x10;
if (n&filter==0) printf("Zero");
else printf("One");

Here's what I'd do
for position
1 loop min from pos to 0(array index -1) and stop when array[min] becomes greater than array[pos](our given num) this will be the index at which our condition breaks so min+1 is in range where array[pos] is the largest num in range
2 similarly loop max from pos to array length, so when our condition breaks max-1 will contain the pos of the last number thats smaller than our given num
3 convert into our range that will be in [1 to array size] from machine index which will be in [0 to array size -1] by adding 1 to min+1 and max-1... which is min+2 and max
heres how the program goes

static int[] arr = {1, 5, 4, 3, 6};

public static void main(String[] args) {
    for (int i = 0; i < arr.length; i++) {
        printREIsMax(i);
    }
}

private static void printREIsMax(int pos) {
    int min = pos, max = pos;
    while (min >= 0 && arr[min] <= arr[pos]) min--;
    while (max < arr.length && arr[max] <= arr[pos]) max++;
    System.out.println(arr[pos] + "[" + (min + 2) + "," + (max) + "]");
}

no reason you can use 'while' or 'for' even... just a thought process glitch

I kinda built a binary tree out of an array and use that to print sorted values

#include <stdio.h>

int arr[100], end = 0;

void insert(int index, int v)
{
    int tmp, i;
    for (i = index; i < end; i++)
    {
        tmp = arr[i];
        arr[i] = v;
        v = tmp;
    }
    arr[end] = v;
    end++;
}

void add(int s, int e, int v)
{
    if (s == e)
        insert(s, v);
    else
    {
        int mid = (e + s) / 2;
        if (arr[mid] == v)
            insert(mid, v);
        else if (arr[mid] > v)
            add(s, mid, v);
        else
            add(mid + 1, e, v);
    }
}

void printAsc()
{
    for (int i = 0; i < end; i++)
        printf("%d ", arr[i]);
}

void printDes()
{
    for (int i = end - 1; i >= 0; i--)
        printf("%d ", arr[i]);
}

int main(int argc, char const *argv[])
{
    int n, tmp;
    printf("Enter  the limit n : ");
    scanf("%d", &n);
    for (int i = 0; i < n; i++)
    {
        printf("Enter number %d : ", i + 1);
        scanf("%d", &tmp);
        add(0, end, tmp);
    }
    printf("\nAscending : ");
    printAsc();
    printf("\nDescending : ");
    printDes();
    return 0;
}

hope this helps

Search google for "doubly linked list in c", doubly linked list is quite commonly asked question.
the one from tutorials point is good enough and quite exhaustive.
ignore functions you don't need and comments

This should be enough..

// this strcmp function returns 0 if strings are equal
int strcmp(char *s1, char *s2)
{

    int l1 = strlen(s1);
    int l2 = strlen(s2);

    if (l1 != l2)
        return l1 - l2;

    int i = -1;
    do
    {
        i++;
        if (s1[i] != s2[i])
            return (int)s1[i] - s2[i];
    } while (i < l1);

    return 0;
}

I would do something like this,

public static void main(String[] args) {
    
    int[] a = {1, 2, 3, 4, 5};
    int[] b = {1, 1, 2, 2, 3, 3, 4, 4, 5};
    int[] c = new int[a.length + b.length];
    
    int i = 0, j = 0, end = 0;
    while (i < a.length && j < b.length)
        c[end++] = (a[i] <= b[j]) ? a[i++] : b[j++];
    while (i < a.length)
        c[end++] = a[i++];
    while (j < b.length)
        c[end++] = b[j++];
    
    System.out.println(Arrays.toString(c));
}

just so that I can avoid nulls & unnecessary if conditions
while takes just as much time even when split

Yes I understand, I missed it..
But I can't seem to think of any other way..
2 loops are needed one to loop through the string the other to find the match,even if the match finding function is user defined
please, If you find an answer kindly attach a reply here

Something like this should be ok..
The program should be pretty much self explanatory
Hope this helps

static String string;

public static void main(String[] args) {
    System.out.print("Enter the string : ");
    string = (new Scanner(System.in)).nextLine();
    for (int i = 0; i < string.length(); i++)
        System.out.println("S(" + (i + 1) + "," +
                string.length() + ") = " + S(i, string.length()));
    for (int i = 0; i < string.length(); i++)
        System.out.println("len(LCP(s(" + (i + 1) + "," +
                string.length() + "),s)) = " +
                LCP(S(i, string.length()), string).length());
}

static String S(int start, int end) {
    return string.substring(start, end);
}

static String LCP(String a, String b) {
    for (int i = a.length(); i > 0; i--) {
        String tmp = a.substring(0, i);
        if (b.startsWith(tmp)) return tmp;
    }
    return "";
}

a = *ptr = 32       // changing *ptr changes a and vice versa
ch = cho = 'A' (ASCII value 65) // similarly ch and cho
cho = cho+a = 'A'+32 i.e. 65+32 = 97 i.e. char 'a'
*ptr = *ptr+ch= 32+97(from previous line 'a') ie 129
so the output : 129, a

This is how I'd go about it,
K will denote the level of the string in the reverse order 0 will be the last
based on the level iterate from end of the previous level to N-level
the rest of the string from current end to the last will be recursively solved
if the current substring is palindrome send 1 (c+1) to the next level
the c will be added to count at the end will have the no of palindromes for the current split

static Scanner sc = new Scanner(System.in);
static String input;
static int count = 0;
static int n;

public static void main(String[] args) {
    System.out.print("Enter N and K : ");
    n = sc.nextInt();
    var k = sc.nextInt();
    input = sc.nextLine();
    System.out.print("Enter the String : ");
    input = sc.nextLine();
    checkPalin(0, 0, k);
    System.out.println("The count of Palindrome in " + input + " = " + count);
}

private static void checkPalin(int c, int start, int lvl) {
    if (lvl > 0)
        for (int end = start + 1; end <= n - lvl; end++) {
            int tmp = 0;
            if (isPalin(start, end)) tmp = 1;
            checkPalin(c + tmp, end, lvl - 1);
        }
    if (lvl == 0) {
        if (isPalin(start, n)) c += 1;
        count += c;
    }
}

private static boolean isPalin(int start, int end) {
    for (int i = 0; i < (end - start) / 2; i++)
        if (input.charAt(start + i) != input.charAt(end - i - 1))
            return false;
    return true;
}

This is how I'd go about it
a node having excess coins or deficit of coins requires that many moves of coins from the connected node
so the deficit or excess is to be added to the no of moves the excess or deficit is moved to or from the parent
Note: assumptions made:
only one coin can be moved per move
only up or down one step of the tree

private static Node tree;
private static int moves;

public static void main(String[] args) {
    // init tree here
    moves = 0;
    traverse(tree);

    System.out.println("The number of moves required : " + moves);
}

private static int traverse(Node tmp) {
    int ret = 0;
    for (Node n : tmp.kids) {
        int t = traverse(n);
        ret += t;
        moves += Math.abs(t);
    }
    ret += tmp.val - 1;
    return ret;
}

This is how I'd do it,
use counting semaphores for resources
thread will acquire required resources and process for a certain amount of time
release after the sleep
Note : variable time , t and sleep(t) have been used for fine tuning the start time of threads
and would not be required if its too much trouble

public class EgThread {
    private static final Semaphore sem = new Semaphore(10);
    private static final long time = System.currentTimeMillis() + 5000; // not required
    
    public static void main(String[] args) {
        MyThread[] threads = new MyThread[5];
        
        for (int i = 0; i < 5; i++) {
            threads[i] = new MyThread(String.valueOf(i + 1));
        }
        for (int i = 0; i < 5; i++)
            threads[i].start();
        
        try {
            for (int i = 0; i < 5; i++)
                threads[i].join();
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    static class MyThread extends Thread {
        String name;
        
        MyThread(String name) {
            this.name = name;
        }
        
        @Override
        public void run() {
            try {
                long t = time - System.currentTimeMillis(); // not required
                sleep(t); //---------------------------------- not required
                for (int i = 0; i < 10; i++) {
                    int req = (int) (6 * Math.random()) + 1;
                    System.out.println("T[" + name + "] run : " + (i + 1) + " asks for " + req + " resources");
                    sem.acquire(req);
                    System.out.println("T[" + name + "] run : " + (i + 1) + " acquires " + req + " resources");
                    sleep((long) (500 * Math.random()) + 200);
                    System.out.println("T[" + name + "] run : " + (i + 1) + " releases " + req + " resources");
                    sem.release(req);
                }
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Hope this helps

public static void main(String[] args) {
    System.out.print("Enter the limit : ");
    int n = (new Scanner(System.in)).nextInt();
    ArrayList<Integer> list = new ArrayList<>();
    for (int i = 1; i <= n; i++) {
        if (i == findSOC(i)) {
            list.add(i);
        }
    }
    System.out.println(list);
}

private static int findSOC(int i) {
    if (i == 0)
        return 0;
    return findSOC(i / 10) + cube(i % 10);
}

private static int cube(int i) {
    return i * i * i;
}

This is how I'd do it
1 push on (,{,[,<
2 pop on ),},],>
compare popped value
the fail conditions are
1 no opening brace
2 opening brace not matching with closing brace
3 unsatisfied opening braces
the success condition would be all braces matching in the right order
i.e stack empty at end

public class BracketChk {
    static Stack<Character> stack = new Stack<>();
    
    public static void main(String[] args) {
        System.out.print("Enter the String with brackets : ");
        String input = (new Scanner(System.in)).nextLine();
        try {
            for (int i = 0; i < input.length(); i++) {
                System.out.println(stack.toString());
                char c = input.charAt(i);
                boolean flag = true;
                switch (c) {
                    case '(': case '{': case '[': case '<':
                        stack.push(c);
                        break;
                    case ')': case '}': case ']': case '>':
                        char o = stack.pop(); // closing brace not having any opening brace
                                              // throws exception
                        switch (c) {
                            case ')':
                                if (o != '(') flag = false;
                                break;
                            case '}':
                                if (o != '{') flag = false;
                                break;
                            case ']':
                                if (o != '[') flag = false;
                                break;
                            case '>':
                                if (o != '<') flag = false;
                                break;
                        }
                }
                if (!flag) throw new EmptyStackException(); // opening and closing brace not matching
            }
            if (stack.size() > 0) throw new EmptyStackException(); // more opening braces
            System.out.println("Successful : Brackets balanced!!"); // all braces match
        }
        catch (EmptyStackException e) {
            System.out.println("Unsuccessful : Brackets not balanced");
        }
    }
}

the good thing is that only int is used so it will not take as much space as String

1 fill an array list with the increasing numbers 1-N
2 sort the array list with compare lambda expression
the comparison is to be done after converting the num to a value between 0-9
eg 1 10 ...19 all produce 1 only rearrange when nums produce negative
2 and 11 will be compared as 1-2 will produce -1 and so swapped

public static void main(String[] args) {
    
    ArrayList<Integer> list = new ArrayList<>();
    System.out.print("Enter the size : ");
    Scanner in = new Scanner(System.in);
    int n = in.nextInt();
    for (int i = 1; i <= n; i++) {
        list.add(i);
    }
    
    // sort using num converted to 0-9
    list.sort((o1, o2) -> {
        while (o1 > 9) o1 /= 10;
        while (o2 > 9) o2 /= 10;
        return o1 - o2;
    });
    
    System.out.println("The list is : " + list.toString());
    int t;
    do {
        System.out.print("Enter the index you want to get <negative num to exit> : ");
        t = in.nextInt();
        if (t >= 0 && t < n)
            System.out.println("The Queried num is " + list.get(t));
        else System.out.println("Error : Index out of bounds");
    } while (t >= 0);
}

1 keep track of the number of toffees in the boxes initially 0.
2 add the incoming toffee packet to the first box with the minimum number of toffees

note 1 : under the given circumstances this will produce the minimum max toffees in all the boxes
note 2 : I assume that you are not allowed to rearrange toffee packets in the boxes

if you need the Java program ask so in the reply

lets assume
1 rats are to be fed once and at the same time and we know how fast the poison acts, then the following would be optimal
feed rat1 with milk1 and milk2
feed rat2 with milk2 and milk3
wait for the time the poison should act
if only rat1 dies milk1 has poison
if both rat1 and rat2 die then milk2 has poison
if only rat2 dies then milk3 has poison
if no rats die then milk4 has poison

This is how I'd do it
optimizations
1: always start j after i so that we don need to check for i<j
2: i will always be less than size-max so that there is always a array that is larger than max to check for
3: j should start after i but also i+max so that the length of a[i], a[j] in comparison will never be smaller than max

public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    
    System.out.print("Enter the size of arr : ");
    int size = in.nextInt();
    
    int[] arr = new int[size];
    for (int i = 0; i < size; i++) arr[i] = in.nextInt();
    
    int max=0;
    for(int i=0;i<size-max;i++)
        for(int j=i+max+1;j<size;j++)
            if (arr[i]<arr[j]&&j-i>max)
                max=j-i;

    System.out.println("the max length between a[i],a[j] where a[i]<a[j] is "+max);
}

Using the diff method does lower the code complexity

public class MinSumBt2 {
    public static void main(String[] args) {
        ArrayList<CostPair> list = new ArrayList<>();
        
        try (Scanner in = new Scanner(new FileReader("inputMinSum"))) {
            while (in.hasNext()) {
                list.add(new CostPair(in.nextInt(), in.nextInt()));
            }
        }
        catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        list.sort(CostPair::compareTo);
        int sum = 0;
        for (int i = 0; i < 100; i++)
            sum += i < 50 ? list.get(i).toNY : list.get(i).toSF;
        System.out.println(sum);
    }
    
    private static class CostPair implements Comparable<CostPair> {
        int toNY;
        int toSF;
        int diff;
        
        CostPair(int toNY, int toSF) {
            this.toNY = toNY;
            this.toSF = toSF;
            diff = toSF - toNY;
        }
        
        @Override
        public int compareTo(CostPair o) {
            return diff - o.diff;
        }
    }
}