Как найти цифру в числе

12345678904 % 10
4

Третье от конца:

Math.floor(12345678904 % 1000 / 100)
9

Четвертое:

Math.floor(12345678904 % 10000 / 1000)
8

% это остаток от деления. Уже написали что 12345678904 % 10 = 4 это можно записать так 12345678904 / 10 = 1234567890.4. Тоесть / просто поделит число, а % поделит число, уберёт целое и оставит остаток. % это оператор деления по модулю в виде функций оно имеет вид такой часто mod() На курсах должны это разжевать.

int(str(num)[-i])

вот так делайте раз это питон;-)

(num % 10 ** 1) // 10 ** 0 последняя цифра

Нормальные погромисты цифры в числе считают с другой стороны. Привыкайте.

Тема // не раскрыта!

Вообще за переход от целочисленного деления в py2 к «обычному» в py3 ИМНО надо клавой по пальцам разработчиков.

А это я уже не знаю :3

Ну вот…

В python2, как и в других нормальных ЯП, было 3/2=1

В python3 решили что это источник ошибок и стало 3/2=1.5

Но ввели операцию //, 3//2=1

Креатифщики…

Кажется, я понял. Если конечную цифру находим так: n % 10 или остаток от n / 10 (что является последней единицей), то второе от конца должно быть так: n % 100 (запятая на еще один знак влево, что знаит что покажет последний десяток в числе), после нахождения десятка надо найти его первую цифру (от лева), т.е. найти число десятков (что нам и нужно): n / 10. И потом для каждой цифры левее в числе прибавляем по нолику в делителях:

второе от конца:

n % 100 / 10

третье от конца:

n % 1000 / 100 #плюс нолик

А как находить первое число?

Только не / а //, см выше.

А как находить первое число?

num%10**(n-1)//10**(n-2)

где

n = len(str(num))

ps и не число а цифру.

Если конечную цифру находим так: n % 10

Используйте нормальную терминологию - разряд, соответственно младший или старший разряд, а не «конечная цифра» и «первое число».

В противном случае вас никто не поймёт и даже может быть над вами будут смеяться.

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

Я не знаю питон и это хорошо я знать его не хочу ^.^

Хороший ЯП для своей ниши. Не без проблем конечно…

А как находить первое число?
num%10**(n-1)//10**(n-2)

только num%10**(n)//10**(n-1).

Мне Lua хватает, для меня он почти идеален. Более того был бы ещё более куцый в идеале с 1 единственной версией или 100% обратной совместимостью, но отлаженный временем язык яб его взял. Питон я использовать не буду просто потому что принудительное форматирование, я прощаю это мake, но дальше для меня это уже перебор. Могу себе позволить дропнуть целый язык и всё что с ним связано ибо просто любитель, ключевое слово любитель если не любо то фтопку=)

А, да, спасибо.

Я не знаю Lua, но слышал много хорошего.

Да, с питоном уже начинаются проблемы из за его толстоты (с обратной совместимостью давно начались). Скажем мне сейчас на кластере развернутся не удается потому что нет python-dev (хидеров). Понятно что это решается, но времени жалко на все эти танцы с бубном.

Хотелось бы какую то минимальную версию питона шоб везде легко вставала и работала.

Значит для нахождения первой цифры в числе мы делим ее на ее самый большой разряд, для чего берем num % 10n-1, где n - число цифр (так, чтобы перенести запятую после первой цифры). Он покажет первую цифру. Получившееся необходимо разделить нацело num //10n-2

Если использовать lua как язык общего назначения как используют питон то будет тоже самое если не хуже ибо luajit (lua5.1+пости lua5.2),lua5.2,lua5.3,lua5.4 и всё это в каше и всё несовместимо, байт код не совместим плюс ещё форки парчка. Но «не баг, а фича» луа дефакто всегда встроенный так что что встроил с тем и живёшь, беды с башкой начинаются когда хочешь взять библиотеку, а она на 5.3+ с операциями битовыми ААААААААААААААААААААА :D

Ну питон можно встроить, но он потянет за собой внешние питоньи либы…

У нас одна из канонических архитектур это питоний пускач в котором ворочается плюсовая сошка, биндинг через SWIG. Интерфейс на питоне пишется куда приятнее чем на плюсах, все кучеряво пока есть питоньи хидеры… ;-(

PS бонус питона - он просто учится и его почти все знают. С lua не так;-)

Вот вам для наглядности представление десятичного числа из статьи в википедии:

421 = 4 · 10² + 2 · 10¹ + 1 · 10⁰

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

Прочитайте уже про позиционные системы счисления.

В python3 решили что это источник ошибок и стало 3/2=1.5

так в матлабе. Хотя, целочисленное деление там idivide(A,B), что м.б. еще менее удобоваримо, чем //

Матлаб все таки очень нишевая вещь, я за 25 лет написания числодробилок работал с ним только один раз. ЯП общего назначения испольщуются гораздо чаще чем матлаб. Я слышал что в каких то новомодных ЯП тоже 3/2=1.5, но все таки это ИМНО изврат.

Хотя новички о целочисленное деление больно и регулярно бьются, это правда.

Ой скока букоф… забудьте же про stdin для ввода параметров! Да и остальное лишнее.

#!/usr/bin/python3
import sys
for x in sys.argv[1:]: 
  if not x.isdigit(): print('incorrect', x); continue  
  print(x, '=', ' + '.join(c+'*10**%i'%p for p, c in enumerate(reversed(x))))

Если метод непринципиален, то можно разбить, как строку

#!/usr/bin/pwsh

$nn = [uint64]::MaxValue -split '(?!\b)'
for ($i = 0; $i -lt $nn.count; $i++) { '{0,2}: {1}' -f $i, $nn[$i] }

 0: 1
 1: 8

# 2..17

18: 1
19: 5

Ты о чем вообще? Болеешь?

Спасибо всем, кто отозвался

Я о Вашем коде. Вы циклы в школе еще не проходили? Ну ничего, все впереди.

Про stdin я виноват, не туда посмотрел.

Циклы? Что это? Рекурсию знаю, даже хвостатую, вроде.

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

Но ещё длина цикла ограничена временем, а вот глубина рекурсии ограничена стеком…

Так алгоритм непонятен или реализация не получается?

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

1326 = 1*10**3 + 3*10**2 + 2*10**1 + 6+10**0

Взяв остаток от деления на 10, получим последнюю цифру, взяв остаток от деления на 100 и поделив на 10 — вторую справа и так далее.

Ну а дальше уже да, питонячья специфика начинается, про это в комментариях уже написали.

И эти люди запрещают мне ковыряться в носу… Ужас.

А вроде как начиная с Python 3.5 можно явно объявлять типы. Что, если явно объявленное целое 3 разделить на столь же явное объявленное целое 2 — реально получается вещественный результат? Как же хорошо, что я не на питоне пишу…

Вроде можно типы объявлять, но я этим не пользуюсь. У меня уже есть плюсы где типы обьявляют:-) Я на третий то питон недавно частично перешёл, очень много старого кода на втором который не удаётся перетащить на третий.

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

И объявление типов не спасает, у них просто int/int==>float. Потому что неофиты страдают когда int/int==>int.

divmod дальше сам

Что, если явно объявленное целое 3 разделить на столь же явное объявленное целое 2 — реально получается вещественный результат?

А покажи где ты явно объявил, что тип результата целое?

Ну например, в плюсах:

#include <iostream>

int main()
{
    int i = 3;
    int j = 2;
    std::cout << i/j << std::endl;
    return 0;
}

того факта, что оба операнда целые, достаточно для признания целым и результата. Эта программа, собранная GCC 12.2.1, возвращает 1, а не 1,5.

Я, правда, с момента написания того комментария слегка поостыл. С точки зрения математика результат деления двух целых чисел — действительно не целое, а действительное число. Вот с точки зрения компилятора осторожно предполагаю, что питоновский «умолчальный» вариант порождает намного больше кода.

Ну в питоне же утиная типизация, и тип результата объявить низя - каким будет таким будет. Можно правда кастануть результат к нужному типу.

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

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

а другого там нету

Вроде аж целых три проекта было по нативной компиляции из питоновского кода…

А, мб. Я не слежу честно говоря, ИМНО это все неактуально.

Но фактически, ты не объявлял тип для результата, а просто соглашался с тем, что «/» для целых операндов означает целочисленное деление. Если ты хочешь получить действительное число, то тебе придётся кастовать один из операндов. Вполне могло бы быть и наоборот.

А в третьепитоне ты можешь написать «//» для целочисленного деления или «/» для «нормального». Единственное чем это «плохо», так это тем, что во втором питоне «/» было целочисленным делением.