বিপরীত এবং বিয়োগ

22

চ্যালেঞ্জের বিবরণ

আসুন একটি ধনাত্মক পূর্ণসংখ্যা নেওয়া যাক , এই দুটি সংখ্যার পার্থক্যের নিখুঁত মান nপেতে rev(n)এবং তার সংখ্যাগুলি বিপরীত করুন : |n - rev(n)|(বা abs(n - rev(n)))।

উদাহরণ:

n = 5067 
rev(n) = 7605
|n - rev(n)| = |5067 - 7605| = |-2538| = 2538

এই অপারেশনটি পর্যাপ্ত পরিমাণে পুনরাবৃত্তি করার পরে, বেশিরভাগ সংখ্যা হয়ে যাবে 0(এইভাবে লুপটি সমাপ্ত করা হবে ) ...

5067 -> 2538 -> 5814 -> 1629 -> 7632 -> 5265 -> 360 -> 297 -> 495 -> 99 -> 0

... যদিও কিছু সংখ্যা (যেমন 1584) অসীম লুপটিতে আটকে যায়:

1584 -> 3267 -> 4356 -> 2178 -> 6534 -> 2178 -> 6534 -> 2178 -> 6534 -> ...
                        ^ infinite loop starts here

আপনার কাজটি কোনও নির্ধারিত পূর্ণসংখ্যা অসীম লুপের মধ্যে আটকে যায় কিনা তা নির্ধারণ করা।

ইনপুট বিবরণ

একটি ধনাত্মক পূর্ণসংখ্যা।

আউটপুট বিবরণ

সত্যের মান ( True, 1) যদি সংখ্যাটি অসীম লুপে আটকে যায় False, 0অন্যথায় মিথ্যা মান ( , )।

নোট

  • ট্রেলিং শূন্যগুলি বাদ দেওয়া উচিত। অর্থাত rev(5020) = 205।
  • মনে রাখবেন এটি কোড-গল্ফ , সুতরাং আপনার কোডটি যতটা সম্ভব সংক্ষিপ্ত করুন!
  • প্রাসঙ্গিক ক্রম: A072140
code-golf  number-theory 
— shooqie
সূত্র
— মার্টিন ইন্ডার
একটি আকর্ষণীয় নোট: A072141- এ মন্তব্যগুলিতে বর্ণিত হিসাবে 2 এর লুপিং পিরিয়ড সহ নির্বিচারে দীর্ঘ দৈর্ঘ্য পূর্ণসংখ্যার নির্মাণ করা সম্ভব । পদ্ধতিটি 12, 14, 17, এবং 22 এর মতো অন্যান্য সময়ের জন্যও অভিন্ন
— mbomb007

উত্তর:

18

পাইথ, 5 বাইট

ফ্রাইআমডেজিমনকে 4 বাইট ধন্যবাদ

uas_`

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

সত্যবাদী মানটি লুপের একটি সংখ্যা numbers

মিথ্যা মান হয় 0।

ব্যাখ্যা

uas_`      Input:Q
uas_`GGQ   Implicit filling of variables.

u      Q   Set G as Q: do this repeatedly until result seen before: Set G as
 a             the absolute difference of
     G             G
    `              convert to string
   _               reverse
  s                convert to integer
      G        and G
— ফুটো নুন
সূত্র
অটো-ফিল ভেরিয়েবলের দুর্দান্ত ব্যবহার!
— FryAmTheEggman
1
* আপত্তি - - - - -
— লিকি নুন
পাইথকে চেনেন না এমন ব্যক্তির পক্ষে কীভাবে এটি কাজ করে?
— ফ্যাটালাইজ করুন
3
কীভাবে পাইথ এত সংক্ষিপ্ত তবুও এখনও ASCII সীমার মধ্যে রয়েছে _
— ডাউনগোট
3
পছন্দ করুন
— লিকি নুন
11

গণিত, 39 37 বাইট

Nest[Abs[#-IntegerReverse@#]&,#,#]<1&

কেবল ইনপুটটিতে বিপরীত / বিয়োগ ট্রান্সফর্মেশন nবার প্রয়োগ করে nএবং তারপরে ফলাফল কিনা তা পরীক্ষা করে 0। এটি কখনই 10nকোনও লুপে পৌঁছানোর পদক্ষেপের চেয়ে বেশি পদক্ষেপ নিতে পারে না , কারণ রূপান্তরটি অঙ্কের সংখ্যা বাড়িয়ে তুলতে পারে না, এবং 10nসংখ্যার চেয়ে কম কোনও সংখ্যা ছাড়াই রয়েছে n। এই সীমাবদ্ধতা কীভাবে হ্রাস করা যায় তার জন্য ডেনিসের প্রমাণ দেখুন n।

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

জেলি , 6 5 বাইট

ṚḌạµ¡

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

পটভূমি

এই ব্যবহারের @ MartinEnder উপরের আবদ্ধ এর 10n পুনরাবৃত্তিও এবং নিম্নলিখিত পর্যবেক্ষণ।

  1. আছে 9 × 10 1 - ট ধনাত্মক পূর্ণসংখ্যা এন সঙ্গে ট সংখ্যার।

  2. একটি সংখ্যার পার্থক্য এবং এর বিপরীতটি সর্বদা 9 এর একাধিক হয় , সুতরাং কেবলমাত্র 10 কে - 1 প্রথম পুনরাবৃত্তির পরে ঘটতে পারে।

  3. গুণিতক বেশি 1/10 পরবর্তী পুনরাবৃত্তিতে একটি অঙ্ক (নতুনদের জন্য যে সব শুরু করা এবং শেষ একই সংখ্যার সঙ্গে, এবং মোটামুটিভাবে দুইবার অনেক যেন প্রথম সংখ্যা ত্ত একটি হারাবেন 1 অথবা একটি 9 ) তাই হয়, এটি একটি লুপ প্রবেশ করতে বা একটি সংখ্যা হারাতে সর্বাধিক 9 × 10 কে - 2 লাগে ।

  4. কে - 1 ডিজিট ইত্যাদির শেষ ফলাফলের পূর্ণসংখ্যায় একই যুক্তি প্রয়োগ করা, এটি একটি লুপে প্রবেশ করতে সর্বাধিক 9 × 10 কে - 2 + 9 × 10 কে - 2 +… k 10 কে - 1 ≤ n পুনরাবৃত্তিগুলি গ্রহণ করে বা 0 পৌঁছান ।

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

ṚḌạµ¡  Main link. Argument: n

   µ¡  Iteratively apply the chain to the left n times.
Ṛ      Reverse n (casts to digits).
 Ḍ     Undecimal; convert from base 10 to integer.
  ạ    Take the absolute difference of the result and the argument.
— ডেনিস
সূত্র
11
পাইথ জেলিকে মারল?
— লিকি নুন
3
ঠিক আছে, এটি একটি টাই।
— ডেনিস
এগুলি কোনও বাইট নয়।
— মিক
1
@ এমিক দয়া করে শিরোনামের বাইটস লিঙ্কটি ক্লিক করুন ।
— ডেনিস
5

ওরাকল এসকিউএল 11.2, 136 বাইট

WITH v(n)AS(SELECT :1 FROM DUAL UNION ALL SELECT ABS(n-REVERSE(n||''))FROM v WHERE n>0)CYCLE n SET c TO 0 DEFAULT 1 SELECT MIN(c)FROM v;

আন golfed

WITH v(n) AS
(
  SELECT :1 FROM DUAL
  UNION ALL
  SELECT ABS(n-REVERSE(n||''))FROM v WHERE n>0 
) CYCLE n SET c TO 0 DEFAULT 1
SELECT MIN(c)FROM v
— Jeto
সূত্র
5

এপিএল, 26 টি অক্ষর

0∘{⍵∊⍺:×⍵⋄(⍺,⍵)∇|⍵-⍎⌽⍕⍵}

আমরা ইতিমধ্যে দেখেছি মানগুলির সঞ্চয়ের হিসাবে বাম যুক্তিটি ব্যবহার করি। আমরা এটিকে "0" থেকে শুরু করি, যা দুটি সমাপ্ত শর্তগুলির মধ্যে একটি। প্রহরীটি ⍵∊⍺:×⍵পড়েন: "সঠিক যুক্তি এমন কিছু যা আমরা ইতিমধ্যে দেখেছি (এবং এর মধ্যে শূন্য রয়েছে)? যদি সংখ্যার চিহ্নটি ফেরত দেয় তবে এটি 1 বা 0"। অন্যথায় আসুন বর্তমান বাম আর্গুমেন্টকে আবৃত করার পরে বিয়োগের পরম মানের সাথে নিজেকে কল করে পুনরাবৃত্তি করি।


মার্টিন এন্ডারের গাণিতিক সমাধানটি পুনরায় পাঠের সময় 21 মিনিটের সময় ঘড়ি হত :

 {×{|⍵-⍎⌽⍕⍵}⍣(10×⍵)⊣⍵}

এটিতে লেখা আছে: "10n বার বার চেয়েছিলেন পরে ফলাফলের চিহ্নটি কী"?

— lstefano
সূত্র
4

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

n=input()
exec'n=abs(n-int(`n`[::-1]));'*n
print n

আইডিয়নে এটি পরীক্ষা করুন ।

পটভূমি

এই ব্যবহারের @ MartinEnder উপরের আবদ্ধ এর 10n পুনরাবৃত্তিও এবং নিম্নলিখিত পর্যবেক্ষণ।

  1. আছে 9 × 10 1 - ট ধনাত্মক পূর্ণসংখ্যা এন সঙ্গে ট সংখ্যার।

  2. একটি সংখ্যার পার্থক্য এবং এর বিপরীতটি সর্বদা 9 এর একাধিক হয় , সুতরাং কেবলমাত্র 10 কে - 1 প্রথম পুনরাবৃত্তির পরে ঘটতে পারে।

  3. গুণিতক বেশি 1/10 পরবর্তী পুনরাবৃত্তিতে একটি অঙ্ক (নতুনদের জন্য যে সব শুরু করা এবং শেষ একই সংখ্যার সঙ্গে, এবং মোটামুটিভাবে দুইবার অনেক যেন প্রথম সংখ্যা ত্ত একটি হারাবেন 1 অথবা একটি 9 ) তাই হয়, এটি একটি লুপ প্রবেশ করতে বা একটি সংখ্যা হারাতে সর্বাধিক 9 × 10 কে - 2 লাগে ।

  4. কে - 1 ডিজিট ইত্যাদির শেষ ফলাফলের পূর্ণসংখ্যায় একই যুক্তি প্রয়োগ করা, এটি একটি লুপে প্রবেশ করতে সর্বাধিক 9 × 10 কে - 2 + 9 × 10 কে - 2 +… k 10 কে - 1 ≤ n পুনরাবৃত্তিগুলি গ্রহণ করে বা 0 পৌঁছান ।

— ডেনিস
সূত্র
3

পাইথন, 129 120 96 বাইট

যদি কোনও ব্যতিক্রম ধরা পড়ে (সাধারণত এই ফাংশনটি দিয়ে ফেলে দেওয়া যায় কেবল ব্যতিক্রম একটি রানটাইমরর, অসীম পুনরাবৃত্তির কারণে), মুদ্রণ করুন 1. অন্যথায়, ফলাফলটি মুদ্রণ করুন, 0।

def r(n):a=abs(n-int(str(n)[::-1]));return a and r(a)
try:print(r(int(input())))
except:print(1)

@ লিকিউনকে
ধন্যবাদ @ শুকিতে ধন্যবাদ

— TuxCrafting
সূত্র
এটি আনুষ্ঠানিক পুনরাবৃত্তির সরকারীভাবে একটি (দুর্দান্ত) অপব্যবহার।
— লিকি নুন
return a and rev(a)
— লিকি নুন
3
অপরিহার্যভাবে অসীম না হয়ে পুনরুক্তি খুব দীর্ঘ হওয়ার কারণে কি রানটাইমঅরার পাওয়া সম্ভব নয়?
— ফ্যাটালাইজ করুন
a=[n-x,x-n][n>x]
— লিকি নুন
আপনি এটা আয়তন বহুলাংশে কমান পারেন: def rev(n):a=abs(n-int(str(n)[::-1]));return a and rev(a)। এছাড়াও, পদ্ধতির সংক্ষিপ্ত rrev
— কিছুটির
3

পাইথন, 101 98 বাইট

কচ্ছপ এবং হরে অ্যালগরিদম।

সত্যবাদী লুপের কোনও মান, মিথ্যা হয় 0।

g=lambda n:abs(n-int(str(n)[::-1]))
def r(n):
    t=g(n);h=g(t)
    while t-h:h=g(g(h));t=g(t)
    return h

আইডিয়ন!

— ফুটো নুন
সূত্র
3

পাইথন 2, 85 84 83 বাইট

L=[]
def f(n,L=L):
    if n<1or n in L:print n<1
    else:L+=[n];f(abs(n-int(`n`[::-1])))

আর একটি পাইথন উত্তর। এটি প্রতিটি পুনরাবৃত্তির জন্য একটি তালিকায় এন যুক্ত করে এবং যদি এন ইতিমধ্যে তালিকায় থাকে তবে এটি আউটপুট করে False। অন্যথায়, এটি 0 এ নিচে কাজ করে।

একটি বাইটের জন্য @ ননলাইনারফ্রুটকে ধন্যবাদ।

— atlasologist
সূত্র
1
আমি বিশ্বাস করি print n<1কাজ করে (যেহেতু nসর্বদা অ-নেতিবাচক) এবং এটি একটি বাইট সংরক্ষণ করে
— ননলাইনারফ্রুট
def f(n,L=[]):¶ if n<1or n in L:print n<1¶ else:f(abs(n-int(`n`[::-1])),L+[n])5 বাইট সংরক্ষণ করুন
— লিকি নুন
3

05 এ বি 1 ই , 11 8 6 বাইট

DFÂï-Ä

ব্যাখ্যা

DF          # input number of times do
  Â         # push current number and its reverse
   ï-       # convert reverse to int and subtract
     Ä      # absolute value
            # implicitly print after loop ends

সত্যবাদী মান লুপ থেকে একটি সংখ্যা a
মিথ্যা মান 0 হয়।

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

ডেনিসের জেলি উত্তরে বর্ণিত উপরের সীমাটি ব্যবহার করুন

@ আদনানকে 2 বাইট সংরক্ষণ করা হয়েছে

ইন সংস্করণ 7.9 05AB1E 5 বাইট সমাধান কাজ নিম্নলিখিত হিসাবে @Adnan দ্বারা লক্ষনীয়

DFÂ-Ä
— Emigna
সূত্র
ঠিক আছে, এটি কিছুটা অদ্ভুত গল্ফ তবে DFÂ-Äএটি 7.9 সংস্করণে কাজ করে তবে বর্তমান সংস্করণে নয়। বর্তমান সংস্করণে, আপনাকে এটিকে প্রথমে একটি int (রূপান্তরকারী) রূপান্তর করতে হবে DFÂï-Ä, তবে আপনি এটি 5 বাইট তৈরি করতে 7.9 সংস্করণটি ব্যবহার করতে পারেন: পি।
— আদনান
@ আদনান আমি বিশ্বাস করতে পারি না যে আমি দ্বিখণ্ডনের কাজটি ভুলে গিয়েছি। আমি যদিও বর্তমান সংস্করণে আটকে থাকব। আপনি চাইলে 7.9 টি আলাদা উত্তর হিসাবে পোস্ট করতে পারেন। অন্যথায় আমি এটি একটি নোট হিসাবে রাখব।
— এমিগানা
আমি সম্ভবত এটি পোস্ট করব না, যেহেতু এটি এই উত্তর থেকে মাত্র 1 বাইট দূরে রয়েছে: পি।
— আদনান
1

জাভা 7, 161 বাইট

এর জন্য একটি আমদানি প্রয়োজন তবে আমি এটি একটি ফাংশন হিসাবে লিখেছি। এই দৃশ্যে যদি একটি পূর্ণ প্রোগ্রামকে প্রাধান্য দেওয়া হয় তবে মন্তব্যে আমাকে চিৎকার করুন। অসীম লুপ থাকলে আউটপুট 1 এবং মান 0 এ চলে গেলে 0 0

import java.util.*;int z(int a){int o,r,c=a;Set s=new HashSet();while(c!=0){for(r=0,o=c;o!=0;r=r*10+o%10,o/=10);c=Math.abs(c-r);if(!s.add(c))return 1;}return 0;}
— অকর্মা
সূত্র
আমি এর আগে আমদানি এবং ফাংশনগুলি দেখেছি তা উল্লেখ করে। উদাহরণস্বরূপ
— পোকে
সত্য কি 1?
— লিকি নুন
1
@ লেকিউন 1 টি জাভাতে সত্যবাদী হিসাবে বিবেচনা করা হয় না তবে ওপি তালিকা (সত্য, 1) এবং (মিথ্যা, 0) গ্রহণযোগ্য ফলাফল হিসাবে বিবেচনা করে।
— পোকে
@ লেকিউন জাভা এমনকি সত্যবাদী বা মিথ্যা অনুভূতি আছে?
— নীল
@ নীল জাভায় উল্লম্ব বাজারের প্রেক্ষাপটে সিনারিস্টিক সুযোগসুবিধাগুলির বোধ রয়েছে - এটাই
— বিড়াল
1

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

:10*N,?:N:{r:?-+.}itT'0

রিটার্নস trueঅসীম loops এবং falseঅন্যথায়।

এটি মার্টিন ইন্ডারের অ্যালগরিদমের নির্লজ্জ অভিযোজন।

পূর্ববর্তী উত্তর, 32 বাইট

g{tTr:T-+U(0!\;?:ImU;?:[U]c:1&)}

আগের উত্তরের ব্যাখ্যা

g{                             } Call predicate with [Input] as input
  tT                             T is the last element of Input
    r:T-                         Subtract T from the reverse of T
        +U                       U is the absolute value of T
          (0!\                   If U is 0, return false
              ;                  Or
               ?:ImU             If U is in Input, return true
                    ;            Or
                     ?:[U]c:1&)  Recursive call with U concatenated to the Input
— Fatalize
সূত্র
0

পাওয়ারশেল ভি 2 +, 94 বাইট

param($n)for($a=,0;){if(($n=[math]::Abs($n-(-join"$n"["$n".length..0])))-in$a){$n;exit}$a+=$n}

ইনপুট নেয় $n, প্রাথমিক শর্ত হিসাবে এটি একটি অসীম forলুপ শুরু করে $a=,0(এটি $aএকটি উপাদানের অ্যারেতে সেট করতে কমা অপারেটর ব্যবহার করে 0)। এটি $aইতিমধ্যে দেখা মানগুলির আমাদের অ্যারে।

প্রতিটি লুপ পুনরাবৃত্তি আমরা একটি পরীক্ষা করি if। শর্তটি প্রথমে $nস্ট্রিং-রিভার্সিং এবং [math]::Abs.NET কল ব্যবহারের পরবর্তী মান সেট করে এবং সেই মানটি ইতিমধ্যে কিনা তা পরীক্ষা করে -in $a। যদি তাই হয়, আমরা আউটপুট $nএবং exit। অন্যথায়, আমরা অ্যারেতে এই মানটি যুক্ত করি এবং লুপটি চালিয়ে যাই।

0ইনপুট মানগুলির আউটপুটগুলি যেখানে এটি অসীম লুপে যায় না (যা পাওয়ারশেলের ক্ষেত্রে মিথ্যা) এবং যেখানে লুপটি অন্যথায় দেখা হয়েছিল সেখানে ফলাফলটি বের করে দেয় (শূন্যহীন পূর্ণসংখ্যা সত্য নয়)। উদাহরণস্বরূপ, 2178ইনপুট জন্য আউটপুট 1584।

— AdmBorkBork
সূত্র
0

হাস্কেল, 65 বাইট

_#0=0
a#n|elem n a=1|1<2=(n:a)#abs(n-(read$reverse$show n))
([]#)

রিটার্নস 0মিথ্যা এবং 1সত্য জন্য। ব্যবহারের উদাহরণ: ([]#) 1584-> 1।

সুস্পষ্ট পদ্ধতির: এ পর্যন্ত দেখা সমস্ত ফলাফল সহ একটি তালিকা রাখুন। 0তালিকার মধ্যে বা এটি না হওয়া পর্যন্ত পরবর্তী সংখ্যা গণনা করুন ।

— nimi
সূত্র
0

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

f=(n,...a)=>a.includes(n=n<0?-n:n)?n:f([...n+``].reverse().join``-n,n,...a)

n<0?n=-n:nএবং n*=n>0||-1কাজ। অ্যালগরিদম কিছুটা পাওয়ারশেলের উত্তরটির সাথে সাদৃশ্যযুক্ত, যদিও এটি একটি পুনরাবৃত্ত সূত্র।

— নিল
সূত্র
0

রুবি, 57 বাইট

->n,*h{h[n]=n=(n-"#{n}".reverse.to_i).abs until h[n];n>0}

প্রাথমিকভাবে খালি অ্যারের hট্র্যাকগুলি পূর্বে হিট মানগুলি। আমরা পূর্ববর্তী মানটিকে আঘাত না করা পর্যন্ত আমরা সংখ্যাটি পুনরাবৃত্তি করি, তারপরে শেষ পুনরাবৃত্তির মানটি পরীক্ষা করি। যেহেতু 0 টি একটি চক্র, তাই বৃহত্তর চক্র না থাকলে 0 হবে এবং কেবল হবে। এটিকে বুলিয়ান রূপান্তর করতে আমি অতিরিক্ত 2 বাইট নিই কারণ 0 রুবিতে সত্যবাদী।

— histocrat
সূত্র
0

পার্ল 6  58 53 33  30 বাইট

sub {$/=%;$^a,{return ?1 if $/{$_}++;abs $_-.flip}...0;?0}
{$/=%;?($_,{last if $/{$_}++;abs $_-.flip}...0)[*-1]}
{?($_,{abs $_-.flip}...0)[10**$_]}

{?($_,{abs $_-.flip}...0)[$_]}

ব্যাখ্যা:

{ # block lambda with implicit parameter $_

  # coerce the following to Bool
  # ( False for Nil or 0, True otherwise )
  ?

  (

    $_, # start a sequence with the input

    # block lambda with implicit parameter $_
    # subtracts the previous value in the sequence and its reverse
    # ( .flip is short for $_.flip where a term is expected )
    { abs $_ - .flip } 

    ... # repeat that lambda
    0   # until you get 0

  # get the element indexed with the block's input
  # may be 0, Nil, or a number that is part of a repeating sequence
  )[ $_ ]
}

(পূর্ববর্তী পর্যবেক্ষণের উপর নির্ভর করে যে আপনাকে কেবলমাত্র বেশিরভাগ nসময়ে এই রূপান্তরটি করতে হবে )

— ব্র্যাড গিলবার্ট বি 2 গিলস
সূত্র
0

পার্ল 5, 31 29 বাইট

perl -pe'for$x(1..$_){$_=abs$_-reverse}'


perl -pe'eval"\$_=abs\$_-reverse;"x$_'

এটি n=|n-rev(n)|n বার পুনরুক্ত হয় , সুতরাং লুপ না থাকলে আউটপুট 0 হয়, অন্যথায় 0 হয়। ডেনিস ইতিমধ্যে প্রমাণ করেছেন যে এটি যথেষ্ট।

নতুন সংস্করণ ব্যবহার evalএবং xপুনরাবৃত্তি অপারেটর পরিবর্তে forলুপ।

— MIK
সূত্র
উত্তম উত্তর, এবং পিপিসিজিতে আপনাকে স্বাগতম! নোট করুন যে পার্লের জন্য, কমান্ড-লাইন বিকল্পগুলি অবশ্যই আপনার বাইট-কাউন্টে অন্তর্ভুক্ত থাকতে হবে , সুতরাং এটি বেশিরভাগ 30 বাইট নয়।
— অ্যাডমবর্কবার্ক
@ টিমিমিডি ঠিক আছে, -pবিকল্পের জন্য +1 , -lএকক ইনপুটটির জন্য প্রয়োজনীয় নয়
— মিক
0

মতলব, 89 84 বাইট

n=input('');z=n;while n
z=abs(z-str2num(fliplr(num2str(z))));n=[n z]*all(n~=z);end
z

সহজ পদ্ধতির - সমস্ত নম্বর স্ট্যাক করে এবং কোনও নম্বর আগে উপস্থিত হয় কিনা তা পরীক্ষা করে।

ব্যাখ্যা

n=input('');z=n;  -- take input, initiate z
while n           -- n is said to be positive
z=abs(z-str2num(fliplr(num2str(z)))) -- calculate the "reverse and substract"
n=[n z]           -- put the value at the end of the vector
       *all(n~=z) -- make the n all zeroes if z is previously in the vector (break the loop)
end
z                 -- print z (0 when not entered loop, >0 otherwise)
— pajonk
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.