22

एक स्ट्रिंग लें, sजिसमें मुद्रण योग्य ASCII- वर्ण इनपुट के रूप में हों, और इसका "बाइनरी स्प्लिट सम" आउटपुट हो। एक स्पष्टीकरण की आवश्यकता है?

बाइनरी स्प्लिट योग कैसे मिलता है?

हम A4निम्नलिखित स्पष्टीकरण में एक उदाहरण के रूप में स्ट्रिंग का उपयोग करेंगे ।

अक्षरों को बाइनरी में परिवर्तित करें, प्रत्येक अक्षर को 7-बिट ASCII वर्ण के रूप में मानते हैं
```
A -> ASCII 65 -> 1000001
4 -> ASCII 52 -> 0110100
```
बाइनरी नंबरों को एक नए बाइनरी नंबर में सम्‍मिलित करें
```
A4 -> 1000001 & 0110100 -> 10000010110100
```
नए बाइनरी नंबर को विखंडू में विभाजित करें, जहां कोई 1भी 0इसके बाईं ओर नहीं हो सकता है । आपको लगातार विभाजित नहीं होना चाहिए1 एस ।
```
10000010110100 -> 100000, 10, 110, 100
```
इन बाइनरी नंबरों को दशमलव में बदलें
```
100000, 10, 110, 100 -> 32, 2, 6, 4
```
इन संख्याओं का योग लें:
```
32 + 2 + 6 + 4 = 44
```

तो, स्ट्रिंग के लिए आउटपुट A4 होना चाहिए 44।

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

a
49

A4
44

codegolf
570

Hello, World!
795

— स्टीवी ग्रिफिन
स्रोत

2

मुझे लगता है कि यह ASCII रूपांतरण कदम के बिना एक अच्छा चुनौती था, इनपुट के रूप में चरण 2 के बाद (दशमलव) संख्या ले रहा है।

— xnor

खैर, 8372वास्तव में।

— xnor

1

@xnor, आप सही हो सकते हैं, और यह क्लीनर होगा। हालांकि मुझे ऑक्टेव में इसे हल करने में मज़ा आया था, और मुझे उम्मीद है कि दूसरों को भी इसे हल करने में मज़ा आएगा :)

— स्टीवी ग्रिफिन

12

पायथन 2 , 86 81 76 बाइट्स

^{-5 बाइट्स धन्यवाद अदनान}
^{-5 बाइट्स धन्यवाद xnor}

s=0
for c in input():s=s*128+ord(c)
print eval(bin(s).replace('01','0+0b1'))

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

for c in input():s=s*128+ord(c)ASCII रूपांतरण को संख्यात्मक *128रूप से करने के लिए , जहां विभाजित और योग (चरण 3, 4 और 5) के लिए s7 बार (चरण 1 और 2)
eval(('0'+new_bin).replace('01','0+0b1'))को बाईं ओर स्थानांतरित करने के लिए उपयोग किया जाता है

— छड़ी
स्रोत

अच्छी चाल के साथ eval! कर ASCII रूपांतरण संख्यानुसार कुछ बाइट्स बचाता है।

— xnor

7

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

Oḅ128BŒg;2/ḄS

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

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

Oḅ128BŒg;2/ḄS  Main link. Argument: s (string)

O              Ordinal; map characters to their code points.
 ḅ128          Unbase 128; convert the resulting list from base 128 to integer.
     B         Binary; Convert the resulting integer to base 2.
      Œg       Group consecutive, equal bits.
        ;2/    Concatenate all non-overlapping pairs.
           Ḅ   Unbinary; convert from base 2 to integer.
            S  Take the sum.

— डेनिस
स्रोत

मुझे पहले बेस कन्वर्जन की ट्रिक याद आ गई है।

— जोनाथन एलन

आह, वास्तव में अच्छी चाल!

— अदनान

6

MATL , 14 बाइट्स

YB!'1+0*'XXZBs

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

व्याख्या

'A4'उदाहरण के रूप में इनपुट पर विचार करें ।

YB        % Implicit input. Convert to binary using characters '0' and '1'. 
          % Gives a char matrix, where each row corresponds to a number
          % STACK: ['1000001'; '0110100']
!         % Transpose. This is necessary because MATL uses column-major 
          % order when linearizing a matrix into a vector
          % STACK: ['10'; '01'; '01'; '00'; '01'; '00'; '10']
'1+0*'    % Push this string: regexp pattern
          % STACK: ['10'; '01'; '01'; '00'; '01'; '00'; '10'], '1+0*'
XX        % Regexp. Linearizes the first input into a row (in column-major
          % order), and pushes a cell array of substrings that match the
          % pattern given by the second input
          % STACK: {'100000'; '10'; 110'; '100'}
ZB        % Convert each string into a decimal number. Gives numeric vector
          % STACK: [32; 2; 6; 4]
s         % Sum. Implicitly display
          % STACK: 44

— लुइस मेंडो
स्रोत

5

05AB1E , 18 बाइट्स

कोड:

Çžy+b€¦JTR021:2¡CO

स्पष्टीकरण:

Ç                   # Take the ASCII value of each character
 žy+                # Add 128 to each value (to pad each with enough zeros)
    b               # Convert to binary
     €¦             # Remove the first character
       J            # Join the array
        TR021:      # Replace 01 by 021
              2¡    # Split on the number 2
                C   # Convert from binary to decimal
                 O  # Sum them all up

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत

5

05AB1E , 14 बाइट्स

Çžy+b€¦Jγ2ôJCO

मेरे जेली उत्तर का एक पोर्ट , अदनान के 05ab1e उत्तर से 128 ऑफसेट (जेली उत्तर में 256 के बजाय जो मैंने लिखा था) का उपयोग कर रहा है।

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

कैसे?

Çžy+b€¦Jγ2ôJCO
Ç              - to ordinals
   +           - add
 žy            - literal 128
    b          - to binary
     €         - for each
      ¦        -   dequeue
       J       - join
        γ      - group into chunks of equal elements
          ô    - split into chunks of
         2     - literal 2
           J   - join
            C  - from binary
             O - sum

— जोनाथन एलन
स्रोत

3

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

s=>eval(s.replace(/./g,c=>(128+c.charCodeAt()).toString(2).slice(1)).replace(/1+/g,'+0b$&'))

संपादित करें: @ ConorO'Brien की कुछ मदद से 5 बाइट्स सहेजे गए।

— नील
स्रोत

मेरा अपना समाधान 97 बाइट्स भी था: s=>eval([...s].map(e=>(e.charCodeAt()+128).toString(2).slice(1)).join``.replace(/1+0*/g,'+0b$&'))आप एक बाइट को बचाने के लिए मेरी जगह विधि का उपयोग कर सकते हैं, मुझे लगता है

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

1

@ ConorO'Brien बाइट से ज्यादा, मुझे लगता है!

— नील

Oo, n i c e: D

— Conor O'Brien

3

जाप , 18 12 बाइट्स

c_¤ùT7Ãò< xÍ
c_           // Firstly, take the input and map over it as charcodes.
  ¤          // Take the binary representation of each item
   ùT7       // and left-pad it with zeroes to standardize the items.
      Ã      // After all of the above,
       ò<    // partition the result where ever a 0 precedes a 1.
          xÍ // Then sum the numbers from base 2.

एक स्ट्रिंग के रूप में इनपुट लेता है।
मैंने अन्य उत्तरों द्वारा उपयोग किए गए 128 या 256 जोड़ को भी आज़माया, लेकिन 0-पैडिंग उपयोग करने के लिए छोटा था।

ETHproductions और ओलिवर की बदौलत पूरे बाइट को 6 बाइट्स से काट दिया ।

इसे यहाँ आज़माएँ।

— लीख
स्रोत

आप यहाँ और अधिक ऑटो कार्यों का उपयोग कर सकते हैं: òÈ<YÃहो सकता है ò<(अंतरिक्ष में पूर्ण विराम वाले), और Ën2Ãxहो सकता है xn2। आप अल्पविराम पर सहेजने के Tस्थान पर भी उपयोग कर सकते हैं 0। (इसके अलावा, अगर आप कभी सवाल पूछना चाहते हैं या गोल्फिंग के साथ मदद करना चाहते हैं, तो हमें Japt chatroom में शामिल होने के लिए स्वतंत्र महसूस करें )

— ETHproductions

@ETHproductions फिर से धन्यवाद, विशेष रूप से Tचाल के लिए, आपको नहीं पता था कि आप (ab) इसके लिए चर का उपयोग कर सकते हैं, यह बहुत आसान है। xn2संकलित होने पर ऑटो-फ़ंक्शन थोड़ा अजीब x("n", 2)लगता है, इसलिए मुझे लगता है कि मुझे अभी भी उनके पीछे के तर्क को पूरी तरह समझने से पहले थोड़ा समय लगेगा। आपकी मदद से, अब जेली समाधान जेली उत्तर के साथ पहले स्थान के लिए बंधा हुआ है ।

— नाइट

ETHproductions हाल ही में के लिए एक शॉर्टकट बनाया n2: Í। इसने अभी तक TIO को हिट नहीं किया है, लेकिन आप इसे यहां उपयोग कर सकते हैं: ethproductions.github.io/japt/?v=1.4.5&code=Y1+k+VQ3w/…

— Oliver

@ ओलिवर वाह, यह बहुत खून बहाने वाला किनारा है, जो अभी तक दुभाषिया शॉर्टकट संदर्भ में कवर नहीं किया गया है। आपका बहुत बहुत धन्यवाद!

— नाइट

2

जेली , 16 15 बाइट्स

डेस के लिए -1 बाइट का धन्यवाद (जब एक पूर्ण चपटा ठीक हो तो 1 से समतल करने की आवश्यकता नहीं है - ;/साथ बदलें F)

O+⁹Bṫ€3FŒg;2/ḄS

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

कैसे?

O+⁹Bṫ€3FŒg;2/ḄS - Main link: list of characters, s    e.g. "A4"
O               - cast to ordinal (vectorises)        [65,52]
  ⁹             - literal 256
 +              - add (vectorises)                    [321, 308]
   B            - convert to binary (vectorises)      [[1,0,1,0,0,0,0,0,1],[1,0,0,1,1,0,1,0,0]]
    ṫ€3         - tail €ach from index 3              [[1,0,0,0,0,0,1],[0,1,1,0,1,0,0]]
       F        - reduce with concatenation           [1,0,0,0,0,0,1,0,1,1,0,1,0,0]
        Œg      - group runs of equal elements        [[1],[0,0,0,0,0],[1],[0],[1,1],[0],[1],[0,0]]
          ;2/   - pairwise reduce with concatenation  [[1,0,0,0,0,0],[1,0],[1,1,0],[1,0,0]]
             Ḅ  - convert from binary (vectorises)    [32,2,6,4]
              S - sum                                 44

— जोनाथन एलन
स्रोत

1

;/से बदला जा सकता है F।

— डेनिस

2

PHP, 116 बाइट्स

for(;$c=ord($argn[$i++]);)$r.=sprintf("%07b",$c);$t=mb_split("(?<=0)(?=1)",$r);echo array_sum(array_map(bindec,$t));

ऑनलाइन संस्करण

PHP, 117 बाइट्स

for(;$c=ord($argn[$i++]);)$r.=sprintf("%07b",$c);$t=preg_split("#0\K(?=1)#",$r);echo array_sum(array_map(bindec,$t));

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

PHP, 120 बाइट्स

for(;$c=ord($argn[$i++]);)$r.=sprintf("%07b",$c);preg_match_all("#1+0+#",$r,$t);foreach($t[0]as$b)$s+=bindec($b);echo$s;

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

या

for(;$c=ord($argn[$i++]);)$r.=sprintf("%07b",$c);preg_match_all("#1+0+#",$r,$t);echo array_sum(array_map(bindec,$t[0]));

— जार्ग हुल्सरमन
स्रोत

1

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

ये बहुत लंबा है...

siR2:.BiCMQ128"1+0+"1

परीक्षण सूट।

— लीक नन
स्रोत

1

[एफ #], २४ ९ २४५ बाइट्स

open System
let rec c a=function|[]->[a]|'0'::'1'::y->(a+"0")::(c""('1'::y))|x::y->c(a+string x)y
let x i=c""(String.Join("",(Seq.map(fun c->Convert.ToString(int c,2).PadLeft(7,'0'))i))|>Seq.toList)|>Seq.map(fun c->Convert.ToInt32(c,2))|>Seq.sum

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

नोट: tio.run के संस्करण में हेडर में "ओपन सिस्टम" है, मैंने इसकी गिनती ऊपर दिए गए कोड में जोड़ दी है। मुझे यकीन नहीं है कि आयात पर क्या नियम हैं।

Ungolfed

let rec convert acc = function
    | [] -> [acc]
    | '0'::'1'::xs -> (acc + "0") :: (convert "" ('1'::xs))
    | x::xs -> convert (acc + string x) xs

let calculateSum input =
    let binary = Seq.map (fun x -> Convert.ToString(int x, 2).PadLeft(7, '0')) input

    String.Join("", binary)
    |> Seq.toList
    |> convert ""
    |>Seq.map (fun x -> Convert.ToInt32(x, 2))
    |>Seq.sum

— ब्रूनर
स्रोत

यदि open Systemसी # के समान है, using System;तो हाँ आपको इसे गिनती में शामिल करने की आवश्यकता है। यदि आप इसे F # में कर सकते हैं तो आप जो भी है Systemउसके लिए पूरी तरह से अर्हता प्राप्त कर सकते हैं । उदाहरण के लिए, C # के System.Console...बजायusing System;Console...

— TheLethalCoder

@ लेथलॉकर यह वही है, हाँ। इसके अलावा, इसे स्पष्ट करने के लिए धन्यवाद :) मैंने "ओपन .." संस्करण का विकल्प चुना क्योंकि यह न केवल स्ट्रिंग है, बल्कि उस नेमस्पेस में कन्वर्ट भी है।

— ब्रूनर

0

पर्ल 6 , 62 बाइट्स

{sum map {:2(~$_)},.comb».ord».fmt('%07b').join~~m:g/11*0*/}

— शॉन
स्रोत

के .ordsबजाय का उपयोग करें .comb».ord। उपसर्ग [~]अक्सर के बजाय इस्तेमाल किया जा सकता है .join। combमौजूद है जो m:g/…बात करता है /11*0*/को छोटा किया जा सकता है /1+0*/। मैं साथ आया था{sum map {:2($_)},comb /1+0*/,[~] .ords».fmt('%07b')}

— ब्रैड गिल्बर्ट b2gills

0

जे , 34 बाइट्स

[:+/@(,#.;.1~1,1=2#.\,)(7#2)#:3&u:

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

व्याख्या

[:+/@(,#.;.1~1,1=2#.\,)(7#2)#:3&u:  Input: array of characters S
                              3&u:  Get ASCII values of each character
                       (7#2)        Array with 7 copies of the value 2
                            #:      Convert each value to a base 2 array with length 7
[:  (                 )             Operate on those binary values
                     ,                Flatten it
                 2  \                 For each infix of size 2
                  #.                    Convert it to decimal from binary
               1=                     Test each value for equality to 1
             1,                       Prepend a 1
      ,                               The flattened binary values
         ;.1~                         Chop that at each occurrence of a 1
       #.                               Convert each chop from binary to decimal
 +/@                                Reduce by addition

— मील की दूरी पर
स्रोत

0

गणितज्ञ 193 बाइट्स

f=FromDigits;l=Flatten;(S=Split@l@Table[PadLeft[IntegerDigits[ToCharacterCode@#,2][[k]],7],{k,StringLength@#}];Plus@@Table[f[RealDigits@f@Join[S[[i]],S[[i+1]]],2],{i,1,Length@S-1,2}]+Last@l@S)&

— J42161217
स्रोत

आप f=FromDigits;l=Flatten;शुरुआत में 7 बाइट्स बचा सकते हैं , और फिर उन दो कार्यों के सभी उदाहरणों को प्रतिस्थापित कर सकते हैं fऔर l।

— नंबरमैन

0

जे , 40 बाइट्स

+/>#.&.>(1,}.|.1 0 E.|.b)<;.1 b=.,#:a.i.

उपयोग:

+/>#.&.>(1,}.|.1 0 E.|.b)<;.1 b=.,#:a.i.'A4'

रिटर्न 44

— protist
स्रोत

0

क्लोजर, 150 बाइट्स

#(loop[[c & C](for[i % j[64 32 16 8 4 2 1]](mod(quot(int i)j)2))p 0 r 0 R 0](if c(if(=(dec c)p 0)(recur C c 1(+ R r))(recur C c(+(* 2 r)c)R))(+ R r)))

वैसे मैं आशा कर रहा था कि ASCII से बाइट्स में रूपांतरण इससे कम होगा। rवर्तमान परिणाम प्राप्त करने और Rकुल परिणाम को जमा करने के लिए वास्तविक लूप बॉडी काफी कम है । यदि पिछला बिट pहै 0और वर्तमान बिट cहै, 1तो हम एक नया हिस्सा विभाजित करते हैं और जमा करते हैं R, अन्यथा हम इसे अपडेट करते हैं rऔर Rइसे वैसे ही रखते हैं ।

— NikoNyrh
स्रोत

0

पायथन 123 बाइट्स

lambda w:sum(map(lambda x:int(x,2),"".join(map(lambda x:bin(ord(x))[2:].zfill(7),list(w))).replace("01","0:1").split(":")))

मार्टिन एंडर को धन्यवाद।

— शडौकट
स्रोत

1

PPCG में आपका स्वागत है! सभी उत्तरों को या तो पूर्ण कार्यक्रम या कॉल करने योग्य कार्य करने की आवश्यकता है (स्निपेट के विपरीत जहां इनपुट हार्डकोडेड वैरिएबल में संग्रहीत है)। फ़ंक्शन को अनाम किया जा सकता है, हालांकि, इसलिए सहित lambda w:आपके उत्तर को मान्य बनाने के लिए पर्याप्त होगा।

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

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

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

ओह्ह, ठीक है, मैं इसे प्राप्त करता हूं, यह इस तरह से पर्याप्त होगा: f = lambda w: sum (नक्शा (लैम्ब्डा x: int (x, 2)), ""। (मैप (lambda x: bin) (ord (x) ) [2:]। Zfill (7), सूची (w))। प्रतिस्थापित करें ("01", "0, 1")। विभाजन (":"))

— शैडोक्रेट

हां, यह मान्य है। आपको इसकी आवश्यकता भी नहीं है f=, क्योंकि हम अनाम कार्यों की अनुमति देते हैं (जब तक कि आप पुनरावर्ती कॉलों के लिए फ़ंक्शन नाम का संदर्भ नहीं देते हैं)।

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

0

के (ओके) , 31 बाइट्स

समाधान:

+/2/'_[;x]&x&~~':x:,/(7#2)\'`i$

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

उदाहरण:

+/2/'_[;x]&x&~~':x:,/(7#2)\'`i$,"a"
49
+/2/'_[;x]&x&~~':x:,/(7#2)\'`i$"A4"
44
+/2/'_[;x]&x&~~':x:,/(7#2)\'`i$"codegolf"
570
+/2/'_[;x]&x&~~':x:,/(7#2)\'`i$"Hello, World!"
795

स्पष्टीकरण:

ASCII मूल्यों में कनवर्ट करें, 7-बिट बाइनरी में परिवर्तित करें, समतल करें, जहां 1भिन्नताएं ढूंढें, और मूल सूची के खिलाफ जहां खोजने के लिए अलग है। इन सूचकांकों पर कट करें, दशमलव में वापस बदलें और योग करें:

+/2/'_[;x]&x&~~':x:,/(7#2)\'`i$ / the solution
                            `i$ / convert to integer
                     (7#2)      / draw from 2, 7 times => 2 2 2 2 2 2 2
                          \'    / decode each (convert to binary)
                   ,/           / flatten
                 x:             / save as x
             ~~':               / not-not-each previous (differ)
            &                   / and with
           x                    / x
          &                     / indices where true
     _[;x]                      / projection, cut x at ...
  2/'                           / encode each (convert from binary)
+/                              / sum up

बोनस

एक प्रबंधित 31 बाइट में संस्करण K4 भी है, लेकिन इसके लिए कोई TIO के रूप में मैं अपने ठीक समाधान पोस्टिंग कर रहा हूँ।

+/2/:'_[;x]@&x&~~':x:,/1_'0b\:'

— streetster
स्रोत

0

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

{+/2⊥¨(1∘+⊆⊢)∊¯7↑¨2⊥⍣¯1¨⎕UCS⍵}

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

कैसे?

⎕UCS⍵ - यूनिकोडाइज

2⊥⍣¯1¨ - बाइनरी में प्रत्येक को एनकोड करें

¯7↑¨ - और 7 स्थानों के लिए शून्य के साथ पैड पैड

∊ - चपटा

1∘+⊆⊢ - एक के बाद एक स्वयं द्वारा विभाजन

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

+/ - योग

— Uriel
स्रोत

किसी शब्द के बाइनरी स्प्लिट योग की गणना करें

पायथन 2 , 86 81 76 बाइट्स

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

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

MATL , 14 बाइट्स

व्याख्या

05AB1E , 18 बाइट्स

05AB1E , 14 बाइट्स

कैसे?

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

जाप , 18 12 बाइट्स

जेली , 16 15 बाइट्स

कैसे?

PHP, 116 बाइट्स

PHP, 117 बाइट्स

PHP, 120 बाइट्स

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

[एफ #], २४ ९ २४५ बाइट्स

Ungolfed

पर्ल 6 , 62 बाइट्स

जे , 34 बाइट्स

व्याख्या

गणितज्ञ 193 बाइट्स

जे , 40 बाइट्स

क्लोजर, 150 बाइट्स

पायथन 123 बाइट्स

के (ओके) , 31 बाइट्स

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