महत्वपूर्ण व्हाट्सएप: लुटेरे

Question

यह एक पुलिस और लुटेरों की चुनौती का हिस्सा है। पुलिस के हिस्से के लिए यहां जाएं ।

इस चुनौती के उद्देश्य के लिए, हम व्हाट्सएप को केवल लाइनफीड (0x0A) और रिक्त स्थान (0x20) के रूप में परिभाषित करेंगे । ध्यान दें कि अधिकांश भाषाएं और रेगेक्स फ्लेवर कई अन्य वर्णों को व्हाट्सएप के रूप में मानते हैं, एएससीआईआई रेंज के अंदर और बाहर दोनों, ताकि आप संबंधित बिल्ट-इन का उपयोग करने में सक्षम न हों।

लुटेरों की चुनौती

एक पुलिस के जवाब को एक वैध कार्यक्रम या फ़ंक्शन (चयनित भाषा में) में बदलकर क्रैक किया जा सकता है, जो कोड में व्हॉट्सएप डालकर एक इनपुट स्ट्रिंग से व्हॉट्सएप को हटाने का कार्य करता है। उदाहरण के लिए यदि आपको निम्नलिखित इनपुट मिले:

H e l l o,
 W o r l  d!

कार्यक्रम को आउटपुट देना चाहिए

Hello,World!

व्हॉट्सएप डालने के बाद, सॉल्यूशन की बाइट गिनती पुलिस के जवाब में बताई गई बाइट काउंट से अधिक नहीं होनी चाहिए। जब तक आपका इरादा उपरोक्त बाधाओं से मान्य न हो, आपको ठीक वैसा ही समाधान खोजने की जरूरत नहीं है, जैसा कि पुलिस का इरादा है।

यदि आप इसे प्रबंधित करते हैं, तो समाधान के साथ एक उत्तर पोस्ट करें, पुलिस के उत्तर से लिंक करें, और पुलिस के उत्तर पर एक टिप्पणी छोड़ दें।

डाकू जो सबसे पुलिस का जवाब देता है वह जीतता है। टूट पुलिस के जवाबों के आकार के योग से टूट जाते हैं (डाकू के पक्ष में जो लंबे समय तक प्रस्तुतियाँ तोड़ते हैं)।

प्रत्येक पुलिस उत्तर को केवल एक बार ही क्रैक किया जा सकता है, और निश्चित रूप से, आपको अपने स्वयं के उत्तर को क्रैक करने की अनुमति नहीं है। यदि पुलिस का जवाब फटा होने से पहले या बाद में अमान्य हो जाता है, तो उसे डाकू के स्कोर की ओर नहीं गिना जाता है।

Answer 1

हास्केल, 100 बाइट्स, लाइकोनी द्वारा

main=interact$id doid lines id words 
doid oi d o id=do
 iddoid<-do oi id
 oid<-do o iddoid
 do d oid

Answer 2

> <>, 40 बाइट्स, DanTheMan द्वारा

v <<
i/\
:=
:
:a?
0/>/
1?o
-=
="
?
;"
>^

वास्तव में काम करने का मज़ा।

इसे <> भाषा पर आज़माएँ

Comments

बहुत बढ़िया! मुझे खुशी है कि आपने इसे क्रैक करने का आनंद लिया।

— DanTheMan

Answer 3

जावास्क्रिप्ट ES6, 199 बाइट्स अर्नुलड द्वारा

s=>eval(atob`ISYgJiAtOkI8Qk97BRBeaxZFShoUZSsiOGkMenNy`.replace(/./g,(c,i)=>String.fromCharCode(c.charCodeAt()^(k+="     S    e c  r   e t     C    o   d  e   ".split(/\w/)[i%11].length)),k=0)).join``

मुझे बंटवारे "SecretCode"का एहसास हुआ कि मैं 11 नंबरों की तलाश कर रहा था जो कि (मुझे मान लिया गया) 33 थे। यह एक सितारों और सलाखों की समस्या है जहां रिक्त स्थान की संख्या सितारों और अक्षरों में "SecretCode"बार थे। मैंने यह देखने के लिए गणित किया कि कितने कॉम्बीनेशन करने की कोशिश की गई (1,917,334,783 संयोजन) और इसे पूरी तरह से लागू करने का फैसला किया, पूरे दिन लिया।

शायद एक समझदारी भरा तरीका इसके बारे में चले गए हैं उदाहरण देख रही है कि के लिए है, kहो गया है 33और 66क्रमश: सूचकांक 10 और 21 के लिए, लेकिन मैं आलसी हूँ।

Comments

अरे, अच्छा किया! ;-)

— अरनुलड

$/**/=/[ \n]/;s['sp'+'lit']($)... ओह, यह गंदा है।

— पैट्रिक रॉबर्ट्स

मामले में किसी को भी मेरे क्रूर बल प्रयास के बारे में उत्सुक था, यह pastebin.com/aN9Z1jVM

— पैट्रिक रॉबर्ट्स

Answer 4

सी, 475 बाइट्स रेक्स्रोनी द्वारा

#include<unistd.h>
#define a char
#define b *
#define c write
#define d stdin
#define e stdout
#define f read
#define g (
#define h )
#define i while
#define j if
#define k 0
#define l &
#define m ,
#define n =
#define o ;
#define p 1
#define gpml ml h
#define abo
#define ml d m p
#define jg d o abo
#define lb abo d
#define gf h abo c
#define jgm b e n
#define pml f g
#define gpm lb
int main(){a jg a jgm l jg i g pml k m l gpml h j g d!=' '&&gpm!='\n'gf g p m l gpml o}

मैं इनमें से कुछ को परिभाषित करना शुरू कर सकता हूँ :)

प्री-प्रोसेसर के बाद कोड कुछ इस तरह दिखता है:

int main(){
    char stdin;
    char *stdout = &stdin;
    while(read(0, &stdin, 1))
        if(stdin !='' && stdin!='\n')
            write(1, &stdin, 1);
}   

Comments

वाह! अच्छा कार्य। मुझे इसे अंत तक पढ़ने में भी परेशानी हो रही थी, और मैंने इसे लिखा।

— अक्टूबर को रेक्स्रोनी

@rexroni #defineaboने मुझे थोड़ी देर के लिए दूर फेंक दिया। पहले तो मुझे लगा कि यह होना ही है, #define ab oजो सिर्फ कुछ अतिरिक्त जोड़ देगा ;, लेकिन यह अंत के पास काम नहीं किया।

— रिले

हाँ, यह विशेष रूप से इसे कठिन बनाने के लिए चुना गया था :)

— rexroni

Answer 5

रूबी, 86 बाइट्स + 1 ध्वज = 87 हिस्टोक्रेट द्वारा

eval"( T $ }{(! // ; : 67 8 ? 32. && )".gsub(/ |(.)/){$1&&$&.ord.^($'.count(' ')).chr}

यह वास्तव में मजेदार था, स्ट्रिंग में दिए गए प्रत्येक चरित्र evalको चरित्र कोड से बदल दिया गया है (ord ) ^(...)स्ट्रिंग में शेष रिक्त स्थान की संख्या के खिलाफ XORed । परिणामी कोड है:

$_.tr!(''<<32<<10,'')

Answer 6

RprogN, द्वारा

इस चाल को करने के लिए प्रकट होता है

' ' ` R
"
" ` R

Comments

मैंने गलती से इसे हाहाकार करते हुए गोल्फ किया, नीचे 14 बाइट्स के लिए

— अल्फी गुडाक्रे

मैं वास्तव में उत्सुक हूं कि आपने इसे कैसे गढ़ा।

— 22

@ATaco कार्यक्रम सिर्फ 14 बाइट्स है। क्या आपने एक अनुगामी लाइनफीड या कुछ और गिना?

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

मेरे लिए 15 बाइट्स की तरह लगता है

— ATaco

@ATaco मैं गलत था, मैं ऑनलाइन संकलक पर नई कहानियों का परीक्षण नहीं कर सका, जिसके कारण मुझे लगा कि यह काम कर रहा है, लेकिन मैंने एलएफ शाब्दिक निकाल दिया था

— अल्फी गुडाक्रे

Answer 7

V, 37 बाइट्स, DJMcMayhem द्वारा

O     VrS200@"kIi|D@"A üî|D@"

Unprintables:

O     <esc>Vr<C-a>S200<esc>@"kIi<C-v><C-v><esc>|D@"<esc>A üî<esc>|D@"

TryItOnline

üवास्तव में मुझे एक पाश के लिए फेंक दिया, मैं दोनों यह उम्मीद कर रखा और îआदेशों किया जाना है।

O                 # Insert 5 spaces above this line
Vr<C-a>           # Change them all to <C-a>
S200<esc>         # Replace the line with 200
@"                # Play back the 5 <C-a>'s, 200 -> 205
k                 # ????
Ii<C-v><C-v><esc> # insert "i<C-v>" so our line is now "i<C-v>205"
|D@"<esc>         # Delete the line and then run it, which inserts "Í" (ASCII 205)
A üî<esc>         # Append " üî" so our line is "Í üî"
|D@"              # Delete the line and run it

Í üîमें वी का अनुवाद करता :%s/ \|\n//gहै, जो विश्व स्तर पर सभी व्हाट्सएप को हटा देता है। Íआदेश विकि पर है, और üऔर îकर रहे हैं |और nक्रमश: अपने उच्च बिट सेट के साथ

Comments

बहुत बढ़िया! मेरे पास इसका सटीक समाधान है। :)

— डीजेमैक्मे

Answer 8

सी, बीटसेग द्वारा 140 बाइट्स

#include<stdio.h>
int main(){int a=getchar();while(a!=EOF){//\a=getchar();
if(a!=10&&a!=32)//\\putchar(a^10^32);
putchar(a);a=getchar();}}

(मुझे यह भी उम्मीद है कि मैं यह अधिकार कर रहा हूं।)

Comments

निंजा मुझे एक मिनट से!

— कृतिका लिथोस

@KritiiLithos वही, जब यह एवर पॉप अप करने के लिए बस जमा करने वाला था ^ ^

— डेनकर

Answer 9

MATL, लुइस मेंडो द्वारा 22 बाइट्स

हालांकि मुझे यकीन नहीं हो रहा कि क्यों, यह काम करने लगता है

t' @ * 'dm1e5%M
dw%Y
(

मुझे यह देखना होगा कि क्या मैं यह काम कर सकता हूं। मुझे लगा कि टिप्पणियों को उनके बाद लाइन फीड करना था और फिर सही स्थानों में स्थान पाने की बात थी।

Comments

अच्छा, +1 मैंने अपने उत्तर में एक आंशिक स्पष्टीकरण जोड़ा :) :)

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

@StewieGriffin, स्पष्टीकरण के लिए धन्यवाद। मैं काम करने की कोशिश कर रहा था कि यह क्यों काम किया, लेकिन यह धीरे-धीरे चल रहा था। बहुत व्यापक डॉक्स लुइस :)

— मिक्यट

@ मिक्की आप जावा की तरह क्रिया का मतलब है: -पी अच्छा खुर काम!

— लुइस मेंडू

Answer 10

MATL, 22 21 लुइस द्वारा बाइट्स।

अंत में ... जब मैं एक स्पष्टीकरण लिख रहा था तो मिकी ने इसे क्रैक किया, इसलिए उसका जवाब "वैध" है। मैंने वैसे भी इस मेटा पोस्ट के अनुसार पोस्ट किया ।

---

Mऔर Yअनावश्यक हैं और टिप्पणी की जाती है। यह 4 व्हाट्सएप वर्ण जोड़ने के लिए पर्याप्त है, 5 नहीं।

t' @ *'dm1e5%M
dw%Y
(

यह अधिक कॉम्पैक्ट के बराबर है :

t' @ *'dm7dw(

आंशिक विवरण:

         % Implicit input
t        % Duplicate input
' @ *'   % String with ASCII-values [32   64   32   42]
d        % diff, giving [32  -32   10], 32 is space, 10 is newline
m        % ismember, checking if the character is 32 or 10
1e5      % 10000, but could just as well be 7
d        % Taking the diff of the scalar 1e5, returning an empty matrix []
w        % Swap stack in order to use ( below
(        % Equivalent to x(y)=[], where x is the input string, and y is the logical
         % vector found using ismember (m)
         % Implicit output

Comments

अच्छा खुर काम!

— लुइस मेंडू

धन्यवाद :) मैं शुरू होने से पहले MATL के बारे में कुछ नहीं जानता था ... मुझे लगता है कि मेरा स्पष्टीकरण पूरी तरह से सही नहीं है (लेकिन काफी करीब होना चाहिए?)। मुझे एक लंबा समय लगा, चूंकि 1e5या तो मुद्रित था 100000, या 1eएक कॉल था reshape, लेकिन तब क्या था 5? (मैं अब कि देखने %पंक्ति के अंत में है, इसलिए यह होगा 5M, नहीं एक पांच और एक Mसाथ ही, मैंने सोचा कि मैं करने के लिए किया था। Y(सब में पर एक पंक्ति सभी, एक बहुत अच्छा Matl ट्यूटोरियल :)।

— Stewie ग्रिफिन

स्पष्टीकरण पूरी तरह से सही है :-) हाँ, यह एक अच्छी (यदि केवल थोड़ी मुश्किल है) भाषा के साथ शुरू करने का तरीका है

— लुइस मेंडो

Answer 11

बेन्फुज -98, 65 बाइट्स निंजाल द्वारा

~v       >#@
 >::':'0--\'[';--!8v1+!
*1+j  !j,v         >#@

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

इसमें बड़ा मज़ा आया। मैंने कहा कि चूंकि कुछ दिशा-निर्देश बदलने वाले आदेश हैं और कोई ^<[]?xसमान या समान नहीं है, इसलिए इसे रैपिंग का उपयोग करना होगा। मैंने तब पायथन स्क्रिप्ट लिखी थी, जो j'एस' के लिए रिक्ति प्राप्त करने में मदद करती थी ।

कोड इनपुट ( ~) और इसे दो बार ( ::) दोहराकर काम करता है । यह तब 10 ( ':'0या ord(':') - ord('0')) और 32 ( '[';या ord('[') - ord(';')) घटाता है । फिर, दूसरा परिणाम तार्किक रूप से नकारा जाता है (1 यदि स्थान था, 0 अन्यथा) और एक 8 धक्का दिया जाता है।

अब वह हिस्सा आता है, जिसे छोड़ना चाहिए। 1+!अगली पंक्ति में जारी द्वारा छोड़ी गई है। #छोड़ देता है @। तार्किक रूप से नकारात्मक परिणाम (0 या 1) 8 से गुणा किया जाता है, और 1 जोड़ा जाता है।

कोड तब कूदता है कि कई (यानी 1 या 9) रिक्त स्थान प्लस एक अतिरिक्त आईपी चाल के रूप में। यदि चरित्र एक स्थान नहीं था तो यह समाप्त हो जाता है !। वर्ण कोड माइनस 10 तार्किक रूप से नकारा जाता है (1 यदि न्यूलाइन था, 0 अन्यथा)। jफिर कुछ भी नहीं छोड़ता है, और प्रिंट ( ,) कहा जाता है और लूप ऊर्ध्वाधर रूप से लपेटकर फिर से शुरू होता है।

यदि चरित्र एक स्थान था, तो नीचे की रेखा 32, 22ढेर के नीचे के रूप में फिर से लूप करती है । पहला jजंप 705 रिक्त स्थान है। फिर लाइन तीसरी बार लूप करती है। यदि स्टैक पर दो 10 से अधिक शेष हैं (कोड केवल उन लोगों को छोड़ देता है), पहले j100 रिक्त स्थान को कूदता है और लूप दोहराता है। अन्यथा, पहले jकूदता है !, एक शून्य को नकारा जाता है, jप्रिंट पर दूसरा कूदता है और कार्यक्रम जारी रहता है।

मैं इसे 59 बाइट तक नीचे करने में कामयाब रहा।

Comments

अपने हेडर में पुलिस की संख्या को सूचीबद्ध करना ठीक है (चूंकि टाईब्रेकर वैसे भी बड़े आकार का पुरस्कार देता है)।

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

Answer 12

सी # 6, 201 बाइट्स, दूध द्वारा

using System.Linq;
_=>string./**/
#if trueJoin
(/*"*//*/""/**//*/"*/",
#else
Concat(//*/,
#endif
from m in" "let p=$@"{@" 
"[1]}"from i in(_.Replace(p,@""))where!new[]{p[0]^32^10}.Contains(i)select@i);

repl.it डेमो

trueJoinपरिभाषित नहीं है, इसलिए केवल string.Concat()बनी हुई है।
pहै "\n"। p[0]^32^10अंतरिक्ष है। यह (थोड़ा) अधिक कठिन होता अगर यह p[0]^42या अन्य समान स्थिरांक होते।

Comments

जैसा कि मिल्क्स ने टिप्पणी की है कि यह C # 6+ की जरूरत है, अगर वे इसे बदलते हैं तो आप भी कर सकते हैं?

— TheLethalCoder

Answer 13

कोनिक ओ'ब्रायन द्वारा रेटिक्यूलर, 43 बाइट्स

ISBqv<>>$$4j
E :d/v$v?
c+91d/ v?E
;!?l$/o $

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

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

I               Push all the input on to the stack as a string
 S              Convert it into a character array.
  B             Turns that array into individual characters on the stack.
   q            Reverse the stack so the first letter is on top.
    v           Move down... 
    /           ...and turn left.
E :d            Duplicate the value and test if equal to space.

       v?       If it is a space we move down until we wrap to the top.
       >$$      Drop the test result and the space.
          4j    Jump over the next 4 commands (having wrapped to the start).
    v           Bringing us back to the first down arrow, ready to test the next char.

     v$         If it wasn't a space, drop the test result and move down.
c+91d/          Turn left and push a newline (char 10) on to the stack.
       v?E      If equal, we go down, following the same path as with the space.

     /          If not equal, turn down.
   l$/          Then turn left, drop the test result, and push the stack size.
;!?             If zero (the stack is empty) we terminate.
        o$      Otherwise wrap around, drop the stack size, and output the char. 
     /          Then turn down wrapping around to the top of the program.
    v<          Then turn left and down to start the process from the beginning again.

Comments

गीथूब विकी पर डॉक्स हैं।

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

अच्छा विचार! और प्रभावशाली है कि आपने विकी के बिना ऐसा किया: D

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

Answer 14

लेथलकोडर द्वारा सी #, 159 बाइट्स

using System.Linq;s=>string.Join("",string.Join("",s.Split(@" 
".Replace(new string((char)0x0D,1),"").ToCharArray())).Select(c=>c+""!=""?c+"":"").ToArray());

repl.it

पंक्ति 1 के अंत में स्ट्रिंग " \n"(स्पेस + न्यूलाइन) है।

/*Func<string, string> Lambda =*/ s =>
    string.Join("",                                                           // No-op
    string.Join("",                                                           // Join (without whitespace)
        s.Split(@" \n".Replace(new string((char)0x0D,1),"").ToCharArray())    // Split on whitespace
    ).Select(c=>c+""!=""?c+"":"").ToArray());                                 // No-op

Answer 15

मिंकोलंग v0.15, 88 बाइट्स क्रिति लिथोस द्वारा

$oI[dd" "=$r'10'=1J,? 1R]r$O3.14
$$$
Cdollars             >
$$$
Ceverywhere           >x

व्याख्या

                               # Layer 1
$o                             # input chars onto stack
  I                            # stack length pushed to stack
   [                    ]      # loop popped TOS times (length of string)
    dd                         # duplicate, duplicate
      " "                      # push space to stack
         =                     # equality check
          $r                   # swap
            '10'               # number 10 to stack (LF char)
                =              # equality
                 1J            # or
                   ,           # not
                    ?          # if true jump next
                               # drop to layer 2
                      1R       # rotates the stack 1 time
                         r     # reverse the stack
                          $O   # output the stack
                             . # stop
$$$                            # Layer 2
                     >         # shift right and then drop to layer 3
$$$                            # Layer 3
                      >x       # shift right, pop char off stack and drop to Layer 1 (end loop)

Comments

अच्छी तरह से यह खुर में किया! मैं उम्मीद कर रहा था कि Cचूक भ्रामक होगी, लेकिन फिर भी अच्छा काम!

— कृति लिथोस

@KritiiLithos ईमानदार होने के बाद जब मैंने परतों को विभाजित किया और महसूस किया कि अधिकांश कार्य शीर्ष परत में किया गया था, तो यह आसान हो गया। मैंने ऐसा करने वाली भाषा के बारे में थोड़ा सीखा, इसलिए धन्यवाद :)

— मिकट