d = {'._.\n|.|\n|_|': 0,
     '...\n..|\n..|': 1,
     '._.\n._|\n|_.': 2,
     '._.\n._|\n._|': 3,
     '...\n|_|\n..|': 4,
     '._.\n|_.\n._|': 5,
     '._.\n|_.\n|_|': 6,
     '._.\n..|\n..|': 7,
     '._.\n|_|\n|_|': 8,
     '._.\n|_|\n._|': 9
     }

#include<stdio.h>
#include<math.h>
int main()
{
    int i,sum=0,n;
    scanf("%d",&n);

    if(abs(n)<=10000){

    if(n<0){

    for(i=1;i>=n;i--){
        sum+=i;
    }
    }

    else{
        sum=((n*n)+n)/2;
    }

    printf("%d",sum);}
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main()
{

    int a,p=0,i,*b;
float f,s=0;
scanf("%d",&a);
b=(int *)malloc(sizeof(int)*a);
for(i=0;i<a;i++){
scanf("%d",&b[i]);}
/*if (b[i]<3||b[i]>5)
    scanf("%d",&b[i]);
}*/
for(i=0;i<a;i++)
    s+=b[i];

f=s/a;
for(i=0;i<a;i++)
{

 if(b[i]==3){
 p=1;}
}

if(f==5)
   {printf("Named");
   }

       else if(f>=4.5&&p==0){ printf("High");
    }

        else if(f<4.5&&p==0){
    printf("Common");}
    else {printf("None");}
    free(b);
    return 0;
}

I've passed all of the user tests on here, and any test I can think of.
Still getting WA on #14.
Here's my non-working code.

import java.io.*;

public class P1998 {
    static StreamTokenizer in;
    static PrintWriter out;

    static int nextInt() throws IOException{
        do{
            in.nextToken();
        }while(in.ttype != StreamTokenizer.TT_NUMBER);
        return (int)in.nval;
    }

    public static void main(String[] args) throws IOException{
        in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        out = new PrintWriter(System.out);

        int n = nextInt();
        int m = nextInt();
        int k = nextInt();

        int[] stones = new int[n];
        int[] dropsTo = new int[n];

        int tmp = 0, j = 0;
        for(int i = 0; i < n; i++){
            stones[i] = nextInt();

            while(j < i - 1 && tmp - stones[j] > k){
                tmp -= stones[j];
                j++;
            }
            tmp += stones[i];
            dropsTo[i] = j;
        }

        j = 0;
        int moment, time = 0;
        for(int i = 0; i < m; i++){
            moment = nextInt() - time;

            time += moment;
            j += moment - 1;
            if(j >= n){
                time -= moment - n;
                j = n;
                break;
            }
            j = dropsTo[j];
        }

        out.println(time + n - j);
        out.flush();
    }
}

Create an array of Boolean elements. Size = billion.
For i:=1 to n {{ introduce a variable; element of array with index [variable] equals true }}
For i:=1 to m {{ introduce a variable; if element of array with index [variable] equals true then increase the counter }}

And finally, we output counter))
That's all), sorry for bad english

But this solution takes 58 mb of memory... ((

Edited by author 06.04.2014 16:17

Used Sieve to generate primes till 10^6, and then used those primes to generate larger primes.
counted all such numbers satisfying  L <= p^(q-1) <=R where p & q are primes (q>2). Subtracted it from R-L+1

How to optimize?

I got WA on test 4, but on all tests I could make myself and also on those, which were in the problem, my program answered correctly. Please, suggest some tests, that could help.

import java.util.Scanner;
import java.util.Stack;

public class ReverseRoot_SplitDecimal {

    public static void main(String args[]) {

        Scanner sc = new Scanner(System.in);
        Stack<Integer> integerNumberStack = new Stack<Integer>();
        Stack<Short> floatingNumberStack = new Stack<Short>();

        Double tempDouble = new Double(0);

        while(sc.hasNextInt()) {
            tempDouble = Math.sqrt(sc.nextDouble());
            integerNumberStack.push(Integer.parseInt(String.format("%.4f", tempDouble).split("\\.")[0]));
            floatingNumberStack.push(Short.parseShort(String.format("%.4f", tempDouble).split("\\.")[1]));
        }

        while(!integerNumberStack.isEmpty()) {
            System.out.printf("\n%d.%04d", integerNumberStack.pop(), floatingNumberStack.pop());
        }
        System.out.println();

        sc.close();
    }
}

Just drawing different patterns on paper for several hours and the solution will come!

My solutions in the two languages produce the same output on my tests. However, the Go version gets WA1. Please fix this.

Give me this test

Edited by author 25.10.2017 18:58

Edited by author 25.10.2017 07:16

...

Edited by author 25.10.2017 12:47

n > k in 2nd test

The following code:

cin>>n;
for(i=1;i<=n;i++) {
  cin>>x[i]>>y[i];
  assert(x[i]>=1 && x[i]<=10 && y[i]>=1 && y[i]<=10);
  here[x[i]][y[i]]=true;
}

gives RTE, so test 2 is wrong. After, removing the assert, it gives WA :)

Hello. Task number is 2023.
Timus flatly refuses to accept. He had a lot of tests, but he did not find any flaws. Maybe someone will tell me, otherwise I'll kill myself tomorrow.

n = int(input())
zn = [1]
k=0
y = 0
sh1 = ('Alice', 'Ariel', 'Aurora', 'Phil', 'Peter', 'Olaf', 'Phoebus', 'Ralf', 'Robin')
sh2 = ('Bambi', 'Belle', 'Bolt', 'Mulan', 'Mowgli', 'Mickey', 'Silver', 'Simba', 'Stitch')
for j in range (n):
    i = input()
    if i in sh1:
        zn.append (1)
    elif i in sh2:
        zn.append (2)
    else:
        zn.append (3)
    n-=1
for k in range (len(zn)):
    y+= abs ((int(zn [k-1]))-int(zn [k]))
lop = y-zn[-1]+1
print (lop)

Finally ACed by changing to a direct approch.
But I still don't understand what's wrong with my previous algo(which results to WA5)
It's something like this:

For example, for such a input:
4  6
1  1  2  3  3  7
4  5  2  6  6  7
4  5  8  9  12  11
10 10 8  9  12  11

1.Construct a n*m graph G, every vertices connected with all it's neighbors(up, down, left, right)
(for layout reasons here I use hex to number the vertices)

(the graph left is only a illustration to explain the things happening to the former graph.
the graph right shows the result we get in every stage.)
1-1-2-3-3-7        o-o-o-o-o-o
| | | | | |        | | | | | |
4-5-2-6-6-7        o-o-o-o-o-o
| | | | | |        | | | | | |
4-5-8-9-C-B        o-o-o-o-o-o
| | | | | |        | | | | | |
A-A-8-9-C-B        o-o-o-o-o-o

2.Remove an edge whose endpoints have the same number.
Repeat this operation until no such pairs connected.
finally we get something like this
1 1-2-3 3-7        o o-o-o o-o
| |   | |          | |   | |
4-5-2-6 6-7        o-o-o-o o-o
    | | | |            | | | |
4-5-8-9-C-B        o-o-o-o-o-o
| |                | |
A A-8-9-C-B        o o-o-o-o-o

3.Pick a vertex v, which has a minimum degree(non-zero), and w, an arbitrary neighbor of v.
Assign a incremental number to both v and w, and remove all the edges who cover v or w.
Repeat this operation until Δ(G) == 0.
For the input the process will be:

            (STEP1)
1 1-2-3 3-7        1 o-o-o o-o
| |   | |            |   | |
4-5-2-6 6-7        1 o-o-o o-o
    | | | |            | | | |
4-5-8-9-C-B        o-o-o-o-o-o
| |                | |
A A-8-9-C-B        o o-o-o-o-o

            (STEP2)
1 1-2-3 3 7        1 o-o-o 2 2
  |   |              |   |
4 5-2-6 6-7        1 o-o-o o-o
    | | | |            | | | |
4-5-8-9-C-B        o-o-o-o-o-o
| |                | |
A A-8-9-C-B        o o-o-o-o-o

            (STEP3)
1 1-2-3 3 7        1 o-o-o 2 2
  |   |              |   |
4 5-2-6 6-7        1 o-o-o o-o
    | | | |            | | | |
4 5-8-9-C-B        3 o-o-o-o-o
  |                  |
A A-8-9-C-B        3 o-o-o-o-o

            (STEP4)
1 1-2-3 3 7        1 o-o-o 2 2
  |   |              |   |
4 5-2-6 6-7        1 o-o-o o-o
    | | | |            | | | |
4 5-8-9-C-B        3 o-o-o-o-o
  |                  |
A A-8-9 C B        3 o-o-o 4 4

            (STEP5)
1 1-2-3 3 7        1 o-o-o 2 2
  |   |            | |   |
4 5-2-6 6-7        1 o-o-o o-o
    | | | |            | | | |
4 5-8-9-C-B        3 o-o-o-o-o
  |                  |
A A 8 9 C B        3 o 5 5 4 4

            (STEP6)
1 1-2-3 3 7        1 o-o-o 2 2
  |   |            | |   |
4 5-2-6 6-7        1 o-o-o o-o
    | | | |            | | | |
4 5 8-9-C-B        3 6 o-o-o-o

A A 8 9 C B        3 6 5 5 4 4

            (STEP7)
1 1 2 3 3 7        1 7 7 o 2 2
      |                  |
4 5-2-6 6-7        1 o-o-o o-o
    | | | |            | | | |
4 5 8-9-C-B        3 6 o-o-o-o

A A 8 9 C B        3 6 5 5 4 4

            (STEP8)
1 1 2 3 3 7        1 7 7 o 2 2
      |                  |
4 5 2 6 6-7        1 8 8 o o-o
      | | |              | | |
4 5 8-9-C-B        3 6 o-o-o-o

A A 8 9 C B        3 6 5 5 4 4

            (STEP9)
1 1 2 3 3 7        1 7 7 9 2 2

4 5 2 6 6-7        1 8 8 9 o-o
        | |                | |
4 5 8-9-C-B        3 6 o-o-o-o

A A 8 9 C B        3 6 5 5 4 4

            (STEP10)
1 1 2 3 3 7        1 7 7 9 2 2

4 5 2 6 6-7        1 8 8 9 o-o
        | |                | |
4 5 8 9 C-B        3 6 A A o-o

A A 8 9 C B        3 6 5 5 4 4

            (STEP11)
1 1 2 3 3 7        1 7 7 9 2 2

4 5 2 6 6 7        1 8 8 9 B B

4 5 8 9 C-B        3 6 A A o-o

A A 8 9 C B        3 6 5 5 4 4

            (STEP12)
1 1 2 3 3 7        1 7 7 9 2 2

4 5 2 6 6 7        1 8 8 9 B B

4 5 8 9 C B        3 6 A A C C

A A 8 9 C B        3 6 5 5 4 4

4.Finally we got a valid output:
1 7 7 9 2 2
1 8 8 9 B B
3 6 A A C C
3 6 5 5 4 4

I know I must mistaked something, but I can't find the mistake.
Please tell me where is wrong, or give me some tests to beat this algo.
Thanks in advance.

Edited by author 31.05.2009 00:28

()(
Answer: 0.