Как определять, если все цифры целого числа равны

Я думаю, что ты объяснился плохо, и из-за Г©so существовал столько confusiГіn. Начала у тебя есть один nГєmero, не "цепь" , и ты хочешь знать, они dГ-gitos nГєmero тот же самый ли все dГ-gito. И ты хочешь сделать это из-за mГ©todos numГ©ricos, не конвертируя nГєmero ни в цепь ни в список.

Одна soluciГіn:

def digitos_iguales(n):
    m, c = divmod(n, 10)
    d = c

    while m>0 and d == c:
        m, d = divmod(m, 10)

    return (d==c)

Ответ ChemaCortes правилен и простой способ это делать, как говоришь ты:

Анализ должен быть исключительно числовым - математическим

я это осложнил немножко больше, чтобы это решать, не используя никакого цикла используя какие-то математические свойства, код был бы следующим:

from math import log10

def digitos_iguales(num):
    return num == 0 or num % ((10**int(log10(abs(num))+1) - 1) // 9) == 0

Математическое размышление - следующие:

Если целое число считает все равные цифры, тогда это число, разделенное между одной из Ваших цифр равно целому числу с тем же числом цифр, но будучи всеми ими 1.

Например:

44544/4 = 11136

44444/4 = 11111

Предыдущее легко приходить к заключению:

Каждое число, у которого есть все Ваши равные цифры, - делимое между числом равного количества цифр, но в котором всех Ваших цифр 1.

Это означает, что оставшейся части деления между обоими (модуль) 0:

>>> 44444 % 11111 = 0
>>> 44844 % 11111 = 400

Следовательно наша проблема ограничивается тем, что получает соответствующее целое число, у которого есть то же количество цифр, что и наше число, но которое всех их 1.

Эти числа (1, 11, 111, 1111, 11111, 111111, и т.д.) формируют sequencia, который мы можем видеть здесь, и который отвечает на простую формулу:

f (n) = (10^n - 1) / 9

Где n - число цифр.

Например число этого типа с 5 цифрами:

 f(5) = (10^5 - 1) / 9
 f(5) = (10000 - 1) / 9
 f(5) = (99999) / 9
 f(5) = 11111

Решенный это у нас появляется другая проблема; мы нуждаемся в том, чтобы узнать количество цифр, у которого есть наше число. Чтобы получать число цифр используя математику мы можем бросать логаритма в основание 10 (используя только Вашу целую часть):

digitos = int(log10(n)) + 1

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

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

С этим наш код был бы:

from math import log10

def digitos_iguales(num):
    return num % ((10**int(log10(num))+1) - 1) // 9) == 0

Это функционирует, но есть две проблемы:

• Если мы вводим отрицательное число, переводчик бросает в нас ошибку типа:

  ValueError: math domain error

  это проистекает, чтобы пробовать вычислять логаритм отрицательного числа, чтобы это решать, мы используем абсолютную стоимость для этого вычисления посредством предсооруженной функции python abs()

• Решенный предыдущее, если целого числа, которое мы вводим, 0, бросает нам ту же ошибку (log (0)). Чтобы это решать достаточно использовать один or перед равенством, чтобы отказываться от этого случая следующей формы:

num == 0 or num % ((10**int(log10(abs(num))+1) - 1) // 9) == 0

С этим мы прибыли в функцию, которую я поместил в начало.

Если у тебя есть число в грубой цепи делать:

n = int(cadena)

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

P.D: благодаря Относящемуся к Богородице из-за наблюдений на моем начальном коде, которые были много помощи, чтобы это улучшать. (видеть комментарии).

Это было должно делать работу.

s = "1111"
if s.count(s[:1]) == len(s):
    print("todos iguales")

Edit

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

s = "1111"
n = int(float(s))
ultimoDigito = n % 10
todosIguales = True
while (n != 0) & (todosIguales):
    digito = n % 10
    n = n // 10
    todosIguales = digito == ultimoDigito

if todosIguales:
    print("todos son iguales")
else:
    print("hay al menos un dígito diferente")

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

def funcion(n):
    flag = False
    for i in range(0,len(n)):
        if n[0] != n[i]:
            print "este numero es diferente a los demas --> %s" %n[i]
            flag = True
    if flag:
        print "se encontraron diferencias..."
    else:
        print "todos los numeros son iguales..."
funcion("1111")

Надеялся помочь с этим! Привет! Happy conding;)

С перекурсивной функцией, эквивалентной функции ChemaCortes

def todosiguales(n,d=False):
  if n<10:
    return True if not d else n==d
  else:
    m, r = divmod(n, 10)
    return (not d or r==d) and todosiguales(m, r)

AquГ - я оставляю одну тебе soluciГіn, надеюсь, что он подает тебя и помогает, с которым estГ©s реализовывая.

def NumerosIguales(numero)
    numero = abs(numero)
    if numero < 9:
       return "Todos son iguales"
    ultimo = numero % 10
    while (numero != 0):
       digito = n % 10
       if digito != ultimo:
          return "Existe uno diferente"
       numero = numero  // 10
    return "Todos son iguales"

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

Поскольку я могу знать, что у "1111" есть все Ваши равные числа, не могут использовать списки, анализировать это как string, и т.д.

Возможно интерпретировать это двух форм.

1. Знать, что у него есть Ваши равные числа, без необходимости использовать списки, это анализировать как string.

2. Не используя списков, анализируя это как string.

Несмотря на это, я могу давать ответ "оптом". Я буду предполагать, что это второе.

Не могут, так как strings - цепи символов, а именно, вектор unidimensional, что является тем же самым, что и список.

string "1111" это список, ['1', '1', '1', '1']... Возможно знать, равны ли все, не пробегая списка? Нет, это не является возможным, и это значит, что на уровне бит необходим сравнивать каждый элемент с Вашим следующим.

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

Я понимаю, что анализ должен быть исключительно математическим

Все же, здесь я оставляю версию, используя Expresiones Regulares

#python 2.7.6

import re

def digitos_iguales(numero):
    cadena = str(abs(int(numero)))
    return re.match( r'^'+cadena[0]+'{'+str(len(cadena))+'}$', cadena) != None;

Результаты:

print digitos_iguales(-101) #False
print digitos_iguales(101) #False
print digitos_iguales(-111) #True
print digitos_iguales(111) #True
print digitos_iguales(0) #True

Demo

Похожий на ответ ChemaCortes:

Обновленный (проще и надежный перед overflows)

# Devuelve True si el numero tiene todos sus digitos iguales
#  n deberria ser un numero entero positivo
def todosiguales(n):
    dig = n % 10
    n = n // 10      
    while n > 0:
       if n % 10 != dig:
            return False
       n = n // 10      
    return True

# para testear    
def test_todosiguales(n):
   if todosiguales(n):   
      print("El numero " + str(n) + " tiene los digitos iguales \n")
   else:   
      print("El numero " + str(n) + " NO tiene los digitos iguales \n")

test_todosiguales(2323)
test_todosiguales(2222)
test_todosiguales(1)
test_todosiguales(0)
test_todosiguales(4)
test_todosiguales(41)
test_todosiguales(10)
test_todosiguales(200)
test_todosiguales(88888888888888888)
test_todosiguales(101)
test_todosiguales(121)
test_todosiguales(212)
test_todosiguales(111111)

Так:

Matemáticamente ты можешь разлагать цифры числа разделяя это между Вашим основанием, как мы используем десятичную систему, а именно в основании 10 тогда чтобы переходить с одного сайта на другой в Ваших цифрах просто, мы это разделяем между 10.

Например: номера 3423

3423 % 10 = 3

3423 / / 10 = 342

342 % 10 = 2

342 / / 10 = 34

34 % 10 = 4

34 / / 10 = 3

3 % 10 = 3

3 / / 10 = 0

идея состояла бы в том, чтобы сохранять просто первую цифру, удаленную в переменной и потом сравнивать это с оставшейся частью цифр, если какой-либо бьет козырем "zas" не все цифры, они равны, если он удается до того, чтобы заканчивать со всеми цифрами "eureka" все цифры, - равны.

def digitos_iguales(n):
    n = abs(int(n))
    d = n % 10
    while n > 9:
        n = n // 10
        if d != n % 10:
            return False;
    return True

Эдж:

>>> var = "999999"
>>> digitos_iguales(int(var))
True
>>> var = "2222220"
>>> digitos_iguales(int(var))
False

Мое зернышко песка, но в javaScript, asГ - видит результат:
MГ©todo простой сравнивая dГ-gito несовершеннолетний с оставшейся частью до тех пор, пока он не находит один отличным или остается без dГ-gitos, чтобы сравнивать.

for (var i=0; i<10000; i++)
	document.write (i,":",tieneTodosLosDigitosIguales(i),", ");

function tieneTodosLosDigitosIguales(numero){
	var digitosSonIguales=true; // 1 digito ( 0 incluido) = true
	var digitoAcomparar=digitoMenor(numero);
	var numeroRestante=Math.floor(numero/10);
	while(digitosSonIguales && numeroDigitos(numeroRestante)>0){
		digitosSonIguales = digitoAcomparar==digitoMenor(numeroRestante);
		numeroRestante = Math.floor(numeroRestante/10);
	}
	return digitosSonIguales;
}

function digitoMenor(numero){
	return numero%10;
}

function numeroDigitos(numero){
	var contadorDigitos=0; //0 = 0 digitos
	while (numero) {
		contadorDigitos++;
		numero=Math.floor(numero/10);
	}
	return contadorDigitos;
}