Bir tamsayı verilmişse n > 9, o tamsayıdaki rakamlar arasındaki olası her ekleme için bir ekleme ekleyin +ve değerlendirin Ardından, orijinal sonuçları bu modulo alın. Bu işlemlerin toplamının çıktısını alın.

Bir örnek n = 47852:

47852 % (4785+2) = 4769
47852 % (478+52) =  152
47852 % (47+852) =  205
47852 % (4+7852) =  716
                  -----
                   5842

Giriş

Tek bir pozitif tam sayı , herhangi bir uygun biçimde , n > 9.

Çıktı

Yukarıdaki inşaat tekniğini izleyen tek tamsayı çıkışı.

kurallar

• Dilinizin varsayılan türünden daha büyük olan girdiler için endişelenmenize gerek yok.
• Tam bir program veya bir işlev kabul edilebilir. Bir işlev varsa, çıktıyı yazdırmak yerine geri gönderebilirsiniz.
• Standart boşluklar yasaktır.
• Bu kod-golf olduğundan, tüm normal golf kuralları geçerlidir ve en kısa kod (bayt cinsinden) kazanır.

Örnekler

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

05AB1E , 12 10 bayt

v¹¹N¹‚£O%O

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin!

JavaScript, 43 47 bayt

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

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

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

Girdiyi string olarak alır.

Düzenle:

+4 bayt : JavaScript'te lider sıfıra gitmek, sayıyı sekizli değerine dönüştürür):

Brachylog , 20 bayt

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

Çevrimiçi deneyin!

açıklama

Bu verilen formülü uygular. Bir zaman yaklaşık dikkatli olmak zorunda tek şey 0girdi ortasında: Bir başlayarak sayının bir liste olduğunu kabul etmeyecektir örneğin Brachylog oldukça ilginç alır bu durumda 0(bir tamsayı içine birleştirilmiş edilebilir Liderin yok sayılmasını gerektirecek 0- bu, sonsuz döngülerden kaçınmak için bu şekilde programlanır). Bu nedenle, bu sorunu aşmak için, girişi bir dizgeye dönüştürürüz ve sonra tüm bölünmüş girdileri tam sayılara geri dönüştürürüz.

                       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               

ES6 (Javascript), 42, 40 bayt

DÜZENLEMELER:

• S , -2 bayttan kurtuldu

golfed

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

Ölçek

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)));

Python 2,45 bayt

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

Kullanımları dizeleri girişi bölmek yerine aritmetik nbölüme n/cve n%c, c10 güçleriyle recurses.

Jöle , 12 bayt

ŒṖṖLÐṂḌS€⁸%S

TryItOnline!

Nasıl?

ŒṖṖ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

Perl 35 32 27 Bayt

İçin +3 içerir -p

Dada sayesinde 8 bayt kaydedildi

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

C 77 + 4 = 81 bayt

golfed

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

Ungolfed

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

i,N,t,r,m;

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

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

Python 2, 68 64 68 bayt

^{Atlasolog sayesinde -4 bayt}

lambda x:sum(int(x)%(int(x[:i])+int(x[i:]))for i in range(1,len(x)))

^{* Giriş bir dizedir}

C, 59 bayt

t,s;f(n){s=0;t=10;while(t<n)s+=n%(n/t+n%t),t*=10;return s;}

tolduğunu 10,100,1000,...ve büyük sayıda kesim temsil eder. n/tsağ kısım ve n%tsol kısımdır. Eğert sayısından daha büyüktür, o bitti.

Ungolfed ve kullanım:

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));
}

Retina , 38 bayt

Bayt sayısı, ISO 8859-1 kodlamasını varsayar.

\B
,$';$_¶$`
G-2`
\d+|,
$*
(1+);\1*

1

Tam olarak verimli değil ...

Çevrimiçi deneyin! (İlk satır satır besleme ile ayrılmış bir test takımı sağlar.)

açıklama

\B
,$';$_¶$`

Her karakter çiftinin arasına virgül, maçın önündeki her şey, noktalı virgül, tüm giriş, satır sonu ve maçtan sonraki her şey eklenir. Giriş için 12345bu bize verir:

1,2345;12345
12,345;12345
123,45;12345
1234,5;12345
12345

Yani, girişin bir çift ile birlikte mümkün olan her bölünmesi. Yine de bu son hatta ihtiyacımız yok:

G-2`

Atıyoruz.

\d+|,
$*

Bu, her sayının yanı sıra virgülün de tek başına gösterimi ile değiştirilir. Virgül bir sayı olmadığından sıfır olarak kabul edilir ve basitçe kaldırılır. Bu, her bölmeye iki bölüm ekler.

(1+);\1*

Bu, ilk sayının tüm kopyalarını ikinci sayıdan kaldırarak moduloyu hesaplar.

1

İşte bu, 1dizgede kaç tane kaldığını sayarız ve sonuç olarak basarız.

Pyth, 14 bayt

s.e%QssMc`Q]k`

Bir tamsayı girişi alan ve sonucu basan bir program.

Test odası

Nasıl çalışır

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

Haskell, 62 bayt

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

Bir fonksiyon tanımlar f. Tüm test durumlarını geçtiğini görün.

Perl 6 , 33 bayt

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

Expanded:

{                  # 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
}

Mathematica, 75 bayt

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

Bu, tüm bölümlerini iki parçaya çıkarmak için basamak listesinde desen eşleştirmesini kullanır. Her bir bu bölüm ave içineb sonra ile değiştirilir

Mod[#,FromDigits/@({a}+{b}+{})]

Burada dikkate değer bir şey varsa, örneğin bu yüzden eşit olmayan uzunlukta listelerin toplamları, unevaluated kalmasıdır aolduğunu 1,2ve bbir 3,4,5o zaman ilk olan bu değiştirin {1,2} + {3,4,5} + {}. Son terim, eşit sayıda rakamı eşit şekilde paylaştığımızda hala eşitsiz kalmasını sağlamak için var. Şimdi, MapMathematica'daki işlem, sadece listelerle değil, herhangi bir ifade ile çalıştığı için yeterince genelleştirildi. Dolayısıyla FromDigits, bu toplamın haritasını çıkarırsak , bu listelerin her birini bir sayıya dönüştürür. Bu noktada, ifade şu anda değerlendirilen bir tam sayı toplamıdır. Bu Tr[FromDigits/@{{a},{b}}], önce iki listeyi dönüştüren ve daha sonra sonucu özetleyen daha geleneksel çözüm üzerinde bir bayt tasarrufu sağlar .

Aslında , 16 15 bayt

Golf önerileri hoş geldiniz! Çevrimiçi deneyin!

Düzenleme: Teal pelikan sayesinde -1 bayt.

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

Ungolfing

         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.

Ruby, 64 bayt

->s{s.size.times.reduce{|a,i|a+s.to_i%eval(s[0,i]+?++s[i..-1])}}

Girdiyi dizge olarak alır

Befunge, 101 96 bayt

&10v
`#v_00p:::v>+%\00g1+:9
*v$v+55g00</|_\55+
\<$>>\1-:v ^<^!:-1 
+^+^*+55\_$%\00g55
.@>+++++++

Çevrimiçi deneyin!

açıklama

&              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.

APL, 29 bayt

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

⎕IOolmalı 1. Açıklama (Açıklamakta iyi değilim, bunun için yapılan herhangi bir ithalat çok açıktır):

{+/⍵|⍨{(⍎⍵↑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

C #, 67 bayt

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

Ungolfed ile tam program, yöntem ve test durumlarını açıkladı:

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
    }
}

Ataşesi , 48 bayt

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

Çevrimiçi deneyin!

açıklama

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

Clojure, 91 bayt

Düzenleme: bu, anonim bir işlev olarak bildirildiği için kısadır ve bu şekilde okumak ve çağırmak daha kolay olmasına rağmen makro (fn[v](->> ...))kullanmaz ->>.

(fn[v](apply +(map #(mod v(+(quot v %)(mod v %)))(take 10(iterate #(* 10 %)1)))))

Orijinal:

(defn s[v](->> 1(iterate #(* 10 %))(take 10)(map #(mod v(+(quot v %)(mod v %))))(apply +)))

1, 10, 100, ... dizisini oluşturur ve ilk 10 öğeyi alır (giriş değerlerinin 10 ^ 11'den küçük olduğu varsayımıyla), özelliklerde belirtildiği gibi modüllere eşlenir ve toplamı hesaplar. Uzun fonksiyon isimleri bu çözümü oldukça uzun yapar, ancak en azından golf oyunu bile takip etmek oldukça kolay olmalı.

İlk önce telleri zıplatmaya çalıştım, ancak tonlarca kazan plakası gerekiyordu.

Raket 134 bayt

(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))))))

Ungolfed:

(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)))))))

Test yapmak:

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

Çıktı:

5842
1
6
2097
8331
505598476

R , 50 bayt

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

Çevrimiçi deneyin!

SNOBOL4 (CSNOBOL4) , 92 bayt

	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

Çevrimiçi deneyin!

Yakut 45 Bayt

->q{t=0;q.times{|x|p=10**x;t+=q%(q/p+q%p)};t}

Bu gerçekten temiz bir çözüm. Teknik olarak doğru, ancak süper verimsiz. Q.to_s.size.times {...} yazmak çok daha etkili olacaktır. Q.times komutunu kullanırız çünkü karakterleri kaydeder ve ifadenin sadece sıfıra göre değerlendirildiği prok boyunca kaç kez geçtiğini kullanırız.

PHP , 60 bayt

for($n=1;($n*=10)<$a=$argn;)$r+=$a%(($a/$n^0)+$a%$n);echo$r;

Çevrimiçi deneyin!

Java 8, 127 66 bayt

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

-61 bayt @adrianmp 'ın C # answer portunu oluşturarak .

Burada dene.

Pari / GP , 42 bayt

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

Çevrimiçi deneyin!

Japt , 11 10 bayt

¬x@%OvUi+Y

Dene

açıklama

               :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