25

দশমিক সংখ্যা 7 দ্বারা বিভাজ্য কিনা তা পরীক্ষা করতে:

শেষ অঙ্কটি মুছুন। এটি 2 দিয়ে গুণ করুন এবং যা অবশিষ্ট আছে তা থেকে বিয়োগ করুন। ফলাফলটি যদি 7 দ্বারা বিভাজ্য হয় তবে মূল সংখ্যাটি 7 দ্বারা বিভাজ্য।

(এছাড়াও যেমন বর্ণনা এখানে )

এই নিয়মটি ম্যানুয়াল বিভাজ্যতা পরীক্ষার জন্য ভাল। উদাহরণ স্বরূপ:

2016 কি 7 দ্বারা বিভাজ্য?

6*2201 থেকে বিয়োগ ; আমরা 189 পেয়েছি this এটি কি 7 দ্বারা বিভাজ্য? এটি যাচাই করতে, আবার বিধিটি প্রয়োগ করি।

9*218 থেকে বিয়োগ ; আমরা 0 পাই। সুতরাং, 2016টি 7 দ্বারা বিভাজ্য।

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

ইনপুট : একটি ইতিবাচক পূর্ণসংখ্যা; আপনার কোড 32767 অবধি ইনপুট সমর্থন করা উচিত (স্বেচ্ছাসেবী-নির্ভুলতা পূর্ণসংখ্যার সমর্থন একটি বোনাস; নীচে দেখুন)

আউটপুট : একটি পূর্ণসংখ্যা (সম্ভবত নেতিবাচক), 70 এর বেশি নয়, এটি বিভাজ্য-বাই-7 বিধি শূন্য বা তার বেশি বার প্রয়োগের ফলস্বরূপ।

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

Input                   Output      Alternative output

1                       1
10                      10          1
100                     10          1
13                      13          -5
42                      42          0
2016                    0
9                       9
99                      -9
9999                    -3
12345                   3
32767                   28          -14

---------- Values below are only relevant for the bonus

700168844221            70          7
36893488147419103232    32          -1
231584178474632390847141970017375815706539969331281128078915168015826259279872    8

দুটি সম্ভাব্য আউটপুট যেখানে নির্দিষ্ট করা আছে, ফলাফলগুলি সঠিক: দ্বিতীয়টি নিয়মটি আরও একবার প্রয়োগ করার সাথে সম্পর্কিত। একক-অঙ্কের সংখ্যাটিতে নিয়ম প্রয়োগ করা নিষিদ্ধ: আপনি যদি এই সংখ্যাটি মুছেন তবে কিছুই (0 নয়) বাকী থাকবে না।

বোনাস : যদি আপনার অ্যালগরিদম হয়

নির্বিচারে-নির্ভুলতা পূর্ণসংখ্যার সমর্থন করে
ইনপুটটিতে কেবল একটি পাস সম্পাদন করে
স্থান জটিলতা o(n)(অর্থাত্ কম O(n)); এবং
সময়ের জটিলতা আছে O(n),

nদশমিক সংখ্যার সংখ্যা কোথায় :

আপনার কোডের বাইট গণনা থেকে 50% বিয়োগ করুন।

রিয়েল বোনাস :

তদতিরিক্ত, যদি আপনার অ্যালগরিদম সর্বাধিক উল্লেখযোগ্য অঙ্ক থেকে শুরু করে সাধারণ দিকের ইনপুটটি পড়ে থাকে তবে আবার 50% বিয়োগ করুন - আপনার স্কোরটি আপনার বাইট গণনার 25% (এটি সম্ভব বলে মনে হচ্ছে তবে আমি একেবারে নিশ্চিত নই)।

code-golf number-theory division

— anatolyg
সূত্র

1

@ ডেনারএফি হিসাবে ইনপুটটি ফিরিয়ে দেওয়া গ্রহণযোগ্য। আমি প্রতিফলিত করতে ইনপুট = 10 এর পরীক্ষার কেস আপডেট করেছি; এটাই ছিল প্রথম থেকেই ধারণা।

— অ্যানাটলিগ

4

আমি এই নিয়মটি ব্যবহার করতে চাই না 1000000000000000000001।

— নিল

1

তবে আপনার ভাষায় যদি long longকিছু সমতুল্য অন্তর্নির্মিত থাকে তবে কী হবে?

— সুপারজেডি ২৪

1

আমি যা বলছিলাম তা হ'ল, কিছু বাস্তবায়নে এটি একটি 128-বিট পূর্ণসংখ্যা যা শেষ পরীক্ষার ক্ষেত্রে এটি যথেষ্ট বড়।

— সুপারজেডি ২৪

7

-1। সমস্ত ভাষা নির্বিচারে নির্ভুলতার সমর্থন করে না।

— মার্চ হো

23

গল্ফস্ক্রিপ্ট, 27 22 বাইট

{.9>{.10/\10%2*-f}*}:f

আপনি এটি এইভাবে ব্যবহার করতে পারেন:

1000f

ব্যাখ্যা

{.9>{.10/\10%2*-f}*}:f
{                  }:f    # Define block 'f' (similar to a function)
 .                        # Duplicate the first value of the stack
  9>{            }*       # If the value on top of the stack is greater than 9 then the block is executed
     .10/\10%2*-          # Same as nb/10 - (nb%10 * 2) with some stack manipulations '.' to duplicate the top of the stack and '\' to swap the the first and second element of the stack
                f         # Execute block 'f'

ডেনিসের জন্য 5 টি বাইট সংরক্ষণ করা হয়েছে!

— Dica
সূত্র

1

প্রোগ্রামিং ধাঁধা এবং কোড গল্ফ স্বাগতম। এটি একটি ভাল উত্তর, তবে আপনি উপরের প্রশ্নের মতো একটি কোড ব্রেকডাউন এবং ব্যাখ্যা যোগ করে এটি উন্নত করতে পারেন। এই মন্তব্যের জবাব দিতে, একটি মন্তব্য (বা যে কোনও জায়গায়) এর শুরুতে @wizzwizz4( @তারপরে আমার ব্যবহারকারীর নাম) টাইপ করুন।

— wizzwizz4

1

@ wizzwizz4 আরও ভাল? আমি নিশ্চিত নই যে আপনি 'কোড ব্রেকডাউন' (দেশীয় স্পিকারের জন্য দুঃখিত) বলতে কী বোঝাতে চেয়েছেন আমি তা বুঝতে পেরেছি

— ডিকা

8

আমি "কোড ব্রেকডাউন" দ্বারা বিশ্বাস করি তার অর্থ একটি ব্যাখ্যা, যা আপনি যুক্ত করেছেন। এটি সত্যিই একটি খুব সুন্দর প্রথম উত্তর। সাইটে স্বাগতম!

— অ্যালেক্স এ

1

আপনি সেই {...}{}ifঅংশটি আবার লিখতে পারেন {...}*, যা কেবলমাত্র একবারে কোড ব্লক শূন্য প্রয়োগ করবে, দ্বারা চাপানো মানের উপর নির্ভর করে >। এছাড়াও, আমরা আরো এক পুনরাবৃত্তির (তাই প্রতিস্থাপন সঞ্চালন করার অনুমতি দেওয়া করছি 70সঙ্গে 9একটি বাইট সংরক্ষণ), এবং আমি মনে করি না আপনার সাথে ব্লক পপ করতে হবে ;।

— ডেনিস

3

@ ডিকা, কেবলমাত্র 624 মতামত নিয়ে কোনও প্রশ্নের উপর 12+ আপগেট পাওয়া এবং দু'জন মডারেটরের প্রশংসা পাওয়ার জন্য এটি প্রথম উত্তর যথেষ্ট। যদি আপনি এটি চালিয়ে যান, আপনি শীঘ্রই ডেনিসকে ছাড়িয়ে যাবেন!

— wizzwizz4

13

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

until(<71)(\n->div n 10-2*mod n 10)

ব্যবহারের উদাহরণ: until(<71)(\n->div n 10-2*mod n 10) 36893488147419103232-> 32।

বেশি কিছু বোঝাতে হবে না, এটি অ্যালগরিদমের প্রত্যক্ষ বাস্তবায়ন।

— nimi
সূত্র

9

জেলি, 11 বাইট

d⁵Uḅ-2µ>9$¿

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

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

d⁵Uḅ-2µ>9$¿  Main link. Input: n

d⁵           Divmod; return [n : 10, n % 10].
  U          Upend; yield [n % 10, n : 10].
   ḅ-2       Convert from base -2 to integer, i.e., yield -2 × (n % 10) + (n : 10).

      µ      Push the previous chain as a link and begin a new, monadic chain.
          ¿  Apply the previous chain while...
       >9$     its return value is greater than 9.

— ডেনিস
সূত্র

এবং সর্বদা হিসাবে, জেলি জিতেছে। ডেনিস, জেলিতে একটি জেলি দোভাষীকে প্রয়োগ করতে কতটা বাইট লাগবে?

— বিলিন্ট

6

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

f=lambda x:f(x/10-x%10*2)if x>70else x

এখানে চেষ্টা করুন !

সহজ পুনরাবৃত্তি পদ্ধতির। এক্স প্রিন্ট করে যদি এটি <70 অন্যথায় বিভাজ্য নিয়ম প্রয়োগ করে এবং ফলাফলের সাথে নিজেকে কল করে।

— Denker
সূত্র

তোমার পরে স্থান প্রয়োজন হবে না)

— Maltysen

পছন্দ করুন অনুলিপিটি ভুলটি আটকানো হয়েছে, ইঙ্গিতটির জন্য ধন্যবাদ!

— ডেনকার

2

যদি খুব ভার্জোজ হয়। f=lambda x:x*(x<70)or f(x/10-x%10*2)

— seequ

1

@ সেক চমৎকার কৌশল, ধন্যবাদ! এটি তত্ত্ব হিসাবে কাজ করা উচিত, তবে এটি ইনপুট হিসাবে 2016 সহ সর্বাধিক পুনরাবৃত্তির গভীরতায় পৌঁছেছে যখন আমার সংস্করণটি না। কোন ধারণা কেন?

— ডেনকার

আহ, ঠিক আছে, এটি বিবেচনা করে না। এই কৌশলটি x*(x<70) != 0শেষ শর্ত হিসাবে বিবেচনা করে। যদি এক্স 0 এ যায় - যেমনটি 2016 এর মতো হয় - শেষ শর্তটি কখনই ঘটে না।

— seequ

6

পাইথ, 13 বাইট

.W>H9-/ZTyeZQ

এটি অনলাইনে ব্যবহার করে দেখুন: বিক্ষোভ বা পরীক্ষার স্যুট

এটি বিকল্প বিকল্পগুলি মুদ্রণ করবে।

ব্যাখ্যা:

.W>H9-/ZTyeZQ   
            Q   read a number from input
.W              while
  >H9              the number is greater than 9
                do the following with the number:
      /ZT          divide it by 10
     -             and subtract
         yeZ       2*(number%10)

— Jakube
সূত্র

5

জুলিয়া, 27 26 বাইট

f(x)=x>9?f(x÷10-x%10*2):x

এটি একটি পুনরাবৃত্ত ফাংশন যা একটি পূর্ণসংখ্যা গ্রহণ করে এবং a প্রদান করে BigInt। শেষ উদাহরণের মতো যদি ইনপুটটি একটি বিশাল সংখ্যক হয়, জুলিয়া এটিকে পার্স হিসাবে হিসাবে BigInt, তাই কোনও ম্যানুয়াল রূপান্তর প্রয়োজন।

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

ডেনিসকে একটি বাইট সংরক্ষণ করে!

— অ্যালেক্স এ।
সূত্র

আমরা আরও একটি পুনরাবৃত্তির সঞ্চালন করার অনুমতি দেওয়া করছি, তাই প্রতিস্থাপন 70সঙ্গে 9একটি বাইট পরিমাণ সঞ্চয় হয়।

— ডেনিস

@ ডেনিস শুভ কল, ধন্যবাদ!

— অ্যালেক্স এ।

4

পাইথ, 17 বাইট

L?<b70by-/bT*%bT2

এখানে চেষ্টা করুন!

আমার অজগর উত্তর হিসাবে একই পুনরাবৃত্ত পদ্ধতির । নির্ধারণ করে একটি ল্যামডা yযা এই মত বলা হয়: y12345।
অনলাইন ইন্টারপ্রেটারে বাইট কাউন্টারটি 19 বাইট দেখায় কারণ আমি এতে ল্যাম্বডা কলটি যুক্ত করেছি, তাই আপনি রান-বোতামটি আঘাত করে এটি চেষ্টা করতে পারেন।

ব্যাখ্যা

L?<b70by-/bT*%bT2

L                  # Defines the lambda y with the parameter b
 ?<b70             # if b < 70:
      b            # return b, else:
       -/bT*%bT2   # calculate b/10 - b%10*2 and return it

— Denker
সূত্র

আপনার ব্যাখ্যায় একটি টাইপ আছে, 17 হওয়া উচিত 70: পি

— ফ্রাইআমএইজিগম্যান

4

সিজেম - 19 বাইট

করার সময় সংস্করণ:

r~A*{`)]:~~Y*-_9>}g

এটি অনলাইনে চেষ্টা করুন বা সংস্করণ # 1 করার সময়:

r~{_9>}{`)]:~~Y*-}w

এটি অনলাইনে চেষ্টা করুন বা সংস্করণ # 2 চলাকালীন:

r~{_9>}{_A/\A%Y*-}w

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

r~                     | Read and convert input
  A*                   | Multiply by 10 to get around "if" rule
     `                 | Stringify
      )                | Split last character off
       ]               | Convert stack to array
        :~             | Foreach in array convert to value
          ~            | Dump array
           Y*          | Multiply by 2
             -         | Subtract
              _        | Duplicate
               9>      | Greater than 9?
    {            }g    | do-while

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

3

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

WITH v(i)AS(SELECT:1 FROM DUAL UNION ALL SELECT TRUNC(i/10)-(i-TRUNC(i,-1))*2 FROM v WHERE i>70)SELECT MIN(i)FROM v;

আন golfed

WITH v(i) AS
(
  SELECT :1 FROM DUAL
  UNION ALL
  SELECT TRUNC(i/10)-(i-TRUNC(i,-1))*2 FROM v WHERE i>70
)
SELECT MIN(i) FROM v;

— Jeto
সূত্র

3

হাস্কেল, 157 192 184 167 159 147 138 + 5 বাইট - 50% = 71.5 বাইট

ও (1) স্থান, ও (এন) সময়, একক-পাস!

h d=d%mod d 10
d%r=(quot(r-d)10,r)
p![d]=d-p*10
p![d,e]=d#(e-p)
p!(d:e:f)|(b,a)<-quotRem(2*d)10,(q,r)<-h$e-a-p=(b+q)!(r:f)
m#0=m
m#n=n-2*m
(0!)

২০১ 0![6,1,0,2]2016-তে নিয়ম প্রয়োগ করতে ব্যবহার করুন , অর্থাত্ প্রথমে কমপক্ষে উল্লেখযোগ্য চিত্র সহ এটি স্ট্রিমের ফর্মটিতে একটি নম্বর দিন। এইভাবে, এটি সংখ্যা দ্বারা অঙ্ক সংখ্যা ছাড়িয়ে যাবে, ও (1) স্পেস জটিলতার সাথে নিয়মটি প্রয়োগ করবে।

অবারিত কোডটি এখানে রয়েছে:

import Data.Char

{- sub a b = sub2 0 a b
  where
    sub2 borrow (a:as) (b:bs) = res : sub2 borrow2 as bs
      where
        (borrow2, res) = subDig borrow a b
    sub2 borrow (a:as) [] = sub2 borrow (a:as) (0:[])
    sub2 _ [] _ = [] -}

--subDig :: Int -> Int -> Int -> (Int, Int)
subDig borrow a b = subDig2 (a - b - borrow)
  where
    subDig2 d = subDig3 d (d `mod` 10)
    subDig3 d r = ((r-d) `quot` 10, r)

seven ds = seven2 0 ds
seven2 borrow (d:e:f:gs) = seven2 (b + borrow2) (res:f:gs)
  where
    (a, b) = double d
    (borrow2, res) = subDig borrow e a
seven2 borrow (d:e:[]) = finalApp d (e-borrow)
seven2 borrow (d:[]) = d - borrow*10

double d = ((2*d) `mod` 10, (2*d) `quot` 10)

finalApp m 0 = m
finalApp m n = n - 2*m

num2stream :: Int -> [Int]
num2stream = reverse . map digitToInt . show
sev = seven . num2stream

এটি কীভাবে কাজ করে তার সংক্ষিপ্তসারটি হ'ল এটি একটি ডিজিট বাই বাই ডিজিট বিয়োগের অ্যালগরিদম প্রয়োগ করে তবে বিয়োগ করা প্রতিটি সংখ্যা সর্বাধিক ২-সংখ্যার এবং এই সুবিধাটি গ্রহণ করে আমরা এই 1- এর একটি নির্বিচার পরিমাণকে বিয়োগ করতে পারি বা -2 সংখ্যার প্রধানটি (পাশাপাশি সর্বনিম্ন গুরুত্বপূর্ণ অঙ্কগুলি খাওয়া) থেকে নম্বর numbers

বিয়োগের অ্যালগরিদমটি হ'ল (1) এবং কেবলমাত্র বর্তমান 'orrowণ' মান সংরক্ষণ করে। অতিরিক্ত অঙ্কটিতে (0 বা 1) যোগ করার জন্য আমি এটি পরিবর্তন করেছি এবং আমরা নোট করি যে এই valueণ মূল্য সীমাবদ্ধ (সীমার মধ্যে [-2,2] তাই এটি সংরক্ষণ করার জন্য আমাদের কেবলমাত্র 3 বিট প্রয়োজন)।

স্মৃতিতে সঞ্চিত অন্যান্য মানগুলি হ'ল অস্থায়ী পরিবর্তনশীলগুলি যোগ করতে বর্তমান 2-সংখ্যার সংখ্যার প্রতিনিধিত্ব করে, প্রবাহে একক চেহারা এবং বিয়োগ অ্যালগরিদমের এক ধাপ প্রয়োগ করতে (যেমন এটি দুটি অঙ্ক এবং একটি ধার ধার্য করে, এবং ফেরত দেয়) এক অঙ্ক এবং একটি নতুন orrowণ মূল্য)।

অবশেষে শেষের দিকে এটি সংখ্যার তালিকার চেয়ে একক-অঙ্কের সংখ্যা ফেরত দিতে একবারে প্রবাহে শেষ দুটি সংখ্যা প্রসেস করে।

এনবি sevঅরগল্ফড সংস্করণে ফাংশনটি Integerএটিকে বিপরীত স্ট্রিম রূপে রূপান্তরিত করে একটিতে কাজ করবে ।

— শোরাঘটিত
সূত্র

আমি বোনাসটি হ'ল অঙ্কের স্বাভাবিক ক্রমের জন্য। তবে আমি এটি কখনই বলিনি, সুতরাং এটি কম মজা সত্ত্বেও বিপরীত ক্রমের বোনাস পাওয়ার পক্ষে এটি মোটামুটি। যাইহোক, এমনকি বিপরীত ক্রমটি আমার ভাবার চেয়ে শক্ত, সুতরাং এটি যথেষ্ট মজাদার!

— অ্যানাটলিগ

@ অ্যানাটলিগ: ধন্যবাদ! আমি নিশ্চিত না যে এটি একটি সাধারণ পাসের ও (1) সাধারণ অর্ডারের বাস্তবায়ন সম্ভব কিনা ... নিয়মটি ন্যূনতম উল্লেখযোগ্য পরিসংখ্যানগুলির উপর নির্ভর করে, তাই তত্ত্বের ক্ষেত্রে বিপরীত ক্রম ব্যতীত নিয়মের সরাসরি প্রয়োগ অসম্ভব। আমি কেবল অন্য একটি জিনিসটিই গণিতের সমতুল্য ফর্মটি সন্ধানের মাধ্যমে বিবেচনা করতে পারি - উদাহরণস্বরূপ Mod[18 - Quotient[n, 10] - 2*n, 21] - 18 + Quotient[n, 10]10 থেকে 99 এর মধ্যে n এর জন্য অনুপ্রেরণামূলকভাবে কাজ করে তবে n এর আরও সংখ্যার আরও জটিল হয়ে যায় ...

— নিট্রাস

হুম আমি এটি সম্পর্কে ভেবেছিলাম এবং দেখে মনে হয়েছিল যে সামনের 2 টি সংখ্যা রেখে প্রতিটি পরবর্তী অঙ্ক প্রয়োগ করার উপায় আছে তবে এটি 'ফিল্টারিং' এর হিসাব নিতে (-2) multip n দিয়ে গুণ করে ... যতদূর আমি সমস্ত অঙ্ককে মেমোরিতে না রেখে ও (1) 'নেস বা এমনকি ও (এন)' নেসকে বলি না দিয়ে এই কাজটি করার কোনও উপায় নেই যদিও বলতে পারি ... আমি মনে করি স্বাভাবিক ক্রমটি অবশ্যই অসম্ভব :(

— নাইট্রাস

1

আমি ভীত , 0যখন কল করার সময় আপনাকে প্রাথমিকের বাইটগুলিও গণনা করতে !হবে, যেমন, বিভাগ (0!)(+ একটি নিউলাইন) হিসাবে, +5 বাইট হিসাবে। অন্য দিকে আপনি ধরনে ম্যাচ প্রথম খাটো করতে পারেন !করতে p![d]=এবং p![d,e]=। এছাড়াও, ব্যবহার প্যাটার্ন পরিবর্তে গার্ড let: p!(d:e:f)|(b,a)<-quotRem(2*d)10,(q,r)<-h$e-a-p=(b+q)!(r:f)।

— নিমি

1

@ নাইট্রাস: ওহ আমি (0!)এটির নিজস্ব একটি লাইনে কাজ করি। (0!)আপনি আপনার উত্তর হিসাবে দেওয়া ফাংশন হয়। 0প্রয়োজন, কিন্তু ইনপুট সঙ্গে কিছুই করার আছে, তাই আপনি এটা আউটসোর্স করা আহ্বানকারী করতে পারেন। অবশ্যই আপনি ব্যবহার করতে পারেন f x=0!x, তবে এটি দীর্ঘ।

— নিমি

3

জিএনইউ ডিসি, 20 15 বাইট

[10~2*-d70<F]sF

এটি আমার প্রথম (সর্বদা) ডিসি ফাংশনটি সংজ্ঞায়িত করে F,। এটি স্ট্যাকের শীর্ষে ইনপুট নেয় এবং এটির স্ট্যাকের শীর্ষে ফেলে দেয়। ব্যবহারের উদাহরণ:

36893488147419103232
lFxp
32

— টবির গতি
সূত্র

2

গণিত, 47 44 বাইট

If[#>70,#0[{1,-2}.{⌊#/10⌋,#~Mod~10}],#]&

সহজ পুনরাবৃত্তি পদ্ধতির। সম্ভবত আরও গল্ফ করা যেতে পারে।

— LegionMammal978
সূত্র

#0[{1,-2}.QuotientRemainder[#,10]]একটি বাইট সংরক্ষণ করে।

— njpipeorgan

2

আর, 43 বাইট

x=scan();while(x>70)x=floor(x/10)-x%%10*2;x

ব্যাখ্যা:

x=scan()                                      # Takes input as a double
        ;                                     # Next line
         while(x>70)                          # While-loop that runs as long x > 70
                      floor(x/10)             # Divide x by 10 and round that down
                                 -x%%10*2     # Substract twice the last integer
                    x=                        # Update x
                                         ;    # Next line once x <= 70
                                          x   # Print x

নমুনা রান:

> x=scan();while(x>70)x=floor(x/10)-x%%10*2;x
1: 9999
2: 
Read 1 item
[1] -3

> x=scan();while(x>70)x=floor(x/10)-x%%10*2;x
1: 32767
2: 
Read 1 item
[1] 28

— Laterow
সূত্র

1

জাভাস্ক্রিপ্ট ES6, 38 বাইট

a=i=>i>70?a(Math.floor(i/10)-i%10*2):i

সাথে ব্যর্থ 36893488147419103232এবং ব্যবহার ~~(1/10)ব্যর্থ হবে700168844221

টেস্ট:

a=i=>i>70?a(Math.floor(i/10)-i%10*2):i
O.textContent = O.textContent.replace(/(-?\d+) +(-?\d+)/g, (_,i,o) =>
  _+": "+(a(+i)==o?"OK":"Fail")
);

<pre id=O>1                       1
10                      10
100                     10
13                      13
42                      42
2016                    0
9                       9
99                      -9
9999                    -3
12345                   3
700168844221            70
36893488147419103232    32</pre>

স্নিপেট প্রসারিত করুন

— andlrc
সূত্র

আমি দুটি Failএস পেয়েছি ... 70 এবং 32

— কনর ওব্রায়েন

@ সিও'বু- হ্যাঁ আমাকে, আমি এখনও ভাবছি কেন ...

— andlrc

কারণ জাভাস্ক্রিপ্টের নম্বর টাইপটি সর্বশেষ কেসটি পরিচালনা করে না handle

— কনর ও'ব্রায়েন

1

f=n=>n>70?f((n-n%10*21)/10):nএকটি সংক্ষিপ্ত সংস্করণ তবে এখনও পর্যন্ত কাজ করে 2**56।

— নিল

নিল নিরপেক্ষ নির্ভুলতার জন্য আমার উত্তর দেখুন, এবং দয়া করে গল্ফ নির্দ্বিধায় প্রশংসিত হন

— প্যাট্রিক রবার্টস

1

গণিত, 33 বাইট

#//.a_/;a>70:>⌊a/10⌋-2a~Mod~10&

পরীক্ষা ক্ষেত্রে

%[9999]
(* -3 *)

— njpipeorgan
সূত্র

1

পার্ল 5, 47 46 বাইট

bigintসর্বশেষ পরীক্ষার মামলার জন্য ব্যবহার করতে হয়েছিল। (এটি 20 ছাড়াই ফেরত দেয়)

use bigint;$_=<>;while($_>9){$_-=2*chop;}print

সত্যই নিশ্চিত নয় যে এটি বোনাসের প্রার্থী, তাই আমি এটিকে আমলে নিই নি। (আমি মনে করি এটি হয় তবে আমি ধারণাগুলিতে সত্যিই অভ্যস্ত নই)

এখানে চেষ্টা করুন!

— পল পিকার্ড
সূত্র

1

ES6, 108 বাইট

f=(s,n=0)=>s>1e9?f(s.slice(0,-1),((1+s.slice(-1)-n%10)%10*21+n-s.slice(-1))/10):s>9?f(((s-=n)-s%10*21)/10):s

2²⁵⁷ এবং 1000000000000000000000011 এর জন্য কাজ করে তবে আরও গল্ফিং ব্যবহার করতে পারে।

— নিল
সূত্র

জমা দেওয়ার জন্য পুনরায় ফর্ম্যাট করার সময় @ পেট্রিকরোবার্টস ওফস, ওভারসাইট

— নিল

1

জাভাস্ক্রিপ্ট ES6, 140 142 বাইট

f=s=>s>9?eval("t=s.replace(/.$/,'-$&*2');for(i=-1;0>(n=eval(u=t[c='slice'](i-4)))&&u!=t;i--);n<0?n:f(t[c](0,i-4)+('0'.repeat(-i)+n)[c](i))"):s

এটি সত্য নির্বিচারে-নির্ভুল গণিত, এমনকি বৃহত্তম পরীক্ষার ক্ষেত্রে এটি কাজ করে।

এই ফাংশনটি পুনরাবৃত্তভাবে স্ট্রিং থেকে শেষ অঙ্কটি সরিয়ে দেয়, তারপরে পার্থক্যটি ইতিবাচক হওয়া পর্যন্ত মিনিটটিতে প্রয়োগের জন্য অঙ্কের পরিমাণকে পুনরাবৃত্তভাবে পুনরুক্ত করে বাকী সংখ্যাগত স্ট্রিং থেকে 2 * শেষ অঙ্কটি বিয়োগ করে। তারপরে এটি যথাযথ প্যাডযুক্ত 0এস দিয়ে স্ট্রিংয়ের শেষে এই পার্থক্যটি যুক্ত করে এবং সংখ্যার মান থেকে কম বা সমান না হওয়া পর্যন্ত নিজেকে পুনরাবৃত্তভাবে কল করে 9।

গল্ফড 7 বাইট @ নীলকে ধন্যবাদ (হ্যাঁ আমি জানি আমি 2 বাইট অর্জন করেছি তবে আমি কয়েকটি বাগ স্থির করেছি যার ফলে কিছু ক্ষেত্রে ভুল ফাংশন স্থির হয়ে যায় বা ভুল আউটপুট ফিরে আসে)।

f=s=>s>9?eval("t=s.replace(/.$/,'-$&*2');for(i=-1;0>(n=eval(u=t[c='slice'](i-4)))&&u!=t;i--);n<0?n:f(t[c](0,i-4)+('0'.repeat(-i)+n)[c](i))"):s;[['1',1],['10',1],['100',1],['13',-5],['42',0],['2016',0],['9',9],['99',-9],['9999',-3],['12345',3],['700168844221',7],['36893488147419103232',-1],['231584178474632390847141970017375815706539969331281128078915168015826259279872',8]].map(a=>document.write(`<pre>${f(a[0])==a[1]?'PASS':'FAIL'} ${a[0]}=>${a[1]}</pre>`))

স্নিপেট প্রসারিত করুন

— প্যাট্রিক রবার্টস
সূত্র

দুর্দান্ত, তবে এটি কাজ নাও করতে পারে 1000000000000000000001।

— নিল

1

ব্যবহার করে দেখুন s.replace(/.$/,'-$&*2')। দুঃখিত হলেও আমার কাছে বিশ্রামের জন্য কোনও সুস্পষ্ট ধারণা নেই।

— নিল

1

সি #, 111 104 বাইট

int d(int n){var s=""+n;return n<71?n:d(int.Parse(s.Remove(s.Length-1))-int.Parse(""+s[s.Length-1])*2);}

— TheLethalCoder
সূত্র

1

ব্রেন-ফ্লাক , 368 360 বাইট

অনলাইনে চেষ্টা করে দেখুন!

([([({})]<(())>)](<>)){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}({}<>){{}(({}))(<((()()()()()){}<>)>)<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}{}<>([([([(({}<{}><>)<([{}]{})(<((()()()()()){}(<>))>)<>{({}[()])<>(({}()[({}<({}())>)])){{}(<({}({}<({}[()])>))>)}{}<>}{}<>{}{}({}<>)>){}]{})]<(())>)(<>)]){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}({}<>)}{}

ব্যাখ্যা

সমস্ত কোড শুরু করার জন্য একটি লুপ থাকে যা স্ট্যাকের শীর্ষটি শূন্যের চেয়ে কম না হওয়া পর্যন্ত চলে:

([([({})]<(())>)](<>)){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}({}<>)
{{}
 ...
 ([([({})]<(())>)](<>)){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}({}<>)
}{}

লুপের ভিতরে আমরা সাতটি অ্যালগরিদম দ্বারা বিভাজকটি চালাই:

স্ট্যাকের শীর্ষটি নকল করুন

(({}))

স্ট্যাকের শীর্ষের 10 টি মোড নিন (শেষ অঙ্ক)

(<((()()()()()){}<>)>)<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}{}<>({}<{}><>)

এটি কিছুটা গণ্ডগোল হলেও এটি বাকী অ্যালগরিদমটি আমি পরে এটি ব্যাখ্যা করতে পারি তবে এটি কীভাবে কাজ করে তা পুরোপুরি মনে নেই:

([(({})<([{}]{})(<((()()()()()){}(<>))>)<>{({}[()])<>(({}()[({}<({}())>)])){{}(<({}({}<({}[()])>))>)}{}<>}{}<>{}{}({}<>)>){}]{})

— গম উইজার্ড
সূত্র

1

সি, 56 বাইট - 75% = 14

যদিও এটি পরীক্ষার কেসের মতো ঠিক একই সংখ্যা দেয় না, তবে এটি প্রশ্নের আত্মাকে সন্তুষ্ট করে (এবং আরও যুক্তিযুক্ত)। এটি সঠিকভাবে 7 এর গুণকগুলি চিহ্নিত করে এবং অন্যান্য সংখ্যার জন্য সঠিক অবশিষ্টাংশ দেয় (যেহেতু এটি কখনও নেতিবাচক সংখ্যা ব্যবহার করে না)।

n;f(char*c){for(n=0;*c;)n-=n>6?7:'0'-n-n-*c++;return n;}

অ্যালগরিদমে কোনও গুণ বা বিভাগ নেই, কেবল সংযোজন এবং বিয়োগফল এবং অঙ্কগুলি বাম থেকে ডানে একক পাসে প্রক্রিয়া করা হয়। এটি নিম্নলিখিত হিসাবে কাজ করে, সঞ্চয়ের মধ্যে 0 দিয়ে শুরু করে:

প্রয়োজনে 7 বিয়োগ করুন এবং এখনও প্রয়োজনে আবার বিয়োগ করুন
চলমান মোট তিনটি দিয়ে গুণ করুন এবং পরবর্তী অঙ্কটি যুক্ত করুন

"তিনটি গুণ দ্বারা" পদক্ষেপটি n-=-n-nবাইট সংরক্ষণ এবং গুণক অপারেটর এড়ানোর জন্য লেখা ।

যখন আমরা শেষের দিকে আঘাত করি, আমরা সাতটি বিয়োগ করি না, ফলস্বরূপ 0-24 এর মধ্যে হবে; আপনি যদি একটি কঠোর মডিউলস (0-7), বিকল্প চান তাহলে *cসঙ্গে *c||n>6মধ্যে forলুপ শর্ত।

এটি বর্ধিত বোনাসের জন্য যোগ্যতা অর্জন করে, কারণ এটি

স্বেচ্ছাসেবী-নির্ভুলতা পূর্ণসংখ্যার সমর্থন করে
বাম থেকে ডান ক্রমে ইনপুটটিতে কেবল একটি পাস করে
স্পেস জটিলতা হে (1)
সময়ের জটিলতা O (n) রয়েছে।

পরীক্ষা প্রোগ্রাম এবং ফলাফল

#include <stdio.h>
int main(int argc, char **argv) {
    while (*++argv)
        printf("%s -> %d\n", *argv, f(*argv));
    return 0;
}

540 -> 15
541 -> 16
542 -> 17
543 -> 18
544 -> 19
545 -> 20
546 -> 21
547 -> 22
548 -> 23
549 -> 24
550 -> 18
99 -> 15
999 -> 12
12345 -> 11
32767 -> 7
700168844221 -> 7
36893488147419103232 -> 11
231584178474632390847141970017375815706539969331281128078915168015826259279872 -> 11

বিকল্প সংস্করণ

এখানে একটি পুনরাবৃত্তি করে (আপনি লেজ-কল রূপান্তর করতে সংকলক অনুকূলিতকরণ সক্ষম করতে চান বা আপনি আপনার স্ট্যাককে উপচে ফেলে দিতে পারেন; আমি ব্যবহার করেছি gcc -std=c89 -O3):

f(c,n)char*c;{return n>6?f(c,n-7):*c?f(c+1,n+n+n+*c-'0'):n;}

দ্বিতীয় যুক্তি হিসাবে এটি '0' দিয়ে কল করুন Call

উভয় সংস্করণটি আমার মেশিনে 50 মিলিসেকেন্ডের নীচে 60,000 অঙ্কের সংখ্যার অবশিষ্ট-মডুলো-সাতটি গণনা করে।

— টবির গতি
সূত্র

বোনাসের জন্য ধন্যবাদ - এটি এত প্রতিযোগিতামূলক শেষ হতে সি এর জন্য একটি আসল পরিবর্তন করে! বর্তমানে কেবল জেলি (11) এবং পাইথ (13) দ্বারা পরাজিত । :-)

— টবি স্পিড

1

পিএইচপি, 50 বাইট

for($n=$argv[1];$n>9;)$n=$n/10|0-2*($n%10);echo$n;

বিকল্প আউটপুট ব্যবহার করে; পর্যন্ত কাজ করেPHP_INT_MAX

স্ট্রিং সংস্করণ, কোনও (ধনাত্মক) সংখ্যার জন্য (64 বাইট) কাজ করে:

for($n=$argv[1];$n>9;)$n=substr($n,0,-1)-2*substr($n,-1);echo$n;

— তিতাস
সূত্র

0

জাভা, 133 বাইট

int d(int n){String s=""+n;return n<71?n:d(Integer.parseInt(s.replaceFirst(".$",""))-Integer.parseInt(""+s.charAt(s.length()-1))*2);}

আমি ঘৃণা করি কিভাবে ভার্বোস Integer.parseIntহয়। Ungolfed:

static int div(int n) {
    if (n <= 70) {
        return n;
    } else {
        String num = ("" + n);
        int last = Integer.parseInt("" + num.charAt(num.length() - 1));
        int k = Integer.parseInt(num.replaceFirst(".$", "")) - last * 2;
        return div(k);
    }
}

— জাস্টিন
সূত্র

বিভাজ্য-বাই -২ বিধি কার্যকর করুন

গল্ফস্ক্রিপ্ট, 27 22 বাইট

ব্যাখ্যা

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

জেলি, 11 বাইট

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

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

পাইথ, 13 বাইট

ব্যাখ্যা:

জুলিয়া, 27 26 বাইট

পাইথ, 17 বাইট

ব্যাখ্যা

সিজেম - 19 বাইট

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

হাস্কেল, 157 192 184 167 159 147 138 + 5 বাইট - 50% = 71.5 বাইট

জিএনইউ ডিসি, 20 15 বাইট

গণিত, 47 44 বাইট

আর, 43 বাইট

জাভাস্ক্রিপ্ট ES6, 38 বাইট

গণিত, 33 বাইট

পার্ল 5, 47 46 বাইট

ES6, 108 বাইট

জাভাস্ক্রিপ্ট ES6, 140 142 বাইট

সি #, 111 104 বাইট

ব্রেন-ফ্লাক , 368 360 বাইট

ব্যাখ্যা

সি, 56 বাইট - 75% = 14

পরীক্ষা প্রোগ্রাম এবং ফলাফল

বিকল্প সংস্করণ

পিএইচপি, 50 বাইট

জাভা, 133 বাইট