आउटपुट "फ़िट" संख्या

Question

"फ़िट नंबर"

सैम के पास संपीड़न के लिए एक "शानदार" विचार है! क्या आप मदद कर सकते हैं?

---

यहाँ सैम की संपीड़न योजना का एक हिस्सा है। पहले किसी भी प्राकृतिक संख्या के आधार 10 प्रतिनिधित्व को कड़ाई से 2 ^ 16 से छोटा करें, और इसे बिना किसी अग्रणी शून्य के द्विआधारी स्ट्रिंग के रूप में लिखें।

1 -> 1
9 -> 1001
15 -> 1111
13 -> 1101
16 -> 10000
17 -> 10001
65535 -> 111111111111111

अब एक या अधिक शून्य के किसी भी समूह को एक शून्य के साथ बदलें। ऐसा इसलिए है क्योंकि संख्या झुक गई है। अब आपका बाइनरी स्ट्रिंग इस तरह दिखेगा।

1 -> 1 -> 1
9 -> 1001 -> 101
15 -> 1111 -> 1111
13 -> 1101 -> 1101
16 -> 10000 -> 10
17 -> 10001 -> 101
65535 -> 111111111111111 -> 111111111111111

अब आप बाइनरी स्ट्रिंग को आधार 10 प्रतिनिधित्व में परिवर्तित करते हैं, और इसे किसी भी स्वीकार्य प्रारूप में आउटपुट करते हैं। यहां आपके परीक्षण के मामले हैं। पहला पूर्णांक एक इनपुट का प्रतिनिधित्व करता है, और अंतिम पूर्णांक एक आउटपुट का प्रतिनिधित्व करता है। ध्यान दें कि कुछ संख्याएं नहीं बदलती हैं, और इस प्रकार "फिट" कहा जा सकता है

1 -> 1 -> 1 -> 1
9 -> 1001 -> 101 -> 5
15 -> 1111 -> 1111 -> 15
13 -> 1101 -> 1101 -> 13
16 -> 10000 -> 10 -> 2
17 -> 10001 -> 101 -> 5
65535 -> 1111111111111111 -> 1111111111111111 -> 65535
65000 -> 1111110111101000 -> 11111101111010 -> 16250

---

आप किसी भी भाषा का उपयोग कर सकते हैं, लेकिन कृपया ध्यान दें कि सैम मानक खामियों से नफरत करता है। यह कोड गोल्फ है इसलिए कोड "संपीड़ित" संख्याओं के लिए जगह बनाने के लिए जितना संभव हो उतना कम हो सकता है।

---

नोट: यह स्वीकार्य संपीड़न योजना नहीं है। इसके उपयोग से आपको तुरंत निकाल दिया जाएगा।

---

उद्धरण-आवश्यकता: मैं इस अवधारणा का श्रेय नहीं लेता। यह @Conor O 'Brien के ब्लॉग से आता है यहाँ इस OEIS को फिट नंबरों के साथ देखें। https://oeis.org/A090078

Comments

@ कोनोर के कॉमिक ब्लॉग से: लिंक

— R

OEIS A090078 काम आ सकता है।

— अदनान

यह मैं है जो हास्य लिखा है। <s> मुझे भी 35% प्रतिनिधि रॉयल्टी की उम्मीद है;)

— कॉनर ओ'ब्रायन

क्या डाउनवॉटर कृपया मुद्दे की व्याख्या करेगा?

— रोहन झुनझुनवाला

१६ के बराबर १६ क्यों है? 16 नहीं होना चाहिए 10000?

— eithed

Answer 1

05AB1E , 8 6 बाइट्स

b00¬:C

व्याख्या

b        # convert input to binary
 00¬:    # replace 00 with 0 while possible
     C   # convert to int

इसे ऑनलाइन आज़माएं

अदनान के लिए धन्यवाद 2 बाइट्स बचाए

Comments

आप की जगह ले सकता „00'0द्वारा 00¬:)।

— अदनान

@ अदनान अच्छा लगा! ऐसा नहीं सोचा था।

— एमिगा

मुझे यह भी नहीं पता कि मैंने स्पष्ट रूप से उन्हें स्ट्रिंग्स के रूप में क्यों धकेल दिया ...

— एमिग्ना

हाँ, यह थोड़ा उल्टा है, लेकिन यह काम करता है :)।

— अदनान

ऐसा लग रहा है कि यह जीत जाएगा: डी, ​​मैं इसे स्वीकार करने से पहले थोड़ा और समय दूंगा ताकि अधिक लोग भाग ले सकें।

— रोहन झुनझुनवाला

Answer 2

बैश + जीएनयू उपयोगिताओं, 27

dc -e2o?p|tr -s 0|dc -e2i?p

इनपुट STDIN से पढ़ा जाता है।

Comments

अच्छा! मैंने कभी इस्तेमाल नहीं किया है dc:)

— Master_ex

डीसी आदमी पेज कुछ गोल्फ भाषाओं के लिए दस्तावेज़ जैसे एक बहुत पढ़ता है।

— जॉर्डन

Answer 3

जावास्क्रिप्ट (ईएस 6), 41 बाइट्स

n=>+`0b${n.toString(2).replace(/0+/g,0)}`

Answer 4

जेलिफ़िश , 20 बाइट्स

p
d
# S
,1
*
\dbi
 2

इसे ऑनलाइन आज़माएं!

व्याख्या

• i इनपुट है
• b इसे बाइनरी में कनवर्ट करता है (अंकों की सूची)
• \dतर्कों के साथ 2और अंक सूची लागू होती है d(अंक के लिए द्विआधारी अंक) अंक की सूची के हर लंबाई -2 प्रतिस्थापन।
• * परिणामों के साइन इन करें: 00 0 पर जाता है, बाकी सब 1 के लिए।
• ,1 अंत में 1 को काटता है, इसलिए अंतिम अंक खो नहीं जाता है।
• # Sbiउन अंकों से चयन करता है जिनके ऊपर गणना की गई सूची में 1 है: वे जो 00 के बाएं हिस्से में नहीं हैं।
• dसंख्या में वापस धर्मान्तरित, और pपरिणाम प्रिंट।

Answer 5

पायथन 2, 36 बाइट्स

f=lambda n:n and f(n/2)<<(n%4>0)|n%2

बिना आधार रूपांतरण या स्ट्रिंग संचालन के साथ एक सीधा पुनरावर्ती कार्यान्वयन। कम गोल्फ वाला:

f=lambda n:n and[f(n/2),n%2+2*f(n/2)][n%4>0]

जब n4 का एक गुणक होता है, तो यह द्विआधारी में दो 0 में समाप्त होता है, इसलिए हम फर्श को 2 से विभाजित करके काटते हैं। अन्यथा, हम अलग nहो (n%2) + 2*(n/2)जाते हैं, अंतिम द्विआधारी अंक को छोड़ देते n%2हैं, और अन्य अंकों पर पुनरावृत्ति करते हैं n/2।

Comments

n%2बेमानी नहीं है ?

— xsot

@xsot निश्चित नहीं है कि आपका क्या मतलब है। |nगलत करने से गलत परिणाम मिलते हैं।

— xnor

मेरा मतलब है कि आप पूरे के (n%4>0)|n%2साथ की जगह ले सकते हैं (n%4>0)।

— xsot

@xsot पूर्वता इस प्रकार है (f(n/2)<<(n%4>0)) | n%2।

— xnor

आह, मेरा बुरा तब। मैंने सोचा कि स्थानांतरण में सबसे कम पूर्वता है।

— xsot

Answer 6

बैश (sed + bc), 60 55 43 बाइट्स

echo $[2#`bc<<<obase=2\;$1|sed s/00\*/0/g`]

संपादित करें:

1. बदल sed -E 's/0+करने के लिए sed 's/00*है और इसे बदला गूंज और पाइप के साथ ई.पू. के लिए मूल्य पारित करने के लिए प्रयोग किया जाता है <<<।
2. @Digital ट्रॉमा द्वारा शानदार सुझाव!

उदाहरण:

$ bash script.sh 65000
16250
$ bash script.sh 15
15
$ bash script.sh 9
5

Comments

sed + bc मेरा पहला विचार भी था। echo "obase=2;$1"|bc|sed 's/00*/0/g;s/^/ibase=2;/'|bcहै 2 बाइट्स छोटा

— रिले

पाइप का उपयोग करें और अपने लाभ के लिए भाग जाते हैं echo $[2#`bc<<<obase=2\;$1|sed s/00\*/0/g`]:। लेकिन dcऔर tr इसे छोटा कर दें ।

— डिजिटल ट्रॉमा

@DigitalTrauma: बहुत बहुत धन्यवाद! @ रिले: अच्छा विचार है, यह थोड़ा कम होगा:bc<<<"obase=2;$1"|sed 's/00*/0/g;s/^/ibase=2;/'|bc

— Master_ex

अगर आप tr -s 0सेड के बजाय का उपयोग करते हैं तो आप 36 बाइट्स तक नीचे आ सकते हैं

— रिले

@ रिले: सच है, लेकिन डिजिटल ट्रॉमा पहले से ही दूसरे बैश उत्तर में इसका उपयोग करता है इसलिए मैं इसका उपयोग नहीं करना पसंद करता हूं :)

— Master_ex

Answer 7

पर्ल 6 ,  31  27 बाइट्स

{:2(.base(2).subst(:g,/0+/,0))}
{:2(.base(2)~~{S:g/0+/0/})}

स्पष्टीकरण:

-> $_ {
  # convert from base 2
  :2(

    # convert to base 2
    $_.base(2)

    # substitute
    .subst(
      :global,
      / 0+ /,  # all substrings made of 0s
      '0'      # with one 0
    )
  )
}

उदाहरण:

my &fit-compress = {:2(.base(2)~~{S:g/0+/0/})}
say fit-compress 1;     # 1
say fit-compress 9;     # 5
say fit-compress 15;    # 15
say fit-compress 13;    # 13
say fit-compress 16;    # 2
say fit-compress 17;    # 5
say fit-compress 65535; # 65535
say fit-compress 65000; # 16250

# number created with ｢:2( [~] <0 1>.roll: 256 )｣
say fit-compress 80794946326210692074631955353531749442835289622757526957697718534769445507500
# 4240335298301026395935723255481812004519990428936918

Answer 8

MATL, 11 9 8 बाइट्स

BFFOZtXB

यह संस्करण केवल MATLAB में काम करता है क्योंकि strrepMATLAB तार्किक आदानों को संभाल सकता है। यहां एक संस्करण है जो ऑक्टेव (9 बाइट्स) में काम करेगा (और इस प्रकार ऑनलाइन इंटरप्रेटर) जो स्पष्ट रूप से टाइप करने के लिए तार्किक इनपुट डालता है double।

इसे ऑनलाइन आज़माएं

व्याख्या

    % Implicitly grab input
B   % Convert decimal to binary
FF  % Create the array [0 0]
O   % Number literal
Zt  % Replaces all [0 0] with [0] (will replace any number of 0's with 0)
XB  % Convert binary to decimal
    % Implicitly display

Answer 9

पायथन 3, 55 , 50 बाइट्स।

Sp3000 के लिए धन्यवाद 4 बाइट्स सहेजे गए।

बहुत ही सीधा साधा समाधान।

import re
f=lambda x:eval(re.sub('0+','0',bin(x)))

Comments

क्या आप 0bऔर सिर्फ evalइसके बजाय रख सकते हैं ?

— Sp3000

@ Sp3000 निश्चित रूप से कर सकते हैं! सलाह के लिये धन्यवाद!

— मॉर्गन थ्रैप

अनाम लंबोदर की अनुमति है; आप इस का उपयोग करके 48 बाइट्स को सिकोड़ सकते हैंlambda x:eval(re.sub('0+','0',bin(x))) <insert newline here> import re

— मिल्कीवेय 90

Answer 10

जावास्क्रिप्ट (ईएस 6), 40 बाइट्स

n=>'0b'+n.toString(2).replace(/0+/g,0)-0

Comments

मुझे डर है कि यह एक स्निपेट है। जब तक चुनौती का वर्णन नहीं होता है, अन्यथा समाधान पूर्ण कार्यक्रमों या कार्यों के होने की उम्मीद है।

— मैनटवर्क

यदि मुझे फ़ंक्शन का उपयोग नहीं करना है तो जावास्क्रिप्ट में "पूर्ण कार्यक्रम" की आवश्यकता क्या है? कृपया सलाह दें।

— cychoi

उदाहरण के लिए Node.js के साथ console.log(+('0b'+parseInt(process.argv[1]).toString(2).replace(/0+/g,0))):।

— मैनेटवर्क

विषय से परे। आपके कोड ब्लॉक में @Master_ex जैसी ही समस्या है । क्या यह इसलिए है क्योंकि कुछ लोकप्रिय शेल कॉन्फिगरेशन स्क्रिप्ट टर्मिनल को प्रदूषित कर रहे हैं? या एसई की गलती?

— cychoi

सबसे छोटा फिक्स प्रीपेन्ड N=>करना होगा जो इसे एक वैध फंक्शन सबमिशन बना देगा।

— मार्टिन एंडर

Answer 11

दरअसल, 14 बाइट्स (गैर-प्रतिस्पर्धात्मक)

├`'0;;+(Æ`Y2@¿

इसे ऑनलाइन आज़माएं!

यह प्रस्तुतिकरण गैर-प्रतिस्पर्धात्मक है क्योंकि Æइस चुनौती के पोस्ट होने के बाद इसके लिए एक बगफिक्स बनाया गया था।

स्पष्टीकरण:

├`'0;;+(Æ`Y2@¿
├               bin(input) (automatically discards leading zeroes)
 `'0;;+(Æ`Y     call this function until the output stops changing:
  '0;;+           push "0", "00"
       (Æ         replace "00" with "0" in binary string
           2@¿  convert from binary to decimal

Comments

फिर एक प्रतिस्पर्धी संस्करण पोस्ट करें!

— लीक

Answer 12

रूबी, 35 31 बाइट्स

-2 बाइट्स @Doorknob को धन्यवाद

->n{eval ("0b%b"%n).squeeze ?0}

इसे repl.it पर देखें: https://repl.it/CnnQ/2

Answer 13

जेली , 13 7 बाइट्स

6 एल्गोरिथ्म के लिए ज़गरब को धन्यवाद बाइट्स ।

BŒgμL * x @ Ḣμ € अमेरिकन प्लान
BŒgḄBFḄ

इसे ऑनलाइन आज़माएं!

Answer 14

PHP, 53 51 बाइट्स

<?=bindec(preg_replace("/0+/",0,decbin($argv[1])));

कंसोल से एक तर्क लेता है।

करने के लिए धन्यवाद:

@manatwork 0 के साथ "0" को प्रतिस्थापित करता है

Comments

ज्यादातर "0"और 0उसी तरह से संभाला जाता है।

— मैनटवर्क

@manatwork धन्यवाद। यह एक बहुत स्पष्ट था जो मुझे खुद देखना चाहिए था।

— जीरन

Answer 15

पर्ल, 38 + 1 ( -p) = 39 बाइट्स

$_=oct"0b".sprintf("%b",$_)=~s/0+/0/gr

की जरूरत है -pचलाने के लिए ध्वज (मैं जोड़ा -lझंडा इसे और अधिक पठनीय बनाने के लिए है, लेकिन यह अन्यथा की जरूरत नहीं है):

perl -plE '$_=oct"0b".sprintf("%b",$_)=~s/0+/0/gr' <<< "1
9
15
13
16
17
65535
65000"

कोड के बारे में कहने के लिए बहुत कुछ नोट करें: यह संख्या को बाइनरी में परिवर्तित करता है (sprintf"%b" ) , फिर शून्य के ब्लाकों को केवल एक शून्य से बदलता है, और परिणाम को दशमलव ( oct"0b".) में परिवर्तित करता है ।

Answer 16

C #, 112 91 बाइट्स

int x(int x)=>Convert.ToInt32(Rege‌​x.Replace(Convert.ToS‌​tring(x,2),"0+","0"),2);

-8 बाइट्स टूकाक्स के लिए धन्यवाद

Comments

int f(int x){var a=Regex.Replace(Convert.ToString(x,2),"0+","0");return Convert.ToInt32(a,2);}- रेगेक्स का उपयोग करके 94 बाइट्स। मैंने बहुत सारे सी # समाधानों को शामिल किया है, System.Text.RegularExpressionsइसलिए शायद इसे यहां भी अनुमति दी गई है ...?

— यति

int f(int x){return Convert.ToInt32(Regex.Replace(Convert.ToString(x,2),"0+","0"),2);}86 बाइट्स।

— यति

मुझे नहीं पता कि आप कैसे बाइट्स गिन रहे हैं, मैं इस mothereff.in/byte-counter

— downrep_nation

मैं उस पृष्ठ का भी उपयोग करता हूं, लेकिन यह काम नहीं करेगा, इसलिए मैंने एक अलग पृष्ठ का उपयोग किया। आपको आवश्यक सी # संस्करण का भी उल्लेख करना चाहिए।

— यति

mothereff.in/byte-counter आपके वर्तमान समाधान के लिए 79 बाइट्स की गणना करता है। मुझे हाथ से समाधान लिखना था, अन्यथा यह मुझे 91 देता।

— यति

Answer 17

जावा, 75

int f(Integer x){return x.valueOf(x.toString(x,2).replaceAll("0+","0"),2);}

परीक्षण कार्यक्रम:

public class Fit {
    int f(Integer x){return x.valueOf(x.toString(x,2).replaceAll("0+","0"),2);}

    public static void main(final String... args) {
        final Fit x = new Fit();
        System.out.println(x.f(65000));
    }
}

Comments

जावा 8 लैम्डा x-> ब्लाह में कन्वर्ट; कम बाइट्स के लिए

— रोहन झुनझुनवाला

int f (Integer x) {रिटर्न x.parseInt (x.toString (x, 2) .replaceAll ("0 +", "0");} एक जोड़े के लिए कुछ कम बाइट्स

— रोहन झुनझुनवाला

@ रोहन झुनझुनवाला गलत है, इसे आधार 2 का उपयोग करने की आवश्यकता है। लंबोदर के लिए, मुझे लगता है कि यह प्रकार विनिर्देश के बिना अधूरा है।

— एडिट्स

ओह ठीक है, अन्य जावा उत्तर उसी तकनीक का उपयोग करता है

— रोहन झुनझुनवाला

codegolf.stackexchange.com/a/90085/46918

— रोहन झुनझुनवाला

Answer 18

PARI / GP , 54 43 बाइट्स

n->fold((a,b)->a+if(b,a+1,a%2,a),binary(n))

Answer 19

PowerShell v2 +, 69 बाइट्स

[convert]::ToInt32(([convert]::ToString($args[0],2)-replace'0+',0),2)

( सुविधा-अनुरोध PowerShell में बाइनरी से / में परिवर्तित करने का एक छोटा तरीका )

इनपुट लेता है $args[0], [convert]::ToString(int,base)इनपुट पूर्णांक को बाइनरी बेस स्ट्रिंग में बदलने के लिए .NET अंतर्निहित का उपयोग करता है । वह -replaceसिर्फ एक-या-अधिक-शून्य के किसी भी रन को छीनने के लिए फ़िल्टर किया जाता है 0। उस परिणामी स्ट्रिंग को दूसरी दिशा के माध्यम से वापस भेजा जाता है[convert]::ToInt32(string,base) बाइनरी बैक को पूर्णांक में बदलने के लिए । उस पूर्णांक को पाइप लाइन पर छोड़ दिया गया है और आउटपुट निहित है।

परीक्षण के मामलों

PS C:\Tools\Scripts\golfing> 1,9,15,13,16,17,65535,65000|%{"$_ -> " +(.\output-fit-number.ps1 $_)}
1 -> 1
9 -> 5
15 -> 15
13 -> 13
16 -> 2
17 -> 5
65535 -> 65535
65000 -> 16250

Answer 20

SILOS "केवल" 417 बाइट्स में संदर्भ कार्यान्वयन

golfed

readIO :
i + 1
I = i
z = 1 
n = 32
b = n
z = 1
n = b
lbla
n - 1
GOSUB p
j = i
j - p
if j b
if z c
z = 1
GOTO e
lblc
b - 1
if n a
GOTO f
lblb
z = 0
A = a
A + 1000
set A 1
i - p
lble
a + 1
if n a
lblf
q = 1000
e = q
e + b
i = 0
lbl>
d = q
d - e
if d ?
n = b
n - i
GOSUB p
g = get q
g * p
o + g
i + 1
q + 1
GOTO >
lbl?
o / 2
printInt o
GOTO z
funcp
p = 1
Z = n
lblQ
if Z C
GOTO D
lblC
Z - 1
p * 2
GOTO Q
lblD
return
lblz

यहाँ संदर्भ कार्यान्वयन पूरी तरह से अनियंत्रित है। एक बोनस सुविधा के रूप में यह उत्तर में आने के लिए आवश्यक कदमों का आउटपुट देता है।

/**
*Reference Implementation in the high quality S.I.L.O.S language.
*/
readIO Enter a number to "compress"
//some declarations
i + 1
I = i
z = 1 
//the above is a flag which shows whether or not a zero was last outputted
n = 32
b = n
//maximum number of input bits
printLine Original Binary



lblbinLoop
n - 1
GOSUB pow
j = I
j - p
if j printOne
if z ENDLOOP
print 0
GOTO ENDLOOP
lblprintOne
z = 0
print 1
I - p
lblENDLOOP
if n binLoop




printLine  
printLine Binary "Compressed"


z = 1
n = b


lbltopA
n - 1
GOSUB pow
j = i
j - p
if j printAOne
if z DontPrint
z = 1
print 0
GOTO ENDLOOPA
lblDontPrint
b - 1
if n topA
GOTO endOfBin
lblprintAOne
z = 0
print 1
A = a
A + 1000
set A 1
i - p
lblENDLOOPA
a + 1
if n topA

lblendOfBin

printLine  
printLine -----------
printLine Base 10 Output
print Out Bits:
printInt b

q = 1000
e = q
e + b
i = 0
lblOutputDec
d = q
d - e
if d DONE
n = b
n - i
GOSUB pow
g = get q
g * p
o + g
i + 1
q + 1
GOTO OutputDec
lblDONE
printLine
printLine ---------
o / 2
printInt o

GOTO funcs
//function declarations must be wrapped in gotoes to avoid the interpreter from complaining (breaking)

/**
*This will store the nth power of two in the "p" variable
*/
funcpow
p = 1
Z = n
lbltop
if Z continue
GOTO end
lblcontinue
Z - 1
p * 2
GOTO top
lblend
return

lblfuncs

अनुरोध द्वारा वाष्पोत्सर्जन को हटा दिया गया है। इसे पुनर्प्राप्त करने के लिए संपादित इतिहास देखने के लिए स्वतंत्र महसूस करें, अन्यथा दुभाषिया के लिए इस रेपो में जाएं ।

65000 के लिए नमूना उत्पादन

Enter a number to "compress"
65000
Original Binary
1111110111101000 
Binary "Compressed"
11111101111010 
-----------
Base 10 Output
Out Bits:14
---------
16250

Comments

संदर्भ कार्यान्वयन चुनौती निकाय में होना चाहिए, उत्तर के रूप में नहीं, क्योंकि वे अपढ़ हैं और इस तरह गंभीर दावेदार नहीं हैं।

— मैगू

ठीक है, मैं इसे गोल्फ दूँगा।

— रोहन झुनझुनवाला

मैं इस @Mego

— रोहन झुनझुनवाला के

@ टिम्मीड एक सेकंड मैं इसे अब नीचे गिरा रहा हूँ

— रोहन झुनझुनवाला

@ मेगो मैं इसे अब गोल्फ कर चुका हूं

— रोहन झुनझुनवाला

Answer 21

अजगर, १२

i:.BQ"0+"\02

ऑनलाइन।

  .BQ            # Convert input from base 10 to base 2
 :   "0+"\0      # Replace multiple zeroes with single zero
i          2     # Convert back from base 2 to base 10

Answer 22

रेटिना , 30 बाइट्स

.+
$*1;
+`(1+)\1
$1;
1;
1
;+
0

इसे ऑनलाइन आज़माएं!

और यहाँ मुझे लगा कि रेटिना पहले उत्तरों में से होगी ...

Comments

@randomra मैं ओपी से स्पष्टीकरण के लिए सवाल पूछ रहा हूं

— लीक

क्या रेटिना दशमलव रूपांतरण के लिए बाइनरी या यूनीरी रूपांतरण में बाइनरी करने में सक्षम है? मैं रेटिना को बाहर नहीं करने के लिए एक या तो एक को छोड़कर हूँ

— रोहन झुनझुनवाला

@ रोहन झुनझुनवाला: हाँ, यह है

— बिज़नेस कैट

क्या इस को एकात्मक या दशमलव में परिवर्तित करना संभव है? आदर्श रूप से मैं दशमलव देखना चाहूंगा, लेकिन मैं या तो स्वीकार करूंगा।

— रोहन झुनझुनवाला

Answer 23

जावा, 152 143 138 बाइट्स

interface C{static void main(String[]b){Integer i=0;System.out.print(i.parseInt(i.toString(i.parseInt(b[0]),2).replaceAll("0+","0"),2));}}

• 9 बाइट्स @RohanJhunjhunwala को कम धन्यवाद। मैं इसे मुख्य और पसंद के साथ पूरी तरह से काम करने वाले कार्यक्रम के रूप में रखना पसंद करता हूं। हालांकि, निश्चित रूप से इसे अधिक अन्यथा गोल्फ किया जा सकता है।
• 5 लीक कम @ LeakyNun के सुझावों के लिए धन्यवाद।

Comments

वर्ग A {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग [] a) {पूर्णांक i; System.out.print (i.parseInt (i.toBinaryString (i.parseInt) ([0]))। प्रतिस्थापन ("0+", " 0 "), 2));}} बचत के 8 बाइट्स के लिए

— रोहन झुनझुनवाला

इसे और भी अधिक बचत के लिए लंबोदर अभिव्यक्ति में लपेटें और कक्षा की परिभाषाएं, और आपके सेट को हटा दें।

— रोहन झुनझुनवाला

@RohanJhunjhunwala: आह! Integer i;भाग सरल और बढ़िया है!

— Master_ex

यह काम करता है, लेकिन अधिकांश समझदार आईडीई पर चेतावनी (त्रुटि के विपरीत) उत्पन्न कर सकता है। बात यह है कि, आप हमेशा गैर-स्थिर संदर्भ से स्थैतिक तरीकों को कॉल कर सकते हैं, लेकिन आप कभी भी स्थैतिक संदर्भ से गैर-स्थैतिक विधि नहीं कह सकते। इस तकनीक का उपयोग करते समय उत्पादन कोड में दृढ़ता से हतोत्साहित किया जाता है, यह कानूनी जावा है।

— रोहन झुनझुनवाला

codegolf.stackexchange.com/questions/6671/… कम ज्ञात के साथ और अधिक परिचित होने के लिए एक अच्छा पढ़ा है (मैं शायर कहते हैं) जावा भाषा की "विशेषताएं"।

— रोहन झुनझुनवाला

Answer 24

दिल्लोग एपीएल , 19 बाइट्स

{2⊥⍵/⍨~0 0⍷⍵}2∘⊥⍣¯1

TryAPL ऑनलाइन!

यह फ़ंक्शन वास्तव में दो कार्यों का "सबसे ऊपर" है, पहला फ़ंक्शन है:

2∘⊥⍣¯1उलटा binary- के लिए -decimal रूपांतरण, यानी binary- से -decimal रूपांतरण
  दो 2 ही है ∘ करने के लिए करने वाली दशमलव ⊥
 दोहराने आपरेशन ⍣ नकारात्मक एक समय ¯1(यानी एक बार, लेकिन उल्टे)

दूसरे फ़ंक्शन में, उपरोक्त बाइनरी परिणाम द्वारा दर्शाया गया है ⍵:

{2⊥⍵/⍨~0 0⍷⍵}
 0 0⍷⍵बूलियन जहां {0, 0} से शुरू होता है
 ~, बूलियन नकार में होता है , इसलिए अब हमारे पास हर जगह ᴛʀᴜᴇ है लेकिन शून्य-रन में गैर-पहले शून्य का
 ⍵/⍨उपयोग to फ़िल्टर करने के लिए करते हैं, इसलिए यह हमारे अवांछित शून्य को
 2⊥बाइनरी-टू-दशमलव से हटा देता है

Answer 25

TSQL, 143 बाइट्स

से और बाइनरी में बदलने के लिए बिल्ड इन्स का उपयोग नहीं करना।

golfed:

DECLARE @i INT=65000

,@ CHAR(99)=''WHILE @i>0SELECT @=REPLACE(LEFT(@i%2,1)+@,'00',0),@i/=2WHILE @>''SELECT @i+=LEFT(@,1)*POWER(2,LEN(@)-1),@=STUFF(@,1,1,'')PRINT @i

Ungolfed:

DECLARE @i INT=65000

,@ CHAR(99)=''
WHILE @i>0
  SELECT @=REPLACE(LEFT(@i%2,1)+@,'00',0),@i/=2

WHILE @>''
  SELECT @i+=LEFT(@,1)*POWER(2,LEN(@)-1),@=STUFF(@,1,1,'')

PRINT @i

बेला

Comments

बिल्ट इन का उपयोग नहीं करने के लिए +1। मेरा SILOS उत्तर (संदर्भ कार्यान्वयन) ऐसा ही करता है, लेकिन यह कम हो गया क्योंकि लोगों को नहीं लगता था कि यह एक गंभीर प्रतियोगी था। क्या नई लाइन महत्वपूर्ण है?

— रोहन झुनझुनवाला

@ रोहन झुनझुनवाला नई लाइन महत्वपूर्ण नहीं है। इनपुट चर को परिभाषित करने और मान निर्दिष्ट करने के बाद मैं कोड के वर्णों की गिनती कर रहा हूं।

— t-clausen.dk 12:17 पर

ok amkes sense -

— रोहन झुनझुनवाला

@ रोहन झुनझुनवाला मुझे लगता है कि यह कूल है कि आप कोडगॉल्फ के सवालों को हल करने के लिए एक अपरिभाषी भाषा का उपयोग करते हैं। ऐसा लगता है कि आपके पास अतिरिक्त जानकारी जोड़ने के लिए अनावश्यक कोड है - शायद केवल आपके अनगढ़ संस्करण में हालांकि। आपको हमेशा सबसे छोटा कोड संभव बनाने की कोशिश करनी चाहिए, कोनों को काटना और भाषा के प्रश्न (प्रश्न के दायरे में) का उपयोग करना। यदि संभव हो तो आपको एक बेला प्रदान करना चाहिए, इसलिए मुझे मैगल्स टेस्ट कर सकते हैं

— t-clausen.dk

अनगोल्डेड संस्करण में अनावश्यक कोड होता है, लेकिन गोल्फ संस्करण में कोई अतिरिक्त कोड नहीं होता है। यदि आप चाहते हैं कि मैं इसका परीक्षण करूं, तो मैं इसे जावा में ट्रांसपॉयलर कर सकता हूं।

— रोहन झुनझुनवाला

Answer 26

CJam, 16

q~2b1+0a%0a*);2b

इसे ऑनलाइन आज़माएं

रेगेक्स की कमी के कारण यह काफी लंबा है।

स्पष्टीकरण:

q~     read and evaluate the input number
2b     convert to base 2 (array of 1s and 0s)
1+     append a 1 to deal with trailing zeros
0a%    split by [0], dropping empty pieces; only chunks of 1s are left
0a*    join by [0]
);     discard the 1 we appended before
2b     convert back from base 2

Answer 27

जावा, 64 बाइट्स

i->{return i.parseInt(i.toString(i,2).replaceAll("0+","0"),2);};

परीक्षण कार्यक्रम

public static void main(String[] args) {
    Function<Integer, Integer> function = i -> {
        return i.parseInt(i.toString(i, 2).replaceAll("0+", "0"), 2);
    };

    System.out.println(function.apply(1)); // 1
    System.out.println(function.apply(9)); // 5
    System.out.println(function.apply(15)); // 15
    System.out.println(function.apply(13)); // 13
    System.out.println(function.apply(16)); // 2
    System.out.println(function.apply(17)); // 5
    System.out.println(function.apply(65535)); // 65535
}

Answer 28

सीजेएम , 23 बाइट्स

ri2be`{_:g:>{:g}&}%e~2b

इसे ऑनलाइन आज़माएं!

व्याख्या

ri          e# Read input as an integer
2b          e# Convert to binary
e`          e# Run-length encoding. Gives a nested (2D) array with run-lengths 
            e# and binary digits
{           e# This block is mapped over the outer array, i.e. is applied to
            e# each inner array
   _        e#   Duplicate the inner array
  :g        e#   Signum of each element of inner array
  :>        e#   This gives true if second element (digit) is false and first
            e#   element (run-length) is not zero. If so, we need to set that
            e#   run-length to 1
  {:g}&     e#   If that's the case, apply signum to original copy of inner
            e#   array, to make run-length 1
}%          e# End block which is mapped over the outer array
e~          e# Run-length decoding
2b          e# Convert from binary. Implicitly display

Answer 29

रूबी, 37 35 बाइट्स

मैनटवर्क के लिए धन्यवाद दो बाइट्स सहेजे गए।

->a{a.to_s(2).gsub(/0+/,?0).to_i 2}

भोला दृष्टिकोण। (:

Comments

के बारे में "0", में 2 बिंदु दिखाई sepp2k की टिप । इस बारे में .to_i(2), जहां पैरामीटर नहीं है, जहां अस्पष्टता है, कोष्ठक वैकल्पिक हैं।

— manatwork

Answer 30

सी, 37 बाइट्स

f(x){return x?f(x/2)<<!!(x%4)|x&1:0;}