src
stringlengths 95
64.6k
| complexity
stringclasses 7
values | problem
stringlengths 6
50
| from
stringclasses 1
value |
|---|---|---|---|
import java.util.Scanner;
public class A {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String ns = sc.next();
sc.close();
int n1 = Integer.parseInt(ns);
int n2 = Integer.parseInt(ns.substring(0, ns.length() - 1));
int n3 = Integer.parseInt(ns.substring(0, ns.length() - 2) + ns.substring(ns.length() - 1));
int max = n1;
max = (n2 > max) ? (n2) : (max);
max = (n3 > max) ? (n3) : (max);
System.out.println(max);
}
} | constant | 313_A. Ilya and Bank Account | CODEFORCES |
/**
* Created with IntelliJ IDEA.
* User: Venky
*/
import java.io.*;
import java.util.StringTokenizer;
public class Main {
static void solve() throws IOException {
String str = br.readLine();
StringBuffer sb1 = new StringBuffer(str);
StringBuffer sb2 = new StringBuffer(str);
StringBuffer sb3 = new StringBuffer(str);
sb1.deleteCharAt(sb1.length()-1);
sb2.deleteCharAt(sb2.length()-2);
int n1 = Integer.parseInt(sb1.toString());
int n2 = Integer.parseInt(sb2.toString());
int n3 = Integer.parseInt(sb3.toString());
out.println(Math.max(n1, Math.max(n2, n3)));
}
static BufferedReader br;
static StringTokenizer st;
static PrintWriter out;
public static void main(String[] args) throws IOException {
InputStream input = System.in;
br = new BufferedReader(new InputStreamReader(input));
out = new PrintWriter(System.out);
solve();
out.close();
}
static long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
static double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
static int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
static String nextToken() throws IOException {
while (st == null || !st.hasMoreTokens()) {
String line = br.readLine();
if (line == null) {
return null;
}
st = new StringTokenizer(line);
}
return st.nextToken();
}
}
| constant | 313_A. Ilya and Bank Account | CODEFORCES |
import java.util.*;
public class ex1 {
public static void main(String[] args) {
int n,i,j;
Scanner scan = new Scanner(System.in);
n = Integer.parseInt(scan.nextLine());
if(n>=0)
System.out.println(n);
else if(n<0) {
n=-1*n;
i=n/10;
j=(n/100)*10+n%10;
i=-i;
j=-j;
if(i>=j)
System.out.println(i);
else
System.out.println(j);
}
}
}
| constant | 313_A. Ilya and Bank Account | CODEFORCES |
import java.io.*;
public class Main {
public static void main(String[] args) throws Exception {
int n = nextInt();
String nn = Integer.toString(n);
if(n >= 0){
println(n);
} else {
println(Math.max(Integer.parseInt(nn.substring(0,nn.length() - 1)), Integer.parseInt(nn.substring(0, nn.length() - 2) + nn.charAt(nn.length() - 1))));
}
}
private static PrintWriter out = new PrintWriter(System.out);
private static BufferedReader inB = new BufferedReader(new InputStreamReader(System.in));
private static StreamTokenizer in = new StreamTokenizer(inB);
private static void exit(Object o) throws Exception {
out.println(o);
out.flush();
System.exit(0);
}
private static void println(Object o) throws Exception{
out.println(o);
out.flush();
}
private static void print(Object o) throws Exception{
out.print(o);
out.flush();
}
private static long nextLong() throws Exception {
in.nextToken();
return (long)in.nval;
}
private static int nextInt() throws Exception {
in.nextToken();
return (int)in.nval;
}
private static String nextString() throws Exception {
in.nextToken();
return in.sval;
}
} | constant | 313_A. Ilya and Bank Account | CODEFORCES |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class CF {
public static void main(String[] args) throws IOException {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
int n = in.nextInt();
if (n >= 0) {
out.println(n);
} else {
int res = n;
n = Math.abs(n);
String s = String.valueOf(Math.abs(n));
if (s.length() == 1) {
res = 0;
} else {
res = Math.max(-Integer.parseInt(s.substring(0, s.length() - 1)), res);
res = Math.max(-Integer.parseInt(s.substring(0, s.length() - 2) + s.charAt(s.length() - 1)), res);
}
out.println(res);
}
out.close();
}
}
class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream));
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
} | constant | 313_A. Ilya and Bank Account | CODEFORCES |
import java.util.Scanner;
import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
* @author AndrewShmig
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
Scanner in = new Scanner(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskA solver = new TaskA();
solver.solve(1, in, out);
out.close();
}
}
class TaskA {
public void solve(int testNumber, Scanner in, PrintWriter out) {
String n = in.nextLine();
int a = Integer.parseInt(n);
int b = Integer.parseInt(n.substring(0, n.length() - 1));
int c = Integer.parseInt(n.substring(0, n.length() - 2) + n.charAt(n.length() - 1));
out.println(Math.max(a, Math.max(b, c)));
}
}
| constant | 313_A. Ilya and Bank Account | CODEFORCES |
import java.io.*;
import java.util.*;
public class TaskA {
public void run() {
InputReader reader = new InputReader(System.in);
PrintWriter writer = new PrintWriter(System.out, true);
reader.nextLine();
String statement = reader.next();
if (!statement.startsWith("-")) {
writer.println(statement);
} else {
try {
int statement1 = Integer.parseInt(statement.substring(0, statement.length() - 1));
int statement2 = Integer.parseInt(statement.substring(0, statement.length() - 2) + statement.charAt(statement.length() - 1));
writer.println(Math.max(statement1, statement2));
} catch (Exception e) {
writer.println(statement);
}
}
writer.close();
}
public static void main(String[] args) {
new TaskA().run();
}
private class InputReader {
BufferedReader reader;
StringTokenizer token;
private InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream));
}
private String next() {
return token.nextToken();
}
private int nextInt() {
return Integer.parseInt(this.next());
}
private double nextDouble() {
return Double.parseDouble(this.next());
}
private long nextLong() {
return Long.parseLong(this.next());
}
private String nextLine() {
String line = "";
try {
line = reader.readLine();
token = new StringTokenizer(line, " ");
} catch(IOException e) {
}
return line;
}
}
}
| constant | 313_A. Ilya and Bank Account | CODEFORCES |
import java.util.Scanner;
public class MargariteBestPresent_1080B {
private static int f(int x) {
return (x%2==0)?x/2:(x-1)/2-x;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n,r,l;
n = sc.nextInt();
while(n-->0) {
l = sc.nextInt();
r = sc.nextInt();
System.out.println(f(r)-f(l-1));
}
sc.close();
}
}
| constant | 1080_B. Margarite and the best present | CODEFORCES |
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
public class e {
public static class FastReader {
BufferedReader br;
StringTokenizer st;
//it reads the data about the specified point and divide the data about it ,it is quite fast
//than using direct
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (Exception r) {
r.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());//converts string to integer
}
double nextDouble() {
return Double.parseDouble(next());
}
long nextLong() {
return Long.parseLong(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (Exception r) {
r.printStackTrace();
}
return str;
}
}
static ArrayList<String>list1=new ArrayList<String>();
static void combine(String instr, StringBuffer outstr, int index,int k)
{
if(outstr.length()==k)
{
list1.add(outstr.toString());return;
}
if(outstr.toString().length()==0)
outstr.append(instr.charAt(index));
for (int i = 0; i < instr.length(); i++)
{
outstr.append(instr.charAt(i));
combine(instr, outstr, i + 1,k);
outstr.deleteCharAt(outstr.length() - 1);
}
index++;
}
static ArrayList<ArrayList<Integer>>l=new ArrayList<>();
static void comb(int n,int k,int ind,ArrayList<Integer>list)
{
if(k==0)
{
l.add(new ArrayList<>(list));
return;
}
for(int i=ind;i<=n;i++)
{
list.add(i);
comb(n,k-1,ind+1,list);
list.remove(list.size()-1);
}
}
public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
public static void main(String[] args) {
// TODO Auto-generated method stub
FastReader in=new FastReader();
HashMap<Integer,Integer>map=new HashMap<Integer,Integer>();
int n=in.nextInt();
int r=in.nextInt();
double theta=(double)360/(double)n;
double b=1-((double)2/(double)(1-Math.cos((double)2*Math.PI/(double)n)));
double x=Math.sqrt(1-b)-1;
double ans=(double)r/(double)x;
System.out.println(ans);
}
}
| constant | 1100_C. NN and the Optical Illusion | CODEFORCES |
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
public class e {
public static class FastReader {
BufferedReader br;
StringTokenizer st;
//it reads the data about the specified point and divide the data about it ,it is quite fast
//than using direct
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (Exception r) {
r.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());//converts string to integer
}
double nextDouble() {
return Double.parseDouble(next());
}
long nextLong() {
return Long.parseLong(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (Exception r) {
r.printStackTrace();
}
return str;
}
}
static ArrayList<String>list1=new ArrayList<String>();
static void combine(String instr, StringBuffer outstr, int index,int k)
{
if(outstr.length()==k)
{
list1.add(outstr.toString());return;
}
if(outstr.toString().length()==0)
outstr.append(instr.charAt(index));
for (int i = 0; i < instr.length(); i++)
{
outstr.append(instr.charAt(i));
combine(instr, outstr, i + 1,k);
outstr.deleteCharAt(outstr.length() - 1);
}
index++;
}
static ArrayList<ArrayList<Integer>>l=new ArrayList<>();
static void comb(int n,int k,int ind,ArrayList<Integer>list)
{
if(k==0)
{
l.add(new ArrayList<>(list));
return;
}
for(int i=ind;i<=n;i++)
{
list.add(i);
comb(n,k-1,ind+1,list);
list.remove(list.size()-1);
}
}
public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
public static void main(String[] args) {
// TODO Auto-generated method stub
FastReader in=new FastReader();
HashMap<Integer,Integer>map=new HashMap<Integer,Integer>();
int n=in.nextInt();
int r=in.nextInt();
double theta=(double)360/(double)n;
double b=1-((double)2/(double)(1-Math.cos((double)2*Math.PI/(double)n)));
double x=Math.sqrt(1-b)-1;
double ans=(double)r/(double)x;
System.out.println(ans);
}
}
| constant | 1100_C. NN and the Optical Illusion | CODEFORCES |
import java.io.*;
import java.util.*;
public class Codechef{
static int max=Integer.MIN_VALUE;
static int res=0;
static int[] checkMax(int arr[],int j){
int sum=0;
int x=arr[j];
while(x!=0){
if(j+1==15){
j=0;
}else{
arr[j+1]=arr[j+1]+1;
}
// if(arr[j+1]%2==0){
// sum=sum+arr[j+1];
// if(sum>=max){
// max=sum;
// }
// }
x--;
j++;
}
return arr;
}
public static void main(String []args){
Scanner sc = new Scanner (System.in);
long a [] = new long [14];
long b [] = new long [14];
long p,q,r,s,max = 0;
for(int i = 0; i < 14; i++) a[i] = sc.nextInt();
for(int i = 0; i < 14; i++){
p = a[i]%14;
q = a[i]/14;
r = 0;
s = 0;
for(int j = 0; j < 14; j++) b[j] = a[j];
b[i] = 0;
int j = (i+1)%14;
for(; r < p; r++) {
b[j]++;
j=(j+1)%14;
}
for( j = 0; j < 14; j++) {
b[j] += q;
if(b[j] % 2 == 0) s+= b[j];
}
max = Math.max(max,s);
}
System.out.println(max);
}
} | constant | 975_B. Mancala | CODEFORCES |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.util.HashSet;
import java.util.StringTokenizer;
public class Main {
public static String conv(String str) {
boolean[] Arr = new boolean[26];
for (int i = 0; i < str.length(); i++) {
Arr[str.charAt(i) - 'a'] = true;
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 26; i++) {
if (Arr[i])
sb.append((char) (i + 'a'));
}
return "" + sb;
}
public static void main(String[] args) throws IOException, InterruptedException {
PrintWriter pw = new PrintWriter(System.out);
Scanner sc = new Scanner(System.in);
HashSet<String> hs = new HashSet<String>();
int[] Arr = new int[14];
long max = 0;
for (int i = 0; i < 14; i++) {
Arr[i] = sc.nextInt();
}
for (int i = 0; i < 14; i++) {
int[] arr = Arr.clone();
long sum = 0;
int r = arr[i];
arr[i] = 0;
for (int j = i + 1; j < arr.length && r > 0; j++) {
arr[j]++;
r--;
}
for (int j = 0; j < arr.length; j++) {
arr[j] +=( r / 14);
if (j + 1 <= (r % 14)) {
arr[j]++;
}
if (arr[j] % 2 == 0) {
sum += arr[j];
}
}
max = Math.max(max, sum);
}
System.out.println(max);
}
static class Scanner {
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream s) {
br = new BufferedReader(new InputStreamReader(s));
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public String nextLine() throws IOException {
return br.readLine();
}
public double nextDouble() throws IOException {
String x = next();
StringBuilder sb = new StringBuilder("0");
double res = 0, f = 1;
boolean dec = false, neg = false;
int start = 0;
if (x.charAt(0) == '-') {
neg = true;
start++;
}
for (int i = start; i < x.length(); i++)
if (x.charAt(i) == '.') {
res = Long.parseLong(sb.toString());
sb = new StringBuilder("0");
dec = true;
} else {
sb.append(x.charAt(i));
if (dec)
f *= 10;
}
res += Long.parseLong(sb.toString()) / f;
return res * (neg ? -1 : 1);
}
public boolean ready() throws IOException {
return br.ready();
}
}
}
| constant | 975_B. Mancala | CODEFORCES |
import java.util.Scanner;
public class A {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String inp = in.nextLine();
System.out.println(25);
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.util.Scanner;
/**
* Created by Gantushig on 2/18/2016.
*/
public class A {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
long n = input.nextLong();
System.out.println("25");
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
public class P1 {
public static void main(String[] args) {
System.out.println("25");
}
} | constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class A {
public static void main(String[] args) throws Exception {
BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
String l[] = bf.readLine().split(" ");
System.out.println(25);
}
} | constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.util.*;
public class a {
public static void main(String[] args){
Scanner br = new Scanner(System.in);
long n = br.nextLong();
System.out.println("25");
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Set;
import java.util.Stack;
public class test {
public static void main(String[] args) throws InterruptedException {
//new careercup().run();
//new CC().run();
//System.out.println(Integer.MAX_VALUE);
try{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
br.readLine();
System.out.println(25);
}catch(IOException io){
io.printStackTrace();
}
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.*;
import java.util.*;
public class Main {
void solve(Scanner in, PrintWriter out) {
long a = in.nextLong();
out.println(25);
}
void run() {
Locale.setDefault(Locale.US);
try (
Scanner in = new Scanner(System.in);
PrintWriter out = new PrintWriter(System.out);
) {
solve(in, out);
}
}
public static void main(String args[]) {
new Main().run();
}
} | constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.BufferedWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author Alex
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
TaskA solver = new TaskA();
solver.solve(1, in, out);
out.close();
}
static class TaskA {
public void solve(int testNumber, InputReader in, OutputWriter out) {
out.printLine(25);
}
}
static class InputReader {
private InputStream stream;
public InputReader(InputStream stream) {
this.stream = stream;
}
}
static class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void close() {
writer.close();
}
public void printLine(int i) {
writer.println(i);
}
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.IOException;
/**
* Created by ww on 13.02.2016.
*/
public class rgb {
public static void main(String[] args) throws IOException {
System.out.print(25);
return ;
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
/*
* Code Author: Akshay Miterani
* DA-IICT
*/
import java.io.*;
import java.util.*;
public class MainY {
static double eps=(double)1e-6;
static long mod=(int)1e9+7;
static boolean f=true;
public static void main(String args[]){
InputReader in = new InputReader(System.in);
OutputStream outputStream = System.out;
PrintWriter out = new PrintWriter(outputStream);
//----------My Code Starts Here----------
long n=in.nextLong();
if(n==1){
System.out.println("5");
}
else{
System.out.println("25");
}
out.close();
//---------------The End------------------
}
static class Pair implements Comparable<Pair>{
int r1=-1;
int r2=-1;
int extra=0;
@Override
public int compareTo(Pair arg0) {
// TODO Auto-generated method stub
return 0;
}
}
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream inputstream) {
reader = new BufferedReader(new InputStreamReader(inputstream));
tokenizer = null;
}
public String nextLine(){
String fullLine=null;
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
fullLine=reader.readLine();
} catch (IOException e) {
throw new RuntimeException(e);
}
return fullLine;
}
return fullLine;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public long nextLong() {
return Long.parseLong(next());
}
public int nextInt() {
return Integer.parseInt(next());
}
}
} | constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.*;
public class Main {
private static void solve() throws IOException {
long n = nextLong();
out.println(25);
}
public static void main(String[] args) throws Exception {
File file = new File("System.in");
InputStream input = System.in;
PrintStream output = System.out;
if (file.exists() && file.canRead()) {
input = new FileInputStream(file);
output = new PrintStream("System.out");
}
br = new BufferedReader(new InputStreamReader(input));
out = new PrintWriter(output);
solve();
out.close();
}
private static BufferedReader br;
private static StringTokenizer st;
private static PrintWriter out;
private static boolean hasNextToken() throws IOException {
while (st == null || !st.hasMoreTokens()) {
String line = br.readLine();
if (line == null) {
return false;
}
st = new StringTokenizer(line);
}
return true;
}
private static String nextToken() throws IOException {
return hasNextToken() ? st.nextToken() : null;
}
private static int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
private static long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
private static double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class A {
static void solve(InputReader in, PrintWriter out) {
long n = in.nextLong();
out.print(25);
}
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
solve(in, out);
out.close();
}
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public long nextDouble() {
return Long.parseLong(next());
}
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
public class main {
public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
public static PrintWriter pw = new PrintWriter(System.out);
public static String line;
public static StringTokenizer st;
public static ArrayList<ArrayList<Integer>> adjList;
public static void main(String[] args) throws Exception{
String s = br.readLine();
pw.print(25);
pw.print("\n");
pw.close();
br.close();
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.util.Scanner;
/**
* Feb 18, 2016 | 4:00:49 PM
* <pre>
* <u>Description</u>
*
* </pre>
*
* @author Essiennta Emmanuel ([email protected])
*/
public class ProblemA{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
sc.next();
System.out.println(25);
sc.close();
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author ATailouloute
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
QuickScanner in = new QuickScanner(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskA solver = new TaskA();
solver.solve(1, in, out);
out.close();
}
static class TaskA {
public void solve(int testNumber, QuickScanner in, PrintWriter out) {
long n = in.nextLong();
out.println(IntegerUtils.pow(5L, n, 100));
}
}
static class QuickScanner {
BufferedReader br;
StringTokenizer st;
InputStream is;
public QuickScanner(InputStream stream) {
is = stream;
br = new BufferedReader(new InputStreamReader(stream), 32768);
}
String nextToken() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return st.nextToken();
}
public long nextLong() {
return Long.parseLong(nextToken());
}
}
static class IntegerUtils {
public static long pow(long a, long base, long mod) {
if (base == 0) return 1;
if (base == 1) return a;
if ((base & 1) == 1)
return (a * pow(a, base - 1, mod)) % mod;
return pow((a * a) % mod, base / 2, mod);
}
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.util.*;
public class AgainTwentyfive {
public static void main(String[] args)
{
System.out.println("25");
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
/* package whatever; // don't place package name! */
import java.util.*;
;
/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
public static void main (String[] args) throws java.lang.Exception
{
// your code goes here
Scanner s = new Scanner(System.in);
long n = s.nextLong();
System.out.println(25);
}
} | constant | 630_A. Again Twenty Five! | CODEFORCES |
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.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author Egor Kulikov ([email protected])
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
TaskA solver = new TaskA();
solver.solve(1, in, out);
out.close();
}
static class TaskA {
public void solve(int testNumber, InputReader in, OutputWriter out) {
out.printLine(25);
}
}
static class InputReader {
private InputStream stream;
public InputReader(InputStream stream) {
this.stream = stream;
}
}
static class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void close() {
writer.close();
}
public void printLine(int i) {
writer.println(i);
}
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.StringTokenizer;
public class LuxuriousHouses {
public static void main(String[] args) throws IOException {
System.out.println(25);
}
static class Scanner {
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream s) {
br = new BufferedReader(new InputStreamReader(s));
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public String nextLine() throws IOException {
return br.readLine();
}
public boolean ready() throws IOException {
return br.ready();
}
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.*;
public class again_25 {
public static void main(String ar[])throws IOException
{
long n;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
n=Long.parseLong(br.readLine());
System.out.println("25");
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.util.Scanner;
public class CF630_A {
public static void main(String[] args) {
try (Scanner s = new Scanner(System.in)) {
long n = s.nextLong();
System.out.println("25");
}
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
/**
*
* @author Mohammad Hadi
*/
public class A630 {
public static void main(String[] args) {
System.out.println(25);
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.util.*;
public class Contests {
public static void main(String[] args) {
Scanner clavier=new Scanner(System.in);
long a=clavier.nextLong();
clavier.close();
if(a==1)
System.out.println(5);
else
System.out.println(25);
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
public class Main {
FastScanner in;
PrintWriter out;
static final String FILE = "";
public void solve() {
out.print(25);
}
public void run() {
if (FILE.equals("")) {
in = new FastScanner(System.in);
out = new PrintWriter(System.out);
} else {
try {
in = new FastScanner(new FileInputStream(FILE +
".in"));
out = new PrintWriter(new FileOutputStream(FILE +
".out"));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
solve();
out.close();
}
public static void main(String[] args) {
(new Main()).run();
}
class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner(InputStream is) {
br = new BufferedReader(new InputStreamReader(is));
}
public String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
public String nextLine() {
st = null;
try {
return br.readLine();
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public float nextFloat() {
return Float.parseFloat(next());
}
}
class Pair<A extends Comparable<A>, B extends Comparable<B>>
implements Comparable<Pair<A, B>> {
public A a;
public B b;
public Pair(A a, B b) {
this.a = a;
this.b = b;
}
@Override
public int compareTo(Pair<A, B> o) {
if (o == null || o.getClass() != getClass())
return 1;
int cmp = a.compareTo(o.a);
if (cmp == 0)
return b.compareTo(o.b);
return cmp;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Pair<?, ?> pair = (Pair<?, ?>) o;
if (a != null ? !a.equals(pair.a) : pair.a != null) return
false;
return !(b != null ? !b.equals(pair.b) : pair.b != null);
}
}
class PairInt extends Pair<Integer, Integer> {
public PairInt(Integer u, Integer v) {
super(u, v);
}
}
class PairLong extends Pair<Long, Long> {
public PairLong(Long u, Long v) {
super(u, v);
}
}
} | constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
import java.util.Set;
import java.util.Map.Entry;
import java.util.HashMap;
import java.util.Iterator;
public class test {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String num = input.nextLine();
System.out.println("25");
}
} | constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.PrintWriter;
import java.util.Locale;
import java.util.Scanner;
public class Main {
public static void main(String args[]) {
new Main().run();
}
void run(){
Locale.setDefault(Locale.US);
try(Scanner in=new Scanner(System.in);
PrintWriter out=new PrintWriter(System.out)){
solve(in, out);
}
catch (Exception e) {
e.printStackTrace();
}
}
private void solve(Scanner in, PrintWriter out) {
String a=in.nextLine();
out.println("25");
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.util.Scanner;
public class A {
public static void main(String[] args){
Scanner in = new Scanner(System.in);
long n = in.nextLong();
System.out.println(25);
}
} | constant | 630_A. Again Twenty Five! | CODEFORCES |
public class pregunta1 {
public static void main(String[] args) {
System.out.println("25");
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class A {
public static void main(String[] args) {
System.out.println(25);
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io. *;
import java.util. *;
public class Main {
void solve(Scanner in, PrintWriter out) {
out.println(25);
}
void run() {
Locale.setDefault(Locale.US);
try (
Scanner in = new Scanner(System.in);
PrintWriter out = new PrintWriter(System.out);
)
{
solve(in, out);
}
}
public static void main(String args[]) {
new Main().run();
}
} | constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
public class Main
{
static ArrayList<Integer> Unique(ArrayList<Integer> x)
{
TreeSet<Integer> tmp=new TreeSet<Integer>();
tmp.addAll(x);
x.clear();
x.addAll(tmp);
return x;
}
public static void main(String[] args)
{
InputReader in = new InputReader();
// Scanner in=new Scanner(System.in);
PrintWriter out = new PrintWriter(System.out);
while(in.hasNext())
{
long n=in.nextLong();
out.println("25");
}
out.close();
}
}
class node
{
ArrayList<Integer> v=new ArrayList<Integer>();
node(){}
void push(Integer a)
{
v.add(a);
}
}
class InputReader
{
BufferedReader buf;
StringTokenizer tok;
InputReader()
{
buf = new BufferedReader(new InputStreamReader(System.in));
}
boolean hasNext()
{
while (tok == null || !tok.hasMoreElements())
{
try
{
tok = new StringTokenizer(buf.readLine());
}
catch (Exception e)
{
return false;
}
}
return true;
}
String next()
{
if (hasNext())
return tok.nextToken();
return null;
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
BigInteger nextBigInteger()
{
return new BigInteger(next());
}
BigDecimal nextBigDecimal()
{
return new BigDecimal(next());
}
} | constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.util.Scanner;
public class TwentyFive {
public static void main(String[] args) {
System.out.println(25);
}
} | constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.PrintWriter;
import java.util.Scanner;
public class Main {
Scanner in;
PrintWriter out;
void solve() {
out.print("25");
}
void run() {
in = new Scanner(System.in);
out = new PrintWriter(System.out);
solve();
out.close();
}
public static void main(String[] args) {
new Main().run();
}
} | constant | 630_A. Again Twenty Five! | CODEFORCES |
public class Main {
public static void main(String[] args){
System.out.println("25");
}
} | constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class Main {
public static void main(String args[]) {
InputStream intputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(intputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskA solver = new TaskA();
solver.solve(in, out);
out.close();
}
static class TaskA {
public void solve(InputReader in, PrintWriter out) {
out.println(25);
}
}
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public String nextLine() {
try {
return reader.readLine();
} catch (IOException e) {
return null;
}
}
}
} | constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.*;
import java.util.*;
import java.math.*;
import static java.lang.Math.*;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Double.parseDouble;
import static java.lang.String.*;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
//(new FileReader("input.in"));
StringBuilder out = new StringBuilder();
StringTokenizer tk;
long n = parseLong(in.readLine());
System.out.println("25");
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.util.Scanner;
/**
* Created by mmaikovych on 18.02.16.
*/
public class EER_A {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
scanner.nextLine();
System.out.println(25);
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.util.*;
public class ProA {
static long n;
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
n=in.nextLong();
System.out.println(25);
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.StringTokenizer;
public class A {
static StringTokenizer st;
static BufferedReader br;
static PrintWriter pw;
public static void main(String[] args) throws IOException {
br = new BufferedReader(new InputStreamReader(System.in));
pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
BigInteger a = new BigInteger(next());
System.out.println(BigInteger.valueOf(5).modPow(a, BigInteger.valueOf(100)));
pw.close();
}
private static int nextInt() throws IOException {
return Integer.parseInt(next());
}
private static long nextLong() throws IOException {
return Long.parseLong(next());
}
private static double nextDouble() throws IOException {
return Double.parseDouble(next());
}
private static String next() throws IOException {
while (st==null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.util.Scanner;
/*
* 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.
*/
/**
*
* @author Madi
*/
public class A630 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();
System.out.println("25");
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
/*
* The MIT License
*
* Copyright 2016 Mouad NACIRI <[email protected]>.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.IOException;
import java.util.StringTokenizer;
/**
*
* @author NACIRI Mouad <[email protected]>
* @version 1.5.1
*/
public class MainA {
/* VIP, DON'T TOUCH!! */
static StringTokenizer ST;
static BufferedReader IN;
static BufferedWriter OUT;
static {
IN = new BufferedReader(new InputStreamReader(System.in));
OUT = new BufferedWriter(new OutputStreamWriter(System.out));
}
public static void main(String[] args) throws IOException {
pl("25");
cAll();
}
//IO stuff...
static void ll() throws IOException { ST = new StringTokenizer(nlnt()); }
static void ll(String del) throws IOException { ST = new StringTokenizer(nlnt(), del); }
static void ll(String s, String del) throws IOException { ST = new StringTokenizer(s, del); }
static void ll(String s, char c) throws IOException { ST = new StringTokenizer(s); }
static int tlen() { return ST.countTokens(); }
static boolean hn() { return ST.hasMoreTokens(); }
static String n() throws IOException { return ST.nextToken(); }
static String nln() throws IOException {
String l;
while((l = IN.readLine()) != null && l.trim().length() == 0) {}
return l;
}
static String nlnt() throws IOException {
String l;
while((l = IN.readLine()) != null && (l = l.trim()).length() == 0) {}
return l;
}
static boolean nbl() throws IOException { return Boolean.parseBoolean(ST.nextToken()); }
static byte nb() throws IOException { return Byte.parseByte(ST.nextToken()); }
static byte nb(int radix) throws IOException { return Byte.parseByte(ST.nextToken(), radix); }
static double nd() throws IOException { return Double.parseDouble(ST.nextToken()); }
static float nf() throws IOException { return Float.parseFloat(ST.nextToken()); }
static int ni() throws IOException { return Integer.parseInt(ST.nextToken()); }
static int ni(int radix) throws IOException { return Integer.parseInt(ST.nextToken(), radix); }
static long nl() throws IOException { return Long.parseLong(ST.nextToken()); }
static long nl(int radix) throws IOException { return Long.parseLong(ST.nextToken(), radix); }
static short ns() throws IOException { return Short.parseShort(ST.nextToken()); }
static short ns(int radix) throws IOException { return Short.parseShort(ST.nextToken(), radix); }
static void p(String s) throws IOException { OUT.write(s); }
static void p(char c) throws IOException { OUT.write(c); }
static void p(char s[]) throws IOException { OUT.write(s); }
static void pl(String s) throws IOException { OUT.write(s); OUT.newLine(); }
static void pl(char c) throws IOException { OUT.write(c); OUT.newLine(); }
static void pl(char s[]) throws IOException { OUT.write(s); OUT.newLine(); }
static void pl() throws IOException { OUT.newLine(); }
static void cAll() throws IOException { IN.close(); OUT.close(); }
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.*;
import static java.lang.Math.*;
import java.lang.reflect.Array;
import java.util.*;
import java.lang.*;
public class Main {
final static boolean debug = false;
final static String fileName = "";
final static boolean useFiles = false;
public static void main(String[] args) throws FileNotFoundException {
PrintWriter writer = new PrintWriter(System.out);
new Task(new InputReader(System.in), writer).solve();
writer.close();
}
}
class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public byte nextByte() {
return Byte.parseByte(next());
}
}
class Task {
public void solve() {
out.println(25);
}
private InputReader in;
private PrintWriter out;
Task(InputReader in, PrintWriter out) {
this.in = in;
this.out = out;
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.*;
public class Main {
private StreamTokenizer in;
private PrintWriter out;
public static void main(String[] args) throws IOException {
//long time = System.currentTimeMillis();
new Main().run();
//time = System.currentTimeMillis() - time;
//System.out.println(time + " ms");
}
private void run() throws IOException {
//in = new StreamTokenizer(new BufferedReader(new InputStreamReader(new FileInputStream("input.txt"))));
//BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("input.txt")));
//out = new PrintWriter(new File("output.txt"));
in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
//BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(new OutputStreamWriter(System.out));
out.print(25);
out.flush();
}
int nextInt() throws IOException {
in.nextToken();
return (int) in.nval;
}
} | constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;
import java.math.BigInteger;
import java.util.Arrays;
/**
* Built using CHelper plug-in
* Actual solution is at the top
* @author Erasyl Abenov
*
*
*/
public class Main {
public static void main(String[] args) throws IOException {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
try (PrintWriter out = new PrintWriter(outputStream)) {
TaskB solver = new TaskB();
solver.solve(1, in, out);
}
}
}
class TaskB {
public void solve(int testNumber, InputReader in, PrintWriter out) throws IOException{
String n = in.next();
out.println(25);
}
}
class InputReader {
private final BufferedReader reader;
private StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream));
tokenizer = null;
}
public String nextLine() {
try {
return reader.readLine();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(nextLine());
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public BigInteger nextBigInteger(){
return new BigInteger(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
} | constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.*;
import java.util.*;
public class a {
public static void main(String[] args) throws IOException {
input.init(System.in);
PrintWriter out = new PrintWriter(System.out);
long n = input.nextLong();
if(n == 1) out.println(5);
else out.println(25);
out.close();
}
public static class input {
static BufferedReader reader;
static StringTokenizer tokenizer;
static void init(InputStream input) {
reader = new BufferedReader(new InputStreamReader(input));
tokenizer = new StringTokenizer("");
}
static String next() throws IOException {
while (!tokenizer.hasMoreTokens())
tokenizer = new StringTokenizer(reader.readLine());
return tokenizer.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt(next());
}
static double nextDouble() throws IOException {
return Double.parseDouble(next());
}
static long nextLong() throws IOException {
return Long.parseLong(next());
}
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.*;
import java.util.*;
public class A {
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out);
String s = bf.readLine();
out.println(25);
out.flush();
out.close();
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.util.*;
public class TwentyFive {
public static void main(String[] args)
{
System.out.println("25");
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.BufferedReader;
import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.StringTokenizer;
public class A {
public static void main(String[] args) {
try (final Scanner sc = new Scanner(System.in)) {
System.out.println(25);
}
}
public static class Scanner implements Closeable {
private BufferedReader br;
private StringTokenizer tok;
public Scanner(InputStream is) {
br = new BufferedReader(new InputStreamReader(is));
}
private void getLine() {
try {
while (!hasNext()) {
tok = new StringTokenizer(br.readLine());
}
} catch (IOException e) { /* ignore */
}
}
private boolean hasNext() {
return tok != null && tok.hasMoreTokens();
}
public String next() {
getLine();
return tok.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public void close() {
try {
br.close();
} catch (IOException e) { /* ignore */
}
}
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
/*
* Code Author: Sanket Udgirkar.
* DA-IICT
*/
import java.util.*;
import java.io.*;
public class Tester
{
public static long mod=(long)1e9+7;
public static void main(String[] args)
{
InputReader s=new InputReader(System.in);
OutputStream outputStream = System.out;
//PrintWriter out=new PrintWriter(outputStream);
String str=s.nextLine();
System.out.println("25");
//out.close();
}
static long gcd(long a,long b)
{
if(b==0)
return a;
a%=b;
return gcd(b,a);
}
static long exp(long a, long b)
{
if(b==0)
return 1;
if(b==1)
return a;
if(b==2)
return a*a;
if(b%2==0)
return exp(exp(a,b/2),2);
else
return a*exp(exp(a,(b-1)/2),2);
}
static class Pair implements Comparable<Pair>
{
long x,f;
Pair(long ii, long cc)
{
x=ii;
f=cc;
}
public int compareTo(Pair o)
{
return Long.compare(this.x, o.x);
}
}
public static class InputReader
{
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream inputstream)
{
reader = new BufferedReader(new InputStreamReader(inputstream));
tokenizer = null;
}
public String nextLine()
{
String fullLine=null;
while (tokenizer == null || !tokenizer.hasMoreTokens())
{
try {
fullLine=reader.readLine();
}
catch (IOException e)
{
throw new RuntimeException(e);
}
return fullLine;
}
return fullLine;
}
public String next()
{
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public long nextLong() {
return Long.parseLong(next());
}
public int nextInt() {
return Integer.parseInt(next());
}
}
} | constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.util.*;
public class A630 {
public static void main(String[] args)
{
Scanner scan = new Scanner(System.in);
long n = scan.nextLong();
System.out.println(25);
}
}
| constant | 630_A. Again Twenty Five! | CODEFORCES |
import java.io.PrintWriter;
import java.util.Scanner;
public class HexadecimalTheorem {
/**
* @param args
*/
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
PrintWriter out = new PrintWriter(System.out);
out.printf("%d %d %d%n", 0, 0, n);
out.flush();
}
}
| constant | 199_A. Hexadecimal's theorem | CODEFORCES |
/**
* Created by IntelliJ IDEA.
* User: SONY
* Date: 27.05.12
* Time: 18:25
* To change this template use File | Settings | File Templates.
*/
import java.io.*;
import java.util.*;
public class TaskA extends Thread {
public TaskA(String inputFileName, String outputFileName) {
try {
if (inputFileName != null) {
this.input = new BufferedReader(new FileReader(inputFileName));
} else {
this.input = new BufferedReader(new InputStreamReader(System.in));
}
if (outputFileName != null) {
this.output = new PrintWriter(outputFileName);
} else {
this.output = new PrintWriter(System.out);
}
this.setPriority(Thread.MAX_PRIORITY);
} catch (Throwable e) {
System.err.println(e.getMessage());
e.printStackTrace();
System.exit(666);
}
}
private void solve() throws Throwable {
long n = nextLong();
output.println("0 0 " + n);
}
public void run() {
try {
solve();
} catch (Throwable e) {
System.err.println(e.getMessage());
e.printStackTrace();
System.exit(666);
} finally {
output.close();
}
}
public static void main(String... args) {
new TaskA(null, null).start();
}
private int nextInt() throws IOException {
return Integer.parseInt(next());
}
private double nextDouble() throws IOException {
return Double.parseDouble(next());
}
private long nextLong() throws IOException {
return Long.parseLong(next());
}
private String next() throws IOException {
while (tokens == null || !tokens.hasMoreTokens()) {
tokens = new StringTokenizer(input.readLine());
}
return tokens.nextToken();
}
private StringTokenizer tokens;
private BufferedReader input;
private PrintWriter output;
}
| constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class A {
public static void main(String[] args) throws FileNotFoundException {
Scanner s = new Scanner(System.in);
int T = s.nextInt();
System.out.println("0 0 "+T);
/*if(T==0) {
return;
}
if(T==1) {
System.out.println("0 0 0");
return;
}
System.out.println();*/
}
}
| constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.util.Scanner;
public class A{
public static void main(String[] args){
Scanner s = new Scanner(System.in);
int n = s.nextInt();
int prev2=0;
int prev1=1;
int prev=1;
int curr = 2;
if(n == 0) {System.out.println("0 0 0"); return;}
else if(n == 1) {System.out.println("0 0 1");return;}
while(true){
if(curr == n) break;
prev2 = prev1;
prev1 = prev;
int temp = prev + curr;
prev = curr;
curr = temp;
}
System.out.println(prev2 + " " + prev1 + " " + prev1);
}
}
| constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
public class CF125A {
private void work() throws IOException {
Scanner sc = new Scanner(new BufferedReader(new InputStreamReader(
System.in)));
int n = sc.nextInt();
System.out.printf("%d %d %d\n", 0, 0, n);
System.out.close();
}
public static void main(String[] args) throws IOException {
new CF125A().work();
}
}
| constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.util.Map.Entry;
public class Main {
public static void main(String[] args) throws IOException {
(new Main()).solve();
}
public void Main() {
}
void solve() throws IOException {
// BufferedReader in = new BufferedReader(new
// InputStreamReader(System.in));
// Scanner in = new Scanner(System.in);
MyReader in = new MyReader();
PrintWriter out = new PrintWriter(System.out);
// Scanner in = new Scanner(new FileReader("input.txt"));
// PrintWriter out = new PrintWriter("output.txt");
int n = in.nextInt();
out.print("0 0 ");
out.print(n);
out.close();
}
};
class MyReader {
private BufferedReader in;
String[] parsed;
int index = 0;
public MyReader() {
in = new BufferedReader(new InputStreamReader(System.in));
}
public int nextInt() throws NumberFormatException, IOException {
if (parsed == null || parsed.length == index) {
read();
}
return Integer.parseInt(parsed[index++]);
}
public long nextLong() throws NumberFormatException, IOException {
if (parsed == null || parsed.length == index) {
read();
}
return Long.parseLong(parsed[index++]);
}
public String nextString() throws IOException {
if (parsed == null || parsed.length == index) {
read();
}
return parsed[index++];
}
private void read() throws IOException {
parsed = in.readLine().split(" ");
index = 0;
}
public String readLine() throws IOException {
return in.readLine();
}
}; | constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.util.Scanner;
public class CF125D2A {
/**
* @param args
*/
public static void main(String[] args) {
Scanner sc = new Scanner (System.in);
System.out.println("0 0 "+ sc.nextInt());
}
}
| constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.util.Scanner;
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
/**
*
* @author scawn
*/
public class Main {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
Scanner cin = new Scanner (System.in);
int n = cin.nextInt();
long res = 2;
long[] a = new long[4];
a[0] = 0;
a[1] = 1;
a[2] = 1;
a[3] = 2;
if (n == 1){
System.out.println("0 0 1");
return;
}
if (n == 2){
System.out.println("0 1 1");
return;
}
if (n == 0){
System.out.println("0 0 0");
return;
}
// if (n == 1 || n == 2 || n == 0){
// System.out.println("I'm too stupid to solve this problem");
// return;
// }
if (n == 3){
System.out.println("1 1 1");
return;
}
do{
a[3] = res;
res = a[2] + a[3];
if (res == n){
System.out.println (a[0] + " " + a[1] + " " + a[3]);
return;
}
a[0] = a[1];
a[1] = a[2];
a[2] = a[3];
}while (true);
}
}
| constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner r = new Scanner(System.in);
int N = r.nextInt();
System.out.println(N + " " + 0 + " " + 0);
}
}
| constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.io.*;
import java.util.*;
import java.math.*;
public class MAIN
{
public static void main(String args[])
{
Scanner sn=new Scanner(System.in);
int n,n1,n2,n3;
int arr[]={0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,17711,28657,46368,75025,121393,196418,317811,514229,832040,1346269,2178309,3524578,5702887,9227465,14930352,24157817,39088169,63245986,102334155,165580141,267914296,433494437,701408733,1134903170};
n=sn.nextInt();
if(n==2)
{
n1=n2=1;
n3=0;
}
else if(n==1)
{
n3=n2=0;
n1=1;
}
else if(n==0)
{
n1=n2=n3=0;
}
else if(n==3)
{
n1=n2=n3=1;
}
else
{
int index=bsearch(arr,0,arr.length-1,n);
n1=arr[index-1];
n2=arr[index-3];
n3=arr[index-4];
}
System.out.println(n3+" "+n2+" "+n1);
}
static int bsearch(int arr[],int l,int h,int n)
{
if(l>h)
return -1;
int mid=(l+h)/2;
if(n==arr[mid])
return mid;
else if(n>arr[mid])
return(bsearch(arr,mid+1,h,n));
else
return(bsearch(arr,l,mid-1,n));
}
} | constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.util.*;
public class Main {
final int INF = Integer.MAX_VALUE / 2;
private void doit(){
Scanner sc = new Scanner(System.in);
//while(sc.hasNext()){
int n = sc.nextInt();
if(n == 0){
System.out.println("0 0 0");
}
else if(n == 1){
System.out.println("0 0 1");
}
else{
//create a fib
ArrayList<Integer> fibList = new ArrayList<Integer>();
int pre = 0;
int next = 1;
fibList.add(pre);
fibList.add(next);
while(next != n){
int temp = next;
next +=pre;
fibList.add(next);
pre = temp;
}
int len = fibList.size();
int a = fibList.get(len-4);
int b = fibList.get(len-3);
int c = fibList.get(len-3);
System.out.println(a + " " + b + " " + c);
}
//}
}
public static void main(String[] args) {
Main obj = new Main();
obj.doit();
}
} | constant | 199_A. Hexadecimal's theorem | CODEFORCES |
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
//package CodeForces3;
import java.util.ArrayList;
import java.util.Scanner;
/**
*
* @author DELL
*/
public class HexadecimalsTheorem {
public void solve() {
Scanner sc = new Scanner(System.in);
long n = sc.nextLong();
ArrayList<Long> a = new ArrayList<Long>();
a.add(0l);
a.add(1L);
a.add(1L);
int i = 1, j = 2;
while ((a.get(i) + a.get(j)) <= n) {
a.add((a.get(i) + a.get(j)));
i++;
j++;
}
if (a.contains(n)) {
if (n == 0) {
System.out.println("0 0 0");
} else if (n == 1) {
System.out.println("0 0 1");
} else if (n == 2) {
System.out.println("0 1 1");
} else {
System.out.println(a.get(j - 4) + " " + a.get(j - 3) + " " + a.get(j - 1));
}
} else {
System.out.println("I'm too stupid to solve this problem");
}
}
public static void main(String[] args) {
new HexadecimalsTheorem().solve();
}
}
| constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.io.*;
import java.util.*;
import java.math.*;
public class MAIN
{
public static void main(String args[])
{
Scanner sn=new Scanner(System.in);
int n,n1,n2,n3;
int arr[]={0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,17711,28657,46368,75025,121393,196418,317811,514229,832040,1346269,2178309,3524578,5702887,9227465,14930352,24157817,39088169,63245986,102334155,165580141,267914296,433494437,701408733,1134903170};
n=sn.nextInt();
if(n==2)
{
n1=n2=1;
n3=0;
}
else if(n==1)
{
n3=n2=0;
n1=1;
}
else if(n==0)
{
n1=n2=n3=0;
}
else if(n==3)
{
n1=n2=n3=1;
}
else
{
int index=bsearch(arr,0,arr.length-1,n);
n1=arr[index-1];
n2=arr[index-3];
n3=arr[index-4];
}
System.out.println(n3+" "+n2+" "+n1);
}
static int bsearch(int arr[],int l,int h,int n)
{
if(l>h)
return -1;
int mid=(l+h)/2;
if(n==arr[mid])
return mid;
else if(n>arr[mid])
return(bsearch(arr,mid+1,h,n));
else
return(bsearch(arr,l,mid-1,n));
}
} | constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.io.*;
import java.util.*;
public class Contest1_1{
public static void main(String ar[]) throws Exception {
BufferedReader buff = new BufferedReader(new InputStreamReader(System.in));
int input = Integer.parseInt(buff.readLine());
if(input==0){
System.out.println("0 0 0");
}else if(input==1){
System.out.println("0 0 1");
}else if(input==2){
System.out.println("0 1 1");
}else if(input==3){
System.out.println("1 1 1");
}else {
int output[] = checkFibo(input);
int get[] = checkFibo(output[1]);
output[0] = get[1];
output[1] = get[2];
System.out.print(output[0]);
System.out.print(" " + output[1]);
System.out.println(" " + output[2]);
}
}
public static int[] checkFibo(int input){
int output[] = new int[3];
int fibo_1 = 0;
int fibo_2 = 1;
int temp = 0;
while(fibo_2!=input){
temp = fibo_2;
output[1] = fibo_1;
output[2] = fibo_2;
fibo_2 += fibo_1;
fibo_1 = temp;
}
return output;
}
} | constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
public class Hexadecimaltheorem {
public static void main(String[] args) {
BufferedReader buf = new BufferedReader(
new InputStreamReader(System.in));
int x;
ArrayList<Integer> arr = new ArrayList<Integer>();
arr.add(0);
arr.add(1);
try {
while ((x = Integer.parseInt(buf.readLine())) != -1) {
if (x == 1) {
System.out.println(arr.get(0) + " " + arr.get(0) + " "
+ arr.get(1));
} else if (x == 0) {
System.out.println(arr.get(0) + " " + arr.get(0) + " "
+ arr.get(0));
} else {
int i = 1;
while (x > arr.get(arr.size() - 1)) {
arr.add(arr.get(i) + arr.get(i - 1));
i++;
}
System.out.println(arr.get(0) + " " + arr.get(i - 2) + " "
+ arr.get(i - 1));
}
}
} catch (NumberFormatException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
| constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
public class CF125D2A {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("0 0 " + sc.nextInt());
}
} | constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.util.Scanner;
public class ProblemA {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long n = sc.nextLong();
long[] answer = new long[3];
if (n == 1) {
answer[0] = 0;
answer[1] = 0;
answer[2] = 1;
} else if (n > 1) {
long f1 = 0;
long f2 = 1;
long m = 0;
while (m < n) {
answer[0] = answer[1];
answer[1] = f1;
answer[2] = f2;
m = f1 + f2;
f1 = f2;
f2 = m;
}
answer[2] = answer[1];
}
System.out.println(answer[0] + " " + answer[1] + " " + answer[2]);
}
} | constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.util.*;
public class A {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
System.out.println("0 0 " + n);
}
} | constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.io.*;
import java.util.*;
import java.util.concurrent.ArrayBlockingQueue;
import javax.print.attribute.HashAttributeSet;
public class CodeForces {
public void solve() throws IOException {
int n = nextInt();
int arr[]=new int[1000];
arr[0]=0;
arr[1]=1;
arr[2]=1;
if(n==0){
out.print("0 0 0");
}
else if(n==1){
out.print("0 0 1");
} else {
int c=2;
while(arr[c]!=n){
c++;
arr[c]=arr[c-1]+arr[c-2];
}
out.print(arr[c-2]+" "+arr[c-2]+" "+arr[c-3]);
}
}
public static void main(String[] args) {
new CodeForces().run();
}
int NOD(int a, int b) {
while (a != 0 && b != 0) {
if (a >= b)
a = a % b;
else
b = b % a;
}
return a + b;
}
BufferedReader reader;
StringTokenizer tokenizer;
PrintWriter out;
boolean isOuterFile = false;
public void run() {
try {
if (isOuterFile) {
reader = new BufferedReader(new FileReader("input.txt"));
out = new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
out = new PrintWriter(System.out);
} else {
reader = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
}
tokenizer = null;
// long t=new Date().getTime();
solve();
// writer.println(t-new Date().getTime());
reader.close();
out.close();
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
String nextToken() throws IOException {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
return tokenizer.nextToken();
}
} | constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.util.Scanner;
/**
*
* @author Gitesh
*/
public class JavaApplication2 {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
Scanner s=new Scanner(System.in);
int n;
n=s.nextInt();
System.out.print(n+" "+"0 0");
}
} | constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.util.Scanner;
public class HexadecimalTheorem {
public static void main(String[] args) {
Scanner read = new Scanner(System.in);
int num = read.nextInt();
int zero, one, two, three;
zero = 0;
one = 1;
two = 1;
three = 2;
if(num == 0)
System.out.println("0 0 0");
else if(num == 1)
System.out.println("0 0 1");
else{
while(num != three){
zero = one;
one = two;
two = three;
three = three + one;
}
System.out.println(zero + " " + one + " " + one);
}
}
}
| constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.io.*;
import java.util.*;
import java.math.*;
public class MAIN
{
public static void main(String args[])
{
Scanner sn=new Scanner(System.in);
int n,n1,n2,n3;
int arr[]={0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,17711,28657,46368,75025,121393,196418,317811,514229,832040,1346269,2178309,3524578,5702887,9227465,14930352,24157817,39088169,63245986,102334155,165580141,267914296,433494437,701408733,1134903170};
n=sn.nextInt();
if(n==2)
{
n1=n2=1;
n3=0;
}
else if(n==1)
{
n3=n2=0;
n1=1;
}
else if(n==0)
{
n1=n2=n3=0;
}
else if(n==3)
{
n1=n2=n3=1;
}
else
{
int index=bsearch(arr,0,arr.length-1,n);
n1=arr[index-1];
n2=arr[index-3];
n3=arr[index-4];
}
System.out.println(n3+" "+n2+" "+n1);
}
static int bsearch(int arr[],int l,int h,int n)
{
if(l>h)
return -1;
int mid=(l+h)/2;
if(n==arr[mid])
return mid;
else if(n>arr[mid])
return(bsearch(arr,mid+1,h,n));
else
return(bsearch(arr,l,mid-1,n));
}
} | constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.util.Scanner;
public class Main {
/**
* @param args
*/
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int x = scan.nextInt();
solve(x);
}
public static void solve (int x){
int z = 0 ;
System.out.print(z+" ");
System.out.print(z+" ");
System.out.print(x);
}
}
| constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.util.Scanner;
public class A {
public static void main(String args[]) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int f1 = 0;
int f2 = 1;
int f3 = 1;
while (f3 < n) {
f1 = f2;
f2 = f3;
f3 = f1 + f2;
}
if (n == 0) {
System.out.println(0 + " " + 0 + " " + 0);
} else if (f3 == n) {
System.out.println(f1 + " " + f1 + " " + (f2 - f1));
} else {
System.out.println("I'm too stupid to solve this problem");
}
}
}
| constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.io.*;
import java.util.StringTokenizer;
/**
* Author: Maksim Novik
* Date: 30.06.12
* Time: 22:34
*/
public class Round125ProblemA {
public static void main(String[] args) {
InputStream in = System.in;
OutputStream out = System.out;
InputReader reader = new InputReader(in);
PrintWriter writer = new PrintWriter(out);
solve(reader, writer);
writer.close();
}
static void solve(InputReader in, PrintWriter out) {
long fib = in.nextLong();
out.write("" + 0 + " " + 0 + " " + fib);
}
static class InputReader {
private BufferedReader reader;
private StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream));
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public long nextLong() {
return Long.parseLong(next());
}
public int nextInt() {
return Integer.parseInt(next());
}
}
}
| constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class Solver {
StringTokenizer st;
BufferedReader in;
PrintWriter out;
public static void main(String[] args) throws NumberFormatException, IOException {
Solver solver = new Solver();
solver.open();
solver.solve();
solver.close();
}
public void open() throws IOException {
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
}
public String nextToken() throws IOException {
while (st == null || !st.hasMoreTokens()) {
st = new StringTokenizer(in.readLine());
}
return st.nextToken();
}
public int nextInt() throws NumberFormatException, IOException {
return Integer.parseInt(nextToken());
}
public long nextLong() throws NumberFormatException, IOException {
return Long.parseLong(nextToken());
}
public double nextDouble() throws NumberFormatException, IOException {
return Double.parseDouble(nextToken());
}
public void solve() throws NumberFormatException, IOException {
int n = nextInt();
out.println(0+" "+0+" "+n);
}
public void close() {
out.flush();
out.close();
}
} | constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
PrintWriter out = new PrintWriter(System.out);
int n = in.nextInt();
out.println(n+" 0 0");
in.close();
out.close();
}
}
| constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.io.*;
import java.util.*;
public class program{
public static void main(String args[]) throws Exception{
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
if(n==0){
System.out.println("0 0 0");
return;
}
else if(n==1){
System.out.println("0 0 1");
return;
}
else if(n==2){
System.out.println("0 1 1");
return;
}
else{
int ppp=0;
int pp=1;
int c=2;
while(true){
if(ppp+pp+c==n){
System.out.println(ppp+" "+pp+" "+c);
return;
}
else{
c=c+pp+ppp;
int temp=pp;
pp=pp+ppp;
ppp=temp;
}
}
}
}
} | constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.util.LinkedList;
import java.util.Scanner;
public class HexadecimalsTheorem {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int num = in.nextInt();
LinkedList<Integer> result = new LinkedList<Integer>();
int temp0 = 1;
int temp1 = 1;
int temp2 = 0;
result.add(0);
result.add(0);
result.add(0);
result.add(temp0);
result.add(temp1);
if (num == 2) {
System.out.println(0 + " " + 1 + " " + 1);
} else if (num == 0) {
System.out.println(0 + " " + 0 + " " + 0);
} else {
while (temp2 < num) {
temp2 = temp1 + temp0;
result.add(temp2);
temp0 = temp1;
temp1 = temp2;
}
int length = result.size();
System.out.println(result.get(length - 5) + " "
+ result.get(length - 4) + " " + result.get(length - 2));
}
}
}
| constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.io.*;
import java.util.*;
import java.util.regex.*;
public class A {
static Scanner scan = new Scanner (System.in);
static PrintStream out = System.out;
static void go (int n) {
if (n == 0) {
System.out.println (0 + " " + 0 + " " + 0);
return;
}
int a = 0, b = 1;
int c = a + b;
while (n > c) {
a = b;
b = c;
c = a + b;
}
System.out.println (0 + " " + a + " " + b);
}
public static void main (String[] args) {
int n = scan.nextInt();
go (n);
}
}
| constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.util.Arrays;
import java.util.Scanner;
public class A {
public static void main(String[] args) {
long fib[] = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155, 165580141, 267914296, 433494437, 701408733, 1134903170, 1836311903, 2971215073L, 4807526976L, 7778742049L, 12586269025L, 20365011074L, 32951280099L, 53316291173L, 86267571272L, 139583862445L, 225851433717L, 365435296162L, 591286729879L, 956722026041L, 1548008755920L, 2504730781961L, 4052739537881L, 6557470319842L, 10610209857723L };
int i = Arrays.binarySearch(fib, new Scanner(System.in).nextLong());
if (i < 4)
if (i == 3)
System.out.println("0 1 1");
else if (fib[i] == 1)
System.out.println("0 0 1");
else
System.out.println("0 0 0");
else
System.out.println(fib[i - 4] + " " + fib[i - 3] + " " + fib[i - 1]);
}
}
| constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.io.*;
import java.util.*;
import java.util.regex.*;
public class Main {
static Scanner scan = new Scanner (System.in);
static PrintStream out = System.out;
static int n;
static void solve () {
System.out.println (0 + " " + 0 + " " + n);
}
public static void main (String[] args) {
n = scan.nextInt();
solve ();
}
}
| constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.io.*;
import java.util.*;
public class Main{
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
List<Integer> fibs = new ArrayList<Integer>();
int fib0 = 0;
int fib1 = 1;
int fibN = fib0+fib1;
fibs.add(fib0);
fibs.add(fib1);
while(fibN < 1000000000){
fibs.add(fibN);
fib0 = fib1;
fib1 = fibN;
fibN = fib0+fib1;
}
int n = Integer.parseInt(br.readLine());
if(n == 0){System.out.println(0+" "+0+" "+0);}
else{
if(n == 1){System.out.println(0+" "+0+" "+1);}
else{
if(n == 2){System.out.println(0+" "+1+" "+1);}
else{
int i = fibs.indexOf(n);
System.out.println(fibs.get(i-4)+" "+fibs.get(i-3)+" "+fibs.get(i-1));
}}
}
}
} | constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class A125D2 {
public static void main(String[] args) throws Exception {
InputReader in = new InputReader(System.in);
System.out.println(0 + " " + 0 + " " + in.nextInt());
}
static class InputReader {
private BufferedReader reader;
private StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream));
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
}
}
| constant | 199_A. Hexadecimal's theorem | CODEFORCES |
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
import java.util.Scanner;
/**
*
* @author dilshan
*/
public class Test {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int n = s.nextInt();
int k = 1;
int t = 0;
int y = 2;
int[] a = new int[100000];
if(n==0){
System.out.println(0+" "+0+" "+0);
}
else
if(n==1){
System.out.println(0+" "+0+" "+1);
}
else
if(n==2){
System.out.println(0+" "+1+" "+1);
}
else{
a[0] = 0;
a[1] = 1;
a[y] = a[y - 2] + a[y - 1];
while (a[y - 1] < n) {
a[y] = a[y - 2] + a[y - 1];
++y;
}
System.out.println(a[y - 2] + " " + a[y - 4] + " " + a[y - 5]);
}
//System.out.println(y);
}
}
| constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.util.*;
public class Hexadecimal {
public static void main(String args[]){
Scanner input = new Scanner(System.in);
int n = input.nextInt();
System.out.print("0 0 " + n);
}
}
| constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Main {
public static void main(String args[]) throws Exception
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
int n=Integer.parseInt(br.readLine());
System.out.println("0 0 "+n);}
}
| constant | 199_A. Hexadecimal's theorem | CODEFORCES |
import java.io.*;
import java.util.*;
public class C125 {
public static void main(String[] args) throws IOException {
BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
String s = r.readLine();
int n = new Integer(s);
System.out.println("0 0 "+n);
}
}
| constant | 199_A. Hexadecimal's theorem | CODEFORCES |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.