যে নম্বরটি নিজেই খেতে পারে

30

একটি ধনাত্মক পূর্ণসংখ্যা দেওয়া হয়েছে, সংখ্যাটি নিজেই খেতে পারে কিনা সে সম্পর্কে সত্যবাদী / মিথ্যা মান আউটপুট করুন।

বিধি

বাম দিকের মাথাটি, ডানদিকের লেজ

মাথা যদি লেজের চেয়ে বড় বা সমান হয় তবে মাথা লেজটি খায় এবং নতুন মাথা তাদের যোগফল হয়ে যায়।

তাহলে sum≥10 তারপর মাথা দ্বারা প্রতিস্থাপিত হয় ।summod10

sum=0 উপেক্ষা করা যায় না, তবে ইনপুট সংখ্যাটিতে কোনও শীর্ষ জিরো থাকবে না।

উদাহরণ:

number=2632
head-2, tail-2

2632 -> 463
head-4, tail-3

463 -> 76
head-7, tail-6

76 -> 3
If only one digit remains in the end, the number can eat itself.

যদি কোনও পর্যায়ে মাথা লেজ খেতে না পারে তবে উত্তরটি মিথ্যা হবে।

number=6724
072
False (0<2)

পরীক্ষার কেস:

True:
[2632, 92258, 60282, 38410,3210, 2302, 2742, 8628, 6793, 1, 2, 10, 100, 55, 121]

False:
[6724, 47, 472, 60247, 33265, 79350, 83147, 93101, 57088, 69513, 62738, 54754, 23931, 7164, 5289, 3435, 3949, 8630, 5018, 6715, 340, 2194]

এটি কোড-গল্ফ তাই সংক্ষিপ্ততম কোডের জয়।

code-golf  decision-problem 
— বেদন্ত কান্দোই
সূত্র
আমরা কি স্ট্রিং হিসাবে ইনপুট নিতে পারি?
— lirtosiast
@ লিরিটোসিস্ট, হ্যাঁ, তবে অঙ্কগুলির তালিকা নয়।
— বেদন্ত কান্দোই
14
এগুলিকে অটোক্যানিবালিস্টিক নাম্বার বলা যেতে পারে ।
— আর্নল্ড
6
অঙ্কের তালিকা হিসাবে আমরা গ্রহণ করতে না পারার কারণ কী? এই সমস্যাটি ইতিমধ্যে তাদের সাথে আচরণ করে যেন তারা অঙ্কের তালিকা। তাদের সংখ্যা হিসাবে বাধ্য করার অর্থ হল যে আপনি তাদের তালিকায় রূপান্তর করতে কেবল অতিরিক্ত কোড পিন করতে হবে।
— গম উইজার্ড 14
1
সত্যবাদী / মিথ্যা বলার পরিবর্তে দুটি ধারাবাহিক স্বতন্ত্র মান ফিরে পাওয়া যায় কি?
— অলিভিয়ার গ্রাগোয়ার

উত্তর:

7

জাভাস্ক্রিপ্ট (ES6),  52 51  50 বাইট

1 টি বাইট সংরক্ষিত হয়েছে @tsh এর জন্য ধন্যবাদ

স্ট্রিং হিসাবে ইনপুট নেয়। একটি বুলিয়ান মান প্রদান করে।

f=n=>n>[n%10]?f(-(-n[0]-n)%10+n.slice(1,-1)):!n[1]

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

মন্তব্য

f = n =>                 // f = recursive function taking n (a string)
  n > [n % 10]           // The last digit is isolated with n % 10 and turned into a
                         // singleton array, which is eventually coerced to a string
                         // when the comparison occurs.
                         // So we do a lexicographical comparison between n and its
                         // last digit (e.g. '231'>'1' and '202'>'2', but '213'<'3').
  ?                      // If the above result is true:
    f(                   //   do a recursive call:
      -(-n[0] - n) % 10  //     We compute (int(first_digit) + int(n)) mod 10. There's no
                         //     need to isolate the last digit since we do a mod 10 anyway.
      + n.slice(1, -1)   //     We add the middle part, as a string. It may be empty.
    )                    //   end of recursive call
  :                      // else:
    !n[1]                //   return true if n has only 1 digit, or false otherwise
— Arnauld
সূত্র
1
— tsh
6

জেলি , 11 বাইট

Ṛṙ-µṖÄ%⁵:ḊẠ

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

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

Ṛṙ-µṖÄ%⁵:ḊẠ  Main link. Argument: n

Ṛ            Reverse n, after casting it to a digit list.
 ṙ-          Rotate the result -1 units to the left, i.e., 1 unit to the right.
             Let's call the resulting digit list D.
   µ         Begin a new chain with argument D.
    Ṗ        Pop; remove the last digit.
     Ä       Accumulate; take the cumulative sum of the remaining digits.
      %⁵     Take the sums modulo 10.
         Ḋ   Dequeue; yield D without its first digit.
        :    Perform integer division between the results to both sides.
             Integer division is truthy iff greater-or-equal is truthy.
          Ạ  All; return 1 if all quotients are truthy, 0 if not.
— ডেনিস
সূত্র
6

পার্ল 6 , 63 62 বাইট

{!grep {.[*-1]>.[0]},(.comb,{.[0,*-1].sum%10,|.[1..*-2]}...1)}

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

ব্যাখ্যা:

{                                                            } # Anonymous code block
                     (                                  ... )       # Create a sequence
                      .comb,  # Starting with the input converted to a list of digits
                            {                          }   # With each element being
                             .[0,*-1]   # The first and last element of the previous list
                                     .sum%10  # Summed and modulo 10
                                            ,|.[1..*-2]   # Followed by the intermediate elements
                                                        ...1 # Until the list is length 1
 !grep   # Do none of the elements of the sequence
       {.[*-1]>.[0]},   # Have the last element larger than the first?
— জো কিং
সূত্র
5

জাভা (জেডিকে) , 83 বাইট

n->{int r=0,h=n;while(h>9)h/=10;for(;n>9;h=(h+n)%10,n/=10)r=h<n%10?1:r;return r<1;}

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

ক্রেডিট

— অলিভিয়ার গ্রাগোয়ার
সূত্র
পাইথনের উত্তরগুলির দৈর্ঘ্য দেওয়া দেখে মনে হচ্ছে আমি কিছু মিস করেছি ... যদিও পরীক্ষার কেসগুলি ঠিক আছে।
— অলিভিয়ের গ্রাগোয়ার
আমি মনে করি না আপনি কিছু মিস করেছেন। পাইথন উভয় উত্তর ইনপুটটিকে স্ট্রিং হিসাবে ব্যবহার করে এবং সূচক ব্যবহার করে এবং আপনি ইনপুটটিকে পূর্ণসংখ্যার হিসাবে এবং ব্যবহার /10এবং %10একটি লুপ হিসাবে গ্রহণ করেন । পাইথনের উত্তরগুলিকে মারধর করা খুব ভাল হয়েছে; আমার কাছ থেকে +1 :)
— কেভিন ক্রুজসেন
1
আপনি গলফ একটি বাইট পরিবর্তন করতে পারেন r+=করতে r=এবং ?1:0করতে ?1:r।
— কেভিন ক্রুইজসেন
@ কেভিন ক্রুইজসেন আসলেই ... পাইথন উত্তরগুলি সাবমোটিমাল: মন্তব্যগুলিতে গল্ফগুলি এই উত্তরটির চেয়ে ছোট। এছাড়াও, বাইট সংরক্ষণের জন্য ধন্যবাদ! ;-)
— অলিভিয়ার গ্রাগোয়ার
শুরু করে এবং করে (1 বাইট সংরক্ষণ করে) আপনি বা 1 ফিরে আসতে পারেন । 01r=1r&=h<n%10?0:r;return r;
— আর্নৌল্ড
4

গণিত, 62 বাইট

0(IntegerDigits@#//.{a_,r___,b_}/;a>=b:>{Mod[a+b,10],r})=={0}&

প্রথমে ইনপুটটিতে IntegerDigitsতার অঙ্কগুলির তালিকা পেতে কল করুন, তারপরে বারবার নিম্নলিখিত নিয়মটি প্রয়োগ করুন:

{a_,r___,b_}       (* match the first digit, 0 or more medial digits, and the last digit... *)
/;a>=b             (* under the condition that the number is edible... *)
:>{Mod[a+b,10],r}  (* and replace it with the next iteration *)

নিয়মটি প্রয়োগ করা হয় যতক্ষণ না প্যাটার্নটি আর মেলে না, এক্ষেত্রে হয় কেবলমাত্র একটি অঙ্ক বাকি থাকে (সত্যবাদী) বা মাথাটি লেজের চেয়ে কম থাকে (মিথ্যা)।

কল করার পরিবর্তে Length[__]==1আমরা কয়েকটি বাইট সংরক্ষণ করতে পারি 0(__)=={0}, তালিকার সমস্ত উপাদানকে দিয়ে গুণিত করে 0 এবং তারপরে তালিকার সাথে তুলনা করতে পারি {0}।

— ডোরকনব
সূত্র
1
আপনি যদি না জানতেন তবে টিআইওর এখন ম্যাথমেটিকা ​​আছে। এটি অনলাইন চেষ্টা করুন!
— ডেনিস
4

পাইথন 3 , 50 বাইট

ব্ল্যাক আউল কাইয়ের উত্তর থেকে প্রথম লাইন চুরি ।

p,*s=map(int,input())
while s:*s,k=s;p%10<k>q;p+=k

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

আউটপুটটি প্রস্থান কোডের মাধ্যমে হয়। মিথ্যা ইনপুটগুলির জন্য ব্যর্থ (1) এবং সত্যবাদী ইনপুটগুলির জন্য সমাপ্তি (0)।

— ovs
সূত্র
আপনি যদি ব্যাখ্যা করতে পারেন যে p%10<k>qযদি নামেরার ছুঁড়ে না কেন p%10 >= k?
— কালো আউল কাই
1
@ ব্লাকওলকাই শৃঙ্খলিত তুলনা পাইথনে অলসভাবে মূল্যায়ন করা হয়। এর অর্থ প্রথম মিথ্যা তুলনা উপস্থিত হওয়ার সাথে সাথে চেইনের আর মূল্যায়ন হবে না। এই ক্ষেত্রে p%10<k>qহিসাবে একই কাজ করে p%10<k and k>q।
— ovs
4

পাইথন 2 , 105 82 81 বাইট

i,x=map(int,input()),1
for y in i[:0:-1]:
 if i[0]%10<y:x=0
 else:i[0]+=y
print x

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

@ JanrjanJohansen- এর পক্ষ থেকে একটি বিশাল -23 এর জন্য অনেক ধন্যবাদ

আরও একটি -1 এর জন্য @ ওয়েডেন্টকান্দোই (এবং @ janrjanJohansen) কে ধন্যবাদ

— ElPedro
সূত্র
1
আপনি forএকটি বিপরীত স্লাইস ব্যবহার করতে পারেন , এবং %10পরীক্ষার সময় শুধুমাত্র এটি
— janrjan জোহানসেন
1
যদি-অন্য শর্তটি অদলবদল করুন if i[0]<i[-1]:x=0এবং তারপরে else:....। @ Janরঞ্জন জোহানসেন, আপনার উত্তরেও।
— বেদন্ত কান্দোই
@ আরজানজাহানসেন - ধন্যবাদ এটা ভাল।
— এলপেড্রো
আরে @ ওয়েডেন্টকান্দোই। ভাল লাগছে তবে ঠিক কী বলতে চাইছেন তা নিশ্চিত নয়। তুমি আমাকে মারতে পেরেছ। আপনি একটি টিআইও যোগ করতে পারেন দয়া করে? যখন আমি চেষ্টা করি এটি সমস্ত Trueক্ষেত্রে কাজ করে তবে সমস্ত ক্ষেত্রে নয় False।
— এলপেড্রো
1
আমি মনে করি @ ওয়েডেন্টকান্দোই এর অর্থ এটি ।
— janর্জন জোহানসেন
4

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

ẹ{bkK&⟨h{≥₁+tg}t⟩,K↰|Ȯ}

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

এটি ফ্যাটালাইজের সমাধানের চেয়ে 1 বাইট বেশি । এটি পুনরাবৃত্তির পরিবর্তে পুনরাবৃত্ত পদ্ধতির ব্যবহার করে

ব্যাখ্যা

ẹ                          Input into a list of digits
 {                    }    Assert that either
  bk                       | the list has at least 2 elements (see later)
      ⟨h{     }t⟩           | and that [head, tail]
         ≥₁                |  | is increasing (head >= tail)
           +               |  | and their sum
            t              |  | mod 10 (take last digit)
             g             |  | as single element of a list
                ,          | concatenated with
  bkK            K         | the number without head and tail (this constrains the number to have at least 2 digits)
                  ↰        | and that this constraint also works on the newly formed number
                   |Ȯ      | OR is a 1 digit number
— Kroppeb
সূত্র
3

এপিএল (ডায়ালগ ইউনিকোড) , 33 বাইট এসবিসিএস

আর্গুমেন্ট হিসাবে একটি স্ট্রিং নিয়ে বেনামে টাসিট উপসর্গ ফাংশন। 

{⊃⍵<t←⊃⌽⍵:0⋄3::1⋄∇10|t+@1⊢¯1↓⍵}⍎¨

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

⍎¨ প্রতিটি অক্ষরকে মূল্যায়ন করুন (এটি আমাদের সংখ্যার একটি তালিকা দেয়)

{… } নিম্নলিখিত "dfn" প্রয়োগ করুন; ⍵আর্গুমেন্ট (সংখ্যার তালিকা):

  ⌽⍵ যুক্তি বিপরীত

  ⊃ প্রথম উপাদানটি বেছে নিন (এটিই লেজ)

  t← নির্ধারিত t(জন্য টি পীড়িত)

  ⍵< প্রতিটি মূল অঙ্কের জন্য, এটির চেয়ে কম কিনা তা দেখুন

  ⊃ প্রথম সত্য / মিথ্যা চয়ন করুন

 : যদি তাই:

  0 মিথ্যা প্রত্যাবর্তন

 ⋄ তারপর:

 3:: যদি এখন থেকে, একটি সূচি ত্রুটি ঘটে (সীমা ছাড়িয়ে):

  1 সত্য ফিরে

  ¯1↓⍵ শেষ অঙ্কটি ছেড়ে দিন

  ⊢ ফলন করুন (পৃথক হয় 1এবং ¯1তাই তারা একক অ্যারে গঠন করবে না)

  t+@1 প্রথম অঙ্কে লেজ যুক্ত করুন (মাথা)

  10| গেলিক ভাষার -10

  ∇ recurse

একবার আমরা একটি অঙ্কে আঘাত করলে, ¯1↓এটি একটি খালি তালিকা তৈরি করে @1দেবে এবং কোনও প্রথম সংখ্যা না থাকায় সূচী ত্রুটির কারণ ঘটবে, যার ফলে ফাংশনটি সত্যে ফিরে আসবে।

— আদম
সূত্র
3

পাইথন 3 , 77 বাইট

p,*s=map(int,input())
print(all(n<=sum(s[i+1:],p)%10for i,n in enumerate(s)))

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

এবং আমার পুনরাবৃত্তির পদ্ধতির সাথে পুরানো সমাধান

পাইথন 3 , 90 বাইট

f=lambda x,a=0:2>len(x)if 2>len(x)or(int(x[0])+a)%10<int(x[-1])else f(x[:-1],a+int(x[-1]))

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

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

— কালো পেঁচা কাই
সূত্র
3

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

ẹ;I⟨⟨h{≥₁+tg}t⟩c{bk}⟩ⁱ⁾Ȯ

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

আমার ⁱডিফল্ট আচরণটি পরিবর্তন করা উচিত যাতে এটি অজানা সংখ্যক বার পুনরাবৃত্তি করে (বর্তমানে এটি ডিফল্টরূপে 1 বার পুনরাবৃত্তি করে যা সম্পূর্ণ অকেজো)। আমার তখন […];I[…]⁾3 বাইট সঞ্চয় করার দরকার নেই

ব্যাখ্যা

এই প্রোগ্রামটিতে একটি কাঁটাচামচের ভিতরে একটি কুরুচিযুক্ত কাঁটাচামচ রয়েছে। সংখ্যার পরিবর্তে অঙ্কের তালিকাগুলিতে কাজ করার জন্য কিছু নদীর গভীরতানির্ণয়ও রয়েছে (কারণ আমরা যদি আমাদের মাথা এবং লেজটি সরিয়ে 76রাখি 0, যা [7,6]আমরা যেখানে শেষ করি তার বিপরীতে কাজ করে না [])।

ẹ                          Input into a list of digits
                       Ȯ   While we don't have a single digit number…
 ;I                  ⁱ⁾    …Iterate I times (I being unknown)…
   ⟨                ⟩      …The following fork:
               c           | Concatenate…
    ⟨         ⟩            | The output of the following fork:
     h       t             | | Take the head H and tail T of the number
      {     }              | | Then apply on [H,T]:
       ≥₁                  | | | H ≥ T
         +                 | | | Sum them
          tg               | | | Take the last digit (i.e. mod 10) and wrap it in a list
                {  }       | With the output of the following predicate:
                 bk        | | Remove the head and the tail of the number
— Fatalize
সূত্র
পুনরাবৃত্তির পরিবর্তে পুনরাবৃত্তি ব্যবহার করা এবং সি-কাঁটাচামচ ব্যবহার করার ,পরিবর্তে আমি 1 বাইট অপসারণ করতে পারলাম অনলাইনে চেষ্টা করুন!
— ক্রপবেব
পছন্দ করুন আমি মনে করি আপনার নিজের উত্তর পোস্ট করা উচিত, কারণ এটি আমার চেয়ে উল্লেখযোগ্যভাবে পৃথক!
— ফ্যাটালাইজ করুন
3

হাস্কেল, 70 64 60 বাইট

f(a:b)=b==""||a>=last b&&f(last(show$read[a]+read b):init b)

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

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

সম্পাদনা: -6 বাইটগুলি পৃথক প্রহরীগুলির|| পরিবর্তে @ লাইকোনির কৌশল ব্যবহার করে । অন্য লাইকনি -4 বাইট ধন্যবাদ।

— nimi
সূত্র
3
read[l b]read bআপনি কেবলমাত্র শেষ সংখ্যাটি যাইহোক দেখেন কারণ এটি হতে পারে । ইন-আস্তরণের মাধ্যমে আরও 4 টি বাইট সংরক্ষণ করুনlast : এটি অনলাইনে চেষ্টা করুন!
— লাইকোনি
2

হাস্কেল , 69 64 বাইট

f n=read[show n!!0]#n
h#n=n<10||h>=mod n 10&&mod(h+n)10#div n 10

এটি অনলাইন চেষ্টা করুন! ব্যবহারের উদাহরণ: f 2632ফলন True।

সম্পাদনা করুন: -5 বাইট কারণmod (h + mod n 10) 10 = mod (h + n) 10

— Laikoni
সূত্র
এর দুর্দান্ত ব্যবহার ||, যা আমাকে আমার উত্তরও ছোট করতে সাহায্য করেছিল। ধন্যবাদ!
— নিমি
2

রুবি, 139 বাইট

->(a){a.length==1?(p true;exit):1;(a[0].to_i>=a[-1].to_i)?(a[0]=(a[-1].to_i+a[0].to_i).divmod(10)[1].to_s;a=a[0..-2];p b[a]):p(false);exit}

এটি অনলাইন চেষ্টা করুন!(ইনপুট প্রক্রিয়াজাতকরণের জন্য কিছু অতিরিক্ত কোড রয়েছে কারণ এটি একটি ফাংশন)

অবহেলিত কোড:

->(a) do
    if a.length == 1
        p true
        exit
    if a[0].to_i >= a[-1].to_i
        a[0] = (a[-1].to_i + a[0].to_i).divmod(10)[1].to_s
        a = a[0..-2]
        p b[a]
    else
        p false
        exit
    end
end
— সিজি ওয়ান হ্যান্ড
সূত্র
1

রেটিনা 0.8.2 , 42 বাইট

\d
$*#;
^((#*).*;)\2;$
$2$1
}`#{10}

^#*;$

এটি অনলাইন চেষ্টা করুন! লিঙ্ক পরীক্ষার কেস অন্তর্ভুক্ত। ব্যাখ্যা:

\d
$*#;

অঙ্কগুলি আনআরিটে রূপান্তর করুন এবং বিভাজক সন্নিবেশ করান।

^((#*).*;)\2;$
$2$1

শেষ সংখ্যাটি যদি প্রথমটির চেয়ে বেশি না হয় তবে তাদের একসাথে যুক্ত করুন।

#{10}

উপযুক্ত হলে মডুলো 10 হ্রাস করুন।

}`

প্রথম সংখ্যাটি প্রথমের চেয়ে বড় না হওয়া পর্যন্ত বা কেবলমাত্র এক অঙ্কের বাকী না হওয়া পর্যন্ত পুনরাবৃত্তি করুন।

^#*;$

কেবলমাত্র একটি অঙ্ক বাকি আছে কিনা তা পরীক্ষা করুন।

— নিল
সূত্র
1

05 এ বি 1 ই , 26 25 24 বাইট

[DgD#\ÁD2£D`›i0qëSOθs¦¦«

সম্ভবত আরও কিছুটা গল্ফ করা যেতে পারে .. এটি অত্যধিক দীর্ঘ অনুভূত হয়, তবে সম্ভবত চ্যালেঞ্জটি কোডের দিক দিয়ে যা আমি আগে চিন্তা করেছিলাম তার চেয়ে জটিল।

এটি অনলাইনে চেষ্টা করুন বা সমস্ত পরীক্ষার কেস যাচাই করুন ।

ব্যাখ্যা:

[                 # Start an infinite loop
 D                #  Duplicate the top of the stack
                  #  (which is the input implicitly in the first iteration)
  gD              #  Take its length and duplicate it
    #             #  If its a single digit:
                  #   Stop the infinite loop
                  #   (and output the duplicated length of 1 (truthy) implicitly)
                  #  Else:
  \               #   Discard the duplicate length
   Á              #   Rotate the digits once towards the left
    D2£           #   Duplicate, and take the first two digits of the rotated number
       D`         #   Duplicate, and push the digits loose to the stack
         ›i       #   If the first digit is larger than the second digit:
           0      #    Push a 0 (falsey)
            q     #    Stop the program (and output 0 implicitly)
          ë       #   Else (first digit is smaller than or equal to the second digit):
           SO     #    Sum the two digits
             θ    #    Leave only the last digit of that sum
           s      #    Swap to take the rotated number
            ¦¦    #    Remove the first two digits
              «   #    Merge it together with the calculated new digit
— কেভিন ক্রুইজসেন
সূত্র
1

সি ++ (জিসিসি) , 144 বাইট

bool f(std::string b){int c=b.length();while(c>1){if(b[0]<b[c-1])return 0;else{b[0]=(b[0]-48+b[c-1]-48)%10+48;b=b.substr(0,c-1);--c;}}return 1;}

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

প্রথমবার আমি এই জাতীয় কিছু চেষ্টা করছি তাই যদি আমি কিছু ভুল ফর্ম্যাট করি তবে দয়া করে আমাকে জানান। 5 বাইট "std ::" মুছে ফেলার জন্য নেমস্পেস ব্যবহার করার মতো স্টাফের নিয়মের বিষয়ে আমি 100% নিশ্চিত নই তাই আমি এটিকে রেখে দিয়েছি।

Ungolfed:

bool hunger(std::string input)
{
    int count=input.length();
    while (count>1)
    {
        if (input[0]<input[count-1])                         //if at any point the head cannot eat the tail we can quit the loop
                                                             //comparisons can be done without switching from ascii
        {
            return false;
        }
        else
        {
             input[0]=(input[0]-48+input[count-1]-48)%10+48; //eating operation has to occur on integers so subtract 48 to convert from ASCII to a number
             input=input.substr(0,count-1);                  //get rid of the last number since it was eaten
             --count;
        }

    }
    return true;                                             //if the end of the loop is reached the number has eaten itself
}
— বেন এইচ
সূত্র
1
তত্ত্বের ক্ষেত্রে আপনার #includeবিবৃতিও দরকার । যাইহোক, আমি প্রিপেন্ড করা সহ সি ++ এর স্ট্যান্ড লাইব সুবিধাগুলি উপ-ডায়ালেক্টে প্রোগ্রামিংয়ের প্রস্তাব দেব #include "std_lib_facilities.h", যা একটিও করে using namespace std;। সেই শিরোনামটি সি ++ এ নতুন শিক্ষার্থীদের জন্য ভাষার পথে ফিরে (সর্বশেষতম সংস্করণ 2010) এর লেখক লিখেছিলেন।
— ইয়াক
@ ইয়াক্ক আপনি যদি এমন কোনও দোভাষী তৈরি না করেন এবং প্রকাশ না করেন যা আপনার জন্য এটি করে থাকে তবে আপনাকে এখনও স্টডি_লিব_ফেসিলিটিএস অন্তর্ভুক্ত গণনা করতে হবে।
— ডেনিস
@ বেনহ পিপিসিজিতে আপনাকে স্বাগতম! আপনার ফাংশনটি সংকলনের জন্য প্রয়োজনীয় সমস্ত গণনা দরকার। সবচেয়ে কম পদ্ধতি আমি জানি #import<string>। এটি অনলাইন চেষ্টা করুন!
— ডেনিস
@ ডেনিস #!/usr/bin/shনিউলাইন gcc -include "std_lib_facilities.h" $@- যদি আমি একটি সি ++ কোর্স পাই যা শেল স্ক্রিপ্ট সরবরাহ করে, তবে তা গণনা করা যাবে?
— ইয়াক
@ ইয়াক্ক এই সুইচটি সম্পর্কে জানতেন না। # অন্তর্ভুক্ত বিবৃতিগুলির বিপরীতে, কমান্ড-লাইন আর্গুমেন্টগুলি বিনামূল্যে কারণ তারা মূলত একটি নতুন ভাষা । ইন সি ++ (জিসিসি)-include iostream , এই প্রকৃতপক্ষে 144 বাইট।
— ডেনিস
1

সি (জিসিসি) (স্ট্রিং। সহ) , 110 108 বাইট

c;f(char*b){c=strlen(b);if(!c)return 1;char*d=b+c-1;if(*b<*d)return 0;*b=(*b+*d-96)%10+48;*d=0;return f(b);}

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

পিপিসিজিতে এখনও তুলনামূলকভাবে নতুন, সুতরাং লাইব্রেরিগুলিকে একটি নতুন ভাষা হিসাবে যুক্ত করার জন্য সঠিক বাক্য গঠন আমার কাছে বিদেশী। এছাড়াও মনে রাখবেন যে ফাংশনটি মিথ্যা / সত্যের জন্য 0 বা 1 প্রদান করে এবং ফলাফলটি মুদ্রণের জন্য stdio প্রয়োজন হয় না। যদি আমরা পেডেন্টিক হয়ে থাকি এবং অনুশীলনের আউটপুট প্রয়োজন হয় তবে ভাষার স্টডিও প্রয়োজন ।

@ বেনহেলের উত্তরের মত ধারণাগতভাবে অনুরূপ, তবে সি তে, তাই কোডো যেখানে তারা প্রদত্ত (পিপিসি, বিটিডব্লুতে স্বাগতম) তবে পুনরাবৃত্তি ব্যবহার করে। এটি অ্যারে পয়েন্টার পাটিগণিতও ব্যবহার করে, কারণ মলিন কোডটি পরিষ্কার কোডের চেয়ে ছোট।

ফাংশনটি লেজ পুনরাবৃত্ত হয়, প্রস্থান শর্তগুলির সাথে যদি প্রথম সংখ্যাটি শেষ না খেতে পারে বা দৈর্ঘ্য 1 হয় যথাক্রমে মিথ্যা বা সত্য প্রত্যাবর্তন করে। এই মানগুলি স্ট্রিংয়ের শুরু এবং শেষের দিকে সি-স্ট্রিংয়ের (যা একটি চর দেয়) একটি পয়েন্টারকে ডিফারেন্স করে এবং তার সাথে তুলনা করে খুঁজে পাওয়া যায়। পয়েন্টার গাণিতিকটি স্ট্রিংয়ের শেষ সন্ধানের জন্য করা হয়। অবশেষে, শেষ চরটি নাল টার্মিনেটর (0) এর পরিবর্তে "মুছে ফেলা" হবে।

এটি সম্ভব যে মডিউলাস গাণিতিকটি একটি বা দুটি বাইট দ্বারা সংক্ষিপ্ত করা যেতে পারে, তবে ইতিমধ্যে সেই পয়েন্টার হেরফেরের পরে আমার একটি ঝরনা দরকার।

অসম্পূর্ণ সংস্করণ এখানে

আপডেট: সি == 1 প্রতিস্থাপনের মাধ্যমে দুটি বাইট সংরক্ষিত! সি। এটি মূলত সি == ০. এটি অতিরিক্ত সময় চলবে এবং অকারণে নিজেকে মুছে ফেলার আগে দ্বিগুণ হবে, তবে দুটি বাইট সংরক্ষণ করে। একটি পার্শ্ব প্রতিক্রিয়া নাল বা শূন্য দৈর্ঘ্যের স্ট্রিং অসীম পুনরাবৃত্তি ঘটায় না (যদিও অনুশীলনটি ইতিবাচক পূর্ণসংখ্যা বলে আমাদের নাল স্ট্রিংগুলি পাওয়া উচিত নয়)।

— অ্যান্ড্রু বাউমার
সূত্র
আপনার ক্ষেত্রে লাইব্রেরিগুলি লিঙ্ক করার দরকার নেই gcc- যদিও সতর্কতা উত্পন্ন gccহবে তবে আনন্দের সাথে আপনার কোডটি সঙ্কলিত করবে #include। এছাড়াও, আপনি 4 বাইটের সাহায্যে সঞ্চয় করতে পারেন -DR=return। অবশেষে, আপনার পরীক্ষার \0কোডগুলিতে এসগুলি অপ্রয়োজনীয়, কারণ স্ট্রিংটি ইতিমধ্যে অন্তর্ভুক্তভাবে অন্তর্ভুক্ত করে।
1
উপরন্তু, আপনি প্রথম পরিবর্তনশীল বরাদ্দ করে একটি ফাংশন থেকে ফিরে যাবে: b=case1?res1:case2?res2:res_else;হিসাবে একইif(case1)return res1;if(case2)return res2;return res_else;
আরও, আপনি ব্যবহার না করে কিছু অতিরিক্ত বাইট ছড়িয়ে দিতে পারেন c: স্ট্রিংটি শূন্য থেকে লম্বা কিনা তা আপনি নির্ধারণ করতে পারেন head-tail।
আপনি কি বুঝতে পারলেন না যে আপনি সি তে টের্নারি (শর্তসাপেক্ষ) অপারেটর ব্যবহার করতে পারেন? নির্বিশেষে, জেনে রাখা ভাল; ভবিষ্যতে আমি এগুলি ব্যবহার করব। চিয়ার্স
— অ্যান্ড্রু বাউমার
1

পাওয়ারশেল, 89 বাইট

"$args"-notmatch'(.)(.*)(.)'-or(($m=$Matches).1-ge$m.3-and(.\g(''+(+$m.1+$m.3)%10+$m.2)))

গুরুত্বপূর্ণ! স্ক্রিপ্ট নিজেকে পুনরাবৃত্তি বলে। সুতরাং স্ক্রিপ্ট হিসাবে সংরক্ষণ করুনg.ps1 বর্তমান ডিরেক্টরিতে ফাইল । এছাড়াও আপনি স্ক্রিপ্ট ফাইল পরিবর্তে স্ক্রিপ্ট ব্লক পরিবর্তনশীল কল করতে পারেন (নীচের পরীক্ষার স্ক্রিপ্ট দেখুন)। এই কলগুলির দৈর্ঘ্য একই।

দ্রষ্টব্য 1: স্ক্রিপ্টটি লজিক অপারেটরগুলির অলস মূল্যায়ন -orএবং ব্যবহার করে -and। যদি "$args"-notmatch'(.)(.*)(.)'হয় Trueতবে এর সঠিক subexpression -orমূল্যায়ন করা হয় না। এছাড়াও যদি ($m=$Matches).1-ge$m.3হয় Falseতবে এর ডান subexpression -andখুব মূল্যায়ন করা হয় না। সুতরাং আমরা অসীম পুনরাবৃত্তি এড়াতে।

দ্রষ্টব্য 2: নিয়মিত এক্সপ্রেশনটিতে '(.)(.*)(.)'সূচনা এবং শেষ অ্যাঙ্কর থাকে না কারণ অভিব্যক্তিটি(.*) ডিফল্টরূপে লোভী।

পরীক্ষার স্ক্রিপ্ট

$g={
"$args"-notmatch'(.)(.*)(.)'-or(($m=$Matches).1-ge$m.3-and(&$g(''+(+$m.1+$m.3)%10+$m.2)))
}

@(
    ,(2632, $true)
    ,(92258, $true)
    ,(60282, $true)
    ,(38410, $true)
    ,(3210, $true)
    ,(2302, $true)
    ,(2742, $true)
    ,(8628, $true)
    ,(6793, $true)
    ,(1, $true)
    ,(2, $true)
    ,(10, $true)
    ,(100, $true)
    ,(55, $true)
    ,(121, $true)
    ,(6724, $false)
    ,(47, $false)
    ,(472, $false)
    ,(60247, $false)
    ,(33265, $false)
    ,(79350, $false)
    ,(83147, $false)
    ,(93101, $false)
    ,(57088, $false)
    ,(69513, $false)
    ,(62738, $false)
    ,(54754, $false)
    ,(23931, $false)
    ,(7164, $false)
    ,(5289, $false)
    ,(3435, $false)
    ,(3949, $false)
    ,(8630, $false)
    ,(5018, $false)
    ,(6715, $false)
    ,(340, $false)
    ,(2194, $false)
) | %{
    $n,$expected = $_
   #$result = .\g $n   # uncomment this line to call a script file g.ps1
    $result = &$g $n   # uncomment this line to call a script block variable $g
                       # the script block call and the script file call has same length
    "$($result-eq-$expected): $result <- $n"
}

আউটপুট:

True: True <- 2632
True: True <- 92258
True: True <- 60282
True: True <- 38410
True: True <- 3210
True: True <- 2302
True: True <- 2742
True: True <- 8628
True: True <- 6793
True: True <- 1
True: True <- 2
True: True <- 10
True: True <- 100
True: True <- 55
True: True <- 121
True: False <- 6724
True: False <- 47
True: False <- 472
True: False <- 60247
True: False <- 33265
True: False <- 79350
True: False <- 83147
True: False <- 93101
True: False <- 57088
True: False <- 69513
True: False <- 62738
True: False <- 54754
True: False <- 23931
True: False <- 7164
True: False <- 5289
True: False <- 3435
True: False <- 3949
True: False <- 8630
True: False <- 5018
True: False <- 6715
True: False <- 340
True: False <- 2194

পাওয়ারশেল, 90 বাইট

কোন পুনরাবৃত্তি। কোনও ফাইলের নাম নির্ভরতা এবং কোনও স্ক্রিপ্ট ব্লকের নাম নির্ভরতা নেই।

for($s="$args";$s[1]-and$s-ge$s%10){$s=''+(2+$s[0]+$s)%10+($s|% S*g 1($s.Length-2))}!$s[1]

একটি পাওয়ারশেল সুস্পষ্টভাবে ডান অপরেন্ডকে এক প্রকারের বাম অপারেণ্ডে রূপান্তর করে। সুতরাং, $s-ge$s%10ডান অপরেন্ড $s%10হিসাবে গণনা করে integerএবং এটির তুলনা করুন stringকারণ বাম অপারেন্ডের ধরণ string। এবং 2+$s[0]+$sএকটি চর $s[0]এবং স্ট্রিংকে রূপান্তর $sকরে integerকারণ বাম অপারেন্ডটি 2পূর্ণসংখ্যা।

$s|% S*g 1($s.Length-2)একটি হল শর্টকাট থেকে$s.Substring(1,($s.Length-2))

— mazzy
সূত্র
1

সি # (ভিজ্যুয়াল সি # ইন্টারেক্টিভ সংকলক) , 69 বাইট

x=>{for(int h=x[0],i=x.Length;i>1;)h=h<x[--i]?h/0:48+(h+x[i]-96)%10;}

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

সাফল্য বা ব্যর্থতা একটি ব্যতিক্রম উপস্থিতি বা অনুপস্থিতি দ্বারা নির্ধারিত হয় । ইনপুট একটি স্ট্রিং আকারে।

কম গল্ফড ...

// x is the input as a string
x=>{
  // h is the head
  for(int h=x[0],
    // i is an index to the tail
    i=x.Length;
    // continue until the tail is at 0
    i>1;)
      // is head smaller larger than tail?
      h=h<x[--i]
        // throw an exception
        ?h/0
        // calculate the next head
        :48+(h+x[i]-96)%10;
}

অক্ষর এবং অঙ্কগুলির মধ্যে রূপান্তর করার জন্য আরও কয়েকটি অতিরিক্ত বাইট রয়েছে তবে সামগ্রিকভাবে এটি আকারটিকে খুব বেশি প্রভাবিত করে না।

— Dana
সূত্র
1

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

ẹ⟨k{z₁{≥₁+t}ᵐ}t⟩ⁱȮ

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

শুধু অ নির্ণায়ক superscriptless শক্তি কর্মদক্ষতার দ্বারা Fatalize এর সমাধান বন্ধ তিন বাইট লাগে ⁱএখন বিদ্যমান, কিন্তু অস্পষ্টভাবে জেলি-অনুপ্রাণিত জিনিসগুলি দ্বারা অন্য তিন হারায় z₁ব্যবহার এড়াতে c, gঅথবা এমনকি h। (চেষ্টা ʰকরেও এবং ব্যর্থ হয়ে অন্য কোনও নতুন বৈশিষ্ট্যটি ব্যবহার করে: অনুপ্রেরণা দ্বারা অনুপ্রাণিত

                 Ȯ    A list of length 1
                ⁱ     can be obtained from repeatedly applying the following
ẹ                     to the list of the input's digits:
 ⟨k{         }t⟩      take the list without its last element paired with its last element,
    z₁                non-cycling zip that pair (pairing the first element of the list with
                      the last element and the remaining elements with nothing),
      {    }ᵐ         and for each resulting zipped pair or singleton list:
       ≥₁             it is non-increasing (trivially true of a singleton list);
          t           take the last digit of
         +            its sum.
— সম্পর্কযুক্ত স্ট্রিং
সূত্র
0

পাওয়ারশেল , 94 91 বাইট

for(;$n-and$n[0]-ge$n[-1]){$n=$n-replace"^.",((+$n[0]+$n[-1]-96)%10)-replace".$"}return !$n

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

পরীক্ষা স্ক্রিপ্ট

function f($n){

for(;$n-and$n[0]-ge$n[-1]){$n=$n-replace"^.",((+$n[0]+$n[-1]-96)%10)-replace".$"}return !$n

Remove-Variable n
}
Write-Host True values:
@(2632, 92258, 60282, 38410,3210, 2302, 2742, 8628, 6793, 1, 2, 10, 100, 55, 121) |
    % { Write-Host "  $_ $(' '*(6-$_.ToString().Length)) $(f $_.ToString())" }

Write-Host False values:
@(6724, 47, 472, 60247, 33265, 79350, 83147, 93101, 57088, 69513, 62738, 54754, 23931, 7164, 5289, 3435, 3949, 8630, 5018, 6715, 340, 2194) | 
    % { Write-Host "  $_ $(' '*(6-$_.ToString().Length)) $(f $_.ToString())" }

অবহেলিত কোড:

function f ($inVar){
    # While the Input exists, and the first character is greater than last
    while($inVar -and ($inVar[0] -ge $inVar[-1])){

        # Calculate the first integer -> ((+$n[0]+$n[-1]-96)%10)
        $summationChars = [int]$inVar[0]+ [int]$inVar[-1]
        # $summationChars adds the ascii values, not the integer literals. 
        $summationResult = $summationChars - 48*2
        $summationModulo = $summationResult % 10

        # Replace first character with the modulo
        $inVar = $inVar -replace "^.", $summationModulo

        # Remove last character
        $inVar = $inVar -replace ".$"
    }
    # Either it doesn't exist (Returns $True), or 
    # it exists since $inVar[0] < $inVar[-1] returning $False
    return !$inVar
}
— KGlasier
সূত্র
1
$n[0]আপনার forবিবৃতিতে আপনাকে যাচাই করা উচিত নয় - কেবলমাত্র চেকিং $nযথেষ্ট be
— অ্যাডমবর্কবার্ক
আপনি এর -6পরিবর্তে ব্যবহার করতে পারেন -96কারণ এটি% 10
— গণনা করা
আপনি return 7 বাইটগুলি সরিয়ে এবং সংরক্ষণ করতে পারেন
— mazzy
এবং আমার মনে হয় আপনার বাইটস গণনাতে একটি প্যারামিটার ঘোষণা অন্তর্ভুক্ত করা উচিত। হয় param($n)বা function f($n)।
— mazzy
1
@ মমজি পোস্টারে মন্তব্য করা হয়েছে যে আপনাকে স্ট্রিং ব্যবহারের অনুমতি দেওয়া হয়েছিল, আপনাকে কেবল সংখ্যা / স্ট্রিংয়ের তালিকা হিসাবে ইনপুট দেওয়ার অনুমতি দেওয়া হয়নি। আমি ["1","2","3"]এটি বৈধ ইনপুট নয় হিসাবে ব্যাখ্যা করেছি "123"। যদি @ ওয়েডেন্টকান্ডয়ের কোনও সমস্যা থাকে তবে আমি অবশ্যই এটি পরিবর্তন করতে পারি!
— কেজিস্কায়ার
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.