CodeWars （c++）

fishjam123

已于 2023-01-12 15:24:47 修改

阅读量372

点赞数

文章标签： c++

于 2023-01-12 15:04:49 首次发布

本文链接：https://blog.youkuaiyun.com/fishjam123/article/details/128659973

版权

Kyu 6

Roman Numerals Decoder

#include <iostream>
#include <string>

using namespace std;

int solution(string roman) {
   unordered_map<char, int> ri = {{'I', 1}, {'V', 5}, {'X', 10}, {'L', 50}, {'C', 100}, {'D', 500}, {'M', 1000}};
 
        int n = roman.size(), res = 0;
 
        for (int i = 0; i < n; ++i) {
 
            if (i + 1 < n && ri[roman[i]] < ri[roman[i+1]])
 
                res -= ri[roman[i]];
 
            else res += ri[roman[i]];
 
        }
 
        return res;
 
    }

Roman Numerals Encoder

#include <bits/stdc++.h>
using namespace std; 

string solution(int number){
        string r[13] = {"M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"};
        int n[13] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1}; 
        string rnum = "";
        int i = 0;
            for (i = 0 ; i < 13; i++)
            {    
                while(n[i] <= number)
                {
                    number -= n[i];
                   rnum += r[i];
                }
                
            }
       return rnum;
}

Backspaces in string

#include <bits/stdc++.h>
using namespace std;

void reverseStr(string& str) 
{ 
    int n = str.length(); 

    // Swap character starting from two 
    // corners 
    for (int i = 0; i < n / 2; i++) 
        swap(str[i], str[n - i - 1]); 
} 
 

string cleanString(const string &s) {
    stack<char> mystack;
    string ans= "";
    int i;
    int len = s.length();
    
    for(i = 0; i < len; i++)
    {
        if(s[i]!='#')
        {
            mystack.push(s[i]);
        }
        else
        {   
            if(mystack.size() == 0)
            {
                continue;
              }
            mystack.pop();
        }
    }
    char ss;
 
    while(mystack.size())
    {
        ss = mystack.top();
      mystack.pop();
      ans+=ss;
    }
    
    reverseStr(ans);
    return ans;
    
}

Find Numbers with Same Amount of Divisors

#include <bits/stdc++.h>
using namespace std;

unsigned long long getSumdiv(int n)
{
  unsigned long long sum = 0; 
  for(int i=1;i<=sqrt(n);++i)
  {
    if(n%i==0)
    {
      if(n/i == i)
      {   
          sum+=1;
      }
      else
      {   
        sum+=2;
      }
    }
      
  }
  return sum ;
} 

unsigned int countDivisors(const unsigned int diff, const unsigned int nMax) {
   unsigned int count = 0;
  int i = 1;
  int j = 0;
  for ( i = 0; i < nMax; i++)
  {
        j = i + diff;
        if (j >= nMax)
        {
             continue;
      }
      
        if (getSumdiv(i) == getSumdiv(j))
        {
               count++;
      }
  }
  
  return count;
}

Multiples of 3 or 5

#include <bits/stdc++.h>
using namespace std;
int solution(int number) 
{
   int sum_1 = 0;
   for(int i = 1; i < number; i++)
   {
      if(i % 3 == 0 || i % 5 == 0)
      {
         sum_1 += i ;
      } 
   } 

   return sum_1;
}

Pyramid Array

#include <vector>
#include <cstdlib>
using namespace std;
vector<vector<int>> pyramid(size_t n) {
     vector<vector<int>> ans;
     vector<int> vectemp;
     int i = 0;
     while(i < n)
     {
         vectemp.push_back(1);
         ans.push_back(vectemp);
         i++;
     }
  
     return ans;
}

The Supermarket Queue

import java.util.Arrays;
public class Solution {
    public static int solveSuperMarketQueue(int[] customers, int n) {
        int len = customers.length;
        if (len == 0 || n == 0)
            return 0;
        int res = 0;
 
        // 如果人数过少, 直接取最大值
        if (len < n) {
            res = customers[0];
            for (int i = 1; i < len; i++) {
                if (customers[i] > res)
                    res = customers[i];
            }
            return res;
        }
 
        int start = 0, end = n;
        while (end < len) {
            int min = customers[start];
            for (int i = start + 1; i < end; i++) {
                if (customers[i] > 0 && min > customers[i])
                    min = customers[i];
            }
 
            res += min;
            for (int i = start; i < end; i++) {
                if (customers[i] != 0)
                    customers[i] -= min;
            }
 
            while (customers[start] == 0) {
                start++;
            }
 
            int k = 1;
            int count = 1;
 
            // 非0值计数
            while (count < n) {
                if (start + k >= len) {
                    end = start + k;
                    break;
                }
                if (customers[start + k] != 0)
                    count++;
                k++;
            }
 
            end = start + k;
        }
        // 最后一组取最大值
        int max = customers[start];
        for (int i = start + 1; i < len; i++) {
            if (customers[i] > max)
                max = customers[i];
        }
        res += max;
        return res;
    }
}

IPv4 to int32

def ip_to_int32(ip):
    flag=''
    ip_list=ip.split('.')
    for i in ip_list:
        temp=str(bin(int(i))[2:])  #bin()转换之后，字符自动就成为字符串
        length=len(temp)
        if length!=8:
            temp=(8-length)*'0'+temp
        flag+=temp
    decimal=int(flag,2)
    return decimal

Spiral Column Addition

#include <algorithm>

using ull = unsigned long long;

ull spiral_column(unsigned int n, unsigned int col) {
  ull d = std::min(col - 1, n - col);
  ull m = n - d * 2;                                 // m: size of innermost subsquare containing column
  ull s = 4 * d * (n - d);                           // s: shift in value of the innermost subsquare
  ull r = d == col - 1                               // r: the sum of the column of the innermost subsquare,
            ? s * m + 1 + (7 * m - 6) * (m - 1) / 2  //    which will coincide with either leftmost or rightmost
            : s * m + (3 * m - 1) * m / 2;           //    column of the subsquare.
  ull k = (n - m) / 2;                               // Sum the remaining values of the column, using the symmetry:
  return r                                           //  1    ..  a  ..   n
         + k * (3 * (m + k + 1) - 1)                 // 4n-4  ..         n+1      a + b = 3 * n - 1
         - 4 * k * (k + 1) * (2 * k + 1) / 3         //  .                .       where a and b is on the same column
         + 4 * k * (k + 1) * (2 * d - n)             // 3n-1              .
         + 8 * k * d * (n - d);                      // 3n-2  ..  b  ..  2n-1
}

Persistent Bugger.

#include <bits/stdc++.h>
using namespace std;

int persistence(long long n ){
     // string str = to_string(n);
   if (n<10)
   {
       return 0;
   }
    string str;
    int count =0;
    int sum = n;
    int i = 0,k =1;
    while(sum>=10)
    {    
        k =1;
        str = to_string(sum);
        for(i =0 ; i<str.length(); i++)
        {
           k *= (str[i]-'0');
        }  
        count++;
        sum =k;
    }
    
    return count;
}

Convert string to camel case

#include <string>
std::string to_camel_case(std::string text) {
int i,j,k,n;
  for(i=0;i<text.length();i++)
  {
        if( (text[i] == '_' || text[i] == '-')  && text[i+1] >= 'a' && text[i+1] <= 'z')
        {
           text[i+1] =  text[i+1] - 32;    
      }
  }
  
  text.erase(remove(text.begin(), text.end(), '_'), text.end());
  text.erase(remove(text.begin(), text.end(), '-'), text.end());

  return text;
}

Bit Counting

#include <bits/stdc++.h>
using namespace std;
unsigned int countBits(unsigned long long n){
    int result = 0;
        while(n != 0){
            if(n % 2){
                result++;
            }
            n /= 2;
        }
        return result;
}

Sum of Digits / Digital Root

#include <bits/stdc++.h>
using namespace std;
int digital_root(int n)
{   
    string str = to_string(n);
    int sum = 0;
    int i = 0;
    for(i =0 ; i<str.length(); i++)
    {
        sum += (str[i]-'0');
    }
        if(sum>=10)
        {
          return digital_root(sum);
        }
        else 
       {
           return sum;
       }
}

Kyu 5

Moving Zeros To The End

#include <vector>
using namespace std; 
vector<int> move_zeroes(const vector<int>& input) {
   vector<int> ans;
   int i,count = 0 ;
   for ( i = 0; i< input.size(); i++)
   {
        if(input[i] != 0)
        {
            ans.push_back(input[i]);
     }
     else 
      count++;
   }
   
   for(i=0; i<count;i++)
   {
         ans.push_back(0);
   }
   
   return ans;
}

Josephus Permutation

#include <bits/stdc++.h>
using namespace std;

vector < int> josephus( vector <int> items, int k) {
  vector <int>  vecans;
  vector <int>::iterator it = items.begin();
  int vsize = items.size(); 
  int i = 0;
  int loop,temp;
  
    int count = 0;
    while (items.size() > 0) {
        count = (count + k - 1) % items.size(); 
        temp =  *(it + count);
        
        items.erase(it + count);
        vecans.push_back(temp);
    }

   return vecans;
}

Integers: Recreation One

#include <utility>
#include <bits/stdc++.h>
#include <vector>
using namespace std;

unsigned long long getSumdiv(int n)
{
   unsigned long long sum = 0; 
  for(int i=1 ; i<=sqrt(n);++i)
  {
    if(n%i==0)
    {
      if(n/i == i)
      {   
          sum+=( i * i);
      }
      else
      {   
        sum+= ( i * i);
        sum+= ((n/i) * (n/i));
      }
    }
  }
  return sum ;
} 
 
float A(float a)
{   
    if(a-(int)a==0)
    return 0;
    else
    {
    return 1;
    }
}

class SumSquaredDivisors
{
public:
    
    static vector<pair<long long, long long>> listSquared(long long m, long long n);
};

 vector<pair<long long, long long>> SumSquaredDivisors::listSquared(long long m, long long n)
 {
    long long i;
    long long k = 0, kk;
    vector<pair<long long, long long>> vecAns;
     for (i = m ; i <= n; i++)
     {
         k = getSumdiv(i);
      kk = sqrt(k);
         if (A(kk)== 0 && kk*kk == k)
         {
             vecAns.push_back(make_pair(i,k));
             cout<<i<<" "<<k<<endl;; 
        }
    }
      return vecAns;
 }

Simple Pig Latin

#include <bits/stdc++.h>
using namespace std;

void SplitString(const string& s, vector<string>& v, const string& c)
{
     string::size_type pos1, pos2;
     pos2 = s.find(c);
     pos1 = 0;
     while(string::npos != pos2)
     {
         v.push_back(s.substr(pos1, pos2-pos1));

         pos1 = pos2 + c.size();
         pos2 = s.find(c, pos1);
     }
     if(pos1 != s.length())
         v.push_back(s.substr(pos1));
}

string pig_it(string str)
{   
    vector<string> vecans;
    string strr = "";
    SplitString(str, vecans, " ");
    ostringstream  oss;
    int i = 0;
    for(i = 0; i < vecans.size(); i++)
    {
        if ( ( vecans[i][0] >= 'a' && vecans[i][0] <= 'z' ) ||  ( vecans[i][0] >= 'A' && vecans[i][0] <= 'Z' ) )
        {   
             vecans[i] +=  vecans[i][0];
             vecans[i] +=  "ay";
             vecans[i].erase(0,1);
        }
        oss <<  vecans[i] << " ";
        
    }
     
    strr = oss.str();
    strr.erase(strr.length()-1);
    return strr;
    
}

Buddy Pairs

#include <bits/stdc++.h>
using namespace std;
unsigned long long getSumdiv(int n)
{
    unsigned long long sum = 0; 
    for(int i=1;i<sqrt(n);++i)
    {
        if(n%i==0)
        {
            if(n/i == i)
            {   
                sum+=i;
            }
            else
            {   
                sum+=i;
                sum+=n/i;
            }
        }
            
    }
    return sum - n;
} 
namespace Bud
{
    string buddy(long long start, long long limit)
    {   
         string ans ="";
         for (int i = start; i<= limit; i++ )
         {  
            int k = getSumdiv(i) - 1;
            if( k <= i)
            {
                continue;
            }
            if( getSumdiv(i) - 1 == k && getSumdiv(k) - 1 == i  )
            {
                 ans+="(" + to_string(i) + " " + to_string(k) + ")";
                 break;
            }
         }
         
         if( ans.length() == 0)
         {
            return "Nothing";
         }
      
         return ans;
    }
}

Greed is Good

function score( dice ) {
     var diceR = [0,0,0,0,0,0] ;
     var tdr = [1000,200,300,400,500,600] ;
     var sdr = [100,0,0,0,50,0] ;
     dice.forEach(function(item){
       diceR[item -1] ++ ;
     })
  return   diceR.reduce(function(prev,cur,index){
         return prev + ( cur >= 3 ? tdr[index] : 0)+ sdr[index] * (cur%3) ;
    },0)
}

RGB To Hex Conversion

using namespace std;
class RGBToHex
{
  public:
  static std::string rgb(int r, int g, int b);
};

string RGBToHex::rgb(int r, int g, int b)
{   
  if(r>255)
    r=255;
   if(g>255)
    g=255;
    if(b>255)
    b=255;
  string ans ="", tempans = "00" ;
    int i=0,n,m,num[100];
    char hex[16]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
     
    while(r>0){
        num[i++]=r%16;
        r=r/16;
    }
    for(i=i-1;i>=0;i--){
        m=num[i];
        tempans[1-i] = hex[m];
         
    }
    ans+=tempans;
    i=0;
    tempans ="00";
      while(g>0){
        num[i++]=g%16;
        g=g/16;
    }
    for(i=i-1;i>=0;i--){
        m=num[i];
        tempans[1-i] = hex[m];
    
    }
        ans+=tempans;
    i=0;
    tempans ="00";
      while(b>0){
        num[i++]=b%16;
        b=b/16;
    }
    for(i=i-1;i>=0;i--){
        m=num[i];
        tempans[1-i] = hex[m];
    
    }
        ans+=tempans;
   return ans;
}

Kyu 4

Mystery Function

#include <vector>
#include <bits/stdc++.h>

using namespace std; 

unsigned long long  mystery(unsigned long long  n){
  int i = 0, count =0;
  // n = n-1; 
  if (n == 1)
  {
      return 1;
  }
  else if (n == 0)
  {
      return 0;
  }
  unsigned long long  temp = n;
  while(temp > 0)
  {
    temp /= 2;
    count++;
  } 
  unsigned long long  k = pow(2,count);
  return mystery(k - n - 1) + pow(2, count - 1);
   
}

unsigned long long  mysteryInv(unsigned long long  n){
  unsigned long long  temp = n;
  int i = 0, count =0;
  if (n == 1)
  {
      return 1;
  }
  else if (n == 0)
  {
      return 0;
  }
 
  while(temp > 0)
  {
    temp /= 2;
    count++;
  }
  
  unsigned long long  k =  pow(2, count - 1); 
  return 2 * k - 1 - mysteryInv(n - k);
}

string nameOfMystery(){
  return "Gray code";
}

Roman Numerals Helper

#include <string>
#include <bits/stdc++.h>

using namespace std; 
class RomanHelper{
  public:
    std::string to_roman(unsigned int n){
               string ans="";
     int ori = n;
     int i,a,b;
     map<int,string> maptrs;
     maptrs.insert(make_pair(1,"I"));
     maptrs.insert(make_pair(4,"IV"));
     maptrs.insert(make_pair(5,"V"));
     maptrs.insert(make_pair(9,"IX"));
     maptrs.insert(make_pair(10,"X"));
     maptrs.insert(make_pair(40,"XL"));
     maptrs.insert(make_pair(50,"L"));
     maptrs.insert(make_pair(90,"XC"));
     maptrs.insert(make_pair(100,"C"));
     maptrs.insert(make_pair(400,"CD"));
     maptrs.insert(make_pair(500,"D"));
     maptrs.insert(make_pair(900,"CM"));
     maptrs.insert(make_pair(1000,"M"));
    
    map<int,string>::iterator it = maptrs.end() ;
    it--;
    do
    {
        a = n / it->first;
        b = n % it->first;
        n -= (a * it->first);
        for(i =0; i< a; i++)
        {
            ans+=it->second;
            cout<<it->second<<endl;
        }
        
        it--;
    } while(it != maptrs.begin() );
    
    for (i = 0; i < n; i++)
    {
        ans+="I";
    }
    
    return ans;
    
    
    }
  
  
    int from_roman(std::string rn){
     int i,sum =0;
    rn += " ";
    map<char,int> maptrs;
     maptrs.insert(make_pair('I',1));
     maptrs.insert(make_pair('V',5));
     maptrs.insert(make_pair('X',10));
     maptrs.insert(make_pair('L',50));
     maptrs.insert(make_pair('C',100));
     maptrs.insert(make_pair('D',500));
     maptrs.insert(make_pair('M',1000));
     
    for (i=0;i<rn.length();i++)
    {   
       if( ( maptrs[rn[i]] >= maptrs[rn[i+1]] ) &&  ( ' ' !=  rn[i+1] ) )
       {
              sum+=(maptrs[rn[i]]);
       }
       else if ( ( maptrs[rn[i]] < maptrs[rn[i+1]] ) &&  ( ' ' !=  rn[i+1] ) )
       {
             sum+=( maptrs[rn[i+1]] - maptrs[rn[i]] );
             i++;
       }
       else 
       {
           sum+=(maptrs[rn[i]]);
       }
 
    }  
    return sum;
    }
} RomanNumerals;

Human readable duration format

#include <string>
#include <bits/stdc++.h>

using namespace std;
string format_duration(int seconds) {
  
  ostringstream  oss;
  if (seconds == 0)
  {
      return "now"  ;
  }
  
  int year = 365 * 24 * 60 * 60;
  int day = 24 * 60 * 60;
  int hour = 60 * 60;
  int min = 60;
  int sec = 1;
  int count = 0;
  if(seconds/year > 0)
  {  
     int yearnum = seconds/year;
     seconds -=  yearnum * year;
       count++;
       if(yearnum > 1)
       {
            oss<<to_string(yearnum)<<" years, ";
       }
       else
       {
            oss<<to_string(yearnum)<<" year, ";
       }
  }
  
  if(seconds/day > 0)
  {
       int daynum = seconds/day;
     seconds -=  daynum * day;
       count++;
        if(daynum > 1)
       {
            oss<<to_string(daynum)<<" days, ";
       }
       else
       {
            oss<<to_string(daynum)<<" day, ";
       }
  }
  
  if(seconds/hour > 0)
  {
       int hournum = seconds/hour;
     seconds -=  hournum * hour;
       count++;
        if(hournum > 1)
        {
            oss<<to_string(hournum)<<" hours, ";
       }
       else
       {
            oss<<to_string(hournum)<<" hour, ";
       }
  }
  
  if(seconds/min > 0)
  {
       int minnum = seconds/min;
     seconds -=  minnum * min;
       count++;
        if(minnum > 1)
       {
            oss<<to_string(minnum)<<" minutes, ";
       }
       else
       {
            oss<<to_string(minnum)<<" minute, ";
       }
  }
 
  int secnum = 0;
  if(seconds/sec > 0)
  {
       int secnum = seconds/sec;
       seconds -=  secnum * sec;
       count++;
       if(secnum > 1)
       {
            oss<<to_string(secnum)<<" seconds";
       }
       else
       {
            oss<<to_string(secnum)<<" second";
       }
  }
  
  string str = oss.str();
  
   if(str[str.length() - 2] == ',')
  {
      str.erase(str.length() - 2);
  }
  
  
  if (count >= 2)
  { 
    int pos = str.find_last_of(",");
    str.erase(pos,1);
      str.insert(pos , " and");
  }
 
  return str;
  // your code here
}

Kyu 3

Kyu 2

未完待续。。。。