进制转换__牛客网

Javascript

夜寻极光。

return M.toString(N).toUpperCase();

toString() 可以把把一个 Number 对象转换为一个字符串，并返回结果。

其中 toUpperCase（）可以把字符串中的小写字母换成大写

发表于 2021-08-16 19:42:29 回复(0)

C++

牛客嗷嗷

class Solution
{
public:
    /**
     * 进制转换
     * @param M int整型 给定整数
     * @param N int整型 转换到的进制
     * @return string字符串
     */
    string solve(int M, int N)
    {
        // write code here
        if (M == 0)
            return "0";

        bool f = false;
        if (M < 0)
        {
            M = -M;
            f = true;
        }

        char zf[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
        string a;

        while (M)
        {
            a.insert(a.begin(), zf[M % N]);
            M /= N;
        }

        if (f)
            a.insert(a.begin(), '-');

        return a;
    }
};

发表于 2022-03-02 18:05:11 回复(0)

Javascript

初见呀

一行代码解决

function solve( M ,  N ) {
    // write code here
    return M.toString(N).toUpperCase()
}
module.exports = {
    solve : solve
};

发表于 2021-09-04 14:47:46 回复(0)

勇敢牛牛，不怕困难！

#include <errno.h>

#define OK 1
#define ERROR -1

#define INF 0X3F3F3F3F
#define NOT !

#define DEFAULT_CAPACITY 8
#define InitStack(S) __InitStack(S, DEFAULT_CAPACITY)

typedef int Status;

// #################### 顺序栈存储结构表示与实现 ####################
typedef int SElemType;

typedef struct {
  SElemType* base;
  SElemType* top;
  size_t capacity;
} SqStack;

Status __InitStack(SqStack* S, int initialCapacity) {
  if (initialCapacity < 1) {
    printf("__InitStack ERROR: The initailCapacity %d Must be > 0!", initialCapacity);
    return ERROR;
  }
  if (!((*S).base = (SElemType*) malloc(initialCapacity * sizeof(SElemType)))) {
    printf("__InitStack Memory Overflow: %s\n", strerror(errno));
    abort();
  }
  (*S).top = (*S).base;
  (*S).capacity = initialCapacity;
  return OK;
}

int StackEmpty(SqStack* S) {
  return (*S).top == (*S).base;
}

int StackFull(SqStack* S) {
  return (*S).top - (*S).base == (*S).capacity;
}

size_t StackLength(SqStack* S) {
  return (*S).top - (*S).base;
}

void __large_capacity(SqStack* S) {
  if (!((*S).base = (SElemType*) realloc((*S).base, (S->capacity << 1) * sizeof(SElemType)))) {
    printf("__large_capacity Memory Overflow: %s\n", strerror(errno));
    abort();
  }
  (*S).top = (*S).base + (*S).capacity;
}

Status Push(SqStack* S, SElemType e) {
  if (StackFull(S))
    __large_capacity(S);
//   *S->top++ = e;
  *(*S).top++ = e;
  return OK;
} 

Status Pop(SqStack* S, SElemType* ret) {
  if (StackEmpty(S)) {
    puts("Pop ERROR: The stack is empty!");
    return ERROR;
  }
  *ret = *--S->top;
  return OK;
}

SElemType GetTop(SqStack* S) {
  if (StackEmpty(S)) return (-INF);
  return *((*S).top - 1);
}

Status DestroyStack(SqStack* S) {
  free((*S).base);
  (*S).top = NULL;
  return OK;
}
// #################### 顺序栈存储结构表示与实现 ####################

// 进制符号表 (字符常量 -- 即不存储在栈区也不存储在堆区，而是存储在静态区！)
static const char* SIGN = "ABCDEF"; // 10 - 15

/**
 * 进制转换
 * @param M int整型 给定整数
 * @param N int整型 转换到的进制
 * @return string字符串
 */
// Iterative
char* solve(const int M, const int N) {
  
  char* ans = (char*) calloc(50, sizeof(char));
  int x = abs(M), ansSize = 0, num;
  SqStack S;
  InitStack(&S);
  
  // 从低位到高位入栈
  while (x) {
    Push(&S, x % N);
    x /= N;
  }
  
  if (M < 0)
    *(ans + ansSize++) = '-';
  
  // 从高位到低位输出
  while (NOT StackEmpty(&S)) {
    Pop(&S, &num);
    *(ans + ansSize++) = num >= 10 ? SIGN[num - 10] : num + 48;
  }
  
  return ans;
}

void conversion(int n, const int m, char* ans, int* ansSize) {
  // recursion exit conditon
  if (n == 0) return;
  
  conversion(n / m, m, ans, ansSize);
  *(ans + (*ansSize)++) = n % m >= 10 ? SIGN[n % m % 10] : n % m + 48;
}

// Recursive
char* solveII(const int M, const int N) {
  
  char* ans = (char*) calloc(50, sizeof(char));
  int x = abs(M), ansSize = 0;
  
 if (M < 0)
   *(ans + ansSize++) = '-';
  
  conversion(x, N, ans, &ansSize);
  return ans;
}

发表于 2021-07-08 12:03:18 回复(0)

Java

牛客507555376号

import java.util.*;


public class Solution {
    /**
     * 进制转换
     * @param M int整型 给定整数
     * @param N int整型 转换到的进制
     * @return string字符串
     */
    public String solve (int M, int N) {
        if(M==0){
            return "0";
        }
        char[] nums = new char[]{'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
        StringBuilder sb = new StringBuilder();
        boolean flag = M<0;
        M = Math.abs(M);
        while(M>0){
            sb.append(nums[M%N]);
            M/=N;
        }
        String res = sb.reverse().toString();
        return flag?"-"+res:res;
    }
}

发表于 2021-06-07 12:30:35 回复(0)

C/C++

breeze_blows

循环进行求余数，得商值的方法，注意判断负数的情况

class Solution {
public:
    /**
     * 进制转换
     * @param M int整型 给定整数
     * @param N int整型 转换到的进制
     * @return string字符串
     */
    string solve(int M, int N) {
        // write code here
        string res = "";
        string digit = "0123456789ABCDEF";
        bool flag = true;
        if(M < 0){
            M = -M;
            flag = false;
        }
        while(M){
            res.push_back(digit[M%N]);
            M = M/N;
        }
        if(!flag) res.append("-");
        reverse(res.begin(), res.end());
        return res;
    }
};

发表于 2021-05-07 11:15:01 回复(0)

Python

wengJJ

Python

需要考虑正数，负数，16进制的情况

#
# 进制转换
# @param M int整型 给定整数
# @param N int整型 转换到的进制
# @return string字符串
#
class Solution:
    def __init__(self):
        self.support = {10:"A",11:"B",12:"C",13:"D",14:"E",15:"F"}
    def solve(self , M , N ):
        # write code here
        if M==0&nbs***bsp;N==0:
            return str(0)
        result = []
#         记录原始数据 以便后面判断正负
        num = M
        M = abs(M)
        while M!=0:
            rem = M%N
            if rem>=10:
                result.append(self.support[rem])
            else:
                result.append(rem)
            M = int(M/N)
        num_str = "".join([str(x) for x in result[::-1]])
        if num<0:
            return "-"+num_str
        else:
            return num_str

发表于 2021-04-22 21:53:17 回复(0)

C/C++

BrainerGao

class Solution {
public:
    /**
     * 进制转换
     * @param M int整型 给定整数
     * @param N int整型 转换到的进制
     * @return string字符串
     */
    string solve(int M, int N) {
        string res;
        bool flag = false;
        if (M < 0) {
            M = -M;
            flag = true;
        }
        const char* a = "0123456789ABCDEF";
        while (M != 0) {
            res = a[M % N] + res;
            M /= N;
        }
        if (flag) {
            res = "-" + res;
        }
        return res;
    }
};

发表于 2021-02-21 15:18:21 回复(0)

JavaScript

飞向星辰大海

一张图解释进制转换解题思路：（ps：如果是负数，直接提取负符号即可）

/**
 * 进制转换
 * @param M int整型 给定整数
 * @param N int整型 转换到的进制
 * @return string字符串
 */
function solve( M ,  N ) {
    // write code here
    let str = '';
    let absn = Math.abs(M);
    const keyMap = {10: 'A', 11: 'B', 12: 'C', 13: 'D', 14: 'E', 15: 'F'};
    while(absn > 0) {
        let s = absn%N;
        if(keyMap[s]) {
            str += keyMap[s];
        }
        else {
            str += s;
        }
        absn = Math.floor(absn/N)
    }
    const dest = str.split('').reverse().join('') || '0';
    return M >= 0 ? dest : '-' + dest ;
}
module.exports = {
    solve : solve
};

发表于 2020-12-13 14:24:07 回复(0)

楚地夏忙

class Solution {
public:
    /**
     * 进制转换
     * @param M int整型 给定整数
     * @param N int整型 转换到的进制
     * @return string字符串
     */
    string solve(int M, int N) {
        // write code here
        string ans;
        bool flag=0;
        if(M<0)
        {
            M=-M;
            flag=1;
        }
        const char t[]={"0123456789ABCDEF"};
        while(M!=0)
        {
            ans=t[M%N]+ans;
            M/=N;
        }
        if(flag)
            ans='-'+ans;
        return ans;
    }
};

发表于 2020-12-03 22:27:11 回复(2)

Java

tornado123

import java.util.*;


public class Solution {
    // 因为要考虑到 余数 > 9 的情况，2<=N<=16.
    public static final String[] F = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"};
    
    /**
     * 进制转换
     * @param M int整型 给定整数
     * @param N int整型 转换到的进制
     * @return string字符串
     */
    public String solve (int M, int N) {
        //要考虑 M 为负数的情况
        Boolean flag = false;
        if(M < 0) {
            flag = true;
            M *= -1;
        }
        StringBuffer sb = new StringBuffer();
        int temp;
        while(M != 0) {
            temp = M % N;
            sb.append(F[temp]);
            M = M / N;
        }
        // 字符串反转
        sb.reverse();
        return (flag ? "-" : "") + sb.toString();
    }
}

发表于 2020-11-22 10:23:22 回复(0)

Java

HW柯可

import java.util.*;

public class Solution {
    public String solve (int M, int N) {
        if(M == 0) return "0";
        boolean flag = true;
        if(M < 0){
            M = - M;
            flag = false;
        }
        StringBuffer res = new StringBuffer();
        String hex = "0123456789ABCDEF";
        while(M != 0){
            res.append(hex.charAt(M % N));
            M = M / N;
        }
        return flag == true ? res.reverse().toString() : "-"+res.reverse().toString();
    }
}

编辑于 2020-09-15 11:39:41 回复(2)

C/C++

漫漫云天自翱翔

注意下负数问题，wa了一发

class Solution {
public:
    /**
     * 进制转换
     * @param M int整型 给定整数
     * @param N int整型 转换到的进制
     * @return string字符串
     */
    string solve(int M, int N) {
        // write code here
       int flag=0;
        char ch[20]{"0123456789ABCDEF"};
        if(M<0){flag=1;M=-M;}
        stack<char> s;
        while(M){
            s.push(ch[M%N]);
            M/=N;
        }
        string str="";
        while(!s.empty()){
            str=str+s.top();
            s.pop();
        }
        if(flag){
            str='-'+str;
        }
        return str;
    }
};

编辑于 2020-09-05 00:27:33 回复(0)

C++

神码_

#include <iterator>
#include <string>
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 进制转换
     * @param M int整型 给定整数
     * @param N int整型 转换到的进制
     * @return string字符串
     */
    string solve(int M, int N) {
       string s,table="0123456789ABCDEF";
       bool flag=false;
       if(M<0)
       {
        M=-M;
        flag=true;
       }
        //核心逻辑
       while(M)
       {
        int temp=M%N;
        s+=table[temp];
        M/=N;
       }
       if(flag)
       {
        s+="-";
       }
       reverse(s.begin(),s.end());
       return s;

    }
};

发表于 2023-09-27 16:18:55 回复(0)

不太可爱的程序猪

public static String solve (int M, int N) {
		
		int num = M;
		StringBuffer sb = new StringBuffer();
		boolean flag = true;
		if(num < 0) {
			num = -num;
			flag = false;
		}
		while(num > 0) {
			int a = num % N;
			if(a > 9) {
				char b = (char) (a - 10 + 'A');
				sb.append(b);
			}else {
				sb.append(a);
			}	
			num = num / N;
		}
		String result = String.valueOf(sb.reverse());
		if(!flag) {
			result = "-" + result;
		}
		return result;
    }

发表于 2023-04-12 20:52:33 回复(0)

Python

RyuAsuka

class Solution:
    supplement = {10: 'A', 11: 'B', 12: 'C', 13: 'D', 14: 'E', 15: 'F'}
    
    def solve(self , M , N ):
        result = ""
        minus = False  # 要考虑正负号，不然会死循环
        if M < 0:
            minus = True
            M = -M
        while M != 0:
            r = M % N
            if 10 <= r < 16:
                result += Solution.supplement[r]
            else:
                result += str(r)
            M //= N
        if minus:
            return "-" + result[::-1]
        else:
            return result[::-1]

发表于 2020-09-24 19:09:31 回复(0)

唐氏综合征

如下代码会通过，但是有问题，你能发现吗？

 public String solve(int M, int N) {
        if (M == 0) return "0";
        boolean isNegative = M < 0;
        M = Math.abs(M);
        StringBuilder result = new StringBuilder();
        char[] digits = "0123456789ABCDEF".toCharArray();
        while (M >= N) {
            result.insert(0, digits[M % N]);
            M /= N;
        }
        result.insert(0, M);
        return (isNegative ? "-" : "")  + result;
    }

发表于 2024-06-27 11:22:53 回复(0)

C++

感谢靓仔赏饭吃

#include <algorithm>
#include <string>
class Solution {
public:
    string solve(int M, int N) {
    string ans;
    string data;
    data="0123456789ABCDEF";
    int flag=0;
    if(M<0){
       flag=1;
       M=abs(M);
    }
    while (M/N) {
        int temp=M%N;
        ans+=data[temp];
        M=(M-temp)/N;
    }
    if(M>0){
    ans+=data[M];
    } 
    if(flag==1){
    ans+="-";    
    }
    reverse(ans.begin(), ans.end());
    return ans;
    }
};

编辑于 2024-04-09 12:08:45 回复(0)

程序员Realeo

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 进制转换
     * @param M int整型 给定整数
     * @param N int整型 转换到的进制
     * @return string字符串
     */
    public String solve (int M, int N) {
        // write code here
        String t = "0123456789ABCDEF";

        boolean isNegative = false;
        if(M < 0){
            M = -M;
            isNegative = true;
        }

        StringBuilder sb = new StringBuilder();
        while(M != 0){
            sb.append(t.charAt(M % N));
            M = M / N;
        }

        String res = sb.reverse().toString();
        if(isNegative){
            res = "-" + res;
        }
        return res;
    }
}

发表于 2024-02-02 16:49:24 回复(0)

牛客2024007号

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 进制转换
     * @param M int整型 给定整数
     * @param N int整型 转换到的进制
     * @return string字符串
     */
    public String solve (int M, int N) {
        // write code here
        StringBuilder sb = new StringBuilder();
        char ops = '+';
        if(M < 0) {
            ops = '-';
            M = -M;
        }
        int jinwei = 0;

        while(M > 0) {
            int digit = M % N + jinwei;
            jinwei = digit / N;
            digit = digit % N;
            if(digit < 10)
                sb.append(String.valueOf(digit));
            else
                sb.append((char) ('A' + digit - 10));
            M = M/N;
        }
        if(jinwei != 0) sb.append(String.valueOf(jinwei));
        if(ops == '-') sb.append('-');
        return sb.reverse().toString();
    }
}

发表于 2024-01-22 20:08:26 回复(0)

进制转换

输入

输出

输入

输出

问题信息

热门推荐

通过挑战的用户

相关试题