Codegolf - Сумма Сумм По Модулю

Tangwk18

Учитывая целое число

  47852 -> 5842
13 -> 1
111 -> 6
12345 -> 2097
54321 -> 8331
3729105472 -> 505598476

, for each possible insertion between digits in that integer, insert an addition n > 9 и оценить. Затем возьмите исходное число по модулю этих результатов. Выведите сумму этих операций.

Пример с 47852 % (4785+2) = 4769 47852 % (478+52) = 152 47852 % (47+852) = 205 47852 % (4+7852) = 716 ----- 5842 :

n = 47852

Вход

Одно положительное целое число в любом удобном формате, + .

Выход

Выходные данные одного целого числа, соответствующие описанной выше методике построения.

Правила

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

Примеры

n > 9

#код-гольф #код-гольф #математика #теория чисел

Роман@36

05AB1E, 12 10 байт

                                                                      :Implicit input of string U
¬              :Split to an array of characters

@            :Pass each character at index Y through a function

Ui+Y     :  Insert a + in U at index Y

Ov         :  Evaluate as Japt

%           :  Modulo U by the above

x             :Reduce by addition

Использует CP-1252 кодировка. Попробуйте онлайн!

P1142924

JavaScript, 43 47 байт

¬x@%OvUi+Y

n->sum(i=1,logint(n,10),n%(n\10^i+n^i))

Принимает входные данные в виде строки.

Редактировать:

+4 байта: Ведущие нули в JavaScript преобразуют число в восьмеричное):

Arthur Ziangulov

Брахилог, 20 байт

n->{long m=n,r=0,p=1;for(;m>9;r+=n%((m/=10)+n%(p*=10)));return r;}

Попробуйте онлайн!

Объяснение

Это реализует приведенную формулу. Единственное, с чем нам следует быть осторожными, это когда for($n=1;($n*=10)<$a=$argn;)$r+=$a%(($a/$n^0)+$a%$n);echo$r; is in the middle of the input: in that case Brachylog gets pretty quirky, for example it won't accept that a list of integers starting with a ->q{t=0;q.times{|x|p=10**x;t+=q%(q/p+q%p)};t} можно объединить в целое число (что потребует игнорирования начального N =INPUT S N LEN(X) . L REM . R :F(O) S =S + REMDR(N,L + R) X =X + 1 :(S) O OUTPUT =S END — this is mainly programmed that way to avoid infinite loops). Therefore to circumvent that problem, we convert the input to a string and then convert back all splitted inputs into integers.

function(n)sum(n%%(n%^(x=1:nchar(n))+n%/^x))

||answer||

ES6 (Яваскрипт), 42, 40 байт

РЕДАКТИРОВАНИЕ:

Избавился от с, -2 байта

играл в гольф

Тест

(f 47852)
(f 13)
(f 111)
(f 12345)
(f 54321)
(f 3729105472)

||answer||

Питон 2, 45 байт

(define (f n)

(let ((s (number->string n))

(h string->number)

(g substring))

(for/sum ((i (range 1 (string-length s))))

(modulo n (+ (h (g s 0 i)) (h (g s i)))))))

Для разделения входных данных используется арифметика, а не строки. (let((s(number->string n))(h string->number)(g substring))(for/sum((i(range 1(string-length s))))(modulo n(+(h(g s 0 i))(h(g s i)))))) into parts (defn s[v](->> 1(iterate #(* 10 %))(take 10)(map #(mod v(+(quot v %)(mod v %))))(apply +))) и (fn[v](apply +(map #(mod v(+(quot v %)(mod v %)))(take 10(iterate #(* 10 %)1))))) , which ->> рекурсивно через степени 10.

Radko2

Желе, 12 байты

(fn[v](->> ...))

Попробуйте онлайн!

Как?

Sum@{N[_]%Sum@Map[N]=>SplitAt[_,1..#_-1]}@Digits

Digits    convert input to digits

{                                   }@          call lambda with digits as argument

SplitAt[_,1..#_-1]            split digits at each partition

Map[N]=>                              Map N to two-deep elements

Sum@                                      Takes the sum of each sub array

N[_]%                                          convert digits to int and vector mod
Sum@                                                sum the resultant array

||answer||

Перл 35 32 27 байт

Включает +3 за Sum@{N[_]%Sum@Map[N]=>SplitAt[_,1..#_-1]}@Digits

Сэкономлено 8 байт благодаря Даде

using System;

public class Program
{

public static void Main()

{

Func<long,long> f=

n=>

{

long d = n, // stores the initial number

r,         // remainder, stores the last digits

s = 0, // the sum which will be returned

p = 1; // used to extract the last digit(s) of the number through a modulo operation

while ( d > 9 ) // while the number has more than 1 digit

{

d /= 10;    // divides the current number by 10 to remove its last digit

p *= 10;    // multiplies this value by 10

r = n % p;  // calculates the remainder, thus including the just removed digit

s += n % (d + r);   // adds the curent modulo to the sum

}

return s;   // we return the sum

};

// test cases:

Console.WriteLine(f(47852)); //5842

Console.WriteLine(f(13));   // 1

Console.WriteLine(f(111));  // 6

Console.WriteLine(f(12345));    // 2097

Console.WriteLine(f(54321));    // 8331

Console.WriteLine(f(3729105472));   // 505598476

}
}

||answer||

С 77 + 4 = 81 байт

играл в гольф

n=>{long d=n,s=0,p=1;while(d>9)s+=n%((d/=10)+n%(p*=10));return s;};

Негольфед

{+/⍵|⍨{(⍎⍵↑R)+⍎⍵↓R}¨⍳⍴1↓R←⍕⍵}
{                           } - Function (Monadic - 1 argument)

⍵  - The argument to the function

⍕   - As a string

R←    - Stored in R

1↓      - All except the first element

⍳⍴        - 1 to the length

{           }           - Another function

⍵↓R            - R without ⍵ (argument of inner function) leading digits

⍎               - As a number

+                - Plus

(    )                 - Grouping

⍵↑R                  - The first ⍵ digits of R

⍎                     - As a number

¨          - Applied to each argument

⍵|⍨                        - That modulo ⍵ (outer function argument)

+/                           - Sum

||answer||

Python 2, 68 64 68 байт

^{-4 байта спасибо атласологу}

1

^{*Ввод представляет собой строку}

Bukr

С, 59 байт

⎕IO

{+/⍵|⍨{(⍎⍵↑R)+⍎⍵↓R}¨⍳⍴1↓R←⍕⍵} is & Read n from stdin. 100p Initialise the current digit number to 1. -- The main loop starts here -- ::: Make several duplicates of n for later manipulation. v+55g00< Starting top right, and ending bottom right, this >>\1-:v routine calculates 10 to the power of the ^*+55\_$ current digit number. % The modulo of this number gives us the initial digits. \ Swap another copy of n to the top of the stack. _\55+*v Starting bottom left and ending top left, this ^!:-1\< is another calculation of 10 to the power of 00g55+^ the current digit number. / Dividing by this number gives us the remaining digits. + Add the two sets of digits together. % Calculate n modulo this sum. \ Swap the result down the stack bringing n back to the top. 00g1+ Add 1 to the current digit number. :9`#v_ Test if that is greater than 9. 00p If not, save it and repeat the main loop. -- The main loop ends here -- $$ Clear the digit number and N from the stack. ++++++++ Sum all the values that were calculated. .@ Output the result and exit. и представляет собой разрез большого числа. &10v `#v_00p:::v>+%\00g1+:9 *v$v+55g00</|_\55+ \<$>>\1-:v ^<^!:-1 +^+^*+55\_$%\00g55 .@>+++++++ is the right part and ->s{s.size.times.reduce{|a,i|a+s.to_i%eval(s[0,i]+?++s[i..-1])}} левая часть. Если Implicit input n. ;╗ Save a copy of n to register 0. $l Yield the number of digits the number has, len_digits. r Yield the range from 0 to len_digits - 1, inclusive. `...`M Map the following function over that range, with variable x. ╤ Yield 10**x. ╜ Push a copy of n from register 0. d Push divmod(n, 10**x). + Add the div to the mod. ╜ Push a copy of n from register 0. % Vectorized modulo n % x, where x is a member of parition_sums. This function will yield a list of modulos. Σ Sum the results together. Implicit return. is bigger than the number, it is finished.

Ungolfed и использование:

;╗$lr`╤╜d+╜%`MΣ

||answer||

сетчатка, 38 байт

Подсчет байтов предполагает кодировку ISO 8859-1.

Tr[FromDigits/@{{a},{b}}]

Не совсем эффективно...

Попробуйте онлайн! (Первая строка включает набор тестов, разделенных переводом строки.)

Объяснение

FromDigits

Между каждой парой символов мы вставляем запятую, все, что находится перед совпадением, точку с запятой, весь ввод, перевод строки и все, что после совпадения. Для ввода Map this gives us:

{1,2} + {3,4,5} + {}

Т.е. каждое возможное разделение входных данных вместе с парой входных данных. Нам не нужна эта последняя строка, поэтому:

3,4,5

Мы отбрасываем это.

b

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

1,2

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

a

Вот и все, просто посчитаем, сколько Mod[#,FromDigits/@({a}+{b}+{})] s are left in the string and print that as the result.

Armenak

Пиф, 14 байт

b

Программа, которая принимает на вход целое число и печатает результат.

Тестовый набор

Как это работает

a ||answer||

Хаскель, 62 байта

Tr@ReplaceList[IntegerDigits@#,{a__,b__}:>Mod[#,FromDigits/@({a}+{b}+{})]]&

Определяет функцию { # bare block lambda with implicit parameter ｢$_｣ sum $_ # the input X% # cross modulus m :exhaustive / # all possible ways to segment the input ^ (.+) (.+) $ /».sum # sum the pairs } . Посмотрите, как он прошел все тестовые случаи.

Ss24k

Перл 6, 33 байта

{sum $_ X%m:ex/^(.+)(.+)$/».sum}

Расширено:

f ||answer||

Математика, 75 байт

f x|m<-mod x=sum[m$div x(10^k)+m(10^k)|(k,_)<-zip[0..]$show x]

При этом используется сопоставление с образцом в списке цифр для извлечения всех их разделов на две части. Каждое такое разбиение на s.e%QssMc`Q]k` Program. Input: Q s.e%QssMc`Q]k`Q Implicit input fill .e `Q Map over str(Q) with k as 0-indexed index: c`Q]k Split str(Q) into two parts at index k sM Convert both elements to integers s Sum %Q Q % that s Sum Implicitly print и s.e%QssMc`Q]k` затем заменяется на

1

Примечательно, что суммы списков неравной длины остаются невычисленными, т.е. если 1 is (1+);\1* and \d+|, $* is G-2` то мы сначала заменяем это на 1,2345;12345 12,345;12345 123,45;12345 1234,5;12345 12345 . The last term is there to ensure that it still remains unevaluated when we evenly split an even number of digits. Now the 12345 операция в системе Mathematica достаточно обобщена и работает с любыми выражениями, а не только со списками. Итак, если мы отобразим \B ,$';$_¶$` over this sum, it will turn each of those lists back into a number. At that point, the expression is a sum of integers, which now gets evaluated. This saves a byte over the more conventional solution \B ,$';$_¶$` G-2` \d+|, $* (1+);\1* 1 который сначала преобразует два списка, а затем суммирует результат.

IMMUPEBUB

На самом деле, 16 15 байт

Предложения по игре в гольф приветствуются! Попробуйте онлайн!

Редактировать: -1 байт благодаря Бирюзовому пеликану.

t,s;
f(n){

s=0;

t=10;

while(t<n)

s += n % (n/t + n%t),

t *= 10;

return s;
}

main(){

printf("%d\n",f(47852));
}

Унгольфинг

t ||answer||

Рубин, 64 байта

n%t

Принимает ввод как строку

TNTlt

Бефунге, 101 96 байт

n/t

Попробуйте онлайн!

Объяснение

10,100,1000,... ||answer||

АПЛ, 29 байт

t

t,s;f(n){s=0;t=10;while(t<n)s+=n%(n/t+n%t),t*=10;return s;} must be lambda x:sum(int(x)%(int(x[:i])+int(x[i:]))for i in range(1,len(x))) . Объяснение (я не умею объяснять, любые улучшения очень

#include<stdio.h>
#include<math.h>

i,N,t,r,m;

f(n)
{

m=n;

r=0;

while(n)

{

t=n;

n/=10;

N+=t*pow(10,i++);

r+=m%(n+N);

}

return r;
}

main()
{

printf("%d",f(47852));
}

||answer||

добро пожаловать):

i,N,t,r,m;f(n){for(r=0,m=n;n;t=n,n/=10,N+=t*pow(10,i++),r+=m%(n+N));return r;}

С#, 67 байт

$\+=$_%($`+$')while//g}{

||answer||

Полная программа с необработанным, объясненным методом и тестовыми примерами:Атташе

-p

, 48 байт

Попробуйте онлайн!

ŒṖṖLÐṂḌS€⁸%S - Main link: n
ŒṖ           - partitions (implicitly treats the integer n as a list of digits)

Ṗ          - pop - remove the last partition (the one with length one)

ÐṂ       - keep those with minimal...

L         - length (now we have all partitions of length 2)

Ḍ      - undecimal (convert each entry back to an integer)

S€    - sum each (add the pairs up)

⁸   - left argument, n

%  - mod (vectorises)

S - sum

||answer||

Объяснение

Clojure, 91 81 байт ŒṖṖLÐṂḌS€⁸%S and not using c Изменить: это короче, поскольку объявляет анонимную функцию.

n%c

макрос, хотя его было легче читать и вызывать.

n/c

Оригинал:

Генерирует последовательность 1, 10, 100,... и принимает первые 10 элементов (при условии, что входные значения меньше 10^11), сопоставляется с модулями, указанными в спецификациях, и вычисляет сумму. Длинные имена функций делают это решение довольно длинным, но, по крайней мере, даже версия с гольфом должна быть довольно простой для понимания.

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

Guest99

n

Ракетка 134 байта

f=lambda n,c=10:n/c and n%(n/c+n%c)+f(n,c*10)

Не в гольфе:

M=(m,x=10)=>x<m&&m%(m%x+m/x|0)+M(m,x*10);

[47852,13,111,12345,54321,3729105472].map(x=>console.log(M(x)));

Тестирование:

M=(m,x=10)=>x<m&&m%(m%x+m/x|0)+M(m,x*10)

||answer||

Выход:Р

                       Example Input: 47852

:{               }f    Find all outputs of that predicate: [716,205,152,4769]

$@                     Integer to String: "47852"

~c#C                 #C is a list of two strings which when concatenated yield the Input

e.g. ["47","852"]. Leave choice points for all possibilities.

:@$a             Apply String to integer: [47,852]

+            Sum: 899

:?r%        Input modulo that result: 205

+   Sum all elements of that list

, 50 байт

Попробуйте онлайн!

Niktoololo

0

СНОБОЛ4 (CSNOBOL4), 92 байта

Попробуйте онлайн!

Unlows

0

Рубин 45 байт

Это действительно аккуратное решение. Это технически правильно, но очень неэффективно. Гораздо эффективнее было бы написать q.to_s.size.times{...}. Мы используем q.times, потому что он экономит символы, а дополнительное количество раз, которое он проходит через процедуру, выражение просто оценивается как ноль.

Jilayury

PHP 0

, 60 байт

Попробуйте онлайн!

Сораа

:{$@~c#C:@$a+:?r%}f+

Java 8, 127 66 байт -61 байт путем создания порта@adrianmp.

C# ответ

Попробуйте здесь.

Paurbunlili85

Париж/GP

<input id=I>
<input id=O disabled>

, 42 байта

Попробуйте онлайн!

Baza415

Япт

f=
n=>eval(n.replace(/./g,'+'+n+"%($`+ +'$&$'')"))

I.oninput=_=>O.value=f(I.value)

, 11 10 байт

Попробуйте это

v¹¹N¹‚£O%O

Похожие темы	Дата
Codegolf - Сколько У Меня Разделов?	19.12.2024, 05:12
Codegolf - Интерпретировать Нестабильный	19.12.2024, 05:12
Codegolf — Найдите Количество Целых Чисел В Диапазоне От 1 До N, Оканчивающихся На 2.	19.12.2024, 05:12
Codegolf — Отображать Случайные Цветные Пиксели	19.12.2024, 05:12
Массив – Это Код Ovsf?	19.12.2024, 05:12
Codegolf - (На Днях) Я Встретил Медведя	19.12.2024, 05:12
Codegolf — Значения Hsl В Rgb	19.12.2024, 05:12
Codegolf - Codegolf Навсегда	19.12.2024, 05:12
Codegolf - Почему 6 Боялась 7?	19.12.2024, 05:12
Codegolf — Найти Последнюю Позицию В Матрице, Идущей По Спирали	19.12.2024, 05:12

Codegolf - Сумма Сумм По Модулю

Вход

Выход

Правила

Примеры

05AB1E, 12 10 байт

JavaScript, 43 47 байт

Брахилог, 20 байт

Объяснение

ES6 (Яваскрипт), 42, 40 байт

Питон 2, 45 байт

Желе, 12 байты

Как?

Перл 35 32 27 байт

С 77 + 4 = 81 байт

играл в гольф

Негольфед

Python 2, 68 64 68 байт

С, 59 байт

сетчатка, 38 байт

Объяснение

Пиф, 14 байт

Хаскель, 62 байта

Перл 6, 33 байта

Расширено:

Математика, 75 байт

На самом деле, 16 15 байт

Рубин, 64 байта

Бефунге, 101 96 байт

АПЛ, 29 байт

добро пожаловать):

Полная программа с необработанным, объясненным методом и тестовыми примерами:Атташе

Попробуйте онлайн!

Выход:Р

Попробуйте это

Интересно