26

জন্য ডিজিটাল কঠোরতা একটি পূর্ণসংখ্যা এর, তার বাইনারি উপস্থাপনা নিই এবং যতবার গণনা উভয় একটি নেতৃস্থানীয় এবং চিহ্ন 1পর্যন্ত এটা হয় শুরু করলে বা কোনো সঙ্গে প্রান্ত মুছে ফেলা হতে পারে 0। বিটগুলির মোট সংখ্যা হ'ল এটির ডিজিটাল কঠোরতা।

এটি বেশ কথার ব্যাখ্যা - সুতরাং আসুন এটি একটি কাজের উদাহরণ দিয়ে ভেঙে দিন।

এই উদাহরণস্বরূপ, আমরা 3167 নম্বরটি ব্যবহার করব b বাইনারিতে এটি হ'ল:

110001011111

(দ্রষ্টব্য, বাইনারি রূপান্তর করার সময়, আপনি নেতৃস্থানীয় জিরো ফেলা নিশ্চিত করা উচিত)

এটি শুরু বা শেষ হয় না 0, তাই আমরা 1 জোড়া বিটগুলি সরিয়ে ফেলি:

1  1000101111  1

এবং অন্য:

11  00010111  11

তবে এখন শুরুতে 0 রয়েছে, তাই আমরা আর 1জোড়া জোড়া মুছতে পারি না । মোট, 4 টি বিট আমরা সরিয়েছি এবং তাই 4 টি 3167 এর ডিজিটাল কঠোরতা ।

তবে, এমন সংখ্যার জন্য যেগুলি 2 ^এন -1 হিসাবে ধনাত্মক এন (যেমন কেবল 1বাইনারি উপস্থাপনায় থাকে) হিসাবে লিখতে পারে , 0 কখনই পৌঁছাতে পারে না এবং তাই সমস্ত বিট অপসারণ করা যায়। এর অর্থ হল যে কঠোরতা কেবলমাত্র পূর্ণসংখ্যার বিট দৈর্ঘ্য।

চ্যালেঞ্জ

আপনার কাজটি হ'ল একটি প্রোগ্রাম বা ফাংশন লিখুন যা একটি অ-নেতিবাচক পূর্ণসংখ্যার প্রদত্ত হলে n >= 0এর ডিজিটাল কঠোরতা নির্ধারণ করে।

আপনি একটি সম্পূর্ণ প্রোগ্রাম জমা দিতে পারেন যা I / O সম্পাদন করে বা এমন কোনও ফাংশন যা ফলাফল দেয় returns আপনার জমা দেওয়ার ক্ষেত্রে nআপনার ভাষার মানক পূর্ণসংখ্যার ব্যাপ্তির মানগুলির জন্য কাজ করা উচিত ।

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

এর মধ্যে কোনওটি ভুল হলে দয়া করে আমাকে জানান বা আপনি কোনও প্রান্তের কেস যুক্ত করতে চান তবে।

0     -> 0
1     -> 1
8     -> 0
23    -> 2
31    -> 5
103   -> 4
127   -> 7
1877  -> 2
2015  -> 10

আমি এই পরীক্ষাগুলি কেস উত্পন্ন করার জন্য অগল্ফড পাইথন সমাধানটি দিয়েছি (বাগ-কম হওয়ার গ্যারান্টিযুক্ত নেই):

def hardness(num) -> int:
    binary = bin(num)[2:]

    if binary.count('0') == 0:
        return num.bit_length()

    revbin = binary[::-1]

    return min(revbin.find('0'), binary.find('0')) * 2

— FlipTack
সূত্র

1

এতে 11 না থাকলে কীভাবে ফিরে আসবে 0? মানে, আপনি সম্ভবত স্ট্রিংটি থেকে এটি শুরু করতে বা শেষ করতে পর্যাপ্ত 1 টি সরাতে পারবেন না 0।

— বাসুকসুয়ান

2

@ বুসুকক্সুয়ান "দ্য চ্যালেঞ্জ" শিরোনামের ঠিক আগে অনুচ্ছেদটি পড়ুন: 2 ^ n-1 হিসাবে লিখিত হতে পারে এমন সংখ্যার জন্য (যেমন বাইনারি উপস্থাপনায় কেবল 1 টি রয়েছে), 0 কখনই পৌঁছানো যাবে না এবং তাই সমস্ত বিট অপসারণ করা যায় । এর অর্থ হল যে কঠোরতা কেবলমাত্র পূর্ণসংখ্যার বিট দৈর্ঘ্য।

— ফ্লিপট্যাক

2

@ বসুকক্সুয়ান আপনি জিরো পৌঁছানোর আগেই প্রতিটি পক্ষের সংখ্যায় প্যাডযুক্ত সংখ্যা হিসাবে এটি ভাবতে পারেন।

— ফ্লিপট্যাক

2

Downvoter যারা স্পষ্টত প্রান্ত মামলা ভালো লাগে নি করার জন্য: কঠোরতা - যদি পুরো জিনিস কঠিন হয়, তাহলে নিশ্চয় এটা 100% কঠোরতা পূর্ণ বিট দৈর্ঘ্য, কঠিন (1) বিট সংখ্যা এটি দিয়ে প্যাডেড হয়?

— ফ্লিপট্যাক

1

@ ফ্লিপট্যাক আমি খুব বেশি প্রভাবিত করতে চাই না, এটি আপনার চ্যালেঞ্জ। আমি প্রথমদিকে "দৃness়তা "টিকে বাইরের দিকের সর্বাধিক সংখ্যক জোড়া হিসাবে সরিয়ে ফেলতে পারি, প্রতিটি পক্ষ থেকে এক করে one তবে আপনি সঠিক হতে পারেন, যদি কোনও একশেষে থেকে যায়, সম্ভবত এটি গণনা করা উচিত

— লুইস মেন্ডো

6

জেলি , 11 10 বাইট

BµQL××Ṛa\S

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

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

BµQL××Ṛa\S  Main link. Argument: n

B           Binary; convert n to base 2.
 µ          Begin a new, monadic chain. Argument: A (array of binary digits)
  Q         Unique; deduplicate the digits.
   L        Length; count the unique digits.
    ×       Multiply each digit by the result.
     ×Ṛ     Multiply the results by reversed A.
       a\   Cumulative reduce by logical AND.
            This zeroes out all elements after the first zero.
         S  Compute the sum of the result.

— ডেনিস
সূত্র

8

পাইথন , 76 69 68 63 62 60 57 বাইট

f=lambda n,k=0:n>>k&(n&n>>k>n>>k+1)and(n&n+1>0)-~f(n,k+1)

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

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

এটি একটি পুনরাবৃত্ত সমাধান যা একটি ইনপুট এন নেয় এবং কে বাড়িয়ে রাখে - 0 থেকে শুরু করে - উভয় এলএসবি _কে (এন) ( ডান থেকে সূচক কেতে বিট ) এবং এমএসবি _কে (এন) ( বাম দিক থেকে সূচক কেতে বিট ) নির্ধারণ করা হয়. কর্ম সমাপ্ত হলে, এটা ফেরৎ ট যদি সব এন এর বিট সেট করা হয় 2k যদি না।

এর ল্যামডা rewriting দ্বারা শুরু করা যাক চ একটি নামাঙ্কিত ফাংশন হিসাবে এফ , একটি অক্জিলিয়ারী পরিবর্তনশীল সঙ্গে টি ।

def F(n, k = 0):
    t = n >> k
    return t & (n & t > t >> 1) and (n & (n + 1) > 0) + 1 + F(n, k + 1)

প্রতিটি আবাহন সালে এফ , তাই আমরা প্রথমেই বিট-শিফট এন মোট ট ডানদিকে ইউনিট এবং মধ্যে ফলাফলের সংরক্ষণ টন । এইভাবে, এলএসবি ₀ (টি) = এলএসবি _কে (এন) , তাই টি টি বিজোড় হয় এবং কেবলমাত্র এলএসবি _কে (এন) সেট করা থাকলে।

এমএসবি _কে (এন) সেট করা সামান্য কৌশলযুক্ত কিনা তা নির্ধারণ করা ; এটিই n & t > t >> 1অর্জন করে। এটি কীভাবে কাজ করে তা চিত্রিত করতে, আসুন বিট-দৈর্ঘ্যের 8 এর একটি পূর্ণসংখ্যা n = 1αβγδεζη ₂ বিবেচনা করুন এবং এফ (এন, 3) ফাংশনটি কল করুন , অর্থাত্ = = 3 বিশ্লেষণ করুন ।

আমরা নির্ধারণের চেষ্টা করছি যে এমএসবি ₃ (এন) = set তুলনা (এন & টি> টি >> 1) = (1αβγδεζη ₂ এবং 1αβγδ ₂ > 1αβγ ₂ ) এর সত্য মান পরীক্ষা করে সেট করা আছে কিনা । জড়িত পূর্ণসংখ্যার পরীক্ষা করা যাক।

MSB-index  012k4567

n          1αβγδεζη
t             1αβγδ

t >> 1         1αβγ

আমরা দাবি করি যে γ = 1 যদি কেবলমাত্র & n & t> টি >> 1 হয় ।

তাহলে γ = 1 , তারপর এন & ন বিট-দৈর্ঘ্য 5 যখন T >> 1 বিট-দৈর্ঘ্য 4 , তাই এন & ন> T >> 1 ।

এটি প্রমাণ করে যে γ = 1 এর দ্বারা n & t> t >> 1 বোঝায় ।
যদি এন & টি> টি >> 1 না থাকে তবে দুটি বিকল্প রয়েছে: হয় γ = 1 বা γ = 0 । প্রথম ক্ষেত্রে, প্রমাণ করার মতো কিছুই নেই।

দ্বিতীয় ক্ষেত্রে আমরা যে আছে αβγδ ₂ ≥ এন & ন> T >> = 1 1αβγ ₂ ।

Αβγδ ₂ > 1αβγ ₂ , যেহেতু আমাদের অবশ্যই এমএসবি ₀ (αβγδ ₂ ) ≥ এমএসবি ₀ (1αβγ ₂ ) হওয়া উচিত , যার অর্থ α = 1 ।

এইভাবে, 1βγδ ₂ > 11βγ ₂ , সুতরাং আমাদের অবশ্যই এমএসবি ₁ (1βγδ ₂ ) ≥ এমএসবি ₁ (11βγ ₂ ) থাকতে হবে , যার অর্থ β = 1 ।

পরিবর্তে, এর অর্থ 11 imp ₂ > 111γ ₂ । দ্বিতীয় ক্ষেত্রে γ = 0 মনে রেখে আমরা বৈষম্যটি 110δ ₂ > 1110 ₂ পাই , যা এমএসবি ₂ (110δ ₂ ) = 0 <1 = এমএসবি ₂ (1110 ₂ ) থেকে মিথ্যা ।

সুতরাং, কেবলমাত্র প্রথম ক্ষেত্রেই সম্ভব এবং এন & টি> টি >> 1 বোঝায় γ = 1 ।

সারসংক্ষেপ করা, যদি উভয় lsb _ট (ঢ) এবং MSB _ট (ঢ) নির্ধারণ করা হয়, টি বিজোড় হবে এবং এন & ন> T >> 1 হতে হবে সত্য , তাই T & (ঢ & ন> T >> 1) হবে ফলন 1 । তবে, যদি এলএসবি _কে (এন) বা এমএসবি _কে (এন) আনসেট করা থাকে (বা উভয়ই থাকে) তবে টি সমান হবে না বা n & t> t >> 1 টি মিথ্যা হবে , সুতরাং t & (n & t> t> > 1) 0 প্রদান করবে ।

একক যুক্তির সাহায্যে এফ কল করা কে = 0 শুরু করে । আমরা পূর্বে যে শর্তটি নিয়ে আলোচনা করেছি, তার পরে কোডটি andকার্যকর করা হয়, যা (অন্যান্য জিনিসের মধ্যে) বারবার ক্রমবর্ধমান কে দিয়ে এফ কল করে ।

একবার এলএসবি _কে (এন) বা এমএসবি _কে (এন) আনসেট হয়ে গেলে শর্তটি ব্যর্থ হয় এবং এফ (এন, কে) 0 ফিরে আসে । পূর্ববর্তী প্রত্যেকটি ট ফাংশান কল যোগ করা (ঢ & (ঢ + 1 টি)> 0) + 1 টি থেকে এফ (ঢ, ট) = 0 , তাই এফ (ঢ) রিটার্ন ((ঢ & (ঢ + 1 টি)> 0) + + 1) কে ।

এখন, n এর সমস্ত বিট যদি সমান হয় (যেমন, যদি এন হয় 0 হয় বা এর সমস্ত বিট সেট করা থাকে), n + 1 এর সাথে n এর সাথে কোনও বিট মিলবে না , সুতরাং n & (n + 1) = 0 এবং চ (এন) ফেরত কে । যাইহোক, যদি এন উভয় সেট এবং সেট না বিট, হয়েছে এন & (ঢ + 1 টি)> 0 এবং এফ (ঢ) ফেরৎ 2k ।

— ডেনিস
সূত্র

2

পাইথনের পুনরাবৃত্ত সমাধানগুলি ইদানীং খুব ভাল স্কোর করছে বলে মনে হচ্ছে।

— mbomb007

অন্তত পুনরাবৃত্ত সমাধানগুলির সাথে তুলনা করা, তারা সর্বদা থাকে। input(), whileএবং printইতিমধ্যে 17 বাইট রয়েছে ...

— ডেনিস

হ্যাঁ, তবে আমি তাদের লিখতে এতই কঠিন মনে করি।

— mbomb007

1

যথেষ্ট ফর্সা। একই ধারণার একটি সরল পুনরাবৃত্তি বাস্তবায়ন যদিও 5 বাইট বেশি দীর্ঘ হবে। tio.run/nexus/… আরও দুটি বাইট কয়েকটি কৌশল দিয়ে সংরক্ষণ করা যায়। tio.run/nexus/python2#JY1BDsIgFAXX7SnepgUUI1BNm1K4jKVJQ/…

— ডেনিস

6

এমএটিএল , 13 12 বাইট

Btv`6L&)}x@q

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

ব্যাখ্যা

কোডটি প্রতিটি বাইনারি অঙ্কের পুনরাবৃত্তি করে এবং দু'জন বহিরাগতকে সরিয়ে ফেলার জন্য কতবার সম্ভব তা গণনা করে।

B        % Input number (implicit). Horizontal vector of binary digits
tv       % Duplicate and concatenate vertically
`        % Do...while
  6L&)   %   Flatten the array if needed (in column-major order), and split it
         %   into two subarrays: one with the inner entries, and another
         %   with the two outer entries. The latter will be used for deciding
         %   if the loop continues or is exited
}        % Finally (execute before exiting the loop)
  x      %   Delete last subarray of inner entries
  @q     %   Push last iteration index minus 1
         % End (implicit). The next iterarion is executed if the array at the
         % top of the stack is non-empty and only contains nonzero values. 
         % Otherwise the loop is exited, executing the "finally" block first
         % Display (implicit)

— লুইস মেন্ডো
সূত্র

6

পাইথন, 82 বাইট

আমার মনে হচ্ছে এটি এখনও গল্ফ করা যেতে পারে তবে আমি বিভিন্ন পদ্ধতির চেষ্টা করে কিছুটা সময় ব্যয় করেছি এবং এটি ছিল সবচেয়ে স্বল্পতম।

def f(n):b=bin(n)[2:];x=min(b.find('0'),b[::-1].find('0'));print(x<0)*len(b)or x*2

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

যদিও এটি ওপির পাইথন প্রোগ্রামের সাথে একইভাবে কাজ করে, স্যান্ডবক্সে প্রশ্নটি দেখার পরে, প্রশ্ন পোস্ট হওয়ার আগেই আমি এটি তৈরি করেছি, যাতে এই জাতীয় প্রোগ্রাম নেই।

— mbomb007
সূত্র

6

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

s=bin(input())[2:].split('0')
print len(min(s[-1],s[0]))<<1%len(s)

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

— xnor
সূত্র

চতুর, কিন্তু এখনও বুঝতে সহজ। আমি এটা পছন্দ করি!

— mbomb007

5

@ mbomb007 এটিকে ডেনিসের বোঝার জন্য উষ্ণতা হিসাবে গ্রহণ করুন :)

— xnor

3

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

$a=[convert]::ToString($args[0],2)-split0;(((($b=$a[0].length),$a[-1].length|sort)[0]*2),$b)[$a.count-eq1]

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

ইনপুট নেয় $args[0], বেসের সাথে convertএটিতে নেট কল ব্যবহার করে (অর্থাত্ এটি বাইনারি করুন), তারপরে এস স্ট্রিংটি এসটিকে স্টোর করে । খেয়াল করা গুরুত্বপূর্ণ: .NET কল বসানো শূন্যগুলি ফেরত দেয় না, তাই প্রথম অঙ্ক সর্বদা একটি ।toString2-split0$a1

এখানে দুটি সম্ভাবনা রয়েছে - বাইনারি স্ট্রিং সবগুলিই হয়, বা কমপক্ষে একটি শূন্য ছিল। আমরা সিডো-টের্নারি দ্বারা সূচক অনুসারে তাদের মধ্যে পার্থক্য করি $a.count-eq1। বাইনারি অন্তত একটি শূন্য, বাম ক্ষেত্রে থাকে, তাহলে আমরা প্রথমে দৈর্ঘ্য ন্যূনতম নিতে [0]এর স্ট্রিং 1গুলি ও শেষ [-1]স্ট্রিং (দ্বারা পাওয়া |sortএবং তারপর [0])। এর মধ্যে সংক্ষিপ্ততমটি হ'ল আমরা সবচেয়ে বেশি জোড় সরিয়ে ফেলতে পারি, তাই আমরা এটিকে আরও গুণ করি 2। নোট করুন যে যদি মূল বাইনারি স্ট্রিংটি 0ইনপুটগুলির মতো একটিতে শেষ হয় 8, তবে [-1].lengthসেগুলিও হবে 0(যেহেতু এটি একটি খালি স্ট্রিং), যখন এটি যখন গুণিত 2হয় তখনও হয় 0।

অন্যথায়, বাইনারি স্ট্রিংয়ের সাথে আমরা কেবল গ্রহণ করি $b(যা আগে প্রথম [0]স্ট্রিংয়ের দৈর্ঘ্য হিসাবে সেট করা হয়েছিল , এক্ষেত্রে বাইনারি স্ট্রিংয়ের সম্পূর্ণতা)।

উভয় পরিস্থিতিতেই, ফলাফলটি পাইপলাইনে ছেড়ে যায় এবং আউটপুট অন্তর্ভুক্ত থাকে।

— AdmBorkBork
সূত্র

3

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

f=
n=>n.toString(2).replace(/^(1*)(.*(\1))?$/,'$1$3').length

<input oninput=o.value=1/this.value?f(+this.value):''><input id=o readonly>

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

বাইনারি গ্রহণ করে এবং সমস্তটি মিলানোর চেষ্টা করে 1sবা ব্যর্থ হয় যে সমান সংখ্যক শীর্ষস্থানীয় এবং পিছনের দিকে 1s।

— নিল
সূত্র

2

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

.+
$*
+`(1+)\1
$1o
o1
1
m(+`^1(.*)1$
xx¶$1
x|^1$

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

ব্যাখ্যা:

.+              # Convert to unary
$*
+`(1+)\1        # Convert to binary (but with `o` instead of `0` -- it's shorter)
$1o
o1
1
m(+`^1(.*)1$    # Replace pairs of surrounding ones with `xx`
xx¶$1
x|^1$,          # Count x's, including the possibility of a single remaining `1`

— mbomb007
সূত্র

2

সি #, 133 বাইট

ফাংশন যা কঠোরতা ফেরায়। যুক্তি থেকে পূর্ণসংখ্যা গ্রহণ করে।

int h(int b){var n=Convert.ToString(b,2);for(b=0;;){if(n[0]+n[n.Length-1]==98)n=n.Substring(1,n.Length-2);else break;b+=2;}return b;}

ঠিক আছে, আমি আজ '1' + '1' = 98সি # তে খুঁজে পেয়েছি ।

— devRicher
সূত্র

1

কারণ '1'ASCII চর 49, এবং 49 + 49 = 98.

— ফ্লিপট্যাক

আমি কেন 1 + 1 = 2কাজ করি না তা আবিষ্কার করার জন্য আমি আক্ষরিকভাবে 10 মিনিট ব্যয় করেছি । @ ফ্লিপট্যাক

— ডিভ্রিচার

2

সি, 89 88 85 বাইট

@ ফ্লিপট্যাক অকেজো ঘোষণার প্রতিশ্রুতি দেওয়ার কারণে দুটি বাইট সংরক্ষণ করা হয়েছে।

f()পরীক্ষার জন্য নম্বর সহ কল করুন , ফাংশন থেকে আউটপুট ফিরে আসবে।

t,h;f(l){for(t=l;t&&~t&1<<30;t*=2);for(h=0;t&1<<30&&l&1;t*=2,l/=2)++h;return h<<!!l;}

আদর্শে এটি চেষ্টা করুন ।

— owacoder
সূত্র

2

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

f=(n,m=1<<30)=>m>n?f(n,m/2):m>1?n&m&&n&1&&2+f(n/2,m/4):n&1

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

কোড স্নিপেট দেখান

f=(n,m=1<<30)=>m>n?f(n,m/2):m>1?n&m&&n&1&&2+f(n/2,m/4):n&1

console.log(
  [0, 1, 8, 23, 31, 103, 127, 1877, 2015].map(
    n => n + ' -> ' + f(n)
  ).join('\n')
)

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

— Arnauld
সূত্র

2

জেলি , 14 বাইট

Eo2
BµŒg.ịṂS×Ç

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

— লিন
সূত্র

2

সি, 137 132 122 119 117 114 98 94 92 87 85 বাইট

গল্ফিং শুরু করার সময় বি-)

i,j;f(n){for(i=1<<30;i&~n;i/=2);for(j=0;n&i;n/=2,i/=4)j+=~n&1?i=0:2;return j-=n<1*j;}

প্রমাণ এখানে

main()
{
  printf("%d %d\n", 0, f(0));
  printf("%d %d\n", 1, f(1));
  printf("%d %d\n", 8, f(8));
  printf("%d %d\n", 23, f(23));
  printf("%d %d\n", 31, f(31));
  printf("%d %d\n", 103, f(103));
  printf("%d %d\n", 127, f(127));
  printf("%d %d\n", 1877, f(1877));
  printf("%d %d\n", 2015, f(2015));
  printf("%d %d\n", 3167, f(3167));
}

এবং আউটপুট;

— cleblanc
সূত্র

1

জাভা (ওপেনজেডিকে) , 181 156 150 বাইট

n->{int i=0;String s=n.toString(n,2);if(s.matches("1*"))i=s.length();else for(;!s.matches("(.*0)|(0.*)");s=s.substring(1,s.length()-1))i+=2;return i;}

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

— পাভেল
সূত্র

1

গণিত, 63 56 বাইট

(2-Min[l=#~IntegerDigits~2])Min[Tr/@Split[l][[{1,-1}]]]&

ব্যাখ্যা

l=#~IntegerDigits~2

ইনপুটটির বেস -২ উপস্থাপনা তৈরি করুন, এ দিয়ে মোড়ানো List। যে স্টোরl

(2-Min[...])

যদি ন্যূনতম উপাদানটি 1 lহয় তবে আউটপুট 1 হয় না তবে আউটপুট 2 এটি দিয়ে গুণ করুন ...

Split[l]

lরান মধ্যে বিভক্ত ।

... [[{1,-1}]]

প্রথম এবং শেষ উপাদানটি নিন।

Tr/@ ...

উভয় মোট নিতে।

Min[ ... ]

দুজনের মধ্যে আরও ছোটটি সন্ধান করুন।

(প্রথম ফলাফলটি (1 বা 2) এই ফলাফলের সাথে গুণ করুন)।

— জংহওয়ান মিন
সূত্র

1

অক্টাভা, 56 54 বাইট

 @(n)cummin(d=dec2bin(n)-48)*cummin(flip(d))'*2^!all(d)

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

ব্যাখ্যা:

d=dec2bin(n)-48

বাইনারি উপস্থাপনা n

cumd= cummin(d);
cumfd = cummin(flip(d));

ক্রমযুক্ত মিনিট d এবং ফ্লিপযুক্ত সংযোজিত মিনিট নিনd

res = cumd * cumfd ';

ম্যাট্রিক্স গুণ করা

out = res*2^!all(d)

সমস্ত সংখ্যার 1 হলে 2 দিয়ে গুণ করুন;

— rahnema1
সূত্র

@ ফ্লিপট্যাক ধন্যবাদ, লিঙ্ক আপডেট হয়েছে!

— rahnema1

1

পাইথ, 18 বাইট

?*FJjQ2lJyhSxR0_BJ

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

পরীক্ষার স্যুট (বিন্যাসের জন্য প্রথম লাইন)

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

?*FJjQ2lJyhSxR0_BJ  Program. Input: Q
?                   If
  F                 reducing
    jQ2             the binary representation of Q as a list
   J                (store in J)
 *                  by multiplication is truthy:
       lJ            Yield len(J)
                    Else:
          hS         Yield the minimum
            xR0      of the first index of zero
               _BJ   in J and its reverse
         y           * 2
                    Implicitly print

— TheBikingViking
সূত্র

1

এপিএল, 26 বাইট

+/∘(∧\≢↑(∊⊢(,∧∧)¨⌽))2⊥⍣¯1⊢

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

      ( +/∘(∧\≢↑(∊⊢(,∧∧)¨⌽))2⊥⍣¯1⊢ ) ¨ 0 1 8 23 31 103 127 1877 2015    
0 1 0 2 5 4 7 2 10

ব্যাখ্যা:

+ + / ∘ (∧ \ ≢ ↑ (ε⊢ (∧∧) ¨⌽)) 2⊥⍣¯1⊢

                         । ইনপুট
                    2-1 বাইনারি প্রতিনিধিত্ব রূপান্তর
   ()
        (⊢ ¨⌽) প্রতিটি বিটের জন্য এবং অন্যদিকে এর ম্যাচিং বিটের জন্য
            (∧) যৌক্তিক এবং উভয় বিট নিতে,
             , উভয় বিটের একটি তালিকা তৈরি করুন,
              ∧ তারপরে তালিকার এবং তার এবং নিন
         Resulting ফলাফল অ্যারে সমতল করুন
      The only কেবলমাত্র প্রথম এন বিট নিন, যেখানে এন
                                বিটগুলির মূল তালিকার দৈর্ঘ্য
    Running a একটি চলমান যৌক্তিক নিন এবং (কেবলমাত্র এটি রেখে যাচ্ছেন)
                                শুরু করা)
+ / ∘ যোগফলগুলি

— সামুদ্রিক
সূত্র

1

জে, 22 বাইট

(#<.2*(<.&(#.~)|.))@#:

এটি এই চ্যালেঞ্জ থেকে শিখেছি ঝরঝরে কৌশল অবলম্বনে ।

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

ব্যাখ্যা

(#<.2*(<.&(#.~)|.))@#:  Input: integer n
                    #:  Binary digits of n
(                 )@    Operate on those digits D
               |.         Reverse D
       <.                 Take the minimum of
         &(#.~)           the "trailing truths" of D and reverse(D)
    2*                    Multiply by 2
 #                        The length of D
  <.                      Minimum of length and the previous result

— মাইল
সূত্র

1

পিএইচপি, 83 74 বাইট

3 + 6 বাইট জার্গ দ্বারা সংরক্ষিত

<?=(~$s=decbin($argn))[$a=strspn($s,1)]?min($a,strspn(strrev($s),1))*2:$a;

এসটিডিআইএন থেকে ইনপুট নেয়; সাথে চালানো -nR।

ভাঙ্গন

<?=                     # print ...
(~
    $s=decbin($argn)        # $s = binary representation of input
)[
    $a=strspn($s,1)         # $a = number of leading `1`s
]                           # if $s has more than $a digits,
?   min($a,                     # 2. minimum of $a and
        strspn(strrev($s),1)    # 1. number of trailing `1`s
    )*2                         # 3. *2
:   $a                      # else $a (==strlen)

— তিতাস
সূত্র

1

<?=~($s=decbin($argn))[$a=strspn($s,1)]?2*min($a,strspn(strrev($s),1)):$a;

— জার্গ হালসারম্যান

0

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

f=x=>(y=x.toString(2),y.match(/^1*$/)?y:([s,e]=y.match(/^1*|1*$/g),s<e?s:e)).length

Ungolfed:

function f(n) {
    var binStr = n.toString(2);
    if(binStr.match(/^1*$/)) {
        // If binary representation is all 1s, return length of binary
        return binStr.length;
    } else {
        // Grab the starting and ending 1s in the binary representation
        var [start1s, end1s] = binStr.match(/^1*|1*$/g);
        var startHardness = start1s.length;
        var endHardness = end1s.length;
        return Math.min(startHardness, endHardness);
    }
}

— জোশুয়া ডেভিড
সূত্র

0

গণিত, 62 বাইট

(h=0;#~IntegerDigits~2//.{{1,m___,1}:>(h+=2;{m}),{1}:>h++};h)&

খাঁটি ফাংশন যেখানে #প্রথম যুক্তি উপস্থাপন করে।

(h=0;...;h)&সেট করে h=0, একগুচ্ছ জিনিস দেয় ..., তারপরে ফিরে আসে h(কঠোরতা)। চলুন গুচ্ছ জিনিসগুলি দেখুন:

#~IntegerDigits~2                                     Binary representation of the input
                 //.                                  Apply the following list of rules repeatedly until there is no change
                    {                                 Start of the list of rules
                     {1,m___,1}                       If you see a list starting and ending with 1 with the sequence m (possibly empty) in between
                               :>(h+=2;{m}),            replace it with just {m} after incrementing h twice.
                                            {1}       If you see the singleton list {1}
                                               :>h++    replace it with h, then increment h.
                                                    } End of the list of rules

গ্রেগ মার্টিনকে ধন্যবাদ আমাকে এই কৌশলটিতে পরিচয় করিয়ে দেওয়ার জন্য ।

— ngenisis
সূত্র

0

হাস্কেল , 94 92 বাইট

b 0=[]
b n=mod n 2:b(div n 2)
h n|(c,_:_)<-span(>0)$zipWith(*)n$reverse n=c++c|1<3=n
sum.h.b

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

Prelude> sum.h.b $ 3167
4

ব্যাখ্যা:
b একটি সংখ্যাকে বাইনারিতে রূপান্তর করে এবং শূন্যের তালিকা এবং প্রথমে কমপক্ষে উল্লেখযোগ্য বিট সহ একটি তালিকা প্রদান করে। ইন h, এই তালিকাটি বিপরীত হয়েছে এবং উপাদান অনুসারে মূল তালিকাটির সাথে গুণিত হবে, তারপরে span(>0)প্রাথমিকগুলির পরে বিভক্ত হবে 1:

       b 3167 = [1,1,1,1,1,0,1,0,0,0,1,1] = n
    reverse n = [1,1,0,0,0,1,0,1,1,1,1,1] = m
zipWith(*)n m = [1,1,0,0,0,0,0,0,0,0,1,1] = z
   span(>0) z = ([1,1],[0,0,0,0,0,0,0,0,1,1])

ফলস্বরূপ টিপল হ'ল প্যাটার্নটি (c,_:_)যেখানে _:_কোনও খালি খালি তালিকার সাথে মেলে c = [1,1]। কারণ বাইটগুলি সামনে এবং পিছনে সরিয়ে ফেলা হয়, c++c = [1,1,1,1]ফিরে আসে এবং শেষ পর্যন্ত ডিজিটাল কঠোরতা অর্জনের জন্য যোগফল দেওয়া হয় ।

যদি টিউলের দ্বিতীয় তালিকাটি খালি থাকে তবে বাইনারি উপস্থাপনায় কেবল এটি থাকে এবং এর সংখ্যা হ'ল ডিজিটাল কঠোরতা। প্যাটার্নের সাথে মেলে ব্যর্থতার সাথে hফিরে আসে n, যা আবার সংক্ষিপ্ত হয়।

— Laikoni
সূত্র

0

পার্ল, 61 বাইট

sub f{$_=sprintf('%b',pop);length(/0/?/^(1+).*\1$/&&$1x2:$_)}

এর হৃদয় হ'ল রেজেক্স /^(1+).*\1$/যেখানে দৈর্ঘ্যের 2 গুন দৈর্ঘ্যের $1উত্তর। কোডের বাকি অংশগুলি ওভারহেড এবং সমস্ত 1 এর বিশেষ ক্ষেত্রে ডিল করছে।

— cdlane
সূত্র

আপনি sprintfআর্গুমেন্ট কাছাকাছি প্রথম বন্ধনী বাদ দিতে পারেন । এছাড়াও, -pপতাকা ব্যবহারের ফলে আপনি এমন একটি সম্পূর্ণ প্রোগ্রাম লিখতে পারবেন যা আপনার ফাংশনটির চেয়ে কম হবে কারণ আপনি বাদ দিতে পারবেন sub f{...}(পরিবর্তে আপনাকে শেষ করতে হবে $_=...তবে এটি এখনও 4 বাইটের উন্নতি হবে)। শেষ পর্যন্ত, আপনার পরিবর্তে length(...), আপনি এটি করতে পারেন /0/&&s/^(1+).*\1$/$1$1/;$_=y///c। এটি আপনাকে 51 বাইটে পাওয়া উচিত।

— দাদা

0

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

<?=strlen(preg_filter('#^(1*)(.*(\1))?$#',"$1$3",decbin($argn)));

অনলাইন সংস্করণ

— জার্গ হালসারম্যান
সূত্র

0

সিজেম, 14 বাইট

ri2b_0#\W%0#e<

ব্যাখ্যা:

ri e# Read integer:      | 3167
2b e# Convert to binary: | [1 1 0 0 0 1 0 1 1 1 1 1]
_  e# Duplicate:         | [1 1 0 0 0 1 0 1 1 1 1 1] [1 1 0 0 0 1 0 1 1 1 1 1]
0# e# Index of first 0:  | [1 1 0 0 0 1 0 1 1 1 1 1] 2
\  e# Swap:              | 2 [1 1 0 0 0 1 0 1 1 1 1 1]
W% e# Reverse:           | 2 [1 1 1 1 1 0 1 0 0 0 1 1]
0# e# Index of first 0:  | 2 5
e< e# Minimum:           | 2

— ফল ফল
সূত্র

পূর্ণসংখ্যার ডিজিটাল কঠোরতা

চ্যালেঞ্জ

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

জেলি , 11 10 বাইট

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

পাইথন , 76 69 68 63 62 60 57 বাইট

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

এমএটিএল , 13 12 বাইট

ব্যাখ্যা

পাইথন, 82 বাইট

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

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

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

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

ব্যাখ্যা:

সি #, 133 বাইট

সি, 89 88 85 বাইট

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

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

জেলি , 14 বাইট

সি, 137 132 122 119 117 114 98 94 92 87 85 বাইট

জাভা (ওপেনজেডিকে) , 181 156 150 বাইট

গণিত, 63 56 বাইট

অক্টাভা, 56 54 বাইট

পাইথ, 18 বাইট

এপিএল, 26 বাইট

জে, 22 বাইট

ব্যাখ্যা

পিএইচপি, 83 74 বাইট

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

গণিত, 62 বাইট

হাস্কেল , 94 92 বাইট

পার্ল, 61 বাইট

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

সিজেম, 14 বাইট