New tests have been added to the problem. 82 authors have lost AC.

My ac program gives wrong answer on this test:
Input
1
101234

Output:
14231

Edited by author 31.08.2017 22:02

Edited by author 31.08.2017 22:02

is this problem supposed to be solved with random shuffling, or i just got lucky?

Validator was updated. Sample input and output were changed (sample input is Test 1). 109 authors lost AC.

I solved this problem by probabilistic approach and brute-force. No TLE, just stupid WA :)

Please, give me some difficult tests...

Send them please on snipious@mail.ru!!!

I really don't like to do it, but i just can't find what is wrong in my code... In my pc it works pretty fine.. but, i got WA 4#...

my bugged code:

==========================================================

#include <iostream>

using namespace std;

void reordena(int *numeros[],int difzero,int num)
{
    int rdn1,rdn2,aux;

    rdn1 = rand() % difzero;
    rdn2 = rand() % difzero;

    aux = numeros[num][rdn1];
    numeros[num][rdn1] = numeros[num][rdn2];
    numeros[num][rdn2] = aux;
}

void permuta(int *numeros[],int num,int tam)
{
    int cont,cont2,aux,difzero=0,resp=0;
    int mult;
    long int contador=0;

    for(cont=0;cont<tam-1;cont++)
    {
        for(cont2=0;cont2<tam-1;cont2++)
        {
            if(numeros[num][cont2]==0)
            {
                aux = numeros[num][cont2];
                numeros[num][cont2] = numeros[num][cont2+1];
                numeros[num][cont2+1] = aux;
            }
        }
    }

    for(cont=0;cont<tam;cont++)
    {
        if(numeros[num][cont]!=0) difzero++;
    }

    mult=1;
    for(cont=difzero-1;cont>=0;cont--)
    {
        aux=(numeros[num][cont]*mult);
        resp+=aux;
        mult*=10;
    }

    while(resp%7!=0)
    {
        reordena(numeros,difzero,num);
        mult=1;
        resp=0;
        for(cont=difzero-1;cont>=0;cont--)
        {
            aux=(numeros[num][cont]*mult);
            resp+=aux;
            mult*=10;
        }
        contador++;
        if(contador>=1000000)
        {
            numeros[num][0]=0;
            resp=0;
        }
    }

}


int main()
{
    int N,cont,**numeros,*tam;
    char aux[200];

    cin >> N;

    if(N<0) exit(0);
    if(N>10000) exit(0);

    tam = new int[N];
    numeros = new int*[N];
    for(cont=0;cont<N;cont++)
    {
        numeros[cont] = new int[20];
    }

    for(cont=0;cont<N;cont++)
    {
        cin >> aux;
        tam[cont] = strlen(aux);
        if(tam[cont]>20)
        {
            exit(0);
        }

        for(int cont2=0;cont2<tam[cont];cont2++)
        {
            numeros[cont][cont2]=aux[cont2]-'0';
        }

        permuta(numeros,cont,tam[cont]);
    }

    system("cls");
    for(cont=0;cont<N;cont++)
    {
        for(int cont2=0;cont2<tam[cont];cont2++)
        {
            if(numeros[cont][0]==0)
            {
                if(cont2==0) cout << "0";
            }
            else if(numeros[cont][cont2]!=0) cout << numeros[cont][cont2];
        }
        if(cont!=N-1) cout << endl;
    }


    delete [] numeros;
    delete [] tam;

    return 0;
}

========================================================

please, help if you can =/

int pre[8]={4123,1324,1234,1324,1243,2413,2134,4123};

LL solve(LL n)
{
     if (n/10000==0)
     return 4123;

     int k,j,i,p,b[5]={0};
     LL m=0;
     LL res=10000;
     while (true)
      {
          p=n%10;
          n/=10;

          if (p==0)
             b[0]++;
          else
          if (p==1 && !b[1])
           b[1]=1;
           else
          if (p==2 && !b[2])
           b[2]=1;
           else
           if (p==3 && !b[3])
           b[3]=1;
           else
           if (p==4 && !b[4])
           b[4]=1;
            else
             {
                  m+=p*res;
                  res*=10;
             }
             if(n==0) break;
      }

      if (m==0)
      {
         i=-1;
         res=1;
         for (j=1;j<=b[0];j++)
          res*=(LL)10;
          while (true)
          {
              i++;
              if ((pre[i]*res)%7==0)
                 break;
          }
          return pre[i]*res;
      }
      else
      if(b[0]>0)
       {
        for (i=0;i<b[0];i++)
        {
         m*=(LL)10;
         res*=(LL)10;
        }
        k=m%7;
        return m+pre[7-k];
       }

      else
      {
      k=m%7;
      m+=pre[7-k];
      return m;
      }
}

where LL is unsigned long long. Can give me some tests if possible

Edited by author 19.07.2006 14:18

Notification.
In your answer there are no leading zeroes and the length of your answer is equal to the length of corresponding number. (Otherwise possible WA4)

What method or algorithm can we use?
I don't get it...
please help..

If you've got a mistake, check your program on the test:
1
1234567890

;)

Can you give me the test which answer is =0.
And I got WA#4 please give me the tests.

Edited by author 25.06.2008 12:15

Edited by author 25.06.2008 12:15

It is said: "Nikifor knows that a certain positive integer has in its decimal form each of the digits 1,2,3,4."

and in input data there is a number with 5. Where is mistake?

Its example 531234 could be 531342 and more over, why not a special judge?!!

Edited by author 12.07.2005 07:38

I'm curious is unsigned long long enough to contain all positive numbers from input ?
Can I avoid dealing with strings?

Edited by author 22.07.2006 01:59

Edited by author 22.07.2006 01:59

My algo is o(N*length(ch))

DELETED!!!
NOW AC!!

Edited by author 05.08.2005 23:02

please help me!!