Перевод текста в двоичный код PHP

#php #php7 #системы_счисления

Как можно перевести текст в двоичный код?

Пробовал так, он переводит, но как то криво, в отличии от decbin:

$x = "abc12345";
$x = base_convert($x, 16, 2);
echo $x;




И если decbin работает как надо, почему base_convert работает непонятно как?
на официальной странице есть пример показывающий работу 

Пример #1 Пример использования base_convert()




Результат выполнения данного примера:

101000110111001100110100


Сравнил две функции:

";
$y = "abc12345";
$y = base_convert($y, 16, 2);
echo $y;
?>


Результат выполнения:

110000111000101100011110001110010110011110100110101

10101011110000010010001101000101


От чего такая разница? 


  base_convert — Преобразовывает числа между произвольными системами счисления
  
  decbin — Переводит число из десятичной системы счисления в двоичную
  
  ord - Возвращает ASCII код символа


Самое интересно в том что если сделать так 




Результат будет одинаковым:

110000111000101100011110001110010110011110100110101
110000111000101100011110001110010110011110100110101

    

Ответы

Ответ 1

base_convert — Преобразовывает числа между произвольными системами счисления


abc12345 - это корректное шестнадцатеричное число из 4 байт, эквивалент 2881561413
в десятичной системе счисления.

В то же время циклом с вызовом ord по строке вы обрабатываете значение не как число,
а как массив строковых байт. Так, символ a - это байт \x61 (но только для ASCII-совместимых
кодировок! Может быть иначе). Затем вы некорректно собираете результирующую строку,
теряя ведущие нули результата. И потому получаете последовательность из некорректных
51 бит вместо 64:

for ($i = 0; $i < strlen($x); $i++) {
    echo str_pad(decbin(ord($x[$i])), 8, '0', STR_PAD_LEFT);
}

0110000101100010011000110011000100110010001100110011010000110101


Почему 64 бита? Потому что в ASCII строке abc12345 всего 8 байт, каждый символ закодирован
значением в 8 бит. Но в 16-ричном числе abc12345 только 4 байта, потому что одна 16-ричная
цифра кодирует 4 бита информации. Вы преобразуете на самом деле разные исходные данные
и потому получаете различный результат. Вот такое малое различие, которое может быть
непонятно для языка с мягкой динамической типизацией, но крайне важное.


Ответ 2

$x = "abc12345";

for ($i = 0; $i < strlen($x); $i++) {
    echo decbin(ord($x[$i])) . "\n";
}

Алгоритм перехода в другую систему счисления

#алгоритм #любой_язык #системы_счисления

имеется следующий алфавит


  A=1; B=2; C=4;


Число 10, например, переводится как CCB, число 7 как CBA.
Как может выглядеть алгоритм, который преобразует число новую систему с наименьшим
числом символов (должно быть не AAAAA, а CA) На любом языке ответ приемлем, заранее
спасибо)
    

Ответы

Ответ 1

В данном случае вполне применим жадный алгоритм - сначала набираете делением с остатком
наибольшие единицы (C), затем меньшие (B) и потом совсем малые(A).

Типа 11 - сколько можно набрать C? только 2, итак - CC, остается 3. Его можно представить
одним B с остатком 1 - итак, CCB и остаток 1 - т.е. A, так что окончательно - CCBA.

Надо сказать, что такой жадный алгоритм годится не для всех наборов, но в вашем случае
проходит.

Думаю, закодировать проблемы быть не должно...

P.S. Так, как вы сформулировали - это задача о размене, но не о переходе в другую
систему счисления...


Ответ 2

Например на Питоне с использованием словаря алфавита:

alph = {4: 'C', 2: 'B', 1: 'A'}
x = int(input())
answ = ''
Keys = list(alph.keys())
for k in Keys:
   a = x // k
   answ += a * alph[k]
   x -= a * k


Ответ 3

Просто опишу:


дано число X 
Делим на цело Х на 4: d = X div 4
В результирующую строку вставляем d cимволов С
Остаток от деления Х на 4: m = X mod 4
Берем остаток от деления m на 2: m1 = m mod 2 и частное d1 = m div 2
Если d1 равно 1, добавляем в результирующую строку В, если равно нулю, то ничего
Если m1 равно 1, добавляем в результирующую строку A, если равно нулю, то ничего


Ответ 4

Решение на python-3.7:

ALPH = {4: 'C', 2: 'B', 1: 'A'}


def convert(num: int) -> str:
    assert num >= 1

    new_num = ''
    for key in ALPH:
        while num >= key:
            num -= key
            new_num += ALPH[key]

    return new_num


print(convert(int(input())))


Тесты:

print(convert(11))  # CCBA
print(convert(10))  # CCB
print(convert(7))   # CBA

как подсчитать минимальное количество битов требуемое для десятичных чисел в бинарном коде?

#информатика #системы_счисления

как подсчитать минимальное количество битов требуемое для десятичных чисел в бинарном
коде?
Например: 270 или 520
    

Ответы

Ответ 1

Для целых чисел без знака: взять логарифм по основанию 2 и округлить в большую сторону.

n = log2(x+1)

log2271 = 8.082 -> 9 бит

log2521 = 9.025 -> 10 бит

Для представления нуля в памяти всё равно требуется хотя бы 1 бит


Ответ 2

Если уж говорить о скорости, то некоторые архитектуры (в т.ч. x86) имеют инструкцию,
которая считает количество лидирующих нулевых бит.
Компилятор GCC имеет её встроенный аналог (обёртку).

#include 

int main()
{
    std::cout << 32 - __builtin_clz( 270 ) << std::endl; // 9
    std::cout << 32 - __builtin_clz( 520 ) << std::endl; // 10

    std::cout << 32 - __builtin_clz( 511 ) << std::endl; // 9
    std::cout << 32 - __builtin_clz( 512 ) << std::endl; // 10
}


Ответ 3

Делим на 2, пока получается число большее единицы, считаем итерации, к результату
добавляем 1. Добавляем ещё 1, если число отрицательное.


Ответ 4

Предварительно генерируем массив степеней двойки. Cравниваем число со степенями из
массива, пока не найдём первое превышающее. Индекс этого числа и есть искомый размер.

Вот код и тесты:

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;

import java.util.Arrays;
import java.util.Collection;

@RunWith(Parameterized.class)
public class Algorithms {

    public static int[] powersOfTwo = new int[31];

    static {
        powersOfTwo[0] = 1;
        for (int power = 1; power < powersOfTwo.length; power++) {
            powersOfTwo[power] = powersOfTwo[power - 1] * 2;
        }
    }

    @Parameterized.Parameter(0)
    public int number;
    @Parameterized.Parameter(1)
    public int size;

    @Parameterized.Parameters(name = "number:{0}, size:{1}")
    public static Collection data() {
        return Arrays.asList(new Object[][]{
                {0, 1},
                {1, 1},
                {3, 2},
                {((int) Math.pow(2, 10)) - 1, 10},
                {((int) Math.pow(2, 10)), 10},
                {((int) Math.pow(2, 10)) + 1, 11},
                {Integer.MAX_VALUE, 31}
        });
    }

    public static int getSizeOf(int number) {
        for (int power = 1; power < 30; power++) {
            if (powersOfTwo[power] >= number) return power;
        }
        return 31;
    }

    @Test
    public void testSizeOf() {
        Assert.assertEquals(size, getSizeOf(number));
    }
}


Этот алгоритм должен быть быстрее, чем вычисление логарифмов или деление.

Как определить основание системы счисления числа?

#математика #информатика #системы_счисления

118924 в 10 системе счисления = 350214 в х системе счисления, как найти х? если можно
то попродобнее    

Ответы

Ответ 1

Это ж всё брутфорс, это ж несерьезно :)
На самом деле, конечно, перебор здесь вполне подходит, и можно дать ему границы сразу
— по количеству цифр, по максимальной цифре. Но есть же и аналитический метод.
350214х = 11892410
Это означает, что 
3x5 + 5x4 + 0x3 + 2x2 + 1x + 4 = 11892410
или
3x5 + 5x4 + 2x2 + x – 118920 = 0
Классический многочлен пятой степени. И теперь нужно просто решить полиномиальное
уравнение. По основной теореме алгебры у него будет пять комплексных корней, нас, правда,
интересует только действительный, хорошо бы положительный, и хорошо бы целый :)
Из теоремы Абеля-Руффини известно, что аналитически мы такое уравнение не решим в
общем случае, но я бы даже и пробовать не стал: на то придуманы численные методы, которых
всяких есть многатыщ — выбрать можно по вкусу, начиная хоть с метода товарища Ньютона.
Решаем, и получаем:
x = 8
Хорошо и красиво. Ну можете еще добить преподавателя комплексными корнями, сказав,
что это же число записывается точно так же в системе счисления с основанием (-7.07949
- 4.865i) :)


Ответ 2

Что бы перевести число с какой то системы счисления с основой Х в десятичную, нужно
делать так:
1) начальная сумма 0
2) текущая цифра - самая первая
3) текущую сумму умножаем на основу Х
4) добавляем текущую цифру к сумме.
5) если справа ещё есть цифры - к пункту 3 иначе выход
Так как вручную проверять все это лень, пишется небольшая программа, к примеру на питоне
def r(x):
    return (((((3 * x + 5) * x + 0) * x + 2) * x + 1) * x + 4)

for i in range(6,10):
    print i, r(i)

Начинаем с 6, так как все цифры в заданном числе точно меньше 6 и это будет минимально
возможная основа.
А верхняя 9, так как "визуально" число в системе счисления Х больше его записи в
десятичной форме.
и конечный ответ - 8.


Ответ 3

Топовый ответ прекрасен. Осталось только уточнить решение.

Итак, получено уравнение
3*x5 + 5*x4 + 2*x2 + x – 118920 = 0.
И есть следующие соображения к его решению:


x - основание системы счисления, т.е. целое число.
В записи числа встречается цифра 5, т.е. x>5.
Число в искомой системе счисления выглядит больше нежели в десятичной, т.е. x<10.
Все целочисленные решения степенного уравнения являются делителями его свободного
члена, и после проверки остаётся только x=8.


Подстановка в уравнение показывает, что это ответ.


Ответ 4

Попробуй перебором. Начни с 6-ти разрядной системы счисления


Ответ 5

"Оптимизированный" перебор мог бы выглядеть так (Java): 
public static int getNotation(int decBased, int[] xBased) {
    outer: for (int base = 6; ; base++) { // как определить нижнюю границу вы уже знаете
        int tmp = decBased;
        int i = xBased.length - 1;
        while (tmp != 0) {
            int integral = tmp / base;
            int part = tmp % base;

            if (xBased[i] == part) {
                tmp = integral;
                i--;
            }
            else {
                continue outer; // отбрасываем основание, как только остаток от деления
не равен соответствующей цифре чисда
            }
        }
        return base;
    }
}

Набросал по-быстрому и грязновато, но, наверно, суть понятна. Алгоритм основан на
переводе числа в Википедии.

Откуда берутся лишние биты в представлении unsigned long long?

#c #типы_данных #системы_счисления

Разрабатывал спецификатор %x с помощью двоичных тетрад. После чего решил расширить
функционал до %llx. Но не тут то было! По каким-то причинам программа работала не верно.

Решил рассмотреть побитовое представление числа в формате long long unsigned. В итоге
обнаружил, что, например 32 бит числа 1 равен 1. Почему так?

Собственно сабж:

#include 
#include 

int checkbit(unsigned long long value, int position)
{
    return ((value & (1 << position)) != 0);
}

int main (void)
{
    unsigned long long num = 1;

    for (int i = 0; i < sizeof(unsigned long long) * CHAR_BIT; i++)
        printf("%d = %d\n", i, checkbit(num, i));

    return 0;
}


Результат:

0 = 1
1 = 0
2 = 0
3 = 0
4 = 0
5 = 0
6 = 0
7 = 0
8 = 0
9 = 0
10 = 0
11 = 0
12 = 0
13 = 0
14 = 0
15 = 0
16 = 0
17 = 0
18 = 0
19 = 0
20 = 0
21 = 0
22 = 0
23 = 0
24 = 0
25 = 0
26 = 0
27 = 0
28 = 0
29 = 0
30 = 0
31 = 0
32 = 1
33 = 0
34 = 0
35 = 0
36 = 0
37 = 0
38 = 0
39 = 0
40 = 0
41 = 0
42 = 0
43 = 0
44 = 0
45 = 0
46 = 0
47 = 0
48 = 0
49 = 0
50 = 0
51 = 0
52 = 0
53 = 0
54 = 0
55 = 0
56 = 0
57 = 0
58 = 0
59 = 0
60 = 0
61 = 0
62 = 0
63 = 0

    

Ответы

Ответ 1

Всё дело в строке 1 << position
Литерал 1 имеет тип int, который, на вашей платформе имеет размер, меньший, чем unsigned
long long, и при position >= sizeof(int) * CHAR_BIT результат сдвига не может быть
представлен в типе int, поэтому возникает неопределенное поведение.

Из стандарта C++14:


  Otherwise, if E1 has a signed type and non-negative value, and E1×2^E2 is representable
in the corresponding unsigned type of the result type, then that value, converted to
the result type, is the resulting value; otherwise, the behavior is undefined.


Из стандарта C11:


  If E1 has a signed type and nonnegative value, and E1 × 2^E2 is representable in
the result type, then that is the resulting value; otherwise, the behavior is undefined.


Исправление: (1ull << position)

Почему некоторые разработчкики записывают числа в 16-ричном представлении? (C#)

#c_sharp #системы_счисления

Здравствуйте!
Достаточно часто в open-source проектах замечаю, что разработчики записывают числа
не так:

int i = 2147483647;


А так:

int i = 0x7FFFFFFF;


Даёт это один и тот же результат: у нас имеется переменная, содержащая значение =
int.MaxValue, но в чем глубокая логика такой записи? Просто, мол: "Я умею записывать
числа в 16-ричном представлении, посмотрите на меня!"
Или же тут есть некоторые плюсы? Может, присвоение идет на наносекунды быстрее и/или
машине их проще так воспринимать? Разрешите, пожалуйста, мои сомнения по сему поводу!
    

Ответы

Ответ 1

Очевидно, что данное значение инициализатора

int i = 2147483647;


запомнить сложно. Нужно постоянно сверяться со справочником, чтобы правильно выписать
все цифры.

Такая запись

int i = 0x7FFFFFFF;


не требует наличия феноменальной памяти.

Но в любом случае было бы проще, лучше и яснее записать

int i = int.MaxValue;


так как такая запись самодокументируемая.

Запись

int i = 0x7FFFFFFF;


предпочтительнее предыдущей записи лишь в одном случае: когда переменная i используется
как некоторая маска для битовых операций.


Ответ 2

Часто необходимо записать двоичное беззнаковое целое. Каждая шестнадцатиричная цифра
может заменить собой 4 бита в бинарном представлении, т.е. байт - две "сконкатенированных"
шеснадцатиричных цифры. Это удобнее читать и записывать, чем ряды двоичных разрядов.

Как применить оператор побитового сдвига в Java?

#java #системы_счисления

Говорят, что в Java есть оператор побитового сдвига  <<.
Он, в теории, может сдвинуть влево (>> - вправо) двоичное число. К примеру, 1010
преобразовать в 10100.
Это я и хочу сделать: пытаюсь написать простенькую программу, которая сдвинет на
бит (влево или вправо) число:

public class Binary {

    public static void main(String[] args) {
        int x = 0B1010; //запись числа в двоичной системе исчисления
        x << 1;
        System.out.println(x);
    }
}


Но выдаётся ошибка компиляции, как бы я ни переписывал код.
    

Ответы

Ответ 1

Пишите код правильно:

public class Binary {

    public static void main(String[] args) {
        int x = 0B1010; //запись числа в двоичной системе исчисления
        x = x << 1;
        System.out.println(x);
    }
}


А если хотите увидеть в двоичной системе, тогда выводите так:

System.out.println(Integer.toBinaryString(x));


Ответ 2

Как вариант, можно ещё воспользоваться оператором <<=:

public class Binary {
    public static void main(String[] args) {
        int x = 0B1010; //запись числа в двоичной системе исчисления
        x <<= 1;
        System.out.println(x);
    }
}

Числа, цифры, хексы, буквы и другая каша в голове

  Сколько раз слово "и" встречается в букве "цивилизация"?


Никто же так не спрашивает - все понимают, где буквы, а где слова.
Так сколько же можно издеваться над числами, постоянно путая связанные с ними понятия?

Итак, как правильно использовать понятия, связанные с числами, и чем они отличаются?
    

Ответы

Ответ 1

Числа

Число - это абстрактная единица измерения количества.

1, 2, 1888, 712.4 - всё это числа.
-7 - тоже число. Хотя в большинстве языков программирования литеральной записью не обладает.

Число представляет собой значение. Оно не обладает ни единицей измерения, ни системой счисления. Строго говоря, нельзя даже говорить, что оно состоит из цифр.

Числа в рамках языка программирования

К тому, что сказано выше добавляется тип данных, а так же возможность литеральной записи.

В памяти число представлено неким набором бинарных данных. Не надо говорить, чт
в этом куске памяти лежат хексы. Это просто байты и биты. Шестнадцатеричный дамп куска памяти - это именно дамп, но не число.

Например, для Си:


10, 012, 0xa, 0x0A - это разные записи одного и то же числа.
10, 10L, 10.0 - это разные (хотя и равные) числа, поскольку они имеют разный ти
данных. Конечно, они могут рассматриваться как одинаковые, если для нас важна величина, а не тип, но с точки зрения компилятора они различаются.


Системы счисления

Число может быть представлено в виде строки в различных системах счисления.
Это по-прежнему одно и то же число, но строковые представления различны.

"1111111111", "1010", "14", "A" - это всё представления числа 10 в различных системах счисления (унарная, бинарная, шестиричная и шестнадцатеричная соответственно).

Фраза "число в шестнадцатеричной системе счисления" корректна, но неявно подразумевае
"текстовое представление числа в шестнадцатеричной системе счисления", т. е. речь далее идёт о строке, а не о числе.

Цифры

Буква - это один символ в слове, а
Цифра - это один символ в строковом представлении числа (по умолчанию - десятичном).

Цифра может подразумевать и строковый ("5", "A"), и числовой (5, 10) вариант.
Строковый вариант представляет собой выводимый символ, тогда как числовой следует рассматривать как остаток в кольце вычетов.

Арифметические операции над цифрами в производить нельзя.
Фраза "сложить цифры 5 и 7" некорректна, складывать можно только числа.

Однако, в некоторых случаях возможна неявная интерпретация цифр как чисел.

Цифры числа

Если не оговаривается система счисления, то подразумевается десятичная.

Под цифрами числа, как правило, подразумеваются числовой смысл цифр.
Т. е. цифры числа - это набор остатков в кольце вычетов по основанию системы счисления
который при скалярном умножении на соответствующие степени системы счисления (уже вне кольца) даст оригинальное число. По умолчанию этот набор упорядоченный.

В этом контексте можно говорить об арифметических операциях, например "сумма циф
числа" - это сумма чисел указанного выше набора. Поскольку речь уже идёт о числах, система счисления более не играет роли - она была нужна только для получения набора.

Цифры в строковом контексте

Цифра - это любой символ, который относится к соответствующей категории юникода.
Можно считать, что он используется для записи чисел в естественных языках (язык
программирования не подходят: в записи 0xA - символ A используется как цифра, но в реальности является буквой). В то же время я не могу со стопроцентной гарантией сказать, что любая цифра юникода используется хотя бы в одном естественном языке.

PS: В большинстве случаев выше подразумеваются целые числа, однако аналогичная интерпретация возможна и для дробных.


Ответ 2

Как не надо использовать слово "цифры":


Странные цифры в http ответе
Хороший вопрос про chunked encoding, но почему в заголовке цифры, а не числа?
Что означают цифры в строке формата?
Ширина и точность в формате printf/scanf - это тоже числа.
Слова в цифры (один>1)
Цифры "десять" в неоговоренной системе счисления не бывает.
На самом деле подразумевается преобразование числа прописью к числу
Как зашифровать слово в цифры?
Ставим цифры в соответствие emeil'у - правда?
Assembler. Изменение HEX по ходу программы
В памяти по заданному адресу хранятся данные, а не hex.

Где используется ниббл?

Для чего нужен ниббл, если есть байт? Хочу посмотреть примеры использования ниббл

Ответ

Копипаста, настало твое время
В компьютерной графике иногда используется 4-битная глубина цвета, то есть палитра из 16 цветов. Особенно употребителен был 4-битный цвет для адаптеров EGA. LPT-порт, даже на самом старом PC, может передавать данные от принтера к компьютеру по одному нибблу, используя специальные линии состояния. Эта возможность используется некоторыми периферийными устройствами, подключаемыми через такой порт. Кодовая страница CP866 Октет состоит из двух нибблов. Шестнадцатеричное представление октетов (то есть разложение множества 256 значений октетов в прямое произведение 16×16) используется для наглядного представления этого множества, в частности для изображения кодовых страниц в виде таблиц. На рисунке — множество октетов (символы альтернативной кодировки) в виде таблицы. Слева отложен старший ниббл (возрастает снизу вверх), снизу отложен младший ниббл (возрастает слева направо). При использовании двоично-десятичного кода одна десятичная цифра хранится в одном ниббле. Аналогично метру, килограмму, литру, секунде и другим единицам измерения, в которых используются названия: полметра, полкилограмма, поллитра, полсекунды, а не их специальные названия, на практике применяется название — полубайт, а название ниббл не прижилось.
Источник: Ниббл - Википедия
От себя:
Лично я на практике сталкивался только с двоично-десятичным кодом во времена изучения ассемблера. В некоторых случаях он в разы удобее стандартного бинарного представления числа - например, преобразования числа в строку и обратно в нем проводятся гораздо проще. Не говоря уже про отладку.

Как определить основание системы счисления числа?

118924 в 10 системе счисления = 350214 в х системе счисления, как найти х? если можно то попродобнее

Ответ

Это ж всё брутфорс, это ж несерьезно :) На самом деле, конечно, перебор здесь вполне подходит, и можно дать ему границы сразу — по количеству цифр, по максимальной цифре. Но есть же и аналитический метод. 350214х = 11892410 Это означает, что 3x5 + 5x4 + 0x3 + 2x2 + 1x + 4 = 11892410 или 3x5 + 5x4 + 2x2 + x – 118920 = 0 Классический многочлен пятой степени. И теперь нужно просто решить полиномиальное уравнение. По основной теореме алгебры у него будет пять комплексных корней, нас, правда, интересует только действительный, хорошо бы положительный, и хорошо бы целый :) Из теоремы Абеля-Руффини известно, что аналитически мы такое уравнение не решим в общем случае, но я бы даже и пробовать не стал: на то придуманы численные методы, которых всяких есть многатыщ — выбрать можно по вкусу, начиная хоть с метода товарища Ньютона. Решаем, и получаем: x = 8 Хорошо и красиво. Ну можете еще добить преподавателя комплексными корнями, сказав, что это же число записывается точно так же в системе счисления с основанием (-7.07949 - 4.865i) :)

Почему некоторые разработчкики записывают числа в 16-ричном представлении? (C#)

Здравствуйте! Достаточно часто в open-source проектах замечаю, что разработчики записывают числа не так:
int i = 2147483647;
А так:
int i = 0x7FFFFFFF;
Даёт это один и тот же результат: у нас имеется переменная, содержащая значение = int.MaxValue, но в чем глубокая логика такой записи? Просто, мол: "Я умею записывать числа в 16-ричном представлении, посмотрите на меня!" Или же тут есть некоторые плюсы? Может, присвоение идет на наносекунды быстрее и/или машине их проще так воспринимать? Разрешите, пожалуйста, мои сомнения по сему поводу!

Ответ

Очевидно, что данное значение инициализатора
int i = 2147483647;
запомнить сложно. Нужно постоянно сверяться со справочником, чтобы правильно выписать все цифры.
Такая запись
int i = 0x7FFFFFFF;
не требует наличия феноменальной памяти.
Но в любом случае было бы проще, лучше и яснее записать
int i = int.MaxValue;
так как такая запись самодокументируемая.
Запись
int i = 0x7FFFFFFF;
предпочтительнее предыдущей записи лишь в одном случае: когда переменная i используется как некоторая маска для битовых операций.

Числа, цифры, хексы, буквы и другая каша в голове

Сколько раз слово "и" встречается в букве "цивилизация"?
Никто же так не спрашивает - все понимают, где буквы, а где слова. Так сколько же можно издеваться над числами, постоянно путая связанные с ними понятия?
Итак, как правильно использовать понятия, связанные с числами, и чем они отличаются?

Ответ

Числа
Число - это абстрактная единица измерения количества.
1, 2, 1888, 712.4 - всё это числа. -7 - тоже число. Хотя в большинстве языков программирования литеральной записью не обладает.
Число представляет собой значение. Оно не обладает ни единицей измерения, ни системой счисления. Строго говоря, нельзя даже говорить, что оно состоит из цифр.
Числа в рамках языка программирования
К тому, что сказано выше добавляется тип данных, а так же возможность литеральной записи.
В памяти число представлено неким набором бинарных данных. Не надо говорить, что в этом куске памяти лежат хексы. Это просто байты и биты. Шестнадцатеричный дамп куска памяти - это именно дамп, но не число.
Например, для Си:
10, 012, 0xa, 0x0A - это разные записи одного и то же числа. 10, 10L, 10.0 - это разные (хотя и равные) числа, поскольку они имеют разный тип данных. Конечно, они могут рассматриваться как одинаковые, если для нас важна величина, а не тип, но с точки зрения компилятора они различаются.
Системы счисления
Число может быть представлено в виде строки в различных системах счисления. Это по-прежнему одно и то же число, но строковые представления различны.
"1111111111", "1010", "14", "A" - это всё представления числа 10 в различных системах счисления (унарная, бинарная, шестиричная и шестнадцатеричная соответственно).
Фраза "число в шестнадцатеричной системе счисления" корректна, но неявно подразумевает "текстовое представление числа в шестнадцатеричной системе счисления", т. е. речь далее идёт о строке, а не о числе.
Цифры
Буква - это один символ в слове, а Цифра - это один символ в строковом представлении числа (по умолчанию - десятичном).
Цифра может подразумевать и строковый ("5", "A"), и числовой (5, 10) вариант. Строковый вариант представляет собой выводимый символ, тогда как числовой следует рассматривать как остаток в кольце вычетов.
Арифметические операции над цифрами в производить нельзя. Фраза "сложить цифры 5 и 7" некорректна, складывать можно только числа.
Однако, в некоторых случаях возможна неявная интерпретация цифр как чисел.
Цифры числа
Если не оговаривается система счисления, то подразумевается десятичная.
Под цифрами числа, как правило, подразумеваются числовой смысл цифр. Т. е. цифры числа - это набор остатков в кольце вычетов по основанию системы счисления, который при скалярном умножении на соответствующие степени системы счисления (уже вне кольца) даст оригинальное число. По умолчанию этот набор упорядоченный.
В этом контексте можно говорить об арифметических операциях, например "сумма цифр числа" - это сумма чисел указанного выше набора. Поскольку речь уже идёт о числах, система счисления более не играет роли - она была нужна только для получения набора.
Цифры в строковом контексте
Цифра - это любой символ, который относится к соответствующей категории юникода. Можно считать, что он используется для записи чисел в естественных языках (языки программирования не подходят: в записи 0xA - символ A используется как цифра, но в реальности является буквой). В то же время я не могу со стопроцентной гарантией сказать, что любая цифра юникода используется хотя бы в одном естественном языке.
PS: В большинстве случаев выше подразумеваются целые числа, однако аналогичная интерпретация возможна и для дробных.