समस्या:

दो दुश्मन गुप्त एजेंटों ने संचार की एक अद्भुत (आपके लिए) विधि तैयार की है!

यहां बताया गया है कि एन्क्रिप्शन प्रक्रिया कैसे काम करती है:

1) प्रत्येक अक्षर के एएससीआई समतुल्य लें। (कोई स्थान, संख्या या विराम चिह्न नहीं भेजे गए हैं)

2) संदेश में प्रत्येक अक्षर के लिए, एससीआई के बराबर और उसके बाद के अक्षर (यदि यह मौजूद है, यदि ऐसा नहीं है, तो इसे 0 माना जाना चाहिए), गुणा किया जाता है (यह उत्पाद एक सरणी / सूची में संग्रहीत है) और सारांशित (यह संख्या एक अलग सूची में भी संग्रहीत है)।

3) दो सूचियाँ (रकम और उत्पादों की) एक साथ जुड़ती हैं (रकम सूची, फिर गुणक सूची, एक ही सरणी में) और प्रेषित।

आपको इस प्रक्रिया को उलटने में सक्षम सबसे छोटे प्रोग्राम को लिखने और इस प्रारूप में भेजे गए संदेशों को डिक्रिप्ट करने की आवश्यकता है!

उदाहरण इनपुट और आउटपुट जोड़े:

[173, 209, 216, 219, 198, 198, 225, 222, 208, 100, 7272, 10908, 11664, 11988, 9657, 9657, 12654, 12312, 10800, 0] -> “HelloWorld”
[131, 133, 164, 195, 197, 99, 4290, 4422, 6499, 9506, 9702, 0] -> “ABCabc”

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा समाधान जीतता है।

त्रुटि संदेश की अनुमति है।

यदि आप अपने सबमिशन में निर्दिष्ट करते हैं तो आपका प्रोग्राम या तो एक सूची / 1-आयामी सरणी या अल्पविराम से अलग स्ट्रिंग दिया जा सकता है। डिफ़ॉल्ट एक सरणी / सूची है।

code-golf number arithmetic

— iPhoenix
स्रोत

1

वहाँ भी बहुओं की सूची क्यों है? बस रकम पर्याप्त जानकारी है।

— orlp

1

@ और अधिक गोल्फिंग के अवसरों की अनुमति देने के लिए शायद? :)

— जोनाथन एलन

1

@orlp ओह नहीं, आपने मज़ा खराब कर दिया!

— आउटगोल्फ

@JonathanAllan सही है, आंशिक रूप से। मैं चाहता था कि दो गुप्त एजेंट सुपर बेवकूफ दिखाई दें, ताकि वे अपने "कोड" में अनावश्यक भागों को जोड़ दें। यह कुछ और संभावित कार्यक्रमों को भी जोड़ता है जो बाहर आ सकते हैं।

— iPhoenix

@orlp बस गुणक पर्याप्त नहीं है, है ना?

— ericw31415

5

भूसी , 7 6 बाइट्स

mcĠ≠←½

इसे ऑनलाइन आज़माएं! प्रलेखन के अनुसार अग्रणी की mआवश्यकता नहीं होनी चाहिए, लेकिन वर्तमान में एक बग प्रतीत होता है।

संपादित करें: -1 बाइट ज़गरब को धन्यवाद!

स्पष्टीकरण:

     ½ -- split input list into half
    ←  -- take first list
  Ġ≠   -- subtract each list element from the previous one
mc     -- convert list of code points to string

— Laikoni
स्रोत

मुझे लगता है कि `-हो सकता है ≠। cवास्तव में व्यवहार एक बग की तरह दिखता है।

— जर्बर्ब

@Zgarb असमान को लागू करने का एक व्यावहारिक तरीका है। क्या यह कहीं दस्तावेज है?

— लिकोनी

यह हस्क विकी के शब्दार्थ पृष्ठ पर है।

— जरगब

1

ऐसा लगता है कि आपने अपना स्पष्टीकरण बदल दिया है, लेकिन वास्तविक कोड स्निपेट नहीं। :)

— iPhoenix

@iPhoenix धन्यवाद, मैंने इसकी पुष्टि की।

— लकोनी

8

ब्रेनफक , 66 बाइट्स

,[>>>+<[-<+>>-<]<[->+<],]>[<<,>>[-<+>]<-]<<<[>[-<->>+<]<<]>.>>[.>]

इनपुट एन्क्रिप्टेड स्ट्रिंग है। अनंत आकार की कोशिकाओं और 0 ईओएफ पर मान लेता है।

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

,[>>>+<[-<+>>-<]<[->+<],] Gets input and the number of characters divided by 2
>[<<,>>[-<+>]<-]<<< Remove the second half of the string (the multiplication part)
[>[-<->>+<]<<] Subtract each character from the previous one, while keeping a copy of the previous one.
>.>>[.>] Print the characters

— मजाक कर रहा है
स्रोत

5

हास्केल , 45 35 बाइट्स

map toEnum.scanr1(-).fst.span(<245)

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

व्याख्या

fst.span(<245)सूची की शुरुआत से सभी संख्याओं को लेता है जो 245 से छोटे हैं। वे केवल समन भाग से संख्याएं हैं, क्योंकि सबसे बड़ा संभव योग है z + z = 122 + 122 = 244, और सबसे छोटा संभव उत्पाद है A * A = 65 * 65 = 4225।
scanr1(-)सूची का अंतिम मान लेता है और इसे प्रारंभिक संचयकर्ता के रूप में उपयोग करता है। फिर पीछे से सूची के प्रत्येक तत्व को वर्तमान संचायक द्वारा घटाया जाता है, और परिणाम को अगले संचायक के रूप में उपयोग किया जाता है और सूची में जोड़ा जाता है।
map toEnum स्ट्रिंग को फिर से बनाने के लिए संबंधित वर्ण के साथ सूची में प्रत्येक संख्या को बदलता है।

— Laikoni
स्रोत

3

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

œs2ḢUạ\ỌU

इसे ऑनलाइन आज़माएं! या दोनों परीक्षण मामलों की जाँच करें।

वैकल्पिक।

व्याख्या

œs2ḢUạ \ ỌU || पूरा कार्यक्रम।

œs2 || दो भागों में विभाजित करें, यदि आवश्यक हो तो पहले वाला लंबा हो।
   Ḣ || सिर (पहले तत्व) प्राप्त करें।
    यू || उल्टा।
     ạ \ _ || घटाव द्वारा संचयी कमी।
       Ọ || कोड बिंदुओं से वर्णों में परिवर्तित करें।
        यू || और फिर से रिवर्स।

— मिस्टर एक्सकोडर
स्रोत

3

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

a=input();p=0;r=''
for v in a[len(a)/2-1::-1]:r=chr(v-p)+r;p=v-p
print r

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

— OVS
स्रोत

2

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

lambda C:"".join(chr(sum((-1)**i*C[j+i]for i in range(len(C)/2-j)))for j in range(len(C)/2))

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

— जोनाथन फ्रेच
स्रोत

2

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

œs2Ḣḅ-$ÐƤAỌ

पूर्णांक की एक सूची लेने और वर्णों की सूची लौटाने वाला एक विचित्र लिंक।

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

कैसे?

œs2Ḣḅ-$ÐƤAỌ - Link: list of integers     e.g. [210,211,201,101,10989,11100,10100,0]
  2         - literal two                     2
œs          - split into equal parts          [[210,211,201,101],[10989,11100,10100,0]]
   Ḣ        - head                            [210,211,201,101]
       ÐƤ   - for postfixes:                  [210,211,201,101],[211,201,101],[201,101],[101]
      $     -   last two links as a monad:
     -      -     literal minus one           -1
    ḅ       -     convert from base           -99              ,111          ,-100      ,101
         A  - absolute value (vectorises)     [99,111,100,101]
          Ọ - convert to ordinal (vectorises) "code"

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

1

Pyt , 60 बाइट्स

←ĐĐŁ₂⁻⦋⇹ĐŁřĐŁ₂>*ž0`ŕĐĐŁ⁻⦋3ȘĐ4Ș3Ș4Ș÷⇹ĐŁřĐŁ<*žĐŁ⁻łŕ⇹Đ3Ș⇹÷Á↔áƇǰ

पूर्णांकों की सूची लेता है और वर्णों की एक स्ट्रिंग लौटाता है।

स्पष्टीकरण:

←ĐĐŁ₂⁻⦋⇹          Gets the ASCII code of the last character
ĐŁřĐŁ₂>*ž         Gets the list of products and removes the 0 from the end of the list
0`ŕ ...  ł        Loops (0 is there so that the length can be removed from the stack)
ĐĐŁ⁻⦋              Gets the last product
3ȘĐ4Ș3Ș4Ș÷        Divides by the last ASCII code obtained
⇹ĐŁřĐŁ<*ž         Removes the last element from the array
ĐŁ⁻ł              Gets the length of the array - 1 (if 0, then exit loop - the last entry still has to be processed)
ŕ⇹Đ3Ș⇹÷           Divides the remaining product by the last ASCII code obtained           
Á↔á               Converts to array of ints
Ƈǰ                Converts to string of ASCII characters

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

— mudkip201
स्रोत

1

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

a=>String.fromCharCode(...eval(`for(a.splice(i=a.length/2);--i;a[i-1]-=a[i])a`))

कोड स्निपेट दिखाएं

f=

a=>String.fromCharCode(...eval(`for(a.splice(i=a.length/2);--i;a[i-1]-=a[i])a`))

console.log(
    f([173, 209, 216, 219, 198, 198, 225, 222, 208, 100, 7272, 10908, 11664, 11988, 9657, 9657, 12654, 12312, 10800, 0]),
    f([131, 133, 164, 195, 197, 99, 4290, 4422, 6499, 9506, 9702, 0])
)

स्निपेट का विस्तार करें

— darrylyeo
स्रोत

1

VB स्क्रिप्ट - 74 71 बाइट्स

(जब मैं Do..Lop के बजाय। का उपयोग करके 74 से 71 को कम करने में कामयाब रहा)

इनपुट एक सरणी () में है, आउटपुट स्ट्रिंग डी में है

d="":p=0:n=(UBound(a)+1)/2:While n>0:n=n-1:t=a(n)-p:d=Chr(t)&d:p=t:Wend

व्याख्या

d=""          '// initialize the output string
p=0          '// initialize the ansii of following char (working back from last char)
n=(Ubound(a)+1)/2 '// the index of the last summed pair + 1 (base 0)
While n>0    '// begin loop working back from last summed pair
n=n-1        '// move back 1 char
t=a(n)-p     '// calculate the ansii by subtracting the ansii of following char
d=Chr(t)&d   '// prepend the char to output
p=t          '// this char becomes the following char for next
Wend         '// repeat etc.

मैंने एक फ़ंक्शन के रूप में लिपटे उपरोक्त कोड के साथ एक vbscript फ़ाइल में इसका परीक्षण किया:

dim s
Dim arr()
s = Split("173, 209, 216, 219, 198, 198, 225, 222, 208, 100, 7272, 10908, 11664, 11988, 9657, 9657, 12654, 12312, 10800, 0", ",")
ReDim arr(UBound(s))
Dim x 
For x = 0 To UBound(s)
    arr(x) = cint(s(x))
Next 

msgbox "=" & d(arr)



Private Function d(a())
d="":p=0:n=(UBound(a)+1)/2:While n>0:n=n-1:t=a(n)-p:d=Chr(t)&d:p=t:Wend
End Function

— JohnRC
स्रोत

1

क्लीन , 96 81 78 77 बाइट्स

zeroअशक्त चरित्र है।
मैं एक और बाइट को बचा सकता था अगर क्लीन स्रोत फ़ाइल में शाब्दिक नल के बारे में इतना अचार नहीं था।

import StdEnv
f=init o foldr(\a t=[toChar a-t!!0:t])[zero]o takeWhile((>)245)

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

— Οurous
स्रोत

अनाम कार्य सामान्य रूप से स्वीकार्य हैं, इसलिए यदि आप चाहें तो आप इसे छोड़ सकते हैं f=।

— लकोनी

@ लिकोनी मुझे इस मामले में इसकी वैधता के बारे में निश्चित नहीं है, क्योंकि इसे इनलाइन उपयोग करने के लिए कोष्ठक की जरूरत है, और f=यह सबसे छोटा असाइनमेंट है, इसलिए न्यूनतम मंगलाचरण वैसे भी दो जोड़ता है।

— Οसूरज

1

पर्ल 5 , 39 + 2 ( `-ap`) = 41 बाइट्स

$#F/=2;$\=chr($p=-$p+pop@F).$\while@F}{

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

— Xcali
स्रोत

1

सी (जीसीसी) , 90 89 बाइट्स

छत के लिए धन्यवाद एक बाइट को बचाया ; s+=(i%2?-1:1)*...<~> s-=~(i%2*-2)।

D(C,l,j,s,i)int*C;{for(j=~0;++j<l/2;putchar(s))for(s=i=0;i+j<l/2;)s-=~(i%2*-2)*C[i+++j];}

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

— जोनाथन फ्रेच
स्रोत

0

मानक एमएल (एमएलटन) , 85 84 82 बाइट्स

fun!(x::r)=if x>244then[]else(fn z::s=>x-z::z::s|_=>[x])(!r);implode o map chr o!;

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

Ungolfed:

fun g (x::r) =
   if   x > 244
   then []
   else case g r of
          z::s => x-z :: z :: s
        |  []  => [x]

val f = implode o map chr o g

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

— Laikoni
स्रोत

0

पर्ल 6 , 43 39 35 बाइट्स

{[~] [R,](produce *R-*,[R,] .[^*/2])».chr}

झसे आज़माओ

{[~] [R,]([\[&(*R-*)]] [R,] .[^*/2])».chr}

इसका परीक्षण करें ^{_{(ऊपर जैसा है)}}

{[~] [R,]([\R[&(*R-*)]] .[^*/2])».chr}

झसे आज़माओ

{[R~] [\R[&(*R-*)]](.[^*/2])».chr}

झसे आज़माओ

स्पष्टीकरण:

{[R~] [\R[&(*R-*)]](.[^*/2])».chr}

{                                }      # block lambda with parameter `$_`

      [\R[&(*R-*)]](.[^*/2])            # turn sums back into ordinals (reversed)

                    .[^*/2]             # first half of `$_` (implicit method call)
            *R-*                        # lambda, reverse of *-*
         [&(    )]                      # use it as an infix operator
                                        # (same as R- except left associative)
        R                               # reverse arguments and associativity
                                        # (same as - except right associative)
      [\          ](       )            # produce values `[\+] 1,2,3` => `(1,3,6)`
                                        # uses associativity to determine direction
                                        # `[\**] 1,2,3` => `(3,8,1)`

                            ».chr       # call `.chr` method on all values
                                        # (possibly concurrently)

 [R~]                                   # concatenate in reverse
                                        # (shorter than `join '', reverse …`)

— ब्रैड गिल्बर्ट b2gills
स्रोत

0

05AB1E , 9 बाइट्स

2ä¬Å«-}çJ

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

व्याख्या

2ä        # Split input list in two (equal if possible) parts.
  ¬       # Push head(a).
   Å«-}   # Cumulative reduce the list by subtraction (from the right).
       ç  # Convert each integer in the list to its corresponding ASCII char.
        J # Join list together to string.

— Wisław
स्रोत

आप Join की जरूरत नहीं है ।

— झबरा

@ शैगी का अर्थ çस्पष्ट रूप से वर्णों की सूची को स्ट्रिंग में बदलना नहीं है। यदि मैं समस्या को सही ढंग से समझता हूं, तो प्रोग्राम को एक स्ट्रिंग आउटपुट करने की आवश्यकता है, न कि पात्रों की सूची।

— विस्लोव

0

जाप, 12 बाइट्स

सरणी की पहली छमाही पाने के लिए एक छोटा सा तरीका होना चाहिए ...

¯UÊz)Ôån Ômd

कोशिश करो

— झबरा
स्रोत

0

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

l,j,s=input(),0,'';n=len(l)/2
while n:n-=1;j=l[n]-j;s=chr(j)+s
print s

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

— mdahmoune
स्रोत

नंबर में एन्क्रिप्टेड!

समस्या:

उदाहरण इनपुट और आउटपुट जोड़े:

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा समाधान जीतता है।

भूसी , 7 6 बाइट्स

स्पष्टीकरण:

ब्रेनफक , 66 बाइट्स

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

हास्केल , 45 35 बाइट्स

व्याख्या

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

व्याख्या

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

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

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

कैसे?

Pyt , 60 बाइट्स

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

VB स्क्रिप्ट - 74 71 बाइट्स

क्लीन , 96 81 78 77 बाइट्स

पर्ल 5 , 39 + 2 ( -ap) = 41 बाइट्स

सी (जीसीसी) , 90 89 बाइट्स

मानक एमएल (एमएलटन) , 85 84 82 बाइट्स

Ungolfed:

पर्ल 6 , 43 39 35 बाइट्स

स्पष्टीकरण:

05AB1E , 9 बाइट्स

व्याख्या

जाप, 12 बाइट्स

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

पर्ल 5 , 39 + 2 ( `-ap`) = 41 बाइट्स