Infosys Coding Questions and Answers

 class SortString{
    static final int MAX_CHAR = 26;

    static void sortString(String str) {

        int letters[] = new int[MAX_CHAR];

    
        for (char x : str.toCharArray()) {

    
            letters[x - 'a']++;
        }

    
        for (int i = 0; i < MAX_CHAR; i++) {
            for (int j = 0; j < letters[i]; j++) {
                System.out.print((char) (i + 'a'));
            }
        }
    }

    public static void main(String[] args) {
        sortString("prepbytes");
    }
}

MAX_CHAR = 26

def sortString(str):
    

    charCount = [0 for i in range(MAX_CHAR)]
    
    
    for i in range(0, len(str), 1):
        
    
        charCount[ord(str[i]) - ord('a')] += 1
    

    for i in range(0, MAX_CHAR, 1):
        for j in range(0, charCount[i], 1):
            print(chr(ord('a') + i), end = "")

if __name__ == '__main__':
    s = "prepbytes"
    sortString(s)
    

import java.util.*;

class Prepbytes{


static int cntDistinct(String str)
{
    

    HashSet<Character> s = new HashSet<Character>();

    for(int i = 0; i < str.length(); i++)
    {
        
    
        s.add(str.charAt(i));
    }

    return s.size();
}

public static void main(String args[])
{
    String str = "prepbytes";
    System.out.print(cntDistinct(str));
}
}

def cntDistinct(st):

    s = set([])

    for i in range(len(st)):


        s.add(st[i])

    return len(s)

if __name__ == "__main__":

    st = "prepbytes"
    print(cntDistinct(st))

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

class Prepbytes {

    static int R1 = 2; 
    static int C1 = 2;  
    static int R2 = 2;  
    static int C2 = 2;  

    
    static void mulMat(int[][] mat1, int[][] mat2)
    {
        
        int[][] rslt = new int[R1][C2];
        System.out.println(
            "Multiplication of given two matrices is:");
        int i, j, k;
        for (i = 0; i < R1; i++) {
            for (j = 0; j < C2; j++) {
                rslt[i][j] = 0;
                for (k = 0; k < R2; k++)
                    rslt[i][j] += mat1[i][k] * mat2[k][j];
                System.out.print(rslt[i][j] + " ");
            }
            System.out.println("");
        }
    }

    public static void main(String[] args)
    {
        int[][] mat1 = { { 4, 4 },
                        { 5, 3 } };

        int[][] mat2 = { { 4, 7 },
                        { 6, 2 } };


        if (C1 != R2) {
            System.out.println(
                "The number of columns in Matrix-1 must be equal to the number of rows in Matrix-2");
            System.out.println(
                "Please update the global variables according to your array dimension");
        }
        else {
        
            mulMat(mat1, mat2);
        }
    }
}

def mulMat(mat1, mat2, R1, R2, C1, C2):
    rslt = [[0, 0, 0, 0],
            [0, 0, 0, 0],
            [0, 0, 0, 0],
            [0, 0, 0, 0]]

    for i in range(0, R1):
        for j in range(0, C2):
            for k in range(0, R2):
                rslt[i][j] += mat1[i][k] * mat2[k][j]

    print("Multiplication of given two matrices is:")
    for i in range(0, R1):
        for j in range(0, C2):
            print(rslt[i][j], end=" ")
        print("\n", end="")


if __name__ == '__main__':
    R1 = 2
    R2 = 2
    C1 = 2
    C2 = 2
    
    mat1 = [[4, 4],
        [5, 3]]
    

    mat2 = [[4, 7],
        [6, 2]]

    if C1 != R2:
        print("The number of columns in Matrix-1 must be equal to the number of rows in " + "Matrix-2", end='')
        print("\n", end='')
        print("Please update MACROs according to your array dimension in #define section", end='')
        print("\n", end='')
    else:
        mulMat(mat1, mat2, R1, R2, C1, C2)

import java.lang.*;

class Prepbytes {

    static double PI = 3.14159265;

    public static double area_inscribed(double P, double B,
                                        double H)
    {
        return ((P + B - H) * (P + B - H) * (PI / 4));
    }

    public static void main(String[] args)
    {
        double P = 3, B = 4, H = 5;
        System.out.println(area_inscribed(P, B, H));
    }
}

PI = 3.14159265

def area_inscribed(P, B, H):
    return ((P + B - H)*(P + B - H)*(PI / 4))

P = 3
B = 4
H = 5
print(area_inscribed(P, B, H))

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

class Prepbytes{
    
private static ArrayList<Character>missingChars(
    String str, int strLength)
{
    final int MAX_CHARS = 26;
    

    boolean[] present = new boolean[MAX_CHARS];
    ArrayList<Character> charsList = new ArrayList<>();
    

    for(int i = 0; i < strLength; i++)
    {
        if ('A' <= str.charAt(i) &&
                str.charAt(i) <= 'Z')
            present[str.charAt(i) - 'A'] = true;
        else if ('a' <= str.charAt(i) &&
                        str.charAt(i) <= 'z')
            present[str.charAt(i) - 'a'] = true;
    }
    
    
    for(int i = 0; i < MAX_CHARS; i++)
    {
        if (present[i] == false)
            charsList.add((char)(i + 'a'));
    }
    return charsList;
}

public static void main(String[] args)
{
    String str = "Welcome to prepbytes";
                
    ArrayList<Character> missing = Prepbytes.missingChars(
        str, str.length());
        
    if (missing.size() >= 1)
    {
        for(Character character : missing)
        {
            System.out.print(character);
        }
    }
}
}

MAX_CHAR = 26


def missingChars(Str):
    

    present = [False for i in range(MAX_CHAR)]


    for i in range(len(Str)):
        if (Str[i] >= 'a' and Str[i] <= 'z'):
            present[ord(Str[i]) - ord('a')] = True
        elif (Str[i] >= 'A' and Str[i] <= 'Z'):
            present[ord(Str[i]) - ord('A')] = True


    res = ""

    for i in range(MAX_CHAR):
        if (present[i] == False):
            res += chr(i + ord('a'))
            
    return res

Str = "Welcome to prepbytes"

print(missingChars(Str))

class Prepbytes {


    static float Cel_To_Fah(float N)
    {
        return ((N * 9.0f / 5.0f) + 32.0f);
    }

    public static void main(String[] args)
    {
        float N = 40.0f;
    
        System.out.println(Cel_To_Fah(N));
    }
}

def Cel_To_Fah(n):

    return (n*1.8)+32



n = 40

print(int(Cel_To_Fah(n)))

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

class Prepbytes {
    

    static int sumOfPrimes(int n)
    {
        boolean prime[]=new boolean[n + 1];
    
        Arrays.fill(prime, true);
    
        for (int p = 2; p * p <= n; p++) {
    
            
            if (prime[p] == true) {
    
                for (int i = p * 2; i <= n; i += p)
                    prime[i] = false;
            }
        }
    
        
        int sum = 0;
        for (int i = 2; i <= n; i++)
            if (prime[i])
                sum += i;
        return sum;
    }

    public static void main(String args[])
    {
        int n = 15;
        System.out.print(sumOfPrimes(n));
    }
}

def sumOfPrimes(n):
    prime = [True] * (n + 1)

    
    p = 2
    while p * p <= n:
        if prime[p] == True:
            i = p * 2
            while i <= n:
                prime[i] = False
                i += p
        p += 1
        

    sum = 0
    for i in range (2, n + 1):
        if(prime[i]):
            sum += i
    return sum

n = 15
print(sumOfPrimes(n))

import java.util.*;

class Prepbytes {

    
    static void printLargest(Vector<String> arr)
    {

        Collections.sort(arr, new Comparator<String>()
        {
    
            @Override public int compare(String X, String Y)
            {

                String XY = X + Y;

                String YX = Y + X;

                
                return XY.compareTo(YX) > 0 ? -1 : 1;
            }
        });

        Iterator it = arr.iterator();

        while (it.hasNext())
            System.out.print(it.next());
    }

    public static void main(String[] args)
    {

        Vector<String> arr;
        arr = new Vector<>();

        arr.add("54");
        arr.add("546");
        arr.add("548");
        arr.add("60");
        printLargest(arr);
    }
}

def largestNumber(array):

    if len(array)==1:
        return str(array[0])
    for i in range(len(array)):
        array[i]=str(array[i])
    for i in range(len(array)):
        for j in range(1+i,len(array)):
            if array[j]+array[i]>array[i]+array[j]:
                array[i],array[j]=array[j],array[i]

    result=''.join(array)
    if(result=='0'*len(result)):
        return '0'
    else:
        return result
        
        
    a = [54, 546, 548, 60]
    print(largestNumber(a))

class Test{
    
    static int arr[] = new int[]{4, 7, 3, 6, 7, 3};
    
    public static void printTriangle(int n)
    {
        int tri[][] = new int[n][n];
        
        for (int i = 0; i < n ; i++)
            tri[n-1][i] = arr[i];
        
        for (int i = n-2; i >=0; i--)
            for (int j = 0; j <= i; j++)
            tri[i][j] = tri[i+1][j] + tri[i+1][j+1];
        
        for (int i = 0; i < n; i++)
        {
            for(int j = 0; j <= i ; j++)
                System.out.print(tri[i][j] + " ");
            System.out.println();
        }
    }
    
    public static void main(String[] args)
    {
        printTriangle(arr.length);
        }
}

def printTriangle(arr, n):
    
    tri = [[0 for i in range(n)]
            for i in range(n)]

    for i in range(n):
        tri[n - 1][i] = arr[i]

    i = n - 2
    while(i >= 0):
        for j in range(0, i + 1, 1):
            tri[i][j] = (tri[i + 1][j] +
                        tri[i + 1][j + 1])
            
        i -= 1

    for i in range(0, n, 1):
        for j in range(0, i + 1, 1):
            print(tri[i][j], end = " ")
        print("\n", end = "")

    arr = [4, 7, 3, 6, 7, 3]
    n = len(arr)
    printTriangle(arr, n)
    

import java.util.*;

class PrepBytes {

    
    static int maxProfit(int price[], int start, int end)
    {

    
        if (end <= start)
            return 0;

        int profit = 0;

        for (int i = start; i < end; i++) {

            for (int j = i + 1; j <= end; j++) {

                if (price[j] > price[i]) {

                    int curr_profit
                        = price[j] - price[i]
                        + maxProfit(price, start, i - 1)
                        + maxProfit(price, j + 1, end);

                    profit = Math.max(profit, curr_profit);
                }
            }
        }
        return profit;
    }

    public static void main(String[] args)
    {
        int price[] = { 100, 180, 260, 310, 40, 535, 695 };
        int n = price.length;

        System.out.print(maxProfit(price, 0, n - 1));
    }
}

def maxProfit(price, start, end):

    if (end <= start):
        return 0

    profit = 0


    for i in range(start, end, 1):

        for j in range(i+1, end+1):

            if (price[j] > price[i]):

                curr_profit = price[j] - price[i] +\
                    maxProfit(price, start, i - 1) + \
                    maxProfit(price, j + 1, end)

                profit = max(profit, curr_profit)

    return profit


if __name__ == '__main__':
    price = [100, 180, 260, 310, 40, 535, 695]
    n = len(price)

    print(maxProfit(price, 0, n - 1))