使用自定义进制（62位），可以用于加密文本。

已于 2022-09-12 03:30:03 修改
阅读量351 收藏 1
点赞数
分类专栏： 文本加密 文章标签： java c++ 开发语言
于 2022-09-12 03:17:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42944928/article/details/126812161
版权

例子：

           StringList_ sl = new StringList_();
            for(int i = 0; i < 100; i++)
            {
                sl.Add(lg.SN10ToSN62(i));
            }

            lg.ShowDialogText(sl.ToString(","));

结果：

       //system of numeration (进制)  
       //0123456789 10                                               6061
       public const string SN62 =    "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; //62进制表示


        //十进制数是组成以10为基础的数字系统，有0，1，2，3， 4， 5， 6， 7， 8， 9十个基本数字组成。十进制，英文名称为Decimal System
        //来源于希腊文Decem，意为十。十进制计数是由印度教教徒在1500年前发明的，由阿拉伯人传承至11世纪。
        //十六进制（hexadecimal）是计算机中数据的一种表示方法。它的规则是“逢十六进一”。

        /// <summary>
        /// 把十进制数转为62进制       
        /// </summary>
        /// <param name="iValue">十进制整数值</param>
        /// 创建时间： 2020-04-26      最后一次修改时间：2020-04-26
        /// <returns>返回62进制字符串</returns>
        public static string SN10ToSN62(int iValue)
        {
            if (iValue == 0)  return "0";            
             
            int iTemp = (iValue > 0 ? iValue : - iValue);

            string sResult = "";

            while (iTemp != 0)
            {
                int n = iTemp % 62;   
                sResult += SN62[n];
                iTemp = iTemp / 62;
            }

            sResult = sResult._reversal();

            return  iValue > 0 ? sResult : "-" + sResult;
        }



        /// <summary>
        /// 把62进制字符串转为十进制整数    
        /// </summary>
        /// <param name="sValue"></param>
        /// 创建时间： 2020-04-25      最后一次修改时间：2020-04-25
        /// <returns></returns>
        public static int SN62ToSN10(string sValue)
        {
            if(sValue.Length == 0)
            {
                throw new Exception("错误的数字！");
            }
   
            string sTemp = (sValue[0] == '-' ?  sValue.Substring(1, sValue.Length - 1) : sValue)._reversal();

            int iResult = 0;
            int iExp = 0;
                   

            foreach(char c in sTemp)
            {
                int n = SN62.IndexOf(c);

                if(n == -1)
                {
                    throw new Exception("错误的62进制数！");
                }    

                iResult +=  n  *  LMath.Pow(62, iExp);

                ++iExp;
            }


            return sValue[0] == '-' ? - iResult : iResult;

        }


      /// <summary>
        /// 把密文解密成明文，如果解密不成功，则回原字符串
        /// </summary>
        /// <param name="sEncryptText"></param>
        /// <returns>成功返回明文，失败返回原字符串</returns>
        /// 创建时间： 2020-04-27      最后一次修改时间：2020-05-15
        public static string TextDecrypt2(string sEncryptText)
        {
            //int 类型的最大值是:2147483647 

            //a~z 97-122   A~Z 65-90  0~9 48-57

            // 字符串长度数值占用的字符位  + (字符串长度)  +   原字符值与字符串长度之和占用的字符位 + (字符值 + 字符串长度)  +  加密字符值总和  + 加密字符值总和占用的字符位(永远1位)

            //  a
            //  1                      +    1        + 2                                + (97+1)


            if (sEncryptText.Length < 5) //不能少于5位，空字符是：101z2
                return sEncryptText;


            //加密字符值总和占用位

            string sCountLength = sEncryptText[sEncryptText.Length - 1].ToString();

            if(!lg.IsSN62Number(sCountLength))
            {
                return sEncryptText;
            }


            int iCountLength = SN62ToSN10(sCountLength);//加密字符值总和占用位

           


            if (iCountLength > sEncryptText.Length - 1 || iCountLength < 0)
            {
                lg.ShowInfo("iCountLength > sEncryptText.Length - 1 || iCountLength < 0");
                return sEncryptText;
            }

                                   
            

            string sCount = sEncryptText.Substring(sEncryptText.Length - 1 - iCountLength, iCountLength);


            //----------------------------------------------------------------2020-05-15加入
            // (1)  10进制 int类型的最大值是:2147483647  =  62进制 2lkCB1
            // (2)   如果sCount不是62进制，则密文错误
            if (sCount.Length > 6 || !lg.IsSN62Number(sCount))   
            {
                return sEncryptText;
            }
            //------------------------------------------------------------------------------



            int iCheckValue = SN62ToSN10(sCount);


            if (iCheckValue <= 0)
            {
                lg.ShowInfo("iCheckValue <= 0");
                return sEncryptText;
            }



            //检查校验码
            string sEncryptData = sEncryptText.Substring(0, sEncryptText.Length - 1 - iCountLength);

            int iCheckValue2 = 0;

            foreach (char c in sEncryptData)
            {
                iCheckValue2 += (int)c;
            }


            if (iCheckValue2 != iCheckValue) //文件检验失败！
            {
                lg.ShowInfo("iCheckValue2 != iCheckValue");
                return sEncryptText;
            }



            //校验码已通过
            int iLengthCount = SN62ToSN10(sEncryptData[0].ToString());



            //  if (iLengthCount >= sEncryptData.Length - 1) 错误： 空字符会失败
            if (iLengthCount > sEncryptData.Length - 1)
            {
                lg.ShowInfo("iLengthCount > sEncryptData.Length - 1");
                return sEncryptText;

            }


            int iTextLength = SN62ToSN10(sEncryptData.Substring(1, iLengthCount));  //明文字符串长度



            int iStart = 1 + iLengthCount;

            string sText = "";

            //一定要加等于，否则最后一个字符是加不进去的
            while (iStart <= sEncryptData.Length - 1 - iLengthCount)
            {
                int iSubLength = SN62ToSN10(sEncryptData.Substring(iStart, 1));

                if (iSubLength < 0 || iSubLength >= sEncryptData.Length)
                {
                    lg.ShowError("iSubLength < 0 || iSubLength >= sEncryptData.Length");
                    return sEncryptText;
                }
                 

                int iCharValue = SN62ToSN10(sEncryptData.Substring(iStart + 1, iSubLength)) - iTextLength;

                if (iCharValue < 0)
                {
                    lg.ShowError("iCharValue < 0");
                    return sEncryptText;
                }

                sText += System.Convert.ToChar(iCharValue);

                iStart = iStart + 1 + iSubLength;
            }



            if (sText.Length != iTextLength)
            {
                lg.ShowError("sText.Length != iTextLength");
                return sEncryptText;  //长度检查
            }


            return sText;
        }



        /// <summary>
        /// 根据密钥来解密字符串
        /// </summary>
        /// <param name="sEncryptText">加密的字符串</param>
        /// <param name="sKey">密钥(用户密码为6~16字符，可使用字母（区分大小写）、数字与特殊符号 用户密码至少包含字母、数字、符号中的两种)</param>
        /// 创建时间： 2020-04-27      最后一次修改时间：2020-04-27
        /// <returns>成功返回解密码字符串，失败返回原字符</returns>
        public static string TextDecrypt2(string sEncryptText, string sKey)
        {

            //(sText.Length的字符占位个数 +  sText.Length) + sText1 +  (sKey.Length的字符占位个数 +  sKey.Length + skey)  +  sText2;

            //关建插入点位置 InsertPos + Length + sKey
            // InsertPos = sKey所有字符相加的和 % sText.Length   //10%7=3
             

            string sDecryptText = TextDecrypt2(sEncryptText);

            if (sDecryptText.Length == 0)  //空字符
                return "";


            if (sDecryptText == sEncryptText) //失败返回原字符
                return sEncryptText;

            int nTextLengthCount = lg.SN62ToSN10(sDecryptText[0].ToString());

            


            //当传递的字符串是不带sKey的加密串时
            if (sDecryptText.Length.ToString().Length < nTextLengthCount) //母字符串的长度的占位数小于子字符串的长度的占位数是错误的
            {
                return sEncryptText;
            }

            if (nTextLengthCount <= 0) //占位最少是1
            {
                return sEncryptText;
            }


            int nTextLength = lg.SN62ToSN10(sDecryptText.Substring(1, nTextLengthCount));



            if (nTextLengthCount == -1 || nTextLength == -1) //失败
                return sEncryptText;




            int nCount = 0;
            foreach (char c in sKey)
            {
                nCount += (int)c;
            }


            int nText1_Lenth = nCount % nTextLength + 1;
            int nStart = 1 + nTextLengthCount + nText1_Lenth;



            int nKeyLengthCount = lg.SN62ToSN10(sDecryptText.Substring(nStart, 1));



            //nKeyLengthCount <= 2  sKey.Length的长度大小是1~15，也就是 <= 2

            if (nKeyLengthCount > 2) //密钥可能不对
            {
                return sEncryptText; //返回原字符

            }



            int nKeyLength = lg.SN62ToSN10(sDecryptText.Substring(nStart + 1, nKeyLengthCount));



            if (nKeyLengthCount == -1 || nKeyLength == -1) //失败
                return sEncryptText;


            string sCheckKey = lg.resumeCode(sDecryptText.Substring(nStart + 1 + nKeyLengthCount, nKeyLength));

            if (sCheckKey != sKey)    //失败
            {
                //return sEncryptText;
                return "密码不正确！";
            }


            string s1 = lg.resumeCode(sDecryptText.Substring(1 + nTextLengthCount, nText1_Lenth));
            string s2 = lg.resumeCode(sDecryptText.Substring(nStart + 1 + nKeyLengthCount + nKeyLength, nTextLength - nText1_Lenth));


            return s1 + s2;

        }



   /// <summary>
        /// 随便打乱字符串，防止一眼就能看清内容,加1取反
        /// </summary>
        /// <param name="aStr"></param>
        /// <returns></returns>
        public static string messCode(string aStr)
        {
            string tmp = "";

            for (int i = 0; i < aStr.Length; ++i)
            {
                tmp += (char)(~((int)aStr[i] + 1));
            }
            return tmp;
        }



        /// <summary>
        ///还原打乱字符串
        /// </summary>
        /// <param name="aStr"></param>
        /// <returns></returns>
        public static string resumeCode(string aStr)
        {
            string tmp = "";

            for (int i = 0; i < aStr.Length; ++i)
            {
                tmp += (char)(~((int)aStr[i]) - 1);
            }
            return tmp;
        }


        /// <summary>
        /// 把字符串加密成密文
        /// </summary>
        /// <param name="aPassword"></param>
        /// 创建时间： ????-??-??      最后一次修改时间：2020-01-06(已丢弃)
        /// <returns></returns>
        public static string Rubbish_passwordEncrypt(string aPassword)
        {
            string mc = messCode(aPassword);

            string tmp = "";

            for (int i = 0; i < mc.Length; ++i)
            {
                tmp += ((int)mc[i] + i * 100).ToString();

                if (i < mc.Length - 1)
                    tmp += ',';
            }

            return tmp;
        }

        /// <summary>
        /// 把字符串译成明文
        /// </summary>
        /// <param name="aPassword"></param>
        /// 创建时间： ????-??-??      最后一次修改时间：2020-01-06(已丢弃)
        /// <returns></returns>
        public static string Rubbish_passwordRevert(string aPassword)
        {
            string[] sList = aPassword.Split(',');


            string tmp = "";

            for (int i = 0; i < sList.Length; ++i)
            {
                tmp += (char)(System.Convert.ToInt32(sList[i]) - (i * 100));
            }

            return resumeCode(tmp);
        }


        /// <summary>
        /// 把正整数的个数，十位、百位等等都用英文表示：例：256 => cFg  123 => bCd
        /// </summary>
        /// <param name="iNumber">正整数</param>
        /// 创建时间： 2020-04-05      最后一次修改时间：2020-04-06
        /// <returns>英文表示的数字</returns>
        public static string NumberShowToEnglishAlphabet(int iNumber)
        {
            //a~z 97-122   A~Z 65-90  0~9 48-57

            if (iNumber < 0)
                return "";

            string sResul = "";

            string sNumber = iNumber.ToString();


            for (int i = 0; i < sNumber.Length; ++i)
            {
                if (i % 2 == 0)
                    sResul += System.Convert.ToChar((int)sNumber[i] + 97 - 48); //小写字母
                else
                    sResul += System.Convert.ToChar((int)sNumber[i] + 65 - 48); //大写字母
            }


            return sResul;
        }

        /// <summary>
        /// 把英文表示的非负数还原成真实的数字，不成功返回-1.  例： 123 => abc   abc = > 123
        /// </summary>
        /// <param name="sEnglishAlphabet"></param>
        /// 创建时间： 2020-04-05      最后一次修改时间：2020-04-06
        /// <returns></returns>
        public static int EnglishAlphabetToNumber(string sEnglishAlphabet)
        {
            string sNumber = "";

            for (int i = 0; i < sEnglishAlphabet.Length; ++i)
            {
                if (i % 2 == 0)
                    sNumber += ((int)sEnglishAlphabet[i] - 97).ToString();
                else
                    sNumber += ((int)sEnglishAlphabet[i] - 65).ToString();
            }

            if (!lg.isNumberString(sNumber))
                return -1;

            return System.Convert.ToInt32(sNumber);
        }


        /// <summary>
        /// 是否62进制数
        /// </summary>
        /// <param name="sValue"></param>
        /// 创建时间： 2020-04-27      最后一次修改时间：2020-04-27
        /// <returns></returns>
        public static bool IsSN62Number(string sValue)
        {
            if (sValue == "")
                return false;

            foreach(char c in sValue)
            {
                if (SN62.IndexOf(c) == -1)
                    return false;
            }
            return true;
        }



        /// <summary>
        /// 把字符串按一定格式加密
        /// </summary>
        /// <param name="sText">明文字符串</param>
        /// 创建时间： 2020-04-05      最后一次修改时间：2020-04-27
        /// <returns>返回加密的字符串</returns>
        public static string TextEncrypt(string sText)
        {
            //a~z 97-122   A~Z 65-90  0~9 48-57

            // 字符串长度数值占用的字符位  + (字符串长度)  +   原字符值与字符串长度和占用的字符位 + (字符值 + 字符串长度)  +  加密字符值总和  + 加密字符值总和占用的字符位

            //  a
            //  1                      +    1        + 2                                + (97+1)


            string sResult = "";
        
            int iLength = sText.Length;

            string sLength = NumberShowToEnglishAlphabet(iLength);
            string sLengthCount = NumberShowToEnglishAlphabet(sLength.Length);

            sResult += sLengthCount;
            sResult += sLength;


            foreach (char c in sText)
            {
                int iCharValue = (int)c;

                string sTemp = NumberShowToEnglishAlphabet(iCharValue + iLength);
                sResult += NumberShowToEnglishAlphabet(sTemp.Length);

                sResult += sTemp;

            }

            int iCheckValue = 0;

            foreach (char c in sResult)
            {
                iCheckValue += (int)c;
            }


             

            string sCheckValue = NumberShowToEnglishAlphabet(iCheckValue);

            sResult += sCheckValue;

            sResult += NumberShowToEnglishAlphabet(sCheckValue.Length);



            return sResult;
        }





        /// <summary>
        /// 创建时间： 2020-04-05      最后一次修改时间：2020-04-19
        /// 把密文解密成明文，如果解密不成功，则回原字符串
        /// </summary>
        /// <param name="sEncryptText"></param>
        /// <returns>成功返回明文，失败返回原字符串</returns>
        public static string TextDecrypt(string sEncryptText)
        {
            //int 类型的最大值是:2147483647 

            //a~z 97-122   A~Z 65-90  0~9 48-57

            // 字符串长度数值占用的字符位  + (字符串长度)  +   原字符值与字符串长度之和占用的字符位 + (字符值 + 字符串长度)  +  加密字符值总和  + 加密字符值总和占用的字符位

            //  a
            //  1                      +    1        + 2                                + (97+1)


            if (sEncryptText.Length < 6) //不能少于6位，空字符是：babJfd
                return sEncryptText;


            int iCountLength = EnglishAlphabetToNumber(sEncryptText[sEncryptText.Length - 1].ToString());



            if (iCountLength > sEncryptText.Length - 1 || iCountLength < 0)
            {

                //lg.ShowInfo("iCountLength > sEncryptText.Length - 1 || iCountLength < 0");
                return sEncryptText;
            }



            int iCheckValue = EnglishAlphabetToNumber(sEncryptText.Substring(sEncryptText.Length - 1 - iCountLength, iCountLength));


            if (iCheckValue <= 0)
            {
                //lg.ShowInfo("iCheckValue <= 0");
                return sEncryptText;
            }



            //检查校验码
            string sEncryptData = sEncryptText.Substring(0, sEncryptText.Length - 1 - iCountLength);

            int iCheckValue2 = 0;

            foreach (char c in sEncryptData)
            {
                iCheckValue2 += (int)c;
            }


            if (iCheckValue2 != iCheckValue) //文件检验失败！
            {
                return sEncryptText;
            }



            //校验码已通过
            int iLengthCount = EnglishAlphabetToNumber(sEncryptData[0].ToString());



            //  if (iLengthCount >= sEncryptData.Length - 1) 错误： 空字符会失败
            if (iLengthCount > sEncryptData.Length - 1)
            {
                return sEncryptText;

            }


            int iTextLength = EnglishAlphabetToNumber(sEncryptData.Substring(1, iLengthCount));  //明文字符串长度



            int iStart = 1 + iLengthCount;

            string sText = "";

            //一定要加等于，否则最后一个字符是加不进去的
            while (iStart <= sEncryptData.Length - 1 - iLengthCount)
            {
                int iSubLength = EnglishAlphabetToNumber(sEncryptData.Substring(iStart, 1));

                if (iSubLength < 0 || iSubLength >= sEncryptData.Length)
                {
                    lg.ShowError("iSubLength < 0 || iSubLength >= sEncryptData.Length");
                    return sEncryptText;
                }

                int iCharValue = EnglishAlphabetToNumber(sEncryptData.Substring(iStart + 1, iSubLength)) - iTextLength;

                if (iCharValue < 0)
                {
                    lg.ShowError("iCharValue < 0");
                    return sEncryptText;
                }

                sText += System.Convert.ToChar(iCharValue);

                iStart = iStart + 1 + iSubLength;
            }



            if (sText.Length != iTextLength)
            {
                lg.ShowError("sText.Length != iTextLength");
                return sEncryptText;  //长度检查
            }


            return sText;
        }
碧海蓝天2022
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mysql 62位进制转换_IPv4/IPv6 双栈网络测试 - 知识图谱PHP 62进制转换函数_running8的博客-CSDN博客_php 转62进制...
weixin_34951416的博客
02-07 274
PHP 62进制转换函数_running8的博客-CSDN博客_php 转62进制PHP 62进制转换函数_running8的博客-CSDN博客_php 转62进制running8CSDN认证博客专家CSDN认证企业博客授予每个自然月内发布4篇或4篇以上原创或翻译IT博文的用户。不积跬步无以至千里，不积小流无以成江海，程序人生的精彩需要坚持不懈地积累！勤写标兵Lv1授予每个自然周发布1篇到3篇原创...
解密加密可加密各种文件和文本
09-05
可解密加密任何二进制文本文件（意思是几乎可以加密任何文件），输入自定义密码，经过16次修改，加入各种锁相，密码长度可达30位，必须输入公共密钥才能打开和解码文件，类似英格玛加密，并且压缩占用空间也达到极致...
【进制转换】JAVA自带任意进制间进行相互转换、超长2进制转10进制、进制补零、位运算（2进制-36进制自定义——亲测好用）
Chen_chenjiasheng的博客
03-28 1952
public class Main2 { public static void main(String[] args) { /** * int 转 String */ int i = 10; // 十进制转成十六进制： String string = Integer.toHexString(i); // 十进制转成八进制 String string1 = Intege.
10进制转62进制详细公式是
weixin_35754962的博客
02-13 477
62 进制转换成 10 进制的公式是： N10 = N62[62^(m-1)] + N62[62^(m-2)] + ... + N62[62^1] + N62[62^0] 其中，N10 是 10 进制下的数字，N62 是 62 进制下的数字，m 是 N62 的位数。 62 进制转换成 10 进制时，每一位数字 N62[i] 乘以 62 的 (m-i-1) 次方，再把所有结果相加即可得到 10 进制...
记录见过的一些简单密码和编码
qq_37441404的博客
11-22 4394
棋盘密码 12——B，34——O，24——I/J（这里要注意），非常的简单 变种（又称ADFGX密码）： 对应法则与上面的一样。 猪圈密码（共济会密码） 变种1： 变种2： 没什么好说的，记就完了。 例题：跳转提示 下载得到一个很怪的东西 根据最后的等号猜测是base64编码，因为题目明示了是猪圈密码，所以应该是base64转图片 再对照上面的表flag就出来了 。 栅栏密码 所谓栅栏密码，就是把要加密的明文分成N个一组，然后把每...
C#编写DES加密、解密类
09-03
2. **Encrypt(string Text, string sKey)**：此方法允许用户自定义密钥`sKey`来加密文本。它首先将输入的字符串转换为字节数组`inputByteArray`，然后使用`ASCIIEncoding.ASCII.GetBytes()`方法将密钥`sKey`哈希为MD...
超大文本阅读器下载PilotEdit
03-08
实测打开16G大文本，功能强大 1. 支持大文件。您可以用它来编辑，上传，下载...14.基于256位AES的文件加密和解密的功能。可以一次对多个文件和目录加密。 15.排序，查找/删除重复的行。 16.强大的文件比较和并功能 ...
基于Java实现的Base64加密、解密原理代码
09-04
Base64是一种常见的数据编码方式，它主要用于将任何可打印的ASCII字符转换成一组可安全地在文本格式下传输的字符。在Java中，Base64编码和解码可以通过内置的`java.util.Base64`类来实现。下面将详细解释Base64的...
详解C#实现MD5加密的示例代码
08-31
此外，还展示了自定义方法`GetMD5()`，它使用`MD5CryptoServiceProvider`进行哈希计算，然后将结果转换为16进制字符串。 ```csharp using System; using System.Security.Cryptography; public static string ...
10进制和62进制互转工具类
02-21
此文件为进制转换工具类，用于10进制和62进制互转，帮助大家解决问题
python怎么自定义进制_python的基础语法和进制
weixin_39714164的博客
12-21 440
python的基础语法和进制1，注释及多行注释注释：在pycharm中，在需要注释的文字前加上一个#那么这句话便被注释了，在程序中不会参与执行多行注释：在pycharm中‘’‘ ’‘’或者“”“ ”“”即可进行多行注释2，语句一条有效代码就是一条语句3，行和缩进如果一行语句很长，换行时需要使用反斜杠连接例：age = 1 + 2 + \3 + 4 + 5python是通过缩进和冒号来产生代码块的，...
PHP自定义多进制
alexander_phper的博客
05-10 1322
/** * 自定义多进制，根据设置的多进制字符串获取十进制对应的多进制 * @param $str 自定义的多进制字符串 * @param $num 十进制数字 * @return $xbin 对应的多进制数字 */ function xbin($str, $num){ $num = floatval($num); $x = strlen($str); $arr =
java-自定义的进制转换-可以处理缩短uuid长度的问题
want_water_fish的博客
05-31 2657
不多说，直接上代码package main;import java.util.HashMap; import java.util.Map;/** * 处理进制的工具类 **/ public class RadixUtil { final static String NAME = RadixUtil.class.getName(); /** * 产生进制的数字 **
任意进制转换(转化器，算法，类)
晨曦雨露的博客
12-08 1540
介绍 此类库支持2（二进制）到36之间任意进制的转换。 类库提供了一些常见的转换（如二进制到十进制），也支持高级的转换（如20进制到5进制） 快速使用：内置转换器 Convert.BinToDec.Convert()Convert.BinToHex.Convert()Convert.BinToOct.Convert()Convert.DecToBin.Convert()Co
62进制累加
04-10 833
private static final String[] l = {           "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",           "a", "b", "c", "d", "e", "f", "g", "h", "i", "j",          "k", "l", "m", "n", "o", "p", "q
Javascript：巧用n进制做加密与解密
甘焕的博客
11-20 1990
对于安全型较低的应用，不妨试试Javascript的n进制转换，能达到简单的对称加密效果。 1. 加密 对于数字，转换为Number进行toString操作即可，toString接受一个进制转换的参数，取值范围为1~36，如下： var x = 640520; // 将x转换为32进制 var secret = Number(x).toString(32); 得到的结果是“jhg8”，是不是有...
十进制和26进制转换算法
热门推荐
乌药ice
03-15 1万+
【问题描述】 在Excel中，列的名称是这样一个递增序列：A、B、C、…、Z、AA、AB、AC、…、AZ、BA、BB、BC、…、BZ、CA、…、ZZ、AAA、AAB…。 我们需要将上述列名序列和以下自然数序列相互转换：1、2、3、…。   【问题分析】 经过分析，我们不难发现，这是一个26进制和十进制相互转换的问题。序列A-Z依次对应序列1-26。进制转换的基本办法就是“取余法”，换算规则...
10进制与62进制互相转换
程序员
09-27 1544
package com.shinedata.util; import com.yeepay.shade.org.apache.commons.lang3.StringUtils; /** * @ClassName SystemConversionUtils 进制转换 * @Author yupanpan * @Date 2019/9/27 9:41 */ public class ...
金盾加密视频逆向 openclipboard
最新发布
07-11
1. 收集剪贴板中的内容：通过调用 openclipboard 函数，可以获取用户在金盾加密视频软件中复制的文本、图像或其他类型的数据。这样，可以实现将剪贴板中的内容展示在软件界面上的功能。 2. 分析剪贴板的数据：通过...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值