Замечательные числа Опции

[volvo]

Числа и СуперЧисла Смита

Составное число называется Числом Смита, если сумма его цифр равна сумме всех чисел, образующихся разложением исходного числа на простые множители. Число Смита называется СуперЧислом Смита, если сумма его цифр является Числом Смита.

Приведенная ниже программа ищет СуперЧисло Смита с номером X...

{
	Функция для подсчета суммы цифр числа N
}
function GetOneDigits(n: LongInt): Integer;
var s: Integer;
begin
	s := 0;
	while n <> 0 do begin
		Inc(s, n mod 10);
		n := n div 10;
	end;
	GetOneDigits := s
end;

{
	Эта функция считает сумму цифр разложения исходного числа N
	на простые множители и возвращает в Amount число простых множителей
}
function GetSimpleDigits(n: LongInt; var amount: Integer): Integer;
var
	s, factor: Integer;
begin
	s := 0; factor := 2;
	amount := 0;
	repeat
		if n mod factor = 0 then begin
			s := s + GetOneDigits(factor); Inc(amount);
			n := n div factor
		end
		else Inc(factor)
	until n = 1;
	GetSimpleDigits := s
end;

{
	Функция возвращает N-ное число Смита
}
function GetSmith(n: Integer): LongInt;
var
	i, amount: Integer; od, sd: Integer;
	count: LongInt;
	Found: Boolean;
begin
	i := 0; count := 2;
	while i <> n do begin
		repeat
			Inc(count);
			Found :=
				(GetOneDigits(count) = GetSimpleDigits(count, amount))
				and
				(amount > 1)
		until Found;
		Inc(i)
	end;
	GetSmith := Count
end;

{
	Функция проверяет, является ли N числом Смита
}
function IsSmith(n: LongInt): Boolean;
var
	i: Integer;
	next: LongInt;
begin
	i := 0;
	repeat
		Inc(i); next := GetSmith(i)
	until next >= n;
	IsSmith := (next = n)
end;

{
	Функция возвращает N-ное суперчисло Смита
}
function Super(n: Integer): LongInt;
var
	i, count: Integer;
	smith: LongInt;
	Found: Boolean;
begin
	i := 0; count := 0;
	while i <> n do begin
		Inc(i);
		repeat
			Inc(count);
			smith := GetSmith(count);
			Found := IsSmith( GetOneDigits(smith) );
		until Found;
	end;
	Super := smith
end;
	
var
	X: Integer;
{
	Пример использования:
}
begin
  Write('X = '); ReadLn(X);
  WriteLn('Smith super number (X) = ', Super(X));
end.

**********

Update: поскольку вышеприведенная функция поиска Суперчисел Смита работает очень медленно - выкладываю обновленную версию:

Спойлер (Показать/Скрыть)

{
   Функция для подсчета суммы цифр числа N
}
function GetOneDigits(n: LongInt): Integer;
var
   s: Integer;
begin
	s := 0;
	while n <> 0 do begin
		Inc(s, n mod 10);
		n := n div 10;
	end;
	GetOneDigits := s
end;

{
   Эта функция считает сумму цифр разложения исходного
   числа N на простые множители и возвращает в Amount
   количество простых множителей.
}
function GetSimpleDigits(n: LongInt; var Amount: Integer): Integer;
var
   s, factor: Integer;
begin
   s := 0; factor := 2;
   Amount := 0;
   repeat
      if n mod factor = 0 then
      begin
         s := s + GetOneDigits(factor); Inc(Amount);
         n := n div factor
      end
      else Inc(factor)
   until n = 1;

   GetSimpleDigits := s
end;

{
   Функция проверяет, является ли N числом Смита
}
function IsSmith(n: LongInt): Boolean;
var
   Amount: integer;
begin
   IsSmith :=
      (GetOneDigits(n) = GetSimpleDigits(n, Amount))
      and
      (Amount > 1)
end;

{
   Функция возвращает N-ное число Смита
   PrevN - номер предыдущего числа Смита, найденного этой функцией
   (при первом вызове параметр PrevN должен быть равен 0)

   PrevSmith - предыдущее число Смита, найденное этой функцией
   (при первом вызове параметр PrevSmith должен быть равен 2)
}
function GetSmith(n: Integer; PrevN: integer;
         StartCount: longint): LongInt;
var
	i: Integer;
	count: LongInt;
begin
   i := PrevN;
   count := StartCount;

   while i <> n do
   begin
      repeat
         Inc(count);
      until IsSmith(count);
      Inc(i);
   end;
   GetSmith := Count
end;

{
   Функция возвращает N-ное суперчисло Смита
}
function Super(n: Integer): LongInt;
var
   i, count: Integer;
   smith: LongInt;
   Found: Boolean;
   Digits: Integer;
begin
   i := 0; count := 0; smith := 2;
   while i <> n do begin
      Inc(i);
      repeat
         Inc(count);
         smith := GetSmith(count, count - 1, smith);
         Found := IsSmith(GetOneDigits(smith));
      until Found;
   end;
   Super := smith
end;

var
   X: Integer;
{
   Пример использования:
}
begin
   Write('X = '); ReadLn(X);
   Writeln('Super Smith = ', Super(X));

   Writeln(GetSmith(1000, 0, 2));
end.

Немного информации о скорости работы:
СуперСмит₅. Старая версия: 62 мс., новая: 1 мс.
СуперСмит₁₀₀. Старая версия: 7653 мс., новая: 63 мс.
СуперСмит₂₀₀. Старая версия: 43891 мс., новая: 220 мс.

Сообщение отредактировано: volvo - 6.11.2010 21:47

[volvo]

Постоянная Капрекара

Выберите любое четырехзначное число, в котором не все цифры одинаковые. Расположите цифры сначала в порядке убывания, затем, переставив их в обратном порядке, образуйте новое число. Вычтите новое число из старого. Повторяя этот процесс с получающимися разностями (не более чем за семь шагов) получим число 6174, которое будет затем воспроизводить самого себя.
Примечание: производя вычитания нули следует сохранять.
Примеры:
4321 - 1234 = 3087 -> 8730 - 0378 = 8352 -> 8532 - 2358 = 6174.
1100 - 11 = 1089 -> 9810 - 189 = 9621 -> 9621 - 1269 = 8352 -> 8532 - 2358 = 6174.

Ниже представлена программа для нахождения постоянной Капрекара из любого 4-х значного числа (распечатывает промежуточные значения и число итераций).

function Justify(s: string; const n: Byte): string;
begin
	while Length(s) < n do s := '0' + s;
	Justify := s
end;

function Trim(s: string): string;
begin
	while s[1] = '0' do Delete(s, 1, 1);
	Trim := s
end;
	
function sort_digits(n: Integer; size: Byte): Integer;
var s: string;
	
	procedure SwapIndex(i, j: Byte);
	var Ch: Char;
	begin
		Ch := s[i]; s[i] := s[j]; s[j] := Ch
	end;
	
var
	i, j: Byte; Err: Word;
	
begin
	Str(n, s);
	s := Justify(s, size);
	
	for i := 1 to size do
		for j := size downto i+1 do
			if s[Pred(j)] < s[j] then SwapIndex(Pred(j), j);
	s := Trim(s);
			
	Val(s, n, Err);
	sort_digits := n
 end;

function revert(n: Integer; size: Byte): Integer;
var
	s, inv: string;
	i, Err: Word;
begin
	s := Justify(s, size);
			
	inv := '';
	for i := Length(s) downto 1 do inv := inv + s[i];
		
	s := Trim(s);
	Val(inv, n, Err);
	
	revert := n
end;

const sz = 4;

var
	res, sort, x: Integer;
	count: Word;
	
begin
	Write('Введите 4-х значное число: '); ReadLn(res);
	count := 0;
	repeat
		Inc(count); x := res;
		sort := sort_digits(x, sz);
		res := Abs(sort - revert(sort, sz))
		write(res, '':2);
	until res = x;
	
	WriteLn;
	WriteLn('Const = ', res:(sz+1), ' (', count, ' итераций)');
end.