konec = int(input())
spisok = []
i=1
if konec <0:
    while i>=konec:
        spisok.append(i)
        i-=1
else:
    while i<=konec:
        spisok.append(i)
        i+=1
print(spisok)
print(sum(spisok))

konec = int(input())
spisok = []
i=1
if konec <0:
    while i>=konec:
        spisok.append(i)
        i-=1
else:
    while i<=konec:
        spisok.append(i)
        i+=1
print(spisok)
print(sum(spisok))

For test you can use this string:
hkjgnnngkikipipekkfkfgg

Correct result is:
hkjgngkikipipefkf

using System;

namespace pain
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = Console.ReadLine();

            char[] ss = new char[s.Length];

            for (int i = 0; i < s.Length; i++)
                ss[i] = s[i];
            for (int i = 0; i < s.Length - 1;)
            {

                if (ss[i] == ss[i + 1])
                {

                    if (i - 1 >= 0)
                    {
                        int n = i + 2;
                        b:
                        if (n <= s.Length - 1)
                        {
                            if (ss[n] != ' ')
                            {
                                ss[i] = ss[n];
                                ss[n] = ' ';
                                ss[i + 1] = ' ';
                            }
                            else
                            {
                                n++;
                                goto b;
                            }
                        }
                        else
                            break;

                    }
                    else
                    {
                        ss[i] = ' ';
                        ss[i + 1] = ' ';
                    }
                    if (i >= 1)
                        i--;
                    else
                        i++;

                }
                else
                    i++;
            }

            for (int i = 0; i < s.Length; i++)
                if(ss[i] != ' ')
                    Console.Write(ss[i]);

            //Console.Write(st2(s));
            Console.ReadLine();
        }

        public static string st1(string s, ref int n)
        {
            if (s.Length - 1 > n)
            {
                if (s[n] == s[n + 1])
                {
                    s = s.Remove(n, 2);
                    if (n >= 2)
                        n -= 2;
                    else
                        n--;
                }
                n++;
                s = st1(s, ref n);
            }
            return s;
        }
        public static string st2(string s)
        {
            for (int i = 0; i < s.Length - 1; i++)
            {
                if (s[i] == s[i + 1])
                {
                    s = s.Remove(i, 2);
                    if (i >= 2)
                        i -= 2;
                }
            }
            return s;
        }
        public static string st3(string s)
        {
            int n = 0;
            int nt = s.Length - 1;

            string[] ss = new string[nt];

            for (int i = 0; i < nt; i++)
            {
                bool d = false;
                for (int j = i; j < nt; j++)
                {
                    if (ss[i] == s[j].ToString())
                    {
                        d = true;
                    }
                }
                if (!d)
                {
                    ss[n] = s[i].ToString();
                    n++;
                }
            }

            n = 0;

            while (nt != 0)
            {
                nt = s.Length;
                for (int i = 0; i < ss.Length; i++)
                {
                    s = s.Replace(ss[i] + ss[i], "");
                }
                if (nt == s.Length)
                    break;
            }
            return s;
        }
    }
}

Edited by author 02.04.2019 03:06

Yeah! I did it! I spent about 4 hours to solve this problem =)

The problem limits are too small.
You can get ac with the O(N^2) algorithm which is VERY
straightforward. The limit should force you to use the O
(log N) algorithm to compute X^N (%M)

0.436 seconds, 6840 kb
just go to google and type there:
monte carlo factorization
---
this algo is O(N^1/4), so its O(1e4 * sqrt(2))

Standard BFS question

This test contain such string that answer (minimal integer number) is more than 99999.

2
jsesi
jesfi

2
tvtx
vtix

2
qfqejjfhrhono
fqwejjfhrhono

2
mciqibekphze
mcqibmekphze

2
affjoromdta
affjromjdta

all answers should contain both strings

I've created file with tests, it seems all checks passes locally, but not in Judge
here is my code:
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

typedef struct list_node{
    long int number;
    struct list_node * previous;
} list_node_t;

list_node_t * create_root(long int number);
list_node_t * create_list(long int number, list_node_t * previous);

int main() {
    long int a;
    list_node_t * current = NULL;
    while (scanf("%ld", &a) != EOF) {
        if (current == NULL) {
            current = create_root(a);
        } else {
            current = create_list(a, current);
        }
    }

    while (current != NULL) {
        printf("%.4Lf\n\r", sqrtl(current->number));
        current = current->previous;
    }

    return 0;
}

list_node_t * create_root(long int number)
{
    list_node_t *lt = malloc(sizeof(list_node_t));

    lt->number = number;
    lt->previous = NULL;

    return lt;
}

list_node_t * create_list(long int number, list_node_t * previous)
{
    list_node_t *lt = create_root(number);

    lt->previous = previous;

    return lt;
}

#include <iostream>
#include <vector>
#include <string>
using namespace std;

int box(char a)
{
    switch (a)
    {
    case 'A': case 'P': case 'O': case 'R':
        return 1;
    case 'B': case 'M': case 'S':
        return 2;
    default:
        return 3;
    }
}


int main()
{
    int n;
    cin >> n;
    string a;
    vector<char>f(n);
    for (int i = 0; i < n; i++)
    {
        cin >> a;
        f[i] = a[0];
    }
    int steps = 0;
    int pos = 1;
    for (int i = 0; i < n; i++)
    {
        steps += abs(pos - box(f[i]));
        pos = box(f[i]);
    }
    cout << steps << endl;


    return 0;
}

#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <set>
#include <unordered_map>
#include <map>
#include <string>
using namespace std;
int main()
{
    vector<vector<int>> v(4, vector<int>(4));
    vector<int> col(4);
    for(int i= 0 ; i < 4; i++)
    {
        for(int j = 0; j < 4; j++)
        {
            cin >> v[i][j];
            if(v[i][j] == 1)
            {
                if(((i == 0 || i == 1) && ((j == 0) || (j == 1))))
                {
                    col[0]++;
                }
                else if((i == 0 || i == 1) && ((j == 2) || (j == 3)))
                {
                    col[1]++;
                }
                else if((i == 2 || i == 3) && (j == 0 || j == 1))
                {
                    col[2]++;
                }
                else
                {
                    col[3]++;
                }
            }
        }
    }
    cout << min(min(col[1] + col[2] + col[3] + col[3], col[2] + col[0] + col[2] + col[3]), min(col[1] + col[2] + col[0] + col[0], col[0] + col[3] + col[1] + col[1]));

}

Here is the right description:

1) A, ..., Z, TRUE, FALSE - are correct boolean expressions;

2) if x and y are correct boolean expressions, then the correct boolean expressions are also:
  (x);  NOT x;  x AND y;  x OR y  (maybe, with some extra spaces).

Edited by author 19.09.2007 23:19

An example from other discussions:

input:
4 3 12
1 2 5
1 3 4
3 4 4

output:
YES

displays the correct answer.
Tell me more examples, please.

In the algorithm, I check loops, two-way roads, cycles, and then look for a way longer than necessary.

UPD: WA#18

Edited by author 20.03.2019 19:17

Java coders:
Use BufferedReader and PrintWriter for IO!

http://acm.timus.ru/status.aspx?space=1&num=1915&author=106686&count=100

;)

Edited by author 23.12.2015 02:45

Edited by author 23.12.2015 02:46

Can anyone give me some clue please?

n = int(input())
d = {}
for i in range(n):
    s = input()
    if s not in d:
        d[s] = 0
    d[s] += 1
ans = sorted(d.items(), key=lambda kv: kv[1])[-1][0]
print(ans)

a

use prim or kruskal can solve it.