A 翻滚吧牛牛(一)
每种翻滚的长度都可以直接求出来的 直接遍历就是了

class Solution {
public:
    const double PI = acos(-1);
    double circumference(int k)
    {
        double r[]={1,sqrt(3),2,sqrt(3),1};
        double res=0;
        for(int i=0;i<k;i++){
            res+=2.0*PI*r[i%6]/6.0;
        }
        return res;
    }
};

B 牛牛的分配
先全部累加计算平均分配行不行 不行再一个个踢出最少的

   int solve(int n, int x, vector<int>& a) {
        // write code here
        long long ans=0;
        for(int i=0;i<n;++i)
        {
            ans+=a[i];
        }
        sort(a.begin(),a.end());
        int k=n;
        for(int i=0;i<n;++i)
        {
            if((ans/k)<x) {ans-=a[i];k--;}
            else break;
        }
        return k;
    }
};

C 牛牛构造等差数列
计算9种开头情况 在计算等差和遍历统计 

    #define ll long long
    int solve(int n, vector<int>& b) {
        if(b.size()<=2)return 0;
        int ans=b.size()+1;
        for(int i=-1; i<=1;++i)
            for(int j=-1;j<=1;++j) 
            {
                int p=b[0]+i, q=b[1]+j,d=q-p,cnt=!!i+!!j;
                for(int k=2;k<b.size();++k) 
                {
                    ll r=k*d+p;
                    if(abs(r-b[k])<=1)cnt+=!!abs(r - b[k]);/// 1 -1  加1   0 不加
                    else cnt=1e9;
                }
                ans=min(ans,cnt);
            }
        if(ans==b.size()+1) return -1;
        else return ans;
    }
};

D playfair
照着题意硬模拟（感谢学长提供的代码

class Solution {
public:
    /**
     * playfair加密算法
     * @param key string字符串 密钥
     * @param str string字符串 明文
     * @return string字符串
     */
    bool vis[200];
    int Map[10][10];
    string s = "";
    pair<int,int> p[30];
    string Encode(string key, string str) {
      memset(vis,0,sizeof(vis));
        memset(Map,0,sizeof(Map));
        int Len1 = key.size(), Len2 = str.size(), Len3 = 0;
        for(int i=0;i<Len2;i++)  if( str[i] == 'j' )  str[i] = 'i';
        for(int i=0;i<Len1;i++)
        {
            if( key[i] == 'j' )  key[i] = 'i';
            if( vis[key[i]-'a'] )  continue;
            s += key[i];
            Len3 ++;
            vis[key[i]-'a'] = true;
        }


        int x=0,y=0;
        for(int i=0;i<Len3;i++)
        {
            Map[x][y] = s[i]-'a';
            y++;
            if( y == 5 )  y = 0, x++;
        }
        for(int i=0;i<26;i++)
        {
            if( vis[i] || i+'a' == 'j' )  continue;
            Map[x][y] = i;
            y++;
            if( y == 5 ) y = 0, x++;
        }
         string ans = "";
        for(int i=0;i<5;i++,cout<<endl)  for(int j=0;j<5;j++)
            p[Map[i][j]] = make_pair(i,j);
        for(int i=0;i+1<Len2;i+=2)
        {
            int a = str[i] - 'a', b = str[i+1] - 'a';
            int x,y;
            if( a == b )  ans += str[i], ans += str[i+1];
            else if( p[a].first == p[b].first )
            {
                x = p[a].first;
                ans += (Map[x][ (p[a].second+1)%5 ] + 'a');
                ans += (Map[x][ (p[b].second+1)%5 ] + 'a');
            }
            else if( p[a].second == p[b].second )
            {
                y = p[b].second;
                ans += (Map[ (p[a].first+1)%5 ][y] + 'a');
                ans += (Map[ (p[b].first+1)%5 ][y] + 'a');
            }
            else
            {
                ans += (Map[ p[a].first ][ p[b].second ] + 'a');
                ans += (Map[ p[b].first ][ p[a].second ] + 'a');
            }
        }
        if( Len2%2 != 0 )  ans += str[Len2-1];

        return ans;
    }
};

E 牛牛摇骰子
小范围直接打表 大范围就应该是一直加11过去的 （后面发现只要22的表就行了

class Solution {
public:
    /**
     * 把所有询问的答案按询问顺序放入vector里
     * @param arr int整型vector 要查询坐标的数组
     * @return int整型vector
     */
    int a[100] = {0,3,4,1,2,3,2,1,2,3,2,1,4,3,2,3,4,3,2,3,4,3,2};
    vector<int> MinimumTimes(vector<int>& arr) {

        int Size=arr.size();
        vector<int> ans;
        for(int i=0;i<Size;++i)
        {
            if(arr[i]<=22)
            {
                ans.push_back(a[arr[i]]);
                continue;
            }
            int m=arr[i]%11,tmp=200000000;
            for(int j=m;j<=22;j+=11)///22范围内以加11起步可能有两个地方
            {
                tmp=min(tmp,a[j]+(arr[i]-j)/11);///要跑多少次11
            }
            ans.push_back(tmp);
        }
        return ans;
    }
};