बाइनरी एन्क्रिप्शन

11

यह xkcd # 153 पर आधारित है ।

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

निष्पादित प्रसंस्करण निम्नलिखित के बराबर होना चाहिए:

  1. प्रत्येक चरित्र के बिट्स को समेटकर गठित एकल बिटस्ट्रिंग में पहले पैरामीटर को परिवर्तित करें (7-बिट एएससीआईआई, 8-बिट विस्तारित एएससीआईआई या एक मानक यूनिकोड एन्कोडिंग के रूप में व्याख्या की गई)। जैसे अगर पहला पैरामीटर है "AB"तो यह 10000011000010(7-बिट), 0100000101000010(8-बिट या UTF-8) 00000000010000010000000001000010, या 01000001000000000100001000000000(UTF-16 दो एंडियननेस में), आदि में से एक होगा।
  2. प्रत्येक पैरामीटर के लिए दूसरे पैरामीटर में, क्रम में, इसी निर्देश को निष्पादित करें:
    • lएक छोड़ दिया बिटस्ट्रिंग घूमता है। जैसे 10000011000010बन जाता है 00000110000101।
    • rबिटस्ट्रिंग को सही घुमाता है। जैसे 10000011000010बन जाता है 01000001100001।
    • fफ़्लिप (या inverts) बिटस्ट्रिंग में प्रत्येक बिट। जैसे 10000011000010बन जाता है 01111100111101।
    • uबिटस्ट्रिंग को उलट देता है। जैसे 10000011000010बन जाता है 01000011000001।
  3. बिटस्ट्रिंग को एक ASCII स्ट्रिंग में परिवर्तित करें जो प्रति बिट एक वर्ण का उपयोग करता है। जैसे 10000011000010बन जाता है "10000011000010"। इसका कारण यह है कि 7/8 बिट्स के सभी सेटों में एक वर्ण उन्हें नहीं सौंपा गया है।

उदाहरण (पायथन में):

>>> f("b", "rfu")
01110011

यह "b"अपने 8-बिट ASCII बाइनरी प्रतिनिधित्व में बदल जाता है 01100010, इसे सही घुमाता है ( 00110001), प्रत्येक बिट ( 11001110) को फ़्लिप करता है , और इसे उलट देता है ( 01110011)।

लचीलापन

अन्य पात्रों अक्षरों के स्थान पर इस्तेमाल किया जा सकता l, r, f, और u, पर वे स्पष्ट रूप से प्रलेखित किया जाना चाहिए।

स्कोरबोर्ड

निम्न कोड स्निपेट बनाने के लिए @Optimizer का धन्यवाद । उपयोग करने के लिए, "शो कोड स्निपेट" पर क्लिक करें, नीचे स्क्रॉल करें और "click रन कोड स्निपेट" पर क्लिक करें।

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

code-golf  string  binary 
3
दूसरा पैरामीटर क्या हो सकता है? क्या यह हो सकता है "rrfrburb"? इसके अलावा, जब कोई बिट्स को बदलता है या उलटता है, तो क्या प्रत्येक व्यक्ति पत्र या पूरे के रूप में स्ट्रिंग के लिए करता है? अधिक परीक्षण मामले इसे स्पष्ट करेंगे।
— xnor
1
क्या आपका मतलब है शिफ्ट या घूमना? सी में एक लेफ्टशिफ्ट सबसे बाईं ओर खो दिया जाएगा और सबसे सही बिट शून्य हो जाएगा। एक अहस्ताक्षरित संख्या पर अधिकार के लिए रिवर्स होता है। एक हस्ताक्षरित संख्या के लिए मुझे यकीन नहीं है कि यदि नकारात्मक संख्याओं के लिए स्थानांतरित होने वाला एक सार्वभौमिक रूप से परिभाषित व्यवहार है (क्या यह 0 या 1 है?) किसी भी तरह, जानकारी हमेशा खो जाती है जब एक बदलाव किया जाता है, जो मामला नहीं है एक चक्कर के लिए।
— स्तर नदी सेंट
2
— पीटर टेलर
2
@flawr, मुझे नहीं लगता कि 'xkcd' की खोज
— पीटर टेलर
1
@ मुझे लगता है कि मैं उस के लिए नहीं कहने जा रहा हूँ। इसे जोड़कर एक तार बनाओ।

जवाबों:

1

CJam, 34 32 बाइट्स

1l+256b2b1>l{~"11W:mm%!<>">4%~}/

यह निर्देशों के लिए निम्नलिखित वर्णों का उपयोग करता है:

0: left rotation
1: right rotation
2: reverse
3: flip

इनपुट STDIN से पहली लाइन पर शब्द और दूसरी लाइन पर निर्देश स्ट्रिंग से ले रहा है।

इसका परीक्षण यहां करें।

व्याख्या

बिट स्ट्रिंग प्राप्त करना वास्तव में केवल आधार-256 नंबर के अंकों के रूप में वर्ण कोड की व्याख्या करने का मामला है (और इसका आधार -2 प्रतिनिधित्व प्राप्त करना)। मुश्किल बात यह है कि बाद का आधार रूपांतरण बाईं ओर 0s के साथ परिणाम को पैड नहीं करेगा। इसलिए, मैं प्रारंभिक इनपुट में एक अग्रणी 1 जोड़ता हूं, और फिर बाइनरी प्रतिनिधित्व में उस 1 को फिर से विभाजित करता हूं। एक उदाहरण के रूप में, यदि इनपुट है ab, तो मैं इसे एक सरणी में बदल देता हूं [1 'a 'b], व्याख्या करता हूं कि बेस-256 (अक्षर स्वचालित रूप से वर्ण कोड में बदल जाते हैं), जो कि है 90466और बेस -2 है, जो है [1 0 1 1 0 0 0 0 1 0 1 1 0 0 0 1 0]। अब अगर मैं अभी हटाता हूं तो मुझे 1वह बिटस्ट्रीम मिल गया है जिसकी मुझे तलाश है।

कोड का यह हिस्सा क्या करता है:

1l+256b2b1>

अब मैं निर्देशों की सूची पढ़ता हूं और निर्देश स्ट्रिंग में प्रत्येक वर्ण के लिए एक ब्लॉक निष्पादित करता हूं:

l{...}/

ऐसा करने के लिए पहली बात यह चरित्र और वास्तविक पूर्णांकों का मूल्यांकन करना है 0, 1, 2या 3। अब असली गोल्फ मैजिक ... निर्देश के आधार पर मैं एक छोटा कोड चलाना चाहता हूं जो ऑपरेशन को लागू करता है:

Integer:  Code  Operation
0         1m<   "Left rotation";
1         1m>   "Right rotation";
2         W%    "Reverse";
3         :!    "Flip each bit";

मैं इन्हें ब्लॉक की एक सरणी में संग्रहीत कर सकता हूं और चलाने के लिए सही ब्लॉक चुन सकता हूं, लेकिन उन्हें एक स्ट्रिंग में एन्कोडिंग वास्तव में छोटा है:

"11W:mm%!<>">4%~

सबसे पहले, मैं स्ट्रिंग की शुरुआत को बंद करने के निर्देश के साथ पूर्णांक सहयोगी का उपयोग करता हूं। तो बाएं रोटेशन के लिए, स्ट्रिंग अपरिवर्तित है, दाएं रोटेशन के लिए पहला वर्ण छोड़ दिया गया है और इसी तरह। फिर मैं पहले से शुरू होने वाले स्ट्रिंग से प्रत्येक चौथे वर्ण का चयन करता हूं 4%। ध्यान दें कि पूरे स्ट्रिंग में चार कोड स्निपेट कैसे वितरित किए जाते हैं। अंत में मैं सिर्फ कोड के साथ स्ट्रिंग का मूल्यांकन करता हूं ~।

बिट स्ट्रिंग प्रोग्राम के अंत में स्वचालित रूप से मुद्रित होता है।

— मार्टिन एंडर
स्रोत
1m<बजाय इसके क्यों (+? आप एक संख्या के बजाय एक सरणी पर काम कर रहे हैं, क्या आप नहीं हैं?
— पीटर टेलर
@Peter ओह ठीक है, धन्यवाद। बाद में ठीक कर दूंगा।
— मार्टिन एंडर
2

CJam, 34 बाइट्स

CJam में एक और दृष्टिकोण।

1l+256b2b1>l_S/,1&@f=_,,@f{W%~}\f=

इनपुट टेक्स्ट पहली लाइन पर है और निर्देश दूसरी लाइन पर हैं।

निर्देश:

)        Rotate left.
(        Rotate right.
 (space) Flip.
~        Reverse.
— jimmy23013
स्रोत
1
यह बहुत चालाक है। एक शर्म की बात है कि f~हालांकि, यह लागू नहीं है? ;)
— मार्टिन एंडर
2

अजगर ३३

jku@[+eGPG+tGhG_Gms!dG)sHwsmjCk2z

उपयोग:

0    : rotate right
1    : rotate left
2    : reverse order
3    : flip values

पायथ गीथूब

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

यह एक प्रोग्राम है जो स्ट्रिंग को पहले तर्क के रूप में लेता है और दूसरे तर्क के रूप में कमांड का स्ट्रिंग। ऑनलाइन संस्करण में, आपको स्ट्रिंग्स को एक नई रेखा से अलग करना चाहिए, जैसे:

AbC
0321

स्पष्टीकरण:

                                    : z=input() (implicit)
jk                                  : join("", ...)
  u@[                 )sHw          : reduce(select from [...] the value at int(H), input(), ...)
     +eGPG                          : [ G[-1] + G[:1],
          +tGhG                     : G[1:] + G[1],
               _G                   : G[::-1],
                 ms!dG              : map(lambda d: int(not(d)), G) ]
                          smjCk2z   : first arg = sum(map(lambda k:convert_to_base(ord(k),2),z)

कुछ मैं बहुत निचोड़ नहीं सकता है: पायथ reduceस्वचालित रूप Gसे पिछले मूल्य के लिए उपयोग करता है , और Hअगले मूल्य के लिए।

— FryAmTheEggman
स्रोत
अपना स्पर्श खोना? CJam से सिर्फ 1 बाइट छोटी?
— ऑप्टिमाइज़र
@ ऑप्टिमाइज़र दरअसल, मैं उसी निर्देशों का उपयोग करके हरा सकता हूं। लेकिन मुझे नहीं लगा कि यह मान्य होगा क्योंकि चुनौती कहती है "अन्य पत्रों का उपयोग इसके बजाय किया जा सकता है lrfu, लेकिन उन्हें स्पष्ट रूप से प्रलेखित किया जाना चाहिए।" (जोर मेरा)
— मार्टिन एंडर
1

स्काला - 192

def f(i:String,l:String)=(i.flatMap(_.toBinaryString).map(_.toInt-48)/:l){
case(b,'l')⇒b.tail:+b.head
case(b,'r')⇒b.last+:b.init
case(b,'f')⇒b.map(1-_)
case(b,'u')⇒b.reverse}.mkString
— गिलाद होच
स्रोत
1

मतलाब (166 बाइट्स)

इस पत्र का उपयोग करता है abcdके बजाय lrfuक्रमशः।

function D=f(B,C)
D=dec2bin(B,8)';
D=D(:);
g=@circshift;
for c=C
switch c-97
case 0
D=g(D,-1);
case 1
D=g(D,1);
case 2
D=char(97-D);
case 3
D=flipud(D);
end
end
D=D';

अंतरिक्ष को बचाने के लिए यहां कुछ ट्रिक्स:

  • का उपयोग करते हुए abcdपत्र मुझे घटाना की सुविधा देता है 97एक बार, और उसके बाद पत्र बन 0, 1, 2, 3। यह switch- caseखंडों में स्थान बचाता है ।
  • circshiftएक-अक्षर अनाम फ़ंक्शन के रूप में परिभाषित करने से अंतरिक्ष की भी बचत होती है, क्योंकि इसका उपयोग दो बार किया जाता है।
  • के बाद से Dहोते हैं '0'और '1'वर्ण (ASCII कोड 48और 49), बयान D=char(97-D)के बीच उलट से मेल खाती है '0'और '1'मूल्यों। ध्यान दें कि इससे 97ऊपर उल्लिखित कुछ भी नहीं करना है।
  • जटिल-संयुग्म पारगमन 'का उपयोग स्थानान्तरण के बजाय किया जाता है .'।
— लुइस मेंडो
स्रोत
0

अजगर 2 - 179

b="".join([bin(ord(i))[2:]for i in input()])
for i in input():b=b[-1]+b[:-1]if i=="r"else b[1:]+b[0]if i=="l"else[str("10".find(j))for j in b]if i=="f"else b[::-1]
print"".join(b)
— KSFT
स्रोत
0

सी #, 418 बाइट्स

using System;using System.Collections.Generic;using System.Linq;class P{string F(string a,string o){var f=new Dictionary<char,Func<string,IEnumerable<char>>>{{'l',s=>s.Substring(1)+s[0]},{'r',s=>s[s.Length-1]+s.Substring(0,s.Length-1)},{'u',s=>s.Reverse()},{'f',s=>s.Select(c=>(char)(97-c))}};return o.Aggregate(string.Join("",a.Select(c=>Convert.ToString(c,2).PadLeft(8,'0'))),(r,c)=>new string(f[c](r).ToArray()));}}

प्रारूपित:

using System;
using System.Collections.Generic;
using System.Linq;

class P
{
    string F(string a, string o)
    {
        // define string operations
        var f = new Dictionary<char, Func<string, IEnumerable<char>>>
        {
            {'l', s => s.Substring(1) + s[0]},
            {'r', s => s[s.Length - 1] + s.Substring(0, s.Length - 1)},
            {'u', s => s.Reverse()},
            {'f', s => s.Select(c => (char) (97 - c))}
        };
        // for each operation invoke f[?]; start from converted a
        return o.Aggregate(
            // convert each char to binary string, pad left to 8 bytes and join them
            string.Join("", a.Select(c => Convert.ToString(c, 2).PadLeft(8, '0'))),
            // invoke f[c] on result of prev operation
            (r, c) => new string(f[c](r).ToArray())
        );
    }
}
— Krzysztof
स्रोत
0

जे, 164

([: >@:}. (([: }. >&{.) ; >@:{.@:>@:{. 128!:2 >@:}.)^:({.@:$@:>@:{.))@:(>@:((<;._1 ' 1&|."1 _1&|."1 -. |."1') {~ 'lrfu' i. 0&({::)@:]) ; ;@:([: (8$2)&#: a. i. 1&({::)))

प्रारूपित:

nextop=:([: }. >&{.)
exec=: (>@:{.@:>@:{.) apply"1 >@:}.
times=: ({.@:$@:>@:{.)
gapply=: [: >@:}. (nextop ; exec)^:(times) f.

tobin=: ;@:([: (8#2)&#:(a.i.1&{::))
g=:'1&|.';'_1&|.';'-.';'|.'
tog =:  g {~ ('lrfu' i. 0&{::@:])
golf=: gapply @: (>@:tog;tobin)  f.

उदाहरण

golf ('rfu';'b')
0 1 1 1 0 0 1 1


golf ('lruuff';'b')
0 1 1 0 0 0 1 0

(8#2)#: 98
0 1 1 0 0 0 1 0

golf ('lruuff';'AB')
0 1 0 0 0 0 0 1 0 1 0 0 0 0 1 0

tobin '';'AB'
0 1 0 0 0 0 0 1 0 1 0 0 0 0 1 0
— joebo
स्रोत
0

जावास्क्रिप्ट (E6), 163 167

पूरी तरह से इनपुट लचीलेपन का उपयोग करते हुए, 2 सरणी मापदंडों के साथ एक नामित फ़ंक्शन।

  • पहला पैरामीटर, 7 बिट वर्ण कोड के अनुरूप बाइट्स की सरणी
  • एससीआई अक्षर 'एफ', 'एल', 'आर', 'यू' -> 70, 76, 82, 85

फ़ंक्शन '1' और '0' से बना एक वर्ण स्ट्रिंग देता है

F=(a,s,r='')=>
  a.map(c=>r+=(128|c).toString(2).slice(-7))-
  s.map(c=>a=c<71?a.map(c=>1-c):c<77?a.concat(a.shift):c<83?[a.pop(),...a]:a.reverse(),a=[...r])
  ||a.join('')

उदाहरण के लिए f("b", "rfu") अनुवाद F([98],[82,70,85]), परिणाम है0111001

नोट वर्ण स्ट्रिंग का उपयोग करना जावास्क्रिप्ट में बहुत लंबा है! बाइट की गिनती 186

F=(a,s,r='')=>
  [for(c of a)r+=(128|c.charCodeAt()).toString(2).slice(-7)]-
  [for(c of(a=[...r],s))a=c<'G'?a.map(c=>1-c):c<'M'?a.concat(a.shift):c<'S'?[a.pop(),...a]:a.reverse()]
  ||a.join('')

उदाहरण F("b", "RFU") , परिणाम 0111001फिर से है

— edc65
स्रोत
0

रूबी, 151

f=->i,s{s.chars.inject(i.unpack("B*")[0]){|a,c|
a.reverse! if c==?u
a.tr!"01","10" if c==?f
a<<a.slice!(1..-1) if c==?l
a<<a.slice!(0..-2) if c==?r
a}}

काफी सरल। लूप पात्रों को गर्त में डालते हैं sऔर उनमें से किसी के लिए एक क्रिया करते हैं।

— britishtea
स्रोत
0

अजगर 2, 142

j="".join
f=lambda S,I:reduce(lambda s,i:[s[1:]+s[0],s[-1]+s[:-1],s[::-1],j([`1^int(c)`for c in s])][int(i)],I,j([bin(ord(c))[2:]for c in S]))

एप्रोच में मेरे पाइथ उत्तर के समान: मैं निर्देश स्ट्रिंग के मूल्य के आधार पर इसमें सभी स्ट्रिंग्स और इंडेक्स की एक सूची बनाता हूं जिसे कम करने का उपयोग करता हूं।

उपयोग:

0  ->  Rotate left
1  ->  Rotate right
2  ->  Reverse order
3  ->  Invert bits
— FryAmTheEggman
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.