किसी संख्या का BCD अंतर ज्ञात कीजिए

Question

बीसीडी अंतर

पूर्णांक n को देखते हुए, इसे प्रत्येक 4 अंकों के बाइनरी प्रतिनिधित्व के साथ BCD ( बाइनरी-कोडेड दशमलव ) में बदलकर प्रत्येक दशमलव अंक में बदल दें।

 234 -> 0 0 1 0 0 0 1 1 0 1 0 0

फिर सबसे बड़ी और सबसे छोटी संख्याओं को खोजने के लिए बाइनरी अंकों की सूची को घुमाएं, अन्य पुनर्व्यवस्था के बिना इस सूची द्वारा प्रतिनिधित्व करने योग्य।

max: 1 1 0 1 0 0 0 0 1 0 0 0  (the entire list rotated left 6 times)
min: 0 0 0 0 1 0 0 0 1 1 0 1 (the entire list rotated right 2 times)

बिट्स की सूची को नियमित बाइनरी के रूप में मानते हुए इन संख्याओं को दशमलव में बदलें, और सबसे बड़ी से छोटी को घटाएं:

1 1 0 1 0 0 0 0 1 0 0 0 -> 3336
0 0 0 0 1 0 0 0 1 1 0 1 -> 141

3336 - 141 -> 3195

आउटपुट सबसे बड़ी और सबसे छोटी संख्या का अंतर है।

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

234 -> 3195
1234 -> 52155
12 -> 135
975831 -> 14996295
4390742 -> 235954919
9752348061 -> 1002931578825

Answer 1

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 89 88 बाइट्स

1 बाइट बचाने के लिए जेनी_मैथी को धन्यवाद।

i=IntegerDigits;Max@#-Min@#&[#~FromDigits~2&/@NestList[RotateRight,Join@@i[i@#,2,4],#]]&

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

यह बहुत ही अयोग्य है, क्योंकि यह एन के बीसीडी के एन रोटेशन को उत्पन्न करता है , जो कि हमारी ज़रूरत से ज़्यादा है। हम इस में थोड़ा और अधिक का परिणाम सहेज कर कुशल है बना सकते हैं Join@@में kऔर जगह #के साथ अंत में Length@k। इससे हमें काफी आसानी से एक स्कैटरप्लॉट उत्पन्न होता है:

मैं वास्तव में स्थानीय संरचना और समग्र अराजकता के विपरीत द्वारा साज़िश कर रहा हूं।

Comments

Max@#-Min@#&एक बाइट बचाता है। सही?

— J42161217

@ जेनी_मैथी हाँ, धन्यवाद! :)

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

मैंने इसे हमारे समाधान Max@#-Min@#&[#~FromDigits~2&/@Partition[s=Join@@(i=IntegerDigits)[i@#,2,4],Tr[1^s],1,1]]&89 बाइट्स और कुशल से बनाया है। लानत है कि बाइट!

— J42161217

वास्तव में यह कथानक एक दोहराया हुआ पैटर है। "अराजक बादलों" का हर 10 ^ n (प्लॉट "कूदता है" और एक नया निर्माण होता है): 1-9,10-99,100-999... यहाँ कुछ अलग-अलग ज़ूम हैं: imgur.com/RXLMkco

— 42,161217

@ जेनी_मैथी सुनिश्चित हैं, लेकिन इन अंतरालों के भीतर की संरचना बहुत अराजक (केवल छोटे पैमाने पर संरचनाओं के साथ) दिखाई देती है।

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

Answer 2

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

Dd4d2FṙJ$ḄṢIS

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

यह काम किस प्रकार करता है

Dd4d2FṙJ$ḄṢIS  Main link. Argument: n

D              Decimal; convert n to base 10 (digit array).
 d4            Divmod 4; map each digit d to [d/4, d%4].
   d2          Divmod 2; map each [d/4, d%4] to [[d/8, d/4%2], [d%4/2, d%2]].
     F         Flatten the resulting 3D binary array.
      ṙJ$      Take all possible rotations.
         Ḅ     Convert each rotation from binary to integer.
          Ṣ    Sort the resulting integer array.
           I   Take the forward differences.
            S  Take the sum.

Answer 3

अजगर ३ , 115 108 बाइट्स

जोनाथन फ्रेच को धन्यवाद-7 बाइट्स के लिए

k=''.join(f'{int(i):04b}'for i in input())
v=[int(k[i:]+k[:i],2)for i in range(len(k))]
print(max(v)-min(v))

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

Answer 4

पॉवरशेल , 153 बाइट्स

$b=[char[]]-join([char[]]"$args"|%{[convert]::toString(+"$_",2).PadLeft(4,'0')})
($c=$b|%{$x,$y=$b;[convert]::ToInt64(-join($b=$y+$x),2)}|sort)[-1]-$c[0]

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

द्विआधारी से / में बदलने के लिए बेवकूफ लंबा .NET कॉल वास्तव में यहाँ लंबाई को फुलाता है। ;-)

हम इनपुट के रूप में लेते हैं $args, इसे एक स्ट्रिंग में लपेटते हैं, फिर इसे char-अरे के रूप में डालते हैं। हम प्रत्येक अंक पर लूप करते convertहैं, अंक toStringको आधार में रखते हैं 2(यानी, अंक को बाइनरी नंबर में बदलते हैं), फिर .padLeftइसे चार अंकों का बाइनरी नंबर बनाते हैं। इसके परिणामस्वरूप स्ट्रिंग की सरणी को एक स्ट्रिंग में फिर से -joinएड किया जाता है और charसहेजे जाने से पहले -एरे के रूप में फिर से कास्ट किया जाता है$b ।

अगला, हम लूप ओवर करते हैं $b, जो यह सुनिश्चित करता है कि हम हर घुमाव के लिए पर्याप्त बार लूप करें। प्रत्येक पुनरावृत्ति, हम पहले वर्ण को $xऔर शेष वर्णों को $yकई असाइनमेंट का उपयोग करके छीलते हैं। फिर, हम $b=$y+$xपहले तत्व को अंत तक स्थानांतरित करने के लिए उन्हें एक साथ मर्ज करते हैं , अर्थात्, एक द्वारा सरणी को प्रभावी ढंग से घुमाते हैं। यही कारण है कि है -joinएक स्ट्रिंग है, जो करने के लिए इनपुट के रूप में प्रयोग किया जाता है में एड convertद्विआधारी आधार से स्ट्रिंग चालू करने के लिए कॉल 2एक में Int64। हम फिर sortउन सभी परिणामी संख्याओं और उन्हें संग्रहीत करते हैं $c। अंत में, हम सबसे बड़ा लेते हैं और सबसे [-1]छोटे को घटाते हैं [0]। यह पाइपलाइन पर छोड़ दिया गया है और आउटपुट निहित है।

Answer 5

ओम v2 , 15 बाइट्स

€b4Ü. 0\;Jγó↕]a

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

स्पष्टीकरण:

€b4Ü. 0\;Jγó↕]a  Main wire, arguments: a (integer)

€       ;        Map the following over each digit of a...
 b                 Convert to binary
  4Ü               Right-justify w/ spaces to length 4
    . 0\           Replace all spaces with zeroes
         J       Join together binary digits
          γó     Get all possible rotations and convert back to decimal
            ↕    Find the minimum *and* maximum rotation
             ]a  Flatten onto stack and get the absolute difference

Answer 6

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

f=
n=>(g=m=>Math[m](...[...s=(`0x1`+n-0).toString(2)].map(_=>`0b${s=0+s.slice(2)+s[1]}`)))`max`-g`min`

<input type=number min=0 oninput=o.textContent=f(this.value)><pre id=o>

संपादित करें: @RickHitchcock के लिए 11 बाइट्स सहेजे गए। सहेजे गए 1 बाइट @ETHproductions के लिए धन्यवाद। स्पष्टीकरण: 0x1उपसर्ग इनपुट को एक हेक्साडेसिमल संख्या के रूप में पुन: प्राप्त करने का कारण बनता है, जिसका द्विआधारी मूल संख्या के बीसीडी के समान होता है जिसमें 1 उपसर्ग होता है (मुझे लगता है कि यह किसी भी अन्य तरीके से 4 अंकों के पैडल करने की तुलना में है) । उपसर्ग को छोड़कर, जिसे 1 से 0 में बदल दिया जाता है, जिसके परिणामस्वरूप स्ट्रिंग को प्रत्येक संभावित स्थान पर घुमाया जाता है और बाइनरी से वापस दशमलव में बदल दिया जाता है। अंत में अधिकतम और न्यूनतम घटाए जाते हैं।

Comments

@ हिचकीकॉक स्ट्रिंग को डबल बैकटिक्स में लपेटें ... जब तक आप कुछ लिखना नहीं चाहते हैं .join`` , जिस स्थिति में आपको ट्रिपल बैकटीक्स आदि की आवश्यकता होती है

— नील

हेक्साडेसिमल का उपयोग करने के लिए अच्छा विचार है। इस तरह से 11 बाइट्स बचाएं:n=>(g=m=>Math[m](...[...s=(+`0x1${n}`).toString(2).slice(1)]‌​.map(_=>`0b${s=s.sli‌​ce(1)+s[0]}`)))`max`‌​-g`min`

— रिक हिचकॉक

@RickHitchcock धन्यवाद, जिसने मेरी मदद की ... स्लाइस ... एक और बाइट को हटाकर एक और 7 बाइट्स slice!

— नील

m=>Math[m]चाल बहुत अच्छा है। शायद या इसी तरह बदलने के (+`0x1${n}`)लिए ('0x1'+n-0)?

— 3:16 बजे ETHproductions

Answer 7

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

• कुछ बाइट्स ओव्स के लिए धन्यवाद बचा ।
• श्री Xcoder के लिए दो बाइट्स धन्यवाद सहेजा ।

b="".join(format(int(n),"04b")for n in`input()`)
b=[int(b[s:]+b[:s],2)for s in range(len(b))]
print max(b)-min(b)

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

Answer 8

पायथ , 29 बाइट्स

Ksm.[\04.Bsd`Q-eJSmi.<Kd2lKhJ

यहाँ कोशिश करो! या परीक्षण सूट की जाँच करें।

Comments

-3 या -5 बाइट्स

— स्टीवन एच।

Answer 9

हस्क , 18 बाइट्स

§-▼▲mḋUMṙNṁȯtḋ+16d

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

किसी अंक को उसके 4-बिट बाइनरी प्रतिनिधित्व में बदलने का एक छोटा तरीका होना चाहिए ...

व्याख्या

§-▼▲mḋUMṙNṁȯtḋ+16d
                 d    Get the list of digits of the input
          ṁȯ          For each digit...
              +16      add 16
             ḋ         convert to binary
            t          drop the first digit
       MṙN            Rotate the list by all possible (infinite) numbers
      U               Get all rotations before the first duplicated one
    mḋ                Convert each rotation from binary to int
§-▼▲                  Subtract the minimum from the maximum value

Answer 10

APL (Dyalog) , 31 बाइट्स

पूर्ण कार्यक्रम निकाय। एसटीडीआईएन से नंबर के लिए संकेत। प्रिंट STDOUT का परिणाम है।

(⌈/-⌊/)2⊥¨(⍳≢b)⌽¨⊂b←,⍉(4/2)⊤⍎¨⍞

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

⍞ STDIN से पाठ की लाइन के लिए संकेत

⍎¨ निष्पादित (मूल्यांकन) प्रत्येक (चरित्र)

(… )⊤ निम्नलिखित संख्या प्रणाली में एनकोड (एंटी-बेस):

 4/2 चार बाइनरी बिट्स

⍉ पक्षांतरित

, उठाव (चपटा)

b← स्टोर में b( b inary के लिए)

⊂ संलग्न करें (ताकि हम प्रत्येक रोटेशन के लिए इस पूरी सूची का उपयोग करेंगे)

(… )⌽¨ निम्नलिखित मात्राओं में से प्रत्येक को घुमाएं (बाएं):

≢b की लंबाई b

 ⍳ मैं उस की ndices

2⊥¨ बेस -2 से प्रत्येक को डीकोड करें।

(… ) उस के लिए निम्नलिखित tacit फ़ंक्शन लागू करें

 ⌈/ अधिकतम (कटौती)

 - ऋण

 ⌊/ न्यूनतम (कटौती)

Comments

आप आसानी से इस बिट को प्रशिक्षित कर सकते हैं: (easilyb) ←

— b n

या इससे भी बेहतर - स्पष्ट (n) के बजाय (even, /, ⍨) का उपयोग करें

— ngn

Answer 11

APL (Dyalog) , 37 34 बाइट्स

{(⌈/-⌊/)2⊥¨(⍳⍵)∘.⌽⊂,↑(4⍴2)∘⊤¨⍎¨⍕⍵}

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

Answer 12

जेली , 21 बाइट्स

DB0;$4¡€ṫ€-3FṙJ$ḄµṀ_Ṃ

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

Answer 13

रूबी , ₉₆ 91 बाइट्स

->n{r=""
n.digits.map{|d|r="%04b"%d+r}
s=r.chars.map{(r=r[1..-1]+r[0]).to_i 2}
s.max-s.min}

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

• 5 बाइट्स प्रदर्शित करने के लिए धन्यवाद सहेजा गया

Comments

-> n {r = "" n.digits.map {| d | r = "% 04b"% d + r} s = r.chars.map {(r = r [1 ..- 1] + r [ 0]) ._i 2} s.max-s.min} 91 बाइट्स होना चाहिए

— displayname

@displayname हा, हाँ, तुम सही हो। धन्यवाद

— notmaynard - को पुनः स्थापित मोनिका

Answer 14

गणितज्ञ, ११० ९९ बाइट्स

Max@#-Min@#&[#~FromDigits~2&/@Partition[s=Join@@Tuples[{0,1},4][[IntegerDigits@#+1]],Tr[1^s],1,1]]&

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

Answer 15

पायथन 3, 141 बाइट्स

def f(a):a=''.join([format(int(i),'#010b')[-4:]for i in str(a)]);b=[int(''.join(a[-i:]+a[:-i]),2)for i in range(len(a))];return max(b)-min(b)

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

Answer 16

रेटिना , 96 89 बाइट्स

.
@@@$&
@(?=@@[89]|@[4-7]|[2367])
_
T`E`@
\d
_
.
$&$'$`¶
O`
_
@_
+`_@
@__
s`(_+).*\W\1

_

इसे ऑनलाइन आज़माएं! थोड़ा धीमा, इसलिए लिंक में केवल एक छोटा परीक्षण मामला शामिल है। संपादित करें: @MartinEnder के लिए 7 बाइट्स सहेजे गए। स्पष्टीकरण:

.
@@@$&

@प्रत्येक अंक के लिए तीन एस उपसर्ग । (ये 0बीसीडी के प्रतिनिधित्व करते हैं, लेकिन गोल्फर हैं।)

@(?=@@[89]|@[4-7]|[2367])
_

जहां उपयुक्त हो वहां एस ( बीसीडी के एस का प्रतिनिधित्व) @को बदलें ।_1

T`E`@
\d
_

BCD के अंतिम अंक को ठीक करें।

.
$&$'$`¶

सभी घुमाव उत्पन्न करें।

O`

उन्हें आरोही क्रम में क्रमबद्ध करें।

_
@_
+`_@
@__

उन्हें एकता में परिवर्तित करें।

s`(_+).*\W\1

_

अंतिम संख्या से पहली घटाएँ, मध्यवर्ती संख्याओं की अनदेखी, और दशमलव में परिवर्तित करें।

Comments

उपयोग करने के लिए कोई ज़रूरत नहीं है %एकल रूपांतरण के लिए द्विआधारी के लिए और आप कुछ और अधिक से अधिक अन्य पात्रों का उपयोग करके बाइट्स बचा सकता है 0और 1द्विआधारी के लिए: tio.run/##K0otycxL/...

— मार्टिन Ender

@MartinEnder ओह, मुझे लगता है कि जब मैं कोशिश कर रहा था और आपके द्विआधारी रूपांतरण दिनचर्या में से एक का उपयोग करने में विफल रहने से दिनांकित ...

— नील

Answer 17

हास्केल , 130 बाइट्स

r=foldl1
f x=max#x-min#x
f#x|s<-show x=r((+).(2*)).r f.take(sum$4<$s).iterate(drop<>take$1)$do d<-s;mapM(pure[0,1])[1..4]!!read[d]

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

स्पष्टीकरण / अनलॉक्ड

चूंकि हम foldl1((+).(2*))बाइनरी से दशमलव में बदलने के लिए उपयोग करने जा रहे हैं , इसलिए हम उपयोग नहीं कर सकते हैं maximumऔर minimumबल्कि foldl1 max(या minक्रमशः साथ ही ) और एक संक्षिप्त का उपयोग कर सकते हैं r = foldr1।

अब, हम एक ऑपरेटर को परिभाषित करते हैं f#x जो धर्मान्तरित होता हैx BCD में होता है, सभी घुमाव उत्पन्न करता है, इनका उपयोग कम करें fऔर इसे दशमलव में परिवर्तित करें:

f # xs
  | s <- show xs
  = foldr1 ((+).(2*))                             -- convert from binary to decimal
  . foldr1 f                                      -- reduce by either max or min
  . take (4 * length s)                           -- only keep 4*length s (ie. all "distinct" rotations)
  . iterate (drop<>take $ 1)                      -- generate infinite list of rotations
  $ do d<-s; mapM (pure[0,1]) [1..4] !! read [d]  -- convert to BCD

अब यह केवल एक बार इस ऑपरेटर का उपयोग करने और उनके परिणामों के साथ maxऔर एक बार minघटाने की बात है:

f x = max#x - min#x

Answer 18

PHP, 156 153 बाइट्स

<?foreach(str_split($argv[1])as$n)$s.=str_pad(decbin($n),4,0,0);for(;$i<$a=strlen($s);)$r[]=bindec(substr($s,$i).substr($s,0,$i++));echo max($r)-min($r);

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

Answer 19

जाप -x , 20 बाइट्स

®¤ùT4쬣ZéY ì2Ãn äa

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

अंकों की एक सरणी के रूप में इनपुट।

स्पष्टीकरण:

®¤                      #Map each digit to base 2
  ùT4Ã                  #Pad each one to 4 places
      ¬                 #Join them to a single binary string
       ¬                #Split them to an array of single characters
        £      Ã        #For each index Y in that array:
         ZéY            # Get the array rotated Y times
             ì2         # Convert the array from binary to decimal
                n       #Sort the results
                  äa    #Get the absolute difference between each element
                        #Implicitly output the sum

Comments

आप -x2 बाइट को बचाने के लिए ध्वज का उपयोग कर सकते हैं ।

— ओलिवर

20 बाइट्स ।

— ओलिवर

Answer 20

पायथ, 24/26 बाइट्स

s.+Smi.>Gd2l=Gsm.[\04.Bs

एक उद्धृत स्ट्रिंग के रूप में इनपुट लेता है। 26 बाइट्स यदि इसे एक पूर्णांक के रूप में इनपुट लेना है; dzउस मामले में संलग्न करें ।

परीक्षण मामले (तार के रूप में इनपुट, 24 बाइट्स)

परीक्षण मामले (संख्या के रूप में इनपुट, 26 बाइट्स)

Answer 21

जे, 43 बाइट्स

3 :'(>./-<./)#.(i.@#|."0 1]),}.#:8,"."0":y'

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

कभी-कभी टैसिट स्टाइल चीजों को मुश्किल बना देता है। लेकिन शायद यह करने का एक तरीका है कि यह शांत शैली है जो इससे बहुत अधिक संक्षिप्त है। मुझे लगता है कि मुझे एक संख्या को अन्य के अलावा अंकों को विभाजित करने का एक बेहतर तरीका याद है"."0@": लेकिन मैं इसे याद नहीं कर सकता ...

व्याख्या

3 :'(>./-<./)#.(i.@#|."0 1]),}.#:8,"."0":y'
                                         y  the input (integer)
                                       ":   convert to string
                                   "."0     evaluate each char (split to digits)
                                 8,         prepend 8
                               #:           debase 2
                             }.             behead (remove the 8)
                            ,               ravel (flatten)
               (i.@#|."0 1])                create a list of rotations
                    |.    ]                   rotate the list
                      "0 1                    for each number on the left
                i.@#                          range 0 ... length - 1
             #.                             convert rotations back to base 10
    (>./-<./)                               max minus min

प्रस्तुत करने और हटाने 8 यह सुनिश्चित करने के लिए है कि सही संख्या में शून्य मौजूद हैं (जे अपने सरणियों को उनके अधिकतम लंबाई तत्व के आकार के आकार में बदल देगा, और 8 बाइनरी में 4 अंक है इसलिए इसका उपयोग किया जाता है)।

Answer 22

एपीएल (एनएआरएस), 34 चार्ट, 68 बाइट्स

{(⌈/-⌊/)2⊥¨{⍵⌽a}¨⍳≢a←∊⍉(4⍴2)⊤⍎¨⍕⍵}

कुछ छोटे परीक्षण:

  h←{(⌈/-⌊/)2⊥¨{⍵⌽a}¨⍳≢a←∊⍉(4⍴2)⊤⍎¨⍕⍵}
  h 9752348061
1002931578825
  h 0
0

Answer 23

पर्ल 5 , 97 91 89 + 2 ( -F) = 99 93 91 बाइट्स

$a=sprintf"%04b"x@F,@F;@r=sort{$b<=>$a}map{oct"0b".($a=(chop$a).$a)}(@F)x4;say$r[0]-pop@r

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