[Topcoder] SRM232 ~ 239 연습

SRM232 DIV2
: 이문제도 예전에 나왔던 동일한 문제.. 확실히 한번 본 문제는 빨리푼다.. 연습하는 보람이 있군;

class BritishCoins
{
public:
 vector <int> coins(int p)
 {
  VI ret;  
  ret.pb(p/240);
  p = p%240;
  ret.pb(p/12);
  ret.pb(p%12);
  return ret;
 }
};

SRM233 DIV2

class JustifyText
{
public:
 vector <string> format(vector <string> t)
 {
  int n = t.size();
  int m = 0;
  REP(i, n)
   m = max(m, (int)t[i].size());

  REP(i, n)
  {
   while(t[i].size() != m)
    t[i] = ' ' + t[i];
  }

  return t;
 }
};

SRM234 DIV2
: 주로 i와 i-1이 동일한지 여부로 cnt값을 늘리면서 max값을 구하는 솔루션이 많은듯.

class ComboLength
{
public:
 int howLong(string m)
 {
  int a =0, b = 0;
  int maxa = 0, maxb = 0;
  REP(i, m.size())
  {
   if(m[i] == 'A')
   {
    a++;
    maxb = max(maxb, b);
    b=0;
   }
   else
   {
    b++;
    maxa = max(maxa, a);
    a = 0;
   }
  }
  maxa = max(maxa, a);
  maxb = max(maxb, b);

  return max(maxa, maxb);
 }
};

SRM235 DIV2
: 역시 Notes에 나온 구절이 빠른 문제풀이에 도움이 됨

class NoisySensor
{
public:
 vector <int> medianFilter(vector <int> d)
 {
  if(d.size() < 3) return d;
  VI ret(d);
  VI sub(3,0);
  for(int i=1; i+1<d.size(); i++)
  {
   sub[0] = d[i-1];
   sub[1] = d[i];
   sub[2] = d[i+1];
   sort(ALL(sub));
   ret[i] = sub[1];
  }
  return ret;
 }
};

SRM236 DIV2

class MassiveNumbers
{
public:
  string getLargest(string A, string B)
  {
   int a, a1, b, b1;
   char c;
   stringstream(A) >> a >> c >> a1;
   stringstream(B) >> b >> c >> b1;

   double a2 = log((double)a) * a1;
   double b2 = log((double)b) * b1;

   string ret(A);
   if( a2 < b2) ret = B;
   return ret;
  }
};

SRM237 DIV2

class Cards
{
public:
  vector <string> deal(int n, string d)
  {
   vector<string> ret(n);
   REP(m, d.size() / n)
    REP(i, n)
     ret[i] += d[m*n + i];

   return ret;
  }
};

SRM238 DIV2

class ArrayHash
{
public:
  int getHash(vector <string> in)
  {
   int ret = 0;

   REP(i, in.size())
    REP(j, in[i].size())
     ret += in[i][j] -'A' + i + j;
   
   return ret;
  }
};

SRM239 DIV2
: 좋은 문제. 시간이 지난뒤에 다시 한번 풀어볼 것.

class Barbecue
{
public:

  int eliminate(int n, vector <int> v, vector <int> e)
  {
   VI v1(n, 0);
   VI e1(n, 0);

   REP(i, v.size())
   {
    v1[v[i]]++;
    e1[e[i]]++;
   }

   int max_v = 0, max_e = 0, ret = 0;
   REP(i, n)
   {
    if( e1[i] > max_e || (e1[i] == max_e && v1[i] > max_v) )
    {
     max_e = e1[i];
     max_v = v1[i];
     ret = i;
    }
   }
   return ret;

  }
};