মডুলোর যোগফলের যোগফল

34

একটি পূর্ণসংখ্যা দেওয়া হয়েছে n > 9, যে পূর্ণসংখ্যার মধ্যে সংখ্যার মধ্যে প্রতিটি সম্ভাব্য সন্নিবেশ জন্য একটি সংযোজন সন্নিবেশ করুন +এবং মূল্যায়ন করুন। তারপরে, এই ফলাফলগুলির মূল সংখ্যাটি মডুলো নিন। এই ক্রিয়াকলাপগুলির মোটফল আউটপুট করুন।

এর সাথে একটি উদাহরণ n = 47852:

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

ইনপুট

একটি একক ধনাত্মক পূর্ণসংখ্যা কোনো সুবিধাজনক বিন্যাসে , n > 9।

আউটপুট

উপরের নির্মাণ কৌশল অনুসরণ করে একক পূর্ণসংখ্যার ফলাফল output

বিধি

  • আপনার ভাষার ডিফল্ট ধরণের চেয়ে বড় ইনপুট সম্পর্কে আপনাকে চিন্তা করার দরকার নেই।
  • হয় একটি সম্পূর্ণ প্রোগ্রাম বা একটি ফাংশন গ্রহণযোগ্য। যদি কোনও ফাংশন হয় তবে আপনি আউটপুটটি মুদ্রণের পরিবর্তে ফিরে আসতে পারেন।
  • স্ট্যান্ডার্ড লুফোলগুলি নিষিদ্ধ।
  • এটি কোড-গল্ফ তাই সাধারণ গল্ফিংয়ের সমস্ত নিয়ম প্রয়োগ হয় এবং সংক্ষিপ্ততম কোড (বাইটে) জয়ী হয়।

উদাহরণ

47852 -> 5842
13 -> 1
111 -> 6
12345 -> 2097
54321 -> 8331
3729105472 -> 505598476
code-golf  math  number-theory 
— AdmBorkBork
সূত্র

উত্তর:

9

জাভাস্ক্রিপ্ট, 43 47 বাইট

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

I.oninput=_=>O.value=f(I.value)
<input id=I>
<input id=O disabled>
স্নিপেট প্রসারিত করুন

স্ট্রিং হিসাবে ইনপুট লাগে।

সম্পাদনা:

+4 বাইট : জাভাস্ক্রিপ্টের শীর্ষস্থানীয় শূন্যগুলি সংখ্যাটি অষ্টালে রূপান্তর করে):

— ওয়াশিংটন গুয়েডস
সূত্র
2
সেই স্নিপেটটি বেশ ঝরঝরে, এটিকে রিয়েল-টাইমে আপডেট হওয়া দেখে।
— অ্যাডমবর্কবার্ক
আপনি কি করে বাইট বাঁচাতে পারবেন (+'$&$''+$`)?
— নীল
@Neil। প্রথম পুনরাবৃত্তিতে $`খালি, এবং এটি খোলার চেষ্টা করে ত্রুটি ছুঁড়ে দেবে (13+)(উদাহরণস্বরূপ)।
— ওয়াশিংটন গুডিজ
7

ব্র্যাচল্যাগ , 20 বাইট

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

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

এটি প্রদত্ত সূত্রটি কার্যকর করে। কেবলমাত্র যখন আমাদের 0ইনপুটটির মাঝখানে থাকে তখন আমাদের কেবল সাবধান হওয়া উচিত : সেক্ষেত্রে ব্র্যাচল্যাগ বেশ কৌতূহলী হয়ে ওঠে, উদাহরণস্বরূপ এটি গ্রহণ করবে না যে একটি দিয়ে শুরু হওয়া পূর্ণসংখ্যার একটি তালিকা পূর্ণসংখ্যার সাথে সংযুক্ত করা 0যেতে পারে ( যার অগ্রণী অগ্রাহ্য করা দরকার 0- এটি মূলত অসীম লুপগুলি এড়াতে এইভাবে প্রোগ্রাম করা হয়)। সুতরাং সমস্যাটি থেকে মুক্তি পেতে আমরা ইনপুটটিকে স্ট্রিংয়ে রূপান্তর করি এবং তারপরে সমস্ত বিভক্ত ইনপুটগুলিকে পূর্বে পূর্ণসংখ্যায় রূপান্তর করি।

                       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
— Fatalize
সূত্র
6

ES6 (জাভাস্ক্রিপ্ট), 42, 40 বাইট

সম্পাদনাগুলি:

  • এস , -২ বাইট থেকে মুক্তি পেয়েছি

Golfed

M=(m,x=10)=>x<m&&m%(m%x+m/x|0)+M(m,x*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<2**31তবে আপনি x=1বাইট সংরক্ষণের জন্য শুরু করতে পারেন ।
— নীল
6

পাইথন 2, 45 বাইট

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

ইনপুটটিকে nঅংশগুলিতে বিভক্ত করতে স্ট্রিংয়ের পরিবর্তে পাটিগণিত ব্যবহার করে n/cএবং n%cযা c10 এর শক্তির মাধ্যমে পুনরাবৃত্তি করে।

— xnor
সূত্র
6

জেলি , 12 বাইট

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

TryItOnline!

কিভাবে?

ŒṖṖ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
— জোনাথন অ্যালান
সূত্র
5

পার্ল 35 32 27 বাইট

জন্য +3 অন্তর্ভুক্ত -p

দাদাকে ধন্যবাদ 8 বাইট সংরক্ষণ করা

$\+=$_%($`+$')while//g}{
— রিলে
সূত্র
5

সি 77 + 4 = 81 বাইট

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));
}
— মুকুল কুমার
সূত্র
আপনার এমন উদ্যোগ নেওয়া উচিত r=0যদি ফাংশনটি আবার বলা হয় তবে ফলাফলটি সঠিক। এটি মেটাতে কোথাও রয়েছে, আপনি যদি বিশ্বব্যাপী ভেরিয়েবল ব্যবহার করেন তবে আপনাকে একটি ফাংশনটি একাধিকবার কল করার পার্শ্ব প্রতিক্রিয়াগুলি মোকাবেলা করতে হবে।
— কার্ল ন্যাপফ
@ কার্লনাপফ কি ভাল?
— মুকুল কুমার
সি ডিফল্ট ফাংশন মানগুলিকে অনুমতি দেয় না, আপনার কোড সংকলন করে না। আপনি rগ্লোবাল কিন্তু ফাংশনের অভ্যন্তরে একটি বিবৃতি হিসাবে বলতে পারেন r=0;, উদাহরণ হিসাবে আমার উত্তরটি দেখুন।
— কার্ল ন্যাপফ
1
@ কার্লনাপফ আপনার উত্তরগুলি আমার উত্তরগুলির v2 ... আরও ভাল ধন্যবাদ
— মুকুল কুমার
5

পাইথন 2, 68 64 68 বাইট

-4 বাইট অ্যাটলোলজিস্টকে ধন্যবাদ

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

* ইনপুট একটি স্ট্রিং

— যষ্টি
সূত্র
4 সংরক্ষণ করুন:lambda n:sum(int(n)%eval(n[:i]+'+'+n[i:])for i in range(len(n)))
— আটলোলজিস্ট
1
এর সাথে 8বা তার 9পরে শূন্য থাকা ইনপুটগুলিতে ব্যর্থ হয় এবং অন্যের জন্য ভুল উত্তর দেয় (শেষ পরীক্ষার ক্ষেত্রে যেমন)। শূন্যের সাথে শুরু হওয়া নম্বরগুলি অষ্টাল। repl.it/EmMm
— mbomb007
@ mbomb007 স্থির
— রড
4

সি, 59 বাইট

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

tহয় 10,100,1000,...এবং বড় সংখ্যা কাটা প্রতিনিধিত্ব করে। n/tডান অংশ এবং n%tবাম অংশ। যদি tসংখ্যার চেয়ে বড় হয় তবে এটি শেষ।

অবহেলিত এবং ব্যবহার:

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));
}
— কার্ল ন্যাপ
সূত্র
ওহহ্ আমার .... দয়া করে একটি ব্যাখ্যা যুক্ত করুন।
— মুকুল কুমার
@ মুকুলকুমার ঠিক আছে?
— কার্ল ন্যাপ
হ্যাঁ এটা দুর্দান্ত।
— মুকুল কুমার
3

রেটিনা , 38 বাইট

বাইট গণনাটি আইএসও 8859-1 এনকোডিং ধরেছে।

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

1

হুবহু দক্ষ নয় ...

এটি অনলাইন চেষ্টা করুন! (প্রথম লাইন একটি লাইনফিড-বিচ্ছিন্ন পরীক্ষা স্যুট সক্ষম করে))

ব্যাখ্যা

\B
,$';$_¶$`

প্রতিটি জোড়া অক্ষরের মধ্যে আমরা একটি কমা, ম্যাচের সামনের সবকিছু, একটি সেমিকোলন, পুরো ইনপুট, একটি লাইনফিড এবং ম্যাচের পরে সমস্ত কিছু সন্নিবেশ করি। ইনপুট জন্য 12345এটি আমাদের দেয়:

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

অর্থাৎ ইনপুটটির এক জোড়া সহ ইনপুটটির প্রতিটি সম্ভাব্য বিভাজন। যদিও আমাদের শেষ লাইনের দরকার নেই:

G-2`

আমরা এটি বাতিল করি।

\d+|,
$*

এটি প্রতিটি সংখ্যার পাশাপাশি কমাটিকে তার অবিচ্ছিন্ন উপস্থাপনের সাথে প্রতিস্থাপন করে। যেহেতু কমা কোনও সংখ্যা নয়, এটি শূন্য হিসাবে গণ্য করা হয় এবং কেবল সরানো হয়। এটি প্রতিটি বিভাজনে দুটি অংশ যুক্ত করে।

(1+);\1*

এটি দ্বিতীয় সংখ্যা থেকে প্রথম সংখ্যার সমস্ত অনুলিপি সরিয়ে মডুলোর গণনা করে।

1

এটি হ'ল, আমরা কেবল গণনা 1করি স্ট্রিংয়ে কতগুলি বাকী রয়েছে এবং ফলাফলটি প্রিন্ট করুন।

— মার্টিন ইন্ডার
সূত্র
3

পাইথ, 14 বাইট

s.e%QssMc`Q]k`

একটি প্রোগ্রাম যা কোনও পূর্ণসংখ্যার ইনপুট নেয় এবং ফলাফল মুদ্রণ করে।

পরীক্ষা স্যুট

কিভাবে এটা কাজ করে

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
— TheBikingViking
সূত্র
3

গণিত, 75 বাইট

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

এটির সমস্ত পার্টিশন দুটি অংশে নিষ্কাশনের জন্য ডিজিটের তালিকার সাথে প্যাটার্ন মেলানো ব্যবহার করে। প্রতিটি যেমন পার্টিশন aএবং bতারপর প্রতিস্থাপিত হয়

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

এখানে উল্লেখযোগ্য যে অসম দৈর্ঘ্যের তালিকার অঙ্কের, unevaluated থাকা তাই যেমন যদি aহয় 1,2এবং bহয় 3,4,5তারপর আমরা প্রথম এই প্রতিস্থাপন {1,2} + {3,4,5} + {}। শেষ শর্তটি নিশ্চিত করার জন্য রয়েছে যে যখন আমরা সমানভাবে সংখ্যার অঙ্কগুলি বিভক্ত করি তখনও এটি অপরিবর্তিত থাকে। এখন Mapম্যাথামেটিকায় অপারেশন পর্যাপ্ত সাধারণীকরণ করা হয়েছে যে এটি কেবল তালিকা নয়, কোনও ধরণের অভিব্যক্তির সাথে কাজ করে। সুতরাং আমরা যদি FromDigitsএই অঙ্কের উপরে মানচিত্র করি তবে এটি সেই তালিকাগুলির প্রত্যেককে একটি সংখ্যায় ফিরিয়ে দেবে। এই মুহুর্তে, অভিব্যক্তিটি পূর্ণসংখ্যার যোগফল, যা এখন মূল্যায়ন হয়। এটি আরও প্রচলিত সমাধানের উপর একটি বাইট সংরক্ষণ করে Tr[FromDigits/@{{a},{b}}]যা প্রথমে দুটি তালিকাকে রূপান্তর করে এবং তারপরে ফলাফলটি যোগ করে।

— মার্টিন ইন্ডার
সূত্র
3

আসলে , 16 15 বাইট

গল্ফিং পরামর্শ স্বাগত! এটি অনলাইন চেষ্টা করুন!

সম্পাদনা করুন: -1 বাইট টিল পেলিকানকে ধন্যবাদ

;╗$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.
— Sherlock9
সূত্র
যদি আপনি functions% কে ফাংশন বিভাগের ভিতরে নিয়ে যান তবে আপনাকে use ব্যবহার করার দরকার নেই এবং এটি আপনাকে 1 বাইট সংরক্ষণ করবে: ডি (; ╗ r lr ╤╜d+╜%MΣ)
— পেলিকান
@ ট্রিলিপেলিকান টিপটির জন্য ধন্যবাদ: ডি আপনি অন্য কোনও গল্ফিং পরামর্শ নিয়ে এসেছেন কিনা আমাকে জানতে দিন
— শার্লক 9
2

রুবি, 64 বাইট

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

স্ট্রিং হিসাবে ইনপুট নেয়

— লি ডাব্লু
সূত্র
দুর্ভাগ্যক্রমে, রুবি অষ্টাল 0হিসাবে শুরু পূর্ণসংখ্যার অক্ষরগুলির ব্যাখ্যা করে , যার অর্থ এটি শেষ পরীক্ষার ক্ষেত্রে ব্যর্থ। এখানে একটি 78-বাইট সমাধান দেওয়া হয়েছে ।
— বেনজ 2240
2

বেফুঞ্জ, 101 96 বাইট

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

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

&              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.
— জেমস হোল্ডারেন্স
সূত্র
2

এপিএল, 29 বাইট

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

⎕IOঅবশ্যই 1। ব্যাখ্যা (আমি ব্যাখ্যা করতে ভাল নই, এটির যে কোনও প্রতিচ্ছবি খুব স্বাগত):

{+/⍵|⍨{(⍎⍵↑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
— Zachary
সূত্র
সেখানে, এটি সম্পন্ন হয়েছে।
— জাকারি
2

সি #, 67 বাইট

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

অসম্পূর্ণ, ব্যাখ্যা পদ্ধতি এবং পরীক্ষার কেস সহ সম্পূর্ণ প্রোগ্রাম:

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
    }
}
— adrianmp
সূত্র
2

সংযুক্তি , 48 বাইট

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

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

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
— কনর ও ব্রায়ান
সূত্র
1

ক্লোজার, 91 81 বাইট

সম্পাদনা করুন: এটি একটি অনামী ফাংশন হিসাবে ঘোষিত (fn[v](->> ...))এবং ->>ম্যাক্রো ব্যবহার না করার কারণে এটি ছোট এবং যদিও সেভাবে পড়া এবং কল করা সহজ ছিল।

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

মূল:

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

1, 10, 100, ... এর ক্রম উত্পন্ন করে এবং প্রথম 10 টি আইটেম নেয় (ধরে নিলে ইনপুট মানগুলি 10 ^ 11 এর চেয়ে কম হয়), চশমাগুলিতে নির্দিষ্ট হিসাবে মডুলগুলিতে মানচিত্রগুলি এবং যোগফল গণনা করে। দীর্ঘ ফাংশন নামগুলি এই সমাধানটিকে বেশ দীর্ঘ করে তোলে তবে কমপক্ষে এমনকি গল্ফযুক্ত সংস্করণটিও অনুসরণ করা বেশ সহজ হওয়া উচিত।

প্রথমে আমি চারপাশে ঝাঁকুনির স্ট্রিং চেষ্টা করেছিলাম তবে এটির জন্য অনেক টাকার বয়লারপ্লেট প্রয়োজন।

— NikoNyrh
সূত্র
1

র‌্যাকেট 134 বাইট

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

পরীক্ষামূলক: 

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

আউটপুট: 

5842
1
6
2097
8331
505598476
— rnso
সূত্র
অনেক কাছের
— পেরেন
এটি প্রদর্শিত হিসাবে এটি কঠিন নয়।
— rnso
0

রুবি 45 বাইট

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

এটি সত্যই ঝরঝরে সমাধান। এটি প্রযুক্তিগতভাবে সঠিক, তবে এটি সুপার অদক্ষ। এটি q.to_s.size.times write ... write লিখতে আরও দক্ষ হবে} আমরা কি.টাইমস ব্যবহার করি কারণ এটি অক্ষরগুলি সংরক্ষণ করে, এবং এক্সপ্রেশনটি কেবল শূন্যকে মূল্যায়িত করে অতিরিক্ত পরিমাণে প্র্যাকের মধ্য দিয়ে যায়।

— ফিলিপ ওয়েস
সূত্র
দুঃখিত! এটি রুবিতে লেখা 45 বাইট সমাধান। আমি তা সম্পাদন করতে পোস্ট সম্পাদনা করেছি।
— ফিলিপ ওয়েইস
46 বাইট রানার-আপ: ->q{(0..q).reduce{|s,x|p=10**x;s+q%(q/p+q%p)}}
— ফিলিপ ওয়েস
0

জাপট , 11 10 বাইট

¬x@%OvUi+Y

চেষ্টা করে দেখুন

ব্যাখ্যা

               :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
— রোমশ
সূত্র
1
এটি নিম্ন মানের হিসাবে চিহ্নিত হয়েছে: পি
— ক্রিস্টোফার
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.