Java 8 coding challenge : Jarvis and Seven Segments

All over the world, peoples are working on energy solution. It would be a tough time for our next generation to survive if we don’t think about solution. Tony stark is working on a new project and wants to display his project using “seven segment display – concept”. Tony Stark gave Jarvis a task to find a number from his Favorite list of number for which the energy consumption is lowest.

(Assuming that for a digit to represent Tony stark is using 7 bulbs and only those bulbs light up which are required to represent a number and rest other would be completely off.)

Help Jarvis and conserve energy.

Seven segment display – https://en.wikipedia.org/wiki/Seven-segment_display

enter image description here

Input:
First line will contain the number of test cases and for every test case first line will contain length of favorite list and the second line for a test case will contain n numbers

Output:
For every test case print the answer. If there exist more than 1 numbers for which same number of bulbs are required than output the number which occurs first in the Favorite list.

Constraints:
Test cases< 10
A[i] < 10^6
Size of list < 10^5

SAMPLE INPUT
1
5
1 2 3 4 5
SAMPLE OUTPUT
1
Explanation

Number 1 needs only two bulbs to represent.

Code:

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.HashMap;
 
 
 
 
public class Solution {
 
 
 public static void main(String args[]) throws IOException{
 InputReader in=new InputReader(System.in);
 PrintWriter out=new PrintWriter(System.out);
 int T=in.readInt();
 
 while(T-->0){
 long N=in.readLong();
 long min=222222222;
 long minnum=0;
 while(N-->0){
 long num=in.readCount();
 long count=in.getcount();
 if(count<min){
 min=count;
 minnum=num;
 }
 }
 out.println(minnum);
 out.flush();
 
 }
 
 out.close();
 
 }
}
 
class InputReader{
 InputStream in;
 int[] segment={6,2,5,5,4,5,6,3,7,6};
 long count=0;
 InputReader(InputStream in){
 this.in=in;
 }
 
 public long getcount(){
 return count;
 }
 private int read() throws IOException{
 return in.read();
 }
 
 
 
 public char readChar() throws IOException{
 int n=read();
 while(isWhiteSpace(n)){
 n=read();
 }
 return (char)n;
 }
 
 public int readInt() throws IOException{
 int number=0;
 int n=read();
 while(isWhiteSpace(n)){
 n=read();
 }
 while(!isWhiteSpace(n)){
 int integer=n-'0';
 number*=10;
 number+=integer;
 n=read();
 }
 return number;
 }
 
 public long readCount() throws IOException{
 long number=0;
 count=0;
 int n=read();
 while(isWhiteSpace(n)){
 n=read();
 }
 while(!isWhiteSpace(n)){
 int integer=n-'0';
 count+=segment[integer];
 number*=10;
 number+=integer;
 n=read();
 }
 return number;
 }
 
 
 public long readLong() throws IOException{
 long number=0;
 int n=read();
 while(isWhiteSpace(n)){
 n=read();
 }
 while(!isWhiteSpace(n)){
 int integer=n-'0';
 number*=10;
 number+=integer;
 n=read();
 }
 return number;
 }
 
 private boolean isWhiteSpace(int n){
 if(n=='\n'||n=='\r'||n=='\t'||n==' '||n==-1){
 return true;
 }else{
 return false;
 }
 
 }
 }

Java 8 Coding challenge: Raees’s Liquor Tank

enter image description here

Raees wants to build a new tank to hide his illegal liquor . He comes up with some designs . Now he asks you to find out maximum units of liquor he can fill in the tank.

You are given N elements , corresponding to heights of walls . See the figure for input 0 ,8 ,0 ,4 ,0 ,3 ,0 ,5 ,0 ,3 ,0 ,1 ,0.

Maximum amount of liquor that can be filled is 5 + 1 + 5 + 2 + 5 + 3 + 1 = 22.

Eg : For input 4 ,2 ,4 ,3 Output will be 2 .

INPUT

  • First line of input contains a single integer N.
  • Second line of input contains N non-negative integers ( A0A(n-1) ).

OUTPUT

  • Single integer , answer to the Raees’s question.

CONSTRAINTS

  • 1 <= N <= 1000
  • 1 <= Ai <= 1000
SAMPLE INPUT
13
0 8 0 4 0 3 0 5 0 3 0 1 0
SAMPLE OUTPUT
22

 Code:

import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;
import static java.lang.Math.*;
 
public class Q1
{
 
 static class InputReader
 {
 private InputStream stream;
 private byte[] buf = new byte[1024];
 private int curChar;
 private int numChars;
 private SpaceCharFilter filter;
 
 public InputReader(InputStream stream)
 {
 this.stream = stream;
 }
 
 public int read()
 {
 if (numChars==-1) 
 throw new InputMismatchException();
 
 if (curChar >= numChars)
 {
 curChar = 0;
 try 
 {
 numChars = stream.read(buf);
 }
 catch (IOException e)
 {
 throw new InputMismatchException();
 }
 
 if(numChars <= 0) 
 return -1;
 }
 return buf[curChar++];
 }
 
 public String nextLine()
 {
 BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
 String str = "";
 try
 {
 str = br.readLine();
 }
 catch (IOException e)
 {
 e.printStackTrace();
 }
 return str;
 }
 public int nextInt()
 {
 int c = read();
 
 while(isSpaceChar(c)) 
 c = read();
 
 int sgn = 1;
 
 if (c == '-') 
 {
 sgn = -1;
 c = read();
 }
 
 int res = 0;
 do 
 {
 if(c<'0'||c>'9') 
 throw new InputMismatchException();
 res *= 10;
 res += c - '0';
 c = read();
 }
 while (!isSpaceChar(c)); 
 
 return res * sgn;
 }
 
 public long nextLong() 
 {
 int c = read();
 while (isSpaceChar(c))
 c = read();
 int sgn = 1;
 if (c == '-') 
 {
 sgn = -1;
 c = read();
 }
 long res = 0;
 
 do 
 {
 if (c < '0' || c > '9')
 throw new InputMismatchException();
 res *= 10;
 res += c - '0';
 c = read();
 }
 while (!isSpaceChar(c));
 return res * sgn;
 }
 
 public double nextDouble() 
 {
 int c = read();
 while (isSpaceChar(c))
 c = read();
 int sgn = 1;
 if (c == '-') 
 {
 sgn = -1;
 c = read();
 }
 double res = 0;
 while (!isSpaceChar(c) && c != '.') 
 {
 if (c == 'e' || c == 'E')
 return res * Math.pow(10, nextInt());
 if (c < '0' || c > '9')
 throw new InputMismatchException();
 res *= 10;
 res += c - '0';
 c = read();
 }
 if (c == '.') 
 {
 c = read();
 double m = 1;
 while (!isSpaceChar(c)) 
 {
 if (c == 'e' || c == 'E')
 return res * Math.pow(10, nextInt());
 if (c < '0' || c > '9')
 throw new InputMismatchException();
 m /= 10;
 res += (c - '0') * m;
 c = read();
 }
 }
 return res * sgn;
 }
 
 public String readString() 
 {
 int c = read();
 while (isSpaceChar(c))
 c = read();
 StringBuilder res = new StringBuilder();
 do 
 {
 res.appendCodePoint(c);
 c = read();
 } 
 while (!isSpaceChar(c));
 
 return res.toString();
 }
 
 public boolean isSpaceChar(int c) 
 {
 if (filter != null)
 return filter.isSpaceChar(c);
 return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
 }
 
 public String next() 
 {
 return readString();
 }
 
 public interface SpaceCharFilter 
 {
 public boolean isSpaceChar(int ch);
 }
 }
 
 public static int[] SOE()
 {
 int n=(int)(1e5); //till which digit
 
 int ip[]=new int[n];
 
 for(int i=2;i<(int)Math.sqrt(n);i++)
 {
 if(ip[i]==0)
 {
 for(int j=i*i;j<n;j=j+i)
 {
 ip[j]++;
 }
 }
 }
 
 ip[1]++; //counts 1 and 0 as primes
 ip[0]++;
 
 return ip;
 }
 
 private static long gcd(long a, long b)
 {
 while (b > 0)
 {
 long temp = b;
 b = a % b; // % is remainder
 a = temp;
 }
 return a;
}
 
 private static long gcd(long[] input)
 {
 long result = input[0];
 
 for(int i = 1; i < input.length; i++) 
 result = gcd(result, input[i]);
 
 return result;
 }
 
 private static long lcm(long a, long b)
 {
 return a * (b / gcd(a, b));
 }
 
 private static long lcm(long[] input)
 {
 long result = input[0];
 
 for(int i = 1; i < input.length; i++) 
 result = lcm(result, input[i]);
 
 return result;
 }
 
 public static void Array_2dsort(Integer[][] a)
 {
 
 Arrays.sort(a, new Comparator<Integer[]>() {
 public int compare(Integer[] int1, Integer[] int2) {
 Integer numOfKeys1 = int1[1]; //about which column u want to sort
 Integer numOfKeys2 = int2[1];
 return numOfKeys1.compareTo(numOfKeys2);
 }
 });
 
 }
 
 
 public static boolean Square(int x)
 {
 boolean ans=false;
 
 int a=(int)Math.sqrt(x);
 
 if(a*a==x)
 ans=true;
 
 return ans;
 }
 
 public static void main(String args[]) throws Exception
 {
 InputReader in=new InputReader(System.in); 
 PrintWriter w=new PrintWriter(System.out);
 
 int n=in.nextInt();
 
 int a[]=new int[n];
 
 for(int i=0;i<n;i++)
 a[i]=in.nextInt();
 
 
 int total=0;
 int l[]=new int[n];
 int r[]=new int[n];
 l[0]=a[0];
 r[n-1]=a[n-1];
 
 for(int i=1;i<n;i++)
 l[i]=(int)Math.max(l[i-1],a[i]);
 
 for(int i=n-2;i>=0;i--)
 r[i]=(int)Math.max(r[i+1],a[i]);
 
 for(int i=0;i<n;i++)
 total+=(int)Math.min(l[i],r[i])-a[i];
 
 w.println(total);
 
 w.close(); 
 }
}

Java 8 Coding challenge: Swapping Characters

Your are given a string of length N. You have to follow some rounds of swapping in the string until the below explained condition is reached.

In each round the, you have to swap the ith and (i+1)th character , then (i+2)th and (i+3)th character and continue till the end of string. In each round , a character from the left will be locked i.e not available for swapping after this round , thus after some rounds of swapping , all the characters will be locked at their final position to stop any more rounds of swapping .

See the sample explanation for more clarity.

Input

The first line of input contains a T, the number of test case. The first line of each Test case will contain an Integer N , denoting the length of the string. The second line of each Test case will contain a string of length N.

Output

For each and every test case, output the string after all positions are locked.

Constraints

  1. 0<T<100
  2. 0<N<10000
SAMPLE INPUT
2
6
abcdef
3
abc
SAMPLE OUTPUT
bdfeca
bca
Explanation

For the first test case , the given string is “abcdef” and all the characters are unlocked.

  1. After First round of swap , the string becomes “badcfe” . Now the leftmost unlocked character is locked i.e the string is now “b_adcfe”.
  2. After Second round of swap , the string becomes “b_dafce”. Now the leftmost unlocked character is locked i.e string is now “bd_afce”.
  3. After Third round of swap , the string becomes “bdfaec” . Now the leftmost unlocked character is locked i.e the string is now “bdf_aec”.
  4. After Fourth round of swap , the string becomes “bdfeac” . Now the leftmost unlocked character is locked i.e the string is now “bdfe_ac”..
  5. After Fifth round of swap , the string becomes “bdfeca” . Now the leftmost unlocked character is locked i.e the string is now “bdfec_a”.
  6. In the sixth round no more swap occur as there is only single unlocked character is left.

** (‘-‘ is the partition , where all the characters to its left are locked characters and all the characters to it right are unlocked characters).**

Therefore , we print the string “bdfeca”.

Code:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
class Main {
 
 public static void main(String args[] ) throws IOException {
 
 BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
 for(int k=Integer.parseInt(br.readLine());k>0;k--){
 br.readLine();
 String str=br.readLine();
 StringBuilder s=new StringBuilder(str);
 int start=0;
 int end=str.length()-1;
 for(int i=1;i<str.length();i+=2){
 s.setCharAt(start++, str.charAt(i));
 }
 for(int i=0;i<str.length();i+=2){
 s.setCharAt(end--, str.charAt(i));
 }
 System.out.println(s);
 }
 }
 public static void swap(StringBuilder s,int i,int j){
 char c=s.charAt(i);
 char d=s.charAt(j);
 s.setCharAt(i, d);
 s.setCharAt(j, c);
 }
 
}

Java 8 coding challenge: Addition ain’t simple

Jack is awesome. His friends call him little Einstein. To test him, his friends gave him a string. They told him to add the string with its reverse string and follow these rules:

  1. Every ith character of string will be added to every ith character of reverse string.
  2. Both string will contain only lower case alphabets(a-z).
  3. Eg:- a+a=b,a+c=d,z+a=a (Refer to sample test cases for more details)

Input:

First line contains a value N denoting number of test cases. Next N lines contains string str.

Output:

For every string str output the string that Jack’s friends wants from him.

Constraints

1 <= N <= 10

1 <= str <= 10^5

SAMPLE INPUT
4
hello
codeapocalypse
programming
world
SAMPLE OUTPUT
wqxqw
hhtdmqrrqmdthh
wfxtebetxfw
aajaa

Code:

import java.io.*;
import java.util.HashMap;
import java.util.InputMismatchException;
import java.util.Map;
 

public class AdditionAintSimple {
 static class Print {
 private final BufferedWriter bw;
 
 public Print() {
 this.bw = new BufferedWriter(new OutputStreamWriter(System.out));
 }
 
 public void print(Object object) throws IOException {
 bw.append("" + object);
 }
 
 public void println(Object object) throws IOException {
 print(object);
 bw.append("\n");
 }
 
 public void close() throws IOException {
 bw.close();
 }
 }
 
 static class Reader
 {
 final private int BUFFER_SIZE = 1 << 16;
 private DataInputStream din;
 private byte[] buffer;
 private int bufferPointer, bytesRead;
 
 public Reader()
 {
 din = new DataInputStream(System.in);
 buffer = new byte[BUFFER_SIZE];
 bufferPointer = bytesRead = 0;
 }
 
 public Reader(String file_name) throws IOException
 {
 din = new DataInputStream(new FileInputStream(file_name));
 buffer = new byte[BUFFER_SIZE];
 bufferPointer = bytesRead = 0;
 }
 
 public String readLine() throws IOException
 {
 byte[] buf = new byte[100000]; // 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 nextInt() throws IOException
 {
 int ret = 0;
 byte c = read();
 while (c <= ' ')
 c = read();
 boolean neg = (c == '-');
 if (neg)
 c = read();
 do
 {
 ret = ret * 10 + c - '0';
 } while ((c = read()) >= '0' && c <= '9');
 
 if (neg)
 return -ret;
 return ret;
 }
 
 public long nextLong() throws IOException
 {
 long ret = 0;
 byte c = read();
 while (c <= ' ')
 c = read();
 boolean neg = (c == '-');
 if (neg)
 c = read();
 do {
 ret = ret * 10 + c - '0';
 }
 while ((c = read()) >= '0' && c <= '9');
 if (neg)
 return -ret;
 return ret;
 }
 
 public double nextDouble() throws IOException
 {
 double ret = 0, div = 1;
 byte c = read();
 while (c <= ' ')
 c = read();
 boolean neg = (c == '-');
 if (neg)
 c = read();
 
 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
 {
 bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
 if (bytesRead == -1)
 buffer[0] = -1;
 }
 
 private byte read() throws IOException
 {
 if (bufferPointer == bytesRead)
 fillBuffer();
 return buffer[bufferPointer++];
 }
 
 public void close() throws IOException
 {
 if (din == null)
 return;
 din.close();
 }
 }
 
 public static void main(String[] args) throws Exception{
 Reader rd = new Reader();
 Print pr = new Print();
 
 int t = rd.nextInt();
 String ip;
 
 
 int len;
 
 while(t-->0) {
 ip = rd.readLine();
 len = ip.length();
 char op[] = new char[len];
 
 for (int i = 0; i < len; i++) {
 op[i] = (char) ((( ip.charAt(i) + ip.charAt(len - i - 1) - 193) % 26)+97);
 }
 pr.println(String.valueOf(op));
 }
 pr.close();
 }
}

Java 8 Coding Challenge: COUNT NUMBERS

Your task is pretty simple , given a string S , find the total count of numbers present in the digit.

Input

The first line contains T , the number of test cases. The first line of each and every testc ase will contain a integer N , the length of the string . The second line of each and every test case will contain a string S of length N.

Output

For each and every testcase , output the total count of numbers present in the string.

Constraints

  1. 0<T<200
  2. 0<N<10000
SAMPLE INPUT
1
26
sadw96aeafae4awdw2wd100awd
SAMPLE OUTPUT
4
Explanation

For the first test case , the string given is “sadw96aeafae4awdw2wd100awd”. There are total of 4 numbers in the string – [96,4,2,100]. So , we output 4.

Code

import java.io.BufferedReader;
import java.io.InputStreamReader;
 
class TestClass {
 public static void main(String args[] ) throws Exception {
 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 int T = Integer.parseInt(br.readLine());
 
 boolean bit=false;
 int count=0,i=0,j=0,N=0;
 char c='.';
 String ST = "";
 
 for (i=0; i<T; i++)
 {
 count=0;
 N = Integer.parseInt(br.readLine());
 ST = br.readLine();
 
 for(j=0; j<N; j++)
 {
 c = ST.charAt(j);
 if(c>47 && c<58)
 bit=true;
 else
 { if(bit)
 { bit=false;
 count++;
 }
 }
 }
 if(bit)
 { bit=false;
 count++;
 }
 System.out.println(count);
 }
 }
}

Java 8 coding challenge: Count Divisors

Problem:

You have been given 3 integers l, r and k. Find how many numbers between l and r (both inclusive) are divisible by k. You do not need to print these numbers, you just have to find their count.

Input Format
The first and only line of input contains 3 space separated integers l, r and k.

Output Format
Print the required answer on a single line.

Constraints
1lr10001≤l≤r≤1000
1k10001≤k≤1000

SAMPLE INPUT
1 10 1
SAMPLE OUTPUT
10

Code:

/* IMPORTANT: Multiple classes and nested static classes are supported */
 
/*
 * uncomment this if you want to read input.
//imports for BufferedReader
import java.io.BufferedReader;
import java.io.InputStreamReader;
 
//import for Scanner and other utility classes
import java.util.*;
*/
import java.util.Scanner;
 
class TestClass {
 public static void main(String args[] ) throws Exception {
 Scanner sc = new Scanner(System.in);
 
 int l = sc.nextInt();
 int r = sc.nextInt();
 int k = sc.nextInt();
 
 sc.close();
 int count = 0;
 if(l == r && l%k != 0) {
 System.out.println(0);
 System.exit(0);
 }
 
 while (l <= r) {
 if(l % k == 0) {
 break;
 }
 l++;
 }
 
 count = (r - l) / k + 1;
 System.out.println(count);
 }
}