prompt stringlengths 396 31.4k |
|---|
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.*;
public class java{
public static void main(String[]arg) {
Scanner sc=new Scanner(System.in);
int x=sc.nextInt();
String s=sc.next();
boolean f=true;
boolean f2=true;
bool... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
// A O(n) and O(n) extra space Java program to find
// longest common subarray of two binary arrays with
// same sum
class
Test
{
static
int
arr1[] =
new
int
[]{
0
,
1
,
0
,
1
,
1
,
1
,
1
};
static
int
arr2[] =
new
int
[]{
1
,
1
,
1
,
1
,
... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.*;
import java.io.*;
public class Waw{
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
long[] a = new long[n];
for(int i=0;i<n;i++) a[... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.Scanner;
public class Codeforces {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n, f[], c=0;
n = in.nextInt();
f = new int[n];
while (--n>0){
f[in.nextInt()-1] ++;
f[in.nextInt()-1]++;
in... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>/*
* Created on 17.05.2019
*/
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
* @author Wolfgang Weck
*/
public class C01Easy {
public static void main(String[] args) {
try (BufferedReader r = new Buffere... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Code {
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(Sys... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.io.*;
import java.util.*;
public class Main {
private static void solve(InputReader in, OutputWriter out) {
int n = in.nextInt();
if (n < 6) {
out.println(-1);
} else {
int m = (n - 2);
... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
import java.util.*;
import java.io.*;
import java.math.*;
public class loser
{
static class InputReader {
public BufferedReader br;
public StringTokenizer token;
public InputReader(InputStream stream)
{
br=new Bu... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.io.*;
import java.util.*;
public class LectureSleep {
static class InputReader {
BufferedReader reader;
StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new In... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class Equator {
public static BufferedReader in = new Buffer... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.io.*;
import java.util.*;
public class GFG {
public static void main (String[] args) {
Scanner sc = new Scanner (System.in);
int n = sc.nextInt();
int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();
int a... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.io.*;
import java.util.*;
import java.util.stream.Collectors;
import java.math.*;
public class C {
public static void main(String[] args) throws IOException {
/**/
Scanner sc = new Scanner(new BufferedReader(new InputStreamReader(System.in)))... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.*;
public class Main{
private static final int MAX_SIZE = 100005;
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int a = sc.next... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.io.*;
import java.util.*;
public class Main {
public void solve() {
int n = ni();
int a = ni();
int b = ni();
long ans = 0;
HashMap<Long, Long> m = new HashMap<>();
HashMap<String, Long> s = new ... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.math.BigInteger;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class Practice {
public static void main(String []args)
{
Scanner sc=new Scanner(Syste... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.*;
import java.io.*;
public class TwoGram {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String s = sc.next();
HashMap <String, Integer> hm = new Has... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.io.*;
import java.util.ArrayList;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
int n=I... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
import java.io.*;
import java.util.Scanner;
public class abc{
public static int check(StringBuilder s)
{
int countRemove=0;
if(!s.toString().contains("xxx")) return countRemove;
else{
for(int i=1;i<s.length()-1;i++)
{
... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
class
MergeArrays
{
/* Function to move m elements at the end of array mPlusN[] */
void
moveToEnd(
int
mPlusN[],
int
size)
{
int
i, j = size -
1
;
for
(i = size -
1
; i >=
0
; i--)
{
if
(mPlusN[i] != -
1
)
{
mPlusN[j] = mPlusN[i];
j--; ... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.Scanner;
public class TreasureHunt {
public static String Solve() {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
sc.nextLine();
String kuro = sc.nextLine(), shiro = sc.nextLine(), katie = sc.nextLine();
sc.close();
... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.math.BigInteger;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class Practice {
public static void main(String []args)
{
Scanner sc=new Scanner(Syste... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
import java.math.BigInteger;
import java.util.Scanner;
public class Main {
static Scanner sc = new Scanner (System.in);
public static void main(String[] args) {
int n = sc.nextInt();
int k = sc.nextInt();
char str[][] = new char[5][n];
... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.*;
public class A
{
public static int palin(String str)
{
int flag=0;
int l=str.length();
for(int i=0;i<l/2;i++)
{
if(str.charAt(i)!=str.charAt(l-i-1))
{
flag=1;
... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.io.*;
import java.util.*;
public class Main {
private static void solve(InputReader in, OutputWriter out) {
int n = in.nextInt();
List<List<Integer>> g = new ArrayList<>(n + 1);
for (int i = 0; i < n + 1; i++) {
... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
// Java program to Split the array and
// add the first part to the end
class
Geeks
{
/* Function to reverse arr[] from index start to end*/
static
void
rvereseArray(
int
arr[],
int
start,
int
end)
{
while
(start < end) {
int
temp = arr[start];
a... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
// Efficient Java program to sort an
// array of numbers in range from 1
// to n.
import
java.io.*;
import
java.util.*;
public
class
GFG {
// function for sort array
static
void
sortit(
int
[]arr,
int
n)
{
for
(
int
i =
0
; i < n; i++)
{
... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.*;
public class mohamedy23
{
public static void main (String args[])
{
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();String s=sc.next();int i=s.length()-1;
if(n==1) {
if(s.charAt(0)=... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatch... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
import
java.util.Arrays;
// Java program to test whether an array
// can be sorted by swapping adjacent
// elements using boolean array
class
GFG {
// Return true if array can be
// sorted otherwise false
static
boolean
sortedAfterSwap(
int
A[],
... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.io.*;
import java.util.*;
public class Main {
static StringBuilder data = new StringBuilder();
final static FastReader in = new FastReader();
public static void main(String[] args) {
int n = in.nextInt(), k = in.nextInt(), t... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.io.*;
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
IO io = new IO();
String s=io.nextLine();
if (s.length()<3)io.println("No");
else {
int[]b=new int[200];
... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import javax.print.DocFlavor;
import javax.swing.plaf.basic.BasicInternalFrameTitlePane;
import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.net.CookieHandler;
import java.nio.Buffer;
import java.nio.charset.IllegalCharset... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
/**
*
* @author Haya
*/
public class CommentaryBoxes {
public static void main(String[] args) {
FastReader... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import static java.lang.Math.*;
public class Main {
private FastScanner scanner = new FastScanner();
public static void main(String[] ar... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.HashSet;
import java.util.Scanner;
public class Solution {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
HashSet<Integer> set = new HashSet<>();
for(int... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;
public class Fingerp... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.io.*;
import java.util.*;
public class Main {
static class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner() {
try {
br = new BufferedReader(new InputStreamReader(System... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] a = new int[n];
for (int i = 0; i < a.length; i++) {
a[i] = sc.nextInt... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.io.*;
import java.util.*;
public class Main {
static StringBuilder data = new StringBuilder();
final static FastReader in = new FastReader();
public static void main(String[] args) {
int n = in.nextInt(), m = in.nextInt();
... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.*;
public class Solution{
public static void main(String sp[]){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int k = sc.nextInt();
String st = sc.next();
char arr[] = st.toCharArray();
boolean b=false;
for(cha... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
import java.io.*;
import java.util.*;
public class D999 {
public static void main(String args[])throws IOException
{
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int m=sc.nextInt();
int req=n/m;
int arr... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
import java.util.*;
import java.io.*;
import java.math.*;
public class loser
{
static class InputReader {
public BufferedReader br;
public StringTokenizer token;
public InputReader(InputStream stream)
{
br=new Bu... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.*;
import java.io.*;
public class A
{
public static void main(String ar[]) throws Exception
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String s1[]=br.readLine().split(" ");
... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.io.PrintWriter;
import java.util.Scanner;
public class pr902A {
static Scanner in = new Scanner(System.in);
public static void main(String[] args) {
PrintWriter out = new PrintWriter(System.out);
int n = in.nextInt();
... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.*;
public class ErrorCorrectSystem
{
public static void main(String[] args)
{
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
String a = scan.next();
String b = scan.next();
int[][] mismatch = new int[26][26];
... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
import java.io.*;
import java.util.*;
import java.lang.*;
import static java.lang.Math.*;
// _ h _ r _ t r _
// _ t _ t _ s t _
public class TaskA implements Runnable {
long m = (int)1e9+7;
PrintWriter w;
InputReader c;
final int MAXN = (i... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.InputMismatchException;
public class Solution1 i... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.*;
import java.io.*;
import java.math.*;
import java.util.HashMap;
public class Main
{
static class Reader
{
private InputStream mIs;private byte[] buf = new byte[1024];private int curChar,numChars;public Reader() { this(Syst... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
import java.util.ArrayList;
import java.util.Scanner;
/**
*
* @author A... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int s = sc.nextInt();
int[] f = new int[n];
int[] t = new int[n];
for (int i = 0; i < n; i++) {
f... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.Scanner;
/**
*
* @author User
*/
public class Code {
static int [] reverse(int a[])
{
int[] b = new int[a.length];
int j = 0 ;
for (int i = a.length-1; i >= 0; i--) {
b[i] = a[j] ;
... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.Scanner;
public class HammingDistancesSum {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String a = sc.nextLine(), b = sc.nextLine();
long sum = 0;
int frequency[][] = new int[200010][2];
for (int i... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
// Java program to find union of
// two sorted arrays
class
FindUnion
{
/* Function prints union of arr1[] and arr2[]
m is the number of elements in arr1[]
n is the number of elements in arr2[] */
static
int
printUnion(
int
arr1[],
int
arr2[],
int... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.io.*;
import java.lang.*;
import java.util.*;
import static java.lang.Integer.*;
import static java.lang.Long.*;
import static java.lang.Math.*;
import static java.lang.System.*;
import static java.util.Arrays.*;
import static java.util.Collections.... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[][] x = new int [200010][10];
String a = sc.nextLine();
String b = sc.nextLine();
int n = a.length();
int m = ... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import static java.lang.Math.*;
public class Main2 {
private FastScanner scanner = new FastScanner();
public static void main(String[] a... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>/* package whatever; // don't place package name! */
import java.util.*;
import java.lang.*;
import java.io.*;
/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{
static int check(int temp)
{
int count1 = 0;
wh... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
import java.math.*;
import java.lang.*;
import static java.lang.Math.*;
public class TaskB implements Runnable {
boolean prime[] = new boolean[(int)1e6+10];
InputReader c;
Print... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class BOOL {
static char [][]ch;
static int n,m;
private static FastReader in =new FastReader();
public static void main(String[]... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.Scanner;
public class codef8 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
int beacon[] = new int[1000001];
for (int i = 0; i < num; i++)... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.Scanner;
public class codef8 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
int beacon[] = new int[1000001];
int pos[] = new int[num];
f... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.Scanner;
public class codef8 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
int beacon[] = new int[1000001];
int pos[] = new int[num];
f... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
// Java program to find union of two
// sorted arrays (Handling Duplicates)
class
FindUnion
{
static
void
UnionArray(
int
arr1[],
int
arr2[])
{
// Taking max element present in either array
int
m = arr1[arr1.length -
1
];
int
n = arr2[arr2.len... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.Scanner;
public class ChainReaction {
public static void main(String [] args) {
Scanner kb = new Scanner(System.in);
int num = kb.nextInt();
int[] beacons = new int[1000002];
for (int i=0; i<num; i++) {
beacons[kb.nextInt()] =... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.*;
import java.io.*;
import java.math.*;
public class round569d2a {
public static void main(String args[]) {
FastScanner in = new FastScanner(System.in);
int n = in.nextInt();
int sum = 1;
int tracker = 4;
while (n > 1) {
sum +=... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.io.*;
import java.util.*;
public class Main {
static InputReader in = new InputReader(System.in);
static PrintWriter out = new PrintWriter(System.out);
static long oo = 1000000000000L;
static int[][] memo;
public static void main(Str... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.io.*;
import java.lang.*;
import java.util.*;
public class alex
{
public static void main(String[] args)throws IOException
{
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();int sum=1;
for(int i=1;i<=n;i++)
... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.Scanner;
public class Test{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int num=1;
int add;
for(int i=1;i<n;i++){
add=4*i;
num+=add;
}
System.out.println(num);
}
}<|eot_i... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
// Java program to find the only repeating
// element in an array where elements are
// from 1 to n-1.
class
GFG
{
static
int
findRepeating(
int
arr[],
int
n)
{
// res is going to store value of
// 1 ^ 2 ^ 3 .. ^ (n-1) ^ arr[0] ^
// arr[1] ^ .... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
import
java.util.HashMap;
/* Program for finding out majority element in an array */
class
MajorityElement
{
private
static
void
findMajority(
int
[] arr)
{
HashMap<Integer,Integer> map =
new
HashMap<Integer, Integer>();
for
(
int
i =
0
; i < ar... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
// Java code to find maximum triplet sum
import
java.io.*;
import
java.util.*;
class
GFG {
// This function assumes that there
// are at least three elements in arr[].
static
int
maxTripletSum(
int
arr[],
int
n)
{
// Initialize Maximum, second... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
/* Java program to check if linked list is palindrome recursively */
class
LinkedList {
Node head;
// head of list
Node left;
/* Linked list Node*/
class
Node {
char
data;
Node next;
Node(
char
d)
{
data = d;
next =
null
;
}
}
//... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
// Java program to find maximum sum
// of all rotation of i*arr[i] using pivot.
import
java.util.*;
import
java.lang.*;
import
java.io.*;
class
GFG
{
// function definition
static
int
maxSum(
int
arr[],
int
n)
{
int
sum =
0
;
int
i;
int
piv... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
// Most efficient Java program to count all
// substrings with same first and last characters.
public
class
GFG {
// assuming lower case only
static
final
int
MAX_CHAR =
26
;
static
int
countSubstringWithEqualEnds(String s)
{
int
result =
0
;
... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
// Java program for nth Catalan Number
class
GFG {
// Returns value of Binomial Coefficient C(n, k)
static
long
binomialCoeff(
int
n,
int
k) {
long
res =
1
;
// Since C(n, k) = C(n, n-k)
if
(k > n - k) {
k = n - k;
}
// Calculate value of... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
// A O(n) time and O(1) extra
// space solution to calculate
// the Permutation Coefficient
import
java.io.*;
class
GFG
{
static
int
PermutationCoeff(
int
n,
int
k)
{
int
Fn =
1
, Fk =
1
;
// Compute n! and (n-k)!
for
(
int
i =
1
; i <= n... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
class
GFG {
// Returns count of ways n people
// can remain single or paired up.
static
int
countFriendsPairings(
int
n)
{
int
a =
1
, b =
2
, c =
0
;
if
(n <=
2
) {
return
n;
}
for
(
int
i =
3
; i <= n; i++) {
c = b + (i -
1
) * a;
... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
// Java program to find remaining
// chocolates after k iterations
class
GFG
{
// A O(n) C++ program to count
// even length binary sequences
// such that the sum of first
// and second half bits is same
// Returns the count of
// even length sequenc... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
// A simple JAVA program to rearrange
// contents of arr[] such that arr[j]
// becomes j if arr[i] is j
class
GFG {
// A simple method to rearrange
// 'arr[0..n-1]' so that 'arr[j]'
// becomes 'i' if 'arr[i]' is 'j'
static
void
rearrange(
int
arr[... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
// Java program to find all elements
// in array which have atleast
// two greater elements itself.
import
java.util.*;
import
java.io.*;
class
GFG
{
static
void
findElements(
int
arr[],
int
n)
{
int
first = Integer.MIN_VALUE;
int
second = Integ... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
// Java O(n) solution for
// finding smallest subarray
// with sum greater than x
import
java.io.*;
class
GFG
{
// Returns length of smallest
// subarray with sum greater
// than x. If there is no
// subarray with given sum,
// then returns n+1
st... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
// Java program to find intersection of
// two sorted arrays
class
FindIntersection
{
/* Function prints Intersection of arr1[] and arr2[]
m is the number of elements in arr1[]
n is the number of elements in arr2[] */
static
void
printIntersection(
... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
// Java program to rotate an array by
// d elements
class
RotateArray {
/*Function to left rotate arr[] of size n by d*/
void
leftRotate(
int
arr[],
int
d,
int
n)
{
for
(
int
i =
0
; i < d; i++)
leftRotatebyOne(arr, n);
}
void
leftRotatebyO... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.io.*;
import java.math.BigInteger;
import java.util.InputMismatchException;
import java.util.PriorityQueue;
import java.util.StringTokenizer;
public class D {
static class FastWriter {
private final BufferedWriter bw;
public Fa... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.List;
import java.util.StringTokenizer;
public class D {
int[][] fast(int n, int m){
int[][] ans = new int[2... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
import java.io.BufferedOutputStream;
import java.io.PrintWriter;
import java.util.*;
public class E1180D {
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
PrintWriter pw = new PrintWriter(new BufferedOutputSt... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class D {
private void solve() {
br = new BufferedReader(new InputStreamReader(System.in));
out = new Pri... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class D {
private void solve() {
br = new BufferedReader(new InputStreamReader(System.in));
out = new Pri... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
// Java program to count number of triangles that can be
// formed from given array
import
java.io.*;
import
java.util.*;
class
CountTriangles
{
// Function to count all possible triangles with arr[]
// elements
static
int
findNumberOfTriangles(
in... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.*;
public class TestClass
{
public static void main(String args[])
{
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int m = in.nextInt();
int k = in.nextInt();
int arr[] = new int[n+1];
for(int i =0;i<n... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.*;
import java.math.*;
public class Solution{
private long [] sums;
private void solve(){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int k = sc.nextInt();
int... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>//package ContestEd69;
import java.io.*;
import java.util.StringTokenizer;
public class mainD {
public static PrintWriter out = new PrintWriter(System.out);
public static FastScanner enter = new FastScanner(System.in);
public static long[] arr;
... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>import java.util.*;
import javax.lang.model.util.ElementScanner6;
import java.io.*;
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
I... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
// A simple Java program to
//count pairs with difference k
import
java.util.*;
import
java.io.*;
class
GFG {
static
int
countPairsWithDiffK(
int
arr[],
int
n,
int
k)
{
int
count =
0
;
// Pick all elements one by one
for
(
int
i =
0
; i <... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
// Java program program to merge two
// sorted arrays with O(1) extra space.
import
java.util.Arrays;
class
Test
{
static
int
arr1[] =
new
int
[]{
1
,
5
,
9
,
10
,
15
,
20
};
static
int
arr2[] =
new
int
[]{
2
,
3
,
8
,
13
};
static
void
... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
// Java Program to find max subarray
// sum excluding some elements
import
java.io.*;
class
GFG {
// Function to check the element
// present in array B
static
boolean
isPresent(
int
B[],
int
m,
int
x)
{
for
(
int
i =
0
; i < m; i++)
if
(... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
// java program to find maximum
// equilibrium sum.
import
java.io.*;
class
GFG {
// Function to find maximum
// equilibrium sum.
static
int
findMaxSum(
int
[]arr,
int
n)
{
int
res = Integer.MIN_VALUE;
for
(
int
i =
0
; i < n; i++)
{
in... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
// Java program to find equilibrium
// index of an array
class
EquilibriumIndex {
int
equilibrium(
int
arr[],
int
n)
{
int
i, j;
int
leftsum, rightsum;
/* Check for indexes one by one until
an equilibrium index is found */
for
(i =
0
; i < n... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
class
LeadersInArray
{
/*Java Function to print leaders in an array */
void
printLeaders(
int
arr[],
int
size)
{
for
(
int
i =
0
; i < size; i++)
{
int
j;
for
(j = i +
1
; j < size; j++)
{
if
(arr[i] <= arr[j])
break
;
}
if
(j == siz... |
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
// Java program to find Majority
// element in an array
import
java.io.*;
class
GFG {
// Function to find Majority element
// in an array
static
void
findMajority(
int
arr[],
int
n)
{
int
maxCount =
0
;
int
index = -
1
;
// sentinels
for
(
i... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.