精华内容
下载资源
问答
  • 进制转换计算器.exe

    2021-03-09 23:37:20
    自己闲来无事做了一个基于C语言的进制转换器,可在十进制、十六进制、二进制中任意转换,方便自己平时在写代码时候的推算。
  • Radix 十进制,二进制,八进制,十六进制数相互转换计算器,采用 Rxbinding实现 用到的开源库 RxJava 2.x RxAndroid butterknife RxBinding 界面预览 APK下载 CoolApk GooglePlay
  • 使用VB编写的进制转换器,支持32位位宽数据的操作并具有以下功能: 1. 十进制 十六进制 二进制 互转 2. 左移 右移操作 (新增功能) 3. 连续地与操作, 或操作, 异或操作 (新增功能) 4. 统计结果数值中1的个数用与...
  • 使用VB编写的进制转换器,支持32位位宽数据的操作并具有以下功能: 1. 十进制 十六进制 二进制 互转 2. 左移 右移操作 3. 连续地与操作, 或操作, 异或操作 4. 统计结果数值中1的个数用与辅助测试奇偶校验 6. ...
  • Android Studio简易进制转换计算器 1、问题描述。 设计并实现一个数制转换器,能够对输入的任- -进制类型的数值转换为指定的数制类型的数值。必须实现的数制类型有二进制、八进制、十进制和十六进制四种。 2、基本...

    Android Studio简易进制转换计算器

    1、问题描述。
    设计并实现一个数制转换器,能够对输入的任- -进制类型的数值转换为指定的数制类型的数值。必须实现的数制类型有二进制、八进制、十进制和十六进制四种。
    2、基本要求:
    (1)使用Spinner 控件,列出四种数制类型,即:二进制、八进制、十进制和十六进制;
    (2)“数值”输入框,不使用Android系统提供的输入面板,进行数值输入;且只能是整数数值;
    布局代码:

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        >
        <TextView
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="进制转换器"
            android:textSize="35sp"
            android:textColor="#9900AA"/>
        <TextView
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="输入数据:"
            android:textSize="30sp"
            android:textColor="#99CCAA"/>
    
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="horizontal">
            <TextView
                android:id="@+id/tv_1"
                android:layout_width="125dp"
                android:layout_height="35dp"
                android:text="进制类型:"
                android:textSize="25sp"
                android:textColor="#000"
                />
            <Spinner
                android:id="@+id/spinner1"
                android:layout_width="240dp"
                android:layout_height="35dp"
                android:textSize="30sp"
                />
        </LinearLayout>
        <EditText
            android:id="@+id/et_shuru"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"></EditText>
        <TextView
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="输出数据:"
            android:textSize="30sp"
            android:textColor="#99CCAA"/>
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="horizontal">
            <TextView
                android:id="@+id/tv_2"
                android:layout_width="125dp"
                android:layout_height="35dp"
                android:text="进制类型:"
                android:textSize="25sp"
                android:textColor="#000"
                />
            <Spinner
                android:id="@+id/spinner2"
                android:layout_width="240dp"
                android:layout_height="35dp"
                android:textSize="30sp"
                />
        </LinearLayout>
        <EditText
            android:id="@+id/et_shuchu"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"></EditText>
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="horizontal">
        <Button
            android:id="@+id/btn_0"
            android:layout_width="70dp"
            android:layout_height="35dp"
            android:text="0"
            android:background="@drawable/btn_1"
            />
            <Button
                android:id="@+id/btn_1"
                android:layout_width="70dp"
                android:layout_height="35dp"
                android:text="1"
                android:background="@drawable/btn_1"
                />
            <Button
                android:id="@+id/btn_2"
                android:layout_width="70dp"
                android:layout_height="35dp"
                android:text="2"
                android:background="@drawable/btn_1"
                />
            <Button
                android:id="@+id/btn_3"
                android:layout_width="70dp"
                android:layout_height="35dp"
                android:text="3"
                android:background="@drawable/btn_1"
                />
        </LinearLayout>
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="horizontal">
            <Button
                android:id="@+id/btn_4"
                android:layout_width="70dp"
                android:layout_height="35dp"
                android:text="4"
                android:background="@drawable/btn_1"
                />
            <Button
                android:id="@+id/btn_5"
                android:layout_width="70dp"
                android:layout_height="35dp"
                android:text="5"
                android:background="@drawable/btn_1"
                />
            <Button
                android:id="@+id/btn_6"
                android:layout_width="70dp"
                android:layout_height="35dp"
                android:text="6"
                android:background="@drawable/btn_1"
                />
            <Button
                android:id="@+id/btn_7"
                android:layout_width="70dp"
                android:layout_height="35dp"
                android:text="7"
                android:background="@drawable/btn_1"
                />
        </LinearLayout>
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="horizontal">
            <Button
                android:id="@+id/btn_8"
                android:layout_width="70dp"
                android:layout_height="35dp"
                android:text="8"
                android:background="@drawable/btn_1"
                />
            <Button
                android:id="@+id/btn_9"
                android:layout_width="70dp"
                android:layout_height="35dp"
                android:text="9"
                android:background="@drawable/btn_1"
                />
            <Button
                android:id="@+id/btn_A"
                android:layout_width="70dp"
                android:layout_height="35dp"
                android:text="A"
                android:background="@drawable/btn_1"
                />
            <Button
                android:id="@+id/btn_B"
                android:layout_width="70dp"
                android:layout_height="35dp"
                android:text="B"
                android:background="@drawable/btn_1"
                />
    
        </LinearLayout>
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="horizontal">
            <Button
                android:id="@+id/btn_C"
                android:layout_width="70dp"
                android:layout_height="35dp"
                android:text="C"
                android:background="@drawable/btn_1"
                />
            <Button
                android:id="@+id/btn_D"
                android:layout_width="70dp"
                android:layout_height="35dp"
                android:text="D"
                android:background="@drawable/btn_1"
                />
            <Button
                android:id="@+id/btn_E"
                android:layout_width="70dp"
                android:layout_height="35dp"
                android:text="E"
                android:background="@drawable/btn_1"
                />
            <Button
                android:id="@+id/btn_F"
                android:layout_width="70dp"
                android:layout_height="35dp"
                android:text="F"
                android:background="@drawable/btn_1"
                />
        </LinearLayout>
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="horizontal">
            <Button
                android:id="@+id/btn_CE"
                android:layout_width="70dp"
                android:layout_height="35dp"
                android:text="CE"
                android:background="@drawable/btn_1"
                />
            <Button
                android:id="@+id/btn_js"
                android:layout_width="70dp"
                android:layout_height="40dp"
                android:text="计算"
                android:background="@drawable/btn_1"
                />
        </LinearLayout>
    </LinearLayout>
    
    
    
    
    
    

    按钮按压效果(btn_1.xml)代码

    在这里插入代码片<?xml version="1.0" encoding="utf-8"?>
    <selector xmlns:android="http://schemas.android.com/apk/res/android">
        <item android:state_pressed="true">
            <shape>
                <solid android:color="#CC7A00"/>
                <corners android:radius="10dp"/>
            </shape>
        </item>
        <item android:state_pressed="false">
            <shape>
                <solid android:color="#FF9900"/>
                <corners android:radius="10dp"/>
            </shape>
        </item>
    </selector>
    

    主代码(MainActivity)

    package com.example.hzljinzhi;
    import androidx.appcompat.app.AppCompatActivity;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.AdapterView;
    import android.widget.ArrayAdapter;
    import android.widget.Button;
    import android.widget.EditText;
    import android.widget.Spinner;
    public class MainActivity extends AppCompatActivity {
        Spinner spinner1,spinner2;
        EditText et_shuru,et_shuchu;
        Button btn_CE,btn_js;
        int ids[]={R.id.btn_0,R.id.btn_1,R.id.btn_2,R.id.btn_3,R.id.btn_4,R.id.btn_5, R.id.btn_6,R.id.btn_7,
                R.id.btn_8,R.id.btn_9,R.id.btn_A,R.id.btn_B,R.id.btn_C,R.id.btn_D,R.id.btn_E,R.id.btn_F};
        String  temp=null,num1=null,num2=null,num3=null,num4=null;int k;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            btn_CE=findViewById(R.id.btn_CE);
            btn_js=findViewById( R.id.btn_js);
           btn_CE.setOnClickListener(new View.OnClickListener() {
               @Override
               public void onClick(View v) {
                   et_shuru.setText("");
                   et_shuchu.setText("");
               }
           });
            for(int i=0;i<ids.length;i++){
                Button btn = findViewById(ids[i]);
    
                if(btn != null)
                    btn.setOnClickListener(new View.OnClickListener() {
                        @Override
                        public void onClick(View v) {
                            switch (v.getId()){
                               case  R.id.btn_0:
                                    et_shuru.setText(et_shuru.getText()+"0");
                                break;
                                case  R.id.btn_1:
                                    et_shuru.setText(et_shuru.getText()+"1");
                                    break;
                                case  R.id.btn_2:
                                    et_shuru.setText(et_shuru.getText()+"2");
                                    break;
                                case  R.id.btn_3:
                                    et_shuru.setText(et_shuru.getText()+"3");
                                    break;
                                case  R.id.btn_4:
                                    et_shuru.setText(et_shuru.getText()+"4");
                                    break;
                                case  R.id.btn_5:
                                    et_shuru.setText(et_shuru.getText()+"5");
                                    break;
                                case  R.id.btn_6:
                                    et_shuru.setText(et_shuru.getText()+"6");
                                    break;
                                case  R.id.btn_7:
                                    et_shuru.setText(et_shuru.getText()+"7");
                                    break;
                                case  R.id.btn_8:
                                    et_shuru.setText(et_shuru.getText()+"8");
                                    break;
                                case  R.id.btn_9:
                                    et_shuru.setText(et_shuru.getText()+"9");
                                    break;
                                case  R.id.btn_A:
                                    et_shuru.setText(et_shuru.getText()+"A");
                                    break;
                                case  R.id.btn_B:
                                    et_shuru.setText(et_shuru.getText()+"B");
                                    break;
                                case  R.id.btn_C:
                                    et_shuru.setText(et_shuru.getText()+"C");
                                    break;
                                case  R.id.btn_D:
                                    et_shuru.setText(et_shuru.getText()+"D");
                                    break;
                                case  R.id.btn_E:
                                    et_shuru.setText(et_shuru.getText()+"E");
                                    break;
                                case  R.id.btn_F:
                                    et_shuru.setText(et_shuru.getText()+"F");
                                    break;
                            }
                        }
                    });
            }
            et_shuru=findViewById(R.id.et_shuru);
            et_shuchu=findViewById(R.id.et_shuchu);
           spinner1=(Spinner)findViewById(R.id.spinner1);
           spinner2=(Spinner)findViewById(R.id.spinner2);
            //建立数据源
           String[] mltems = getResources().getStringArray(R.array.data);
            ArrayAdapter<String>adapter= new ArrayAdapter<String>(this,android.R.layout.simple_spinner_item,mltems);
            adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
            //绑定Adapter到控件
            spinner1.setAdapter(adapter);
            spinner1.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
                @Override
                public void onItemSelected(AdapterView<?> parent, View view, int pos, long id) {
                    switch (pos){
                        case 0: k=2;setEnabled(2);break;
                        case 1: k=8;setEnabled(8);break;
                        case 2: k=10;setEnabled(10);break;
                        case 3: k=16;setEnabled(16);break;
                    }
                }
                @Override
                public void onNothingSelected(AdapterView<?> parent) {
                }
            });
            spinner2.setAdapter(adapter);
            spinner2.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
                @Override
                public void onItemSelected(AdapterView<?> parent, View view, final int pos, long id) {
                    switch (pos){
                        case 0: btn_js.setOnClickListener(new View.OnClickListener() {
                                @Override
                                public void onClick(View v) {
                                    temp = et_shuru.getText().toString();
                                    num3 = Integer.valueOf(temp, k).toString();//转换为十进制;
                                    num1 = Integer.toBinaryString(Integer.parseInt(num3));
                                    et_shuchu.setText(num1);
                                }
                            });break;
                        case 1: btn_js.setOnClickListener(new View.OnClickListener() {
                                @Override
                                public void onClick(View v) {
                                    temp = et_shuru.getText().toString();
                                    num3 = Integer.valueOf(temp, k).toString();//转换为十进制;
                                    num2 = Integer.toOctalString(Integer.parseInt(num3));
                                    et_shuchu.setText(num2);
                                }
                            });break;
                        case 2: btn_js.setOnClickListener(new View.OnClickListener() {
                                @Override
                                public void onClick(View v) {
                                    temp = et_shuru.getText().toString();
                                    num3 = Integer.valueOf(temp, k).toString();//转换为十进制;
                                    et_shuchu.setText(num3);
                                }
                            });break;
                        case 3: btn_js.setOnClickListener(new View.OnClickListener() {
                            @Override
                            public void onClick(View v) {
                                temp = et_shuru.getText().toString();
                                num3 = Integer.valueOf(temp, k).toString();//转换为十进制;
                                num4 = Integer.toHexString(Integer.parseInt(num3));
                                et_shuchu.setText(num4);
                            }
                        });break;
                    }
                }
                @Override
                public void onNothingSelected(AdapterView<?> parent) {
                }
            });
        }
        public void setEnabled(int count){
            int i =0,size = Math.min(count,ids.length);
            for( i=0;i<size;i++){
                Button btn = findViewById(ids[i]);
                if(btn != null){
                    btn.setEnabled(true);
                }
            }
            for( i=size;i<ids.length;i++){
                Button btn = findViewById(ids[i]);
                if(btn != null){
                    btn.setEnabled(false);
                }
            }
        }
    }
    

    Spinner 控件的数据源(jinzhi.xml)

    <?xml version="1.0" encoding="utf-8"?>
    <resources>
        <string-array name="data">
            <item>二进制</item>
            <item>八进制</item>
            <item>十进制</item>
            <item>十六进制</item>
        </string-array>
    </resources>
    
    

    一个小白第一次写博客,如果大家发现我有什么错误和不足的地方,欢迎指导,谢谢!

    展开全文
  • 设计初衷: 作为一名嵌入式程序员,进制转换是入门必修课,而学习计算机也是必须要懂的最基础...编写一个程序,实现二进制、八进制、十进制、十六进制的相互转换。 提示:输入的数值后面的字母表示进制数,56D便是...

    题目需求:

    • 编写一个程序,实现二进制、八进制、十进制、十六进制的相互转换。
      提示:输入的数值后面的字母表示进制数,56D便是十进制的56,72O便是八进制的72,ACH便是十六进制的AC。
    • 示例
    输入:56D
    输出:HEX[38]
          DEC[56]
          OCT[70]
          BIN[00111000]
    输入:ACH
    输出:HEX[AC]
          DEC[172]
          OCT[254]
          BIN[10101100]
    输入:72Q
    输出:HEX[3A]
          DEC[58]
          OCT[72]
          BIN[00111010]
    输入:00011010B
    输出:HEX[1A]
          DEC[26]
          OCT[32]
          BIN[00011010]
    

    程序设计

    • 这里的输入数据并非真实的进制数,输入采用的是字符串的形式。例如:二进制“11001010B”,八进制“26Q”,十进制“56D”,十六进制“7CH”。在进制数后面加上进制数标识符以便区分。
    • 通过Funtion(char* array,int len)函数求得的数是10进制数,也就是int型数据。形参array是要传入的进制字符串数据,也就是上面提到的诸如“11001010B”这种风格的进制数,形参len则是字符串长度。
    • DecToAny(int n, int m)函数则是十进制数转任意进制数,形参n为输入的数据,形参m为要转成m进制的意思。
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <math.h>
    int Funtion(char *array,int len)
    {
    	int sum=0;
    	switch (array[len-1])
    	{
    		case 'B'://2进制转10进制
    		{
    			for (int i = len - 2; i >= 0; i--)
    			{
    				sum += (array[i]-'0') * pow(2, len - i - 2);
    			}
    			break;
    		}
    		case 'Q'://8进制转10进制
    		{
    			for (int i = len - 2; i >= 0; i--)
    				sum += (array[i] - '0')*pow(8, len - i - 2);
    			break;
    		}
    		case 'D'://将字符串型的数转成int型十进制数
    		{
    			for (int i = 0; i < len-1; i++)
    				sum += (array[i] - '0')*pow(10, len - i - 2);
    			break;
    		}
    		case 'H'://16进制转10进制
    		{
    			for (int i = len - 2; i >= 0; i--)
    			{
    				if (array[i] > 47 && array[i] < 58)             //0~9
    					sum += (array[i] - 48)*pow(16, len - i - 2);
    				else if (array[i] > 64 && array[i] < 71)        //A~F
    					sum += (array[i] - 55)*pow(16, len - i - 2);
    				else if (array[i] > 96 && array[i] < 103)       //a~f
    					sum += (array[i] - 87)*pow(16, len - i - 2);
    			}
    			break;
    		}
    		default:break;
    	}
    	return sum;
    }
    int DecToAny(int n, int m)// n表示数据,m表示要转成m进制
    {
    	if (n < m) return n;
    	else return DecToAny(n / m, m) * 10 + n % m;
    }
    int main(void)
    {
    	int Length;//数组长度
    	int s;
    	char *Data = (char*)malloc(9 * sizeof(char));//数据字符串数组
    	gets(Data);//输入数据
    	Length = strlen(Data);
    	s=Funtion(Data,Length);//功能函数
    	printf("HEX[%X]\nDEC[%d]\nOCT[%o]\nBIN[%d]\n",s,s,s,DecToAny(s,2));
    }
    

    运行结果

    在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    展开全文
  • 2019开放大学网考系列二级考试教程计算机基础考试中十进制、二进制、八进制和十六进制转换方法首先我们了解下进制,如下,看看就行了不用懂,如果你想研究可以搜一下,我只是介绍下考试时的方法。二进制逢二进一,...

    2019开放大学网考系列二级考试教程计算机基础

    考试中十进制、二进制、八进制和十六进制转换方法

    首先我们了解下进制,如下,看看就行了不用懂,如果你想研究可以搜一下,我只是介绍下考试时的方法。

    二进制逢二进一,所有的数都用两个符号0或1表示。二进制的每一位只能表示0或1。例如十进制数1,2,3用二进制表示分别为:(1)10 = (001)2 ,(2)10 = (010)2 ,(3)10 = (011)2 。二进制的缺点是表示一个数需要的位数多,书写数据和指令不方便。

    63e107b6b2719fdfb0edb4e2aededd0e.png

    八进制逢八进一,值大小从0(000)~7(111),为方便起见,将二进制数从低向高每三位组成一组。例如:有一个二进制(100100001100)2,若每三位一组,即:(100,100,001,100)2可表示成八进制数(4414)8

    836a0b2088cf585b2f539dfe54968101.png

    十六进制逢十六进一,每四位为一组,即:(1001,0000,1100)2,每组的值大小是从0(0000)~15(1111)。用A,B,C,D,E,F分别代表10到15的6个数,则上面的二进制数可以表示成十六进制数(90C)16

    4b4a64ad3e53f4e7dffc0e54c729ad2c.png

    方法:开始----所有程序----附件---计算器---查看---程序员

    dc62120206ab101a6cbb85f8f12ecc87.png
    9517edcac112b52d04902c6a4ddfadc9.png
    23135ce92aaf1f5f1f7f340163c1c04a.png

    1.十进制转其它进制

    默认状态下是十进制,但要细心看好

    a340b218b1a67fda74d4231ccd3afa6f.png

    输入考试的数值

    d9ab0a9467428e7deb32eefd18057a0b.png

    点选转换进制,我们就算完了

    abbfced5b2b80518a645ac7e151fa668.png

    2.举一反三,二进制转16进制或八进制方法一样

    本身现在大家都忙没时间学习(只是给自己一个借口),在有一个基础课讲什么进制转换,会用计算机就可以了,我真搞不懂专家。这样在考试时你就不会发蒙了,自己算了,省事。

    展开全文
  • 计算器能够实现二进制、八进制、十进制和十六进制的相互转换;二进制、八进制、十进制和十六进制的加减乘除运算;以及十进制的简单科学计算:sin,cos,tan,sqrt,ln,exp。
  • 之前已经详细的讨论了十进制整数以及小数和二进制之间的互转,详细的可以参考 理解进制转换的原理。前段时间在 知乎 看到了这样的一个问题。你品,你细品,如果让你把 7 进制数转成 8 进制数,是不是你会先把 7 进制...

    之前已经详细的讨论了十进制整数以及小数和二进制之间的互转,详细的可以参考 理解进制转换的原理。

    前段时间在 知乎 看到了这样的一个问题。

    a38062c6d6b740f88979755cd8f75a7f.png

    你品,你细品,如果让你把 7 进制数转成 8 进制数,是不是你会先把 7 进制数转成 10 进制数,然后再转成 8 进制数。下边就讨论一下这个问题,前提是你已经对二进制和十进制之间的互转已经很清楚了。不然的话,建议先看一下 理解进制转换的原理。

    我们再重新思考一下进制,所谓进制无非是每一位有了不同的权重。

    对于二进制权重依次是

    也就是 ... 8 4 2 1

    所以对于二进制 1100 ,转为十进制就是二进制的每一位乘以它的权重,即

    1 × 8 + 1 × 4 + 0 × 2 + 0 × 1 = 12

    那么问题来了,为什么是转成了十进制?

    这里是关键了,因为我们说权重的时候,习惯性就用 10 进制去计算了权重

    那么这里换下思路,我们不用十进制去表示权重,而是用七进制去表示权重。

    让我们熟悉一下七进制。

    首先七进制用 7 个符号表示,即 0, 1, 2, 3, 4, 5, 6

    再熟悉一下七进制的运算,满 7 进 1

    2 + 6 = 11

    3 + 4 = 10

    2 * 2 = 4

    好的,看起来有些别扭,但事实如此,哈哈。

    让我们回到二进制的权重问题,看一下七进制下的权重。

    对于二进制权重依次是

    也就是,... 11 4 2 1

    所以对于二进制 1100 ,转为七进制就是二进制的每一位乘以它的权重,即

    1 × 11 + 1 × 4 + 0 × 2 + 0 × 1 = 11 + 4 = 15

    所以二进制的 1100 在七进制中就是 15

    我们直接将二进制转为了七进制!

    所以,我们之所以要将其他进制先转换为十进制,就是因为进制的权重我们默认下都是在十进制下进行的。如果在程序中,我们算某个权重,比如

    ,结果一定是
    8,这也决定了,我们只能将其它进制先转为十进制。
    public int twoToTen(String two) {
        char[] array = two.toCharArray();
        int n = array.length;
        int sum = 0;
        int power = 0;
        for (int i = n - 1; i >= 0; i--) {
            sum = sum + (array[i] - '0') * (int) Math.pow(2, power);
            power++;
        }
        return sum;
    }

    输入二进制 1100,就会输出十进制的 12 了。

    为什么是 10 进制的呢,因为上边我们累加以及算权重的时候,调用的加法、乘法、幂次,都是基于 10 进制的。

    那么我们能否修改函数,直接把二进制转为七进制呢?

    我们只需要重新定义加法、乘法、以及幂次,让运算都是基于七进制的即可。这样算出的权重就是基于七进制的,加法、乘法也就会是基于七进制的,最终的结果当然是一个七进制的数字了。

    首先我们定义一个 Seven 类,进行七进制的加法以及乘法、幂次。

    思想的话,参考 Leetcode 的第二题 大数相加 。

    这里的乘法以及幂次,直接递归的进行了,没有进行任何优化,只用于演示,具体优化方法参考可以参考 LeetCode 的 29 题 以及 50 题。

    此外,这里的加法只考虑了两个正数相加,减法也只考虑了减 1

    public final class Seven {
        public static int sum(int n1, int n2) {
            int res = 0;
            int carry = 0;
            int shift = 1;
            while (n1 != 0 || n2 != 0) {
                int x = (n1 != 0) ? n1 % 10 : 0;
                int y = (n2 != 0) ? n2 % 10 : 0;
                int sum = carry + x + y;
                carry = sum / 7; //保存进位
                res = res + sum % 7 * shift;
                n1 /= 10;
                n2 /= 10;
                shift *= 10;
            }
            if (carry != 0) {
                res = res + 1 * shift;
            }
            return res;
        }
    
        //传进来的数是七进制, 实现减 1
        public static int subOne(int n) {
            int count = 0;
            //考虑需要借位的情况,比如这种 43000
            while (n % 10 == 0) {
                n /= 10;
                count++;
            }
            n -= 1; //借位
            //低位补 6
            while (count != 0) {
                n = n * 10 + 6;
                count--;
            }
            return n;
    
        }
    
        public static int mul(int n1, int n2) {
            if (n2 == 0) {
                return 0;
            }
            return Seven.sum(n1, mul(n1, Seven.subOne(n2)));
        }
    
        public static int pow(int a, int b) {
            if (b == 0) {
                return 1;
            }
            return Seven.mul(a, pow(a, Seven.subOne(b)));
        }
    }

    有了七进制运算的类,我们就可以直接把二进制直接转换为七进制了。

    public int twoToSeven(String two) {
        char[] array = two.toCharArray();
        int n = array.length;
        int sum = 0;
        int power = 0;
        for (int i = n - 1; i >= 0; i--) {
            int pow = Seven.pow(2, power);
            int mul = Seven.mul(array[i] - '0', pow);
            sum = Seven.sum(sum, mul);
            power++;
        }
        return sum;
    }

    上边如果输入 1100,就会输出七进制的 15 了。

    甚至,我们可以在函数增加一个参数,就可以将任意进制转为七进制了。

    public int anyToSeven(String two, int radix) {
        char[] array = two.toCharArray();
        int n = array.length;
        int sum = 0;
        int power = 0;
        for (int i = n - 1; i >= 0; i--) {
            int pow = Seven.pow(radix, power);
            int mul = Seven.mul(array[i] - '0', pow);
            sum = Seven.sum(sum, mul);
            power++;
        }
        return sum;
    }

    上边如果输入 1200 3,也就是三进制的 1200,就会输出七进制的 63 了。

    当然上边的 any 只能是小于七进制的,因为我们里边的运算都是基于 7 进制的,允许的符号是 0 - 6,如果大于七进制上边就会乱套了。

    至于大于七进制的转为七进制,方法的话就类似于上边介绍的十进制转为二进制,此时权重是固定的,然后利用除法求出每一位的值。

    因此我们至少还需要实现七进制的除法,然后利用十进制转为二进制的思想即可。这里就不写了,就交给大家了,哈哈。

    ps: 上边的代码,没有做严格的测试,思想应该是对的,哈哈,发现问题可以和我交流。

    总结一下

    进制转换分为两大类。

    低进制转到高进制,也就是我们上边详细讨论的。我们只需要把权重用高进制的数去表示,然后在某个进制下进行相乘相加即可。

    高进制转到低进制,类比于我们熟悉的十进制转二进制,同样用高进制的数表示权重,此时我们在某个进制下通过除法来求出各个位即可。

    其实不管高进制到低进制,还是低进制到高进制,都是基于下边的等式。

    以十进制和二进制的转换为例。

    已知左边,就是低进制到高进制。已知右边,就是高进制到低进制。

    左边权重的幂次的底决定了低进制是多少。

    相乘相加在多少进制下进行,决定了最终转为了多少进制。

    因此需要十进制中转根本原因就是我们手里的计算器,计算机,或者你自己的口算,所有的计算我们都默认在十进制下进行,数量这个概念我们也是用十进制表示的。

    因此不管其他进制转十进制,还是十进制转其他进制都会很方便。

    再补一句,如果自己去实现七进制下的加减乘除。为了减少我们的工作量,因为我们的计算机已经实现了十进制的加减乘除,所以我们可以将七进制转为十进制,然后进行相应的计算,最后再将结果转回七进制即可。而我之前实现的七进制类,相当于在十进制的基础上模拟了七进制的进位借位,所以更麻烦些。

    展开全文
  • vb做界面的二进制计算器。可以自己在写上十六进制和八进制转换
  • 导语:从远古时代开始,人类就已经开始采用十进制来计数了。时至今日,十进制仍然是全世界最通用的计数方法。虽然,我们生活在高度文明的现代社会,十进制却一直沿用至今,在日常生活当中常常离不开它。实际上除了...
  • 基于单片机(AT89C51)的进制转换及进制计算器 闲来无事,用手头51单片机做个进制计算器 成品功能:能实现十进制带负数、带小数点的加减乘除,不同进制之间的转换,同一进制之间的加减乘。 材料 AT89C51开发板要带4x...
  • 使用VS2010的MFC写了一个进制转换的小计算器。 涉及十进制转十六进制,int,char,CString之间的转换等 对初学C++的人可能对进制的转换,以及变量类型的转换很是头疼,希望对初学者有所帮助
  • #include #include #include #include #define STACK_INIT_SIZE 100 #define SIZE_INCREMENT 5 ... if(isdigit(op) || (isalpha(op)&&(tolower(op)||tolower(op)>='a')))//prevent the invalid hexadeciaml number...
  • 十进制转换为十六进制 zhi | LINUX OS | 0 一个小问题,需要数值在十进制和十六进制之间转换。有些计算器应用有此功能,不过还有通过命令行接口的简便方式: zhi@debian-lizhi:~/git/linx$ echo “ibase=...
  • 十进制转二进制/十六进制我觉得最简单也最方便的办法就是直接用计算器算了。 如果不依赖工具,那我们要如何去计算呢。 先来说说二进制。最多见的是短除法。所谓短除法大家可以去看看...
  • 十进制转换成二进制的时候,如果不用计算器是一件很麻烦的事情,需要不断地除以二然后在计算结果,这是一件很浪费时间的算法,现在我就告诉你们一种最简洁的算法;例1:把十进制133转换成二进制;先计算133由多少个2...
  • python手写进制转换(本文仅探讨从十进制转二进制,八进制,十六进制)分析:二进制:代码:八进制:十六进制:小结 看了这篇博客,就想记录一下,免得忘了。 分析: 二进制: 我们都知道,二进制就是逢2进1,但是...
  • 唯美计算器,可用于解决windows自带计算器不能进行小数的多进制之间转换问题,适用于大学计算机基础课程中数制转换中小数的二、八、、十六进制转换
  • 分析题目,很简单的进制转换,因为题目给的十六进制数比较小,可以计算器计算,也可以用代码实现。 简谈进制转换 10进制转2进制 方法:Integer.toBinaryString(n)转换结果为一个二进制字符串. 10进制转8进制方法...
  • JAVA综合程序设计与分析 一 题目 用java语言编写科学计算器要求完成加减乘除以及基本函数处理还有数的进制转换 二 摘要 本计算器可以进行简单的四则运算加减乘除但仅限于十进制下还可以进行二进制八进制十进制之间的...
  • 十六进制就是0 1 2 3 4 5 6 7 8 9 A B C D E F 100以内一点的10转16心算比较快,复杂的用“计算器”算了。10转16用传统的计算方式可以了,就是大于15小于256的10进制数除以16为的值为位的16进制数,其余数为个位的...
  • 进制转换对于学计算机的朋友是必须要学会的一个知识,Reversers Calculator 能进行十六进制的逻辑、数学、转换的计算,支持将十六进制和二进制转换十进制(有/无符号)和八进制结果,并可将字符串转换为十六进制值...
  • 科学计算器进制转换

    热门讨论 2011-05-24 16:01:36
    可以实现+,—,*,%,mod,sin,cos,tan,EXP,m+,m-,mr,mc,x^y 十进制二进制相互转换 换肤
  • 实现算术加、减、乘、除等基本运算; 实现三角函数的运算、对数运算、指数运算、阶乘等科学运算;...能实现基础进制转换(二进制、八进制、十进制、十六进制); 实现计算表达式及结果的保存,便于用户检查计算结果;
  • 一、进制转换 思路 十进制转任意进制: 求余,例如一个十进制17,求二进制 (第一次)17/2 = 8 --------余数1 (第二次)8/2 = 4 ---------余数0 (第三次)4/2 = 2----------余数0 (第四次)2/2 = 1----------...
  • VC++将16进制转换成10进制,运行该程序后,只要输入任意十六进制数,就可以转换成相应的十进制数。以前发过类似程序,相对来说,本款的界面和功能都挺简单,可作为新手学习VC++的参考范例。以下两款同样来自VC++的...
  • 如何解决不同进制之间的运算:把所有输入的数先转为十进制进行运算,然后最后输出的时候再按照之前的进制进行输出 Integer.parseInt(数, 数对应的进制)/Integer.valueOf(数, 数对应的进制) ----- 将不同进制数转为...
  • 首先简单介绍Windows 10操作系统及其内置计算器,Windows 10是由美国微软公司开发的应用于计算机和平板电脑的操作系统,于2015年7月29日发布正式版。Windows 10操作系统在易用性和安全性方面有了极大的提升,除了...

空空如也

空空如也

1 2 3 4 5 ... 14
收藏数 278
精华内容 111
关键字:

十进制转换计算器