Try this test case:

1
1 of vodka
1
2 of vodka

Answer = 1

Could anyone, please, explain it to me? I can't understand how to program it. I'm filling the "amount of name" for the storage in the shop and for the queue, then, for each human from the queue, I check, firstly, whether the shop has the product the customer needs to buy, and then, if the shop has it, I compare the amounts. But I have a problem in understanding the part where the shop doesn't have enough of the product and the customers switch places. Could anyone explain it to me?

#include <stdio.h>
int main()
{
    int N, M;
    scanf("%d%d",&N,&M);
    long int res;
    if (N <= M)
        res = 2 * (N - 1);
    else
        res= 2 * (M - 1)+1;
    printf("\n%d",res);
    return 0;
}

where is the problem
#include<stdio.h>

int main(void)
{
 int a,b,sum;
 printf("a:");
 scanf("%d",a);

 printf("b:");
 scanf("%d",&b);

 sum=a+b;
 printf("Sum=%d",sum);

 return 0;
}

Edited by author 03.12.2015 01:58

I really can't solve this task?
Alwaus got TLE on test 39 :-(
Can someone give me hint or ...

I had a program like that:
while (x <= b/2) {
   ....
   x += dx
}
but it will fail test 1 1 100 (the last piece won't show).
Changed to
while (x <= b/2 + 0.000001) {
   ....
   x += dx
}

Got AC!

I Solved this problem, by transforming x and y into every system and search for the longest common substring.
But I am interested in another Ideas, better than mine, except brute force.

Нас просят найти количество непустНых палиндромов.

whats test #1??

Okay! Haskellers understand here!

If you need use getContents for input you have two options for local executions on linux or unix environments:
1) Create file with inputs and execute on command: cat input.txt | ./main(haskell program)
2) On terminal execute the program, copy and past your entry for program and execute <CTRL>+D for EOF. That form the program execute and complete your operations.

I'm let that here only for informations for others new for Haskell.

Thank you,
Hygens

###################################################################################

Hi, haskellers on duty!

I'm attempting test the script haskell on mine environment for "1001 - Reverse Root" problem using the same code exposed on Guide session for Haskell but here freeze without response on display.
My environment is based on Linux Mint 16.04 with GHC 7.10.3. Exists any detail that I have passed or I have update that script for that version of Haskell?!
Not occure any error on environment simple that freeze without response for long time and I break the execution.
Some can help on that or had same proglem for ubuntu or mint?!

Thank you,
Hygens

Edited by author 28.12.2016 18:59

Edited by author 28.12.2016 19:30

what is the answer for the following test
bbbb
wwwb
wbwb
wbbb

my AC code shows that answer is 7, is that right?

needn't all 2^16 search, divide it two part each 8 bit.

Can you please share some tests?

Answer was correct on every test from forum, still can't pass test 14 + implemented all the hints, including rounding with 0.5000000001 and searching near the optimal values
:(

Thanks in advance!

Edited by author 28.12.2016 02:12

my program calculate:

Input:
======================================
String str = "10.23\n" +
               "0\n" +

               ".04\n" +
               "1\n" +

               "-0.051e0\n" +
               "1\n" +

               "1.1e30\n" +
               "10\n" +

               "-1.1E-30\n" +
               "1\n" +

               "2468097632.1358642324268913e-2\n" +
               "20\n" +

               "e23\n" +
               "3\n" +

               "1 e3\n" +
               "1\n" +

               "-7293874219874982174982174987321e-18446744073709551616\n" +
               "10\n" +

               "#1234\n" +
               "3\n" +

               " 12.0\n" +
               "3\n" +

               "2E-1\n" +
               "3\n" +

               "-\n" +
               "2\n" +

               ".e1\n" +
               "2\n" +

               "#";
======================================

Output:
======================================
10
0.0
0.0
1100000000000000000000000000000.0000000000
0.0
24680976.32135864232426891300
Not a floating point number
Not a floating point number
0.0000000000
Not a floating point number
Not a floating point number
0.200
Not a floating point number
Not a floating point number
======================================

It's correct.

why wrong test-12?

I had WA#3 because of how I was reading the input in C:
while (gets(buff) != NULL) {
    int i = 0;
    while (buff[i] != '\0') {
        // process char by char
        i++;
    }
}

Changed to:
while ((c = getchar()) != EOF) {
    // process char by char
}

And it works AC!!!

Hello! Can somebody tell me if there is a faster algo than O(Q^2*N)? My algo works pretty fast, but I wondered if there is a better way to do it.

you must write "not eoln" no "not eof" and you'll got AC!!

#include <iostream>
#include <vector>
#include <string>
int corrections = 0;
bool words_match(const std::string& w1, const std::string& w2);
void process_word(const std::vector<std::string>& dict, const std::string& word);

int main(){
    std::vector<std::string> dictionary;
    std::string curr_dict_word;
    std::getline(std::cin, curr_dict_word);
    while(curr_dict_word != "#"){
        dictionary.push_back(curr_dict_word);
        std::getline(std::cin, curr_dict_word);
    }
    char c;
    std::string cword;
    while(std::cin.read(&c,1)){
        if('a'<=c && 'z'>=c){
            cword.insert(cword.end(), c);
            continue;
        }
        else if(!cword.empty()){
            process_word(dictionary, cword);
            cword = "";
        }
        std::cout << c;
    }
    if(!cword.empty()){
        process_word(dictionary, cword);
    }
    std::cout << corrections << std::endl;
    return 0;
}
bool words_match(const std::string& w1, const std::string& w2){
    if(w1.length() != w2.length()){
        return false;
    }
    bool mismatch = false;
    for(int i = 0; i < w1.length(); ++i){
        if(w1[i] != w2[i]){
            if(mismatch){
                return false;
            }
            mismatch = true;
        }
    }
    return mismatch;
}
void process_word(const std::vector<std::string>& dict, const std::string& word){
        for(int i = 0; i < dict.size(); ++i){
            if(words_match(dict[i], word)){
                std::cout << dict[i];
                ++corrections;
                return;
            }
        }
        std::cout << word;
}

Maybe there is just small limits or not right topic??