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

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

एक पुलिस के जवाब को हेस्टैक प्रोग्राम के किसी भी उपसमुच्चय को हटाकर क्रैक किया जा सकता है, ताकि यह (जबकि अभी भी उसी भाषा में एक वैध प्रस्तुत करने के Needleबजाय) आउटपुट हो Haystack। जब तक आपका इरादा उपरोक्त बाधाओं से मान्य न हो, आपको ठीक वैसा ही समाधान खोजने की जरूरत नहीं है, जैसा कि पुलिस का इरादा है।

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

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

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

उदाहरण

यहां विभिन्न भाषाओं में सरल उदाहरण दिए गए हैं:

Ruby

Haystack: puts 1>0?"Haystack":"Needle"
Delete:        XXXXXXXXXXXXXXX
Needle:   puts "Needle"

Python 2

Haystack: print "kcatsyaHeldeeN"[-7::-1]
Delete:          XXXXXXXX        XX
Needle:   print "eldeeN"[::-1]

ध्यान दें कि हटाए गए वर्णों के सबसेट को सन्निहित नहीं होना चाहिए।

code-golf source-layout cops-and-robbers

— मार्टिन एंडर
स्रोत

यदि डाकू का उपयोग किया hashing, encryption or random number generationजाता है, तो इसकी अनुमति दी जाती है? (हालांकि संभावना छोटे)

— l4m2

11

जावास्क्रिप्ट, 85 बाइट्स (ES6)

क्रैक अरनॉल्ड का जवाब

f=(k=b=x=35)=>x--?f(k*4853461&268435455):k&2?'N'+(k^12408877).toString(b):'Haystack'

"सुई" डेमो

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

f=(k=b=x=35)=>x--?f(k*4853461&268435455):k&2?'N'+(k^12408877).toString(b):'Haystack'

console.log(f())

Expand snippet

व्याख्या

मूल कार्य था:

f=(k=b=x=35)=>x--?f(k*74837258394056219&268435455):k&2?'N'+(k^124038877).toString(b):'Haystack'

जो अधिक पठनीय है:

f = (k=b=x=35) => {
    if (x--) {
        return f(k*74837258394056219&268435455);
    } else {
        if (k&2) {
            return 'N'+(k^124038877).toString(b);
        } else {
            return 'Haystack';
        }
    }
}

ध्यान दें कि जब n=21625674, तब n.toString(35)है 'eedle'।

इनपुट में 35 को शायद एक उपसमूह में नहीं बदला जा सकता (क्योंकि हम सभी अक्षर 'डेल' को शामिल करने के लिए पर्याप्त आधार चाहते हैं, इसलिए हमें एक आधार की आवश्यकता है जो कम से कम 22 हो)। संख्या को बदलने के लिए तो कर रहे हैं 74837258394056219, 268435455और 124038877। हम उन्हें मूल संख्याओं के अंकों के सबसेट के साथ गठित ए, बी, सी, प्रत्येक के साथ बदलना चाहते हैं, जैसे कि फ़ंक्शन g(k) = (k * a & b), k=3535 बार से शुरू होने और पुनरावृत्त होने के बाद, और फिर सी के साथ XORed, देता है 21625674।

इस एक के लिए, एक सा सोच, के रूप में लंबाई छोटे (अधिक से अधिक कर रहे हैं के बाद aलंबाई 17 है, bऔर cलंबाई 9 है), मैं सिर्फ जानवर बल का इस्तेमाल किया :-) लिखा एक सी ++ प्रोग्राम के लिए सभी संभव संख्या उत्पन्न करने के लिए a, b, cसबसेट के रूप में गठन मूल संख्याओं में, सभी के माध्यम से पुनरावृत्ति aऔर b, और जांचें कि क्या cसेट में आवश्यक था। 15 सेकंड में चलाता है, और केवल उत्पादन होता है a=4853461, b=268435455, c=12408877(संख्या पता चला है bपरिवर्तित करने की आवश्यकता नहीं है)। मुझे यकीन नहीं है कि इस फ़ंक्शन को निष्क्रिय करने का एक अधिक चतुर तरीका है या नहीं।

— ShreevatsaR
स्रोत

5

हेडस्टैक , 82 बाइट्स

दरारें हाइपरन्यूट्रिनो का जवाब

0\1-c\
/    
?10F17+c8F+4+cd8F+3+c6-c1+c,c2+c8+c|
 0   \1++c,c|
F/c++2F8
c\8F+2+cd

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

— fireflame241
स्रोत

1

अच्छा! जिस तरह से मैंने इसे स्थापित किया था, मेरा मूल समाधान वास्तव 0में शुरुआत में ही हटा देना था: पी अच्छा था, हालांकि एक और दृष्टिकोण देखने के लिए! +1

— हाइपरएन्यूट्रीनो

5

ब्रेन-फ्लैक , 96 बाइट्स

Cracks फंकी कंप्यूटर मैन का जवाब ।

([((((()()())){}){}){}](()[()]({}([(((()()()){}))[]])[]({}({}()(((()(({}){}){}){}){}())))[]))())

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

यह एक मजेदार चुनौती थी।

शुरुआत जो धर्मान्तरित पर -24 yके aमूल में अब परिवर्तित करने के लिए प्रयोग किया जाता है eकरने के लिए Mहै, जो तब में बदल जाती है Nकरने के लिए पूरे अंत पाश बदलकर जगह में ())। पहले पुश किए गए पत्र kको eकेवल एक पुश-पॉप को हटाकर बदल दिया गया था जो इसमें 6 जोड़ता है। बाकी ज्यादातर बस जगह में गिर गए, रास्ते में कुछ हास्य के साथ (जिसमें एक कार्यक्रम जिसका आउटपुट था Meddle) शामिल है।

दो कार्यक्रमों की तुलना:

Haystack: ([((((()()())){}){}){}](()([()](()({}([((((()()()){})))[]])[]({}({})[{}]()({}((()(({}){}){}){}){}())))[][][][][][]))[]))(((()[]){}){({}[()()])}{})
Needle:   ([((((()()())){}){}){}](() [()]   ({}([ (((()()()){})) []])[]({}({}     ()(  ((()(({}){}){}){}){}())))[]              ))   ()  )

— Nitrodon
स्रोत

मुझे यकीन था कि यह इस

— H.PWiz

यह निश्चित रूप से काम करता है , लेकिन मैंने किसी तरह खुद को आश्वस्त किया Nथा कि 78 के बजाय 77 था, इसलिए मैंने इसे नहीं पकड़ा।

— नाइट्रोडॉन

तुम्हारा तो वैसे भी छोटा है।

— H.PWiz

दिलचस्प समाधान! मैंने मूल पोस्ट में अपना इच्छित समाधान जोड़ा है यदि आप इसे देखना चाहते हैं।

— पोस्ट रॉक गरफ हंटर

5

हास्केल

दरार @ लकोनी का जवाब ।

s=map;hay=zipWith;a=head;h=s a.(hay(scanr id).s a<*>s(succ<$))$words"Haysta ayst ackH ays k ayst"

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

मूल कोड:

hays=map;hay=zipWith;stack=head;h=stack{-
 hay.(hays.(stackany hay$or id).stack hay
<*>hays(sum$stack haystack<$>hay))-}$words
 "Haystack Hayst ackH aysta ckH aystac k"

हटाए गए वर्णों को अंडरस्कोर के साथ बदलना:

___s=map;hay=zipWith;__a__=head;h=s______
 _a_.(hay__(s__c_an_______r id).s____ _a_
<*>___s(su_____c________c_<$____))__$words
 "Haysta__ _ayst ackH ays__ _k_ ayst____"

कैसे Needleबनाया जाता है: कोड के अंत में स्ट्रिंग शब्दों में विभाजित है। प्रत्येक शब्द के पहले वर्ण को कई बार उतारा जाता है क्योंकि शब्द में वर्ण होते हैं, जैसे Haysta-> Hप्लस 6 वर्ण -> N।

— nimi
स्रोत

5

हेक्सागोनी , 17 बाइट्स, एच.पी.विज

]; एन @ सीएल, ई ;; (\ रों;।। _

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

मूल के साथ तुलना:

];N.@cl;e@;;(\H/;ya;_.>s.;t//<._  original
];N @cl;e ;;(\       . s.;     _  modified

दृश्य:

  ] ; N
 @ c l ;
e ; ; ( \
 . s . ;
  _ . .

व्याख्या

बोनस अंक - सभी 6 आईपी और सभी में से एक सेल का उपयोग करता है!

IP # 0 काले रास्ते में दाईं ओर सिर करके शुरू होता है ]।
फिर हम आईपी # 1 में संक्रमण करते हैं, जो लाल पथ के साथ सिर करता है, फिर से छपाई के Nसाथ N;फिर से वापस लपेटता है ]।
हम फिर आईपी # 2 में संक्रमण करते हैं, जो नीले रंग के रास्ते eपर चलता है, वर्तमान मेमोरी सेल में संग्रहीत होता है, फिर हरे रंग के पथ के साथ, निष्पादित (पर प्रतिबिंब के साथ \) ;;(;जो प्रिंट करता है ee, फिर से मेमोरी सेल eको dप्रिंट करता है d।
ऑरेंज पथ के साथ आईपी जारी रहता है, Nl;seजो वर्तमान मेमोरी सेल में प्रिंट lऔर स्टोर eकरता है। यह भूरे रंग के मार्ग के साथ जारी रहता है, जिसके eसाथ मुद्रण होता है;। इस बिंदु तक हम पहले ही प्रिंट कर चुके हैं Needle, इसलिए बाकी का काम खत्म हो चुका है। IP स्टोर करता है c, फिर हिट करता है ]। हम फिर आईपी # 3 में संक्रमण करते हैं, जो नीले रास्ते से गुजरता है , जिसमें उछलता है , उछलता है । फिर हम आईपी # 4 में संक्रमण करते हैं, जो हरे रास्ते के साथ सिर पर उछलता है , फिर ( और सकारात्मक होने के बाद ) तक शाखा करता है। अंत में, हम IP # 5 में संक्रमण करते हैं, जो बाद में स्टोर हो जाता है ।

\_]
_\]c
e@

— boboquack
स्रोत

अच्छा! यही इच्छित उपाय था।

— H.PWiz

4

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

क्रैक एगॉवर्स का जवाब

import numpy
print "".join([dir(numpy)[int(i)][0] for i in numpy.poly1d([-143/2e1,-31,14,131,61,184])(numpy.arange(-3,3))])

repl.it

तुलना:

print "".join([dir(numpy)[int(i)][1-0] for i in numpy.poly1d([-1*1433/252e1,-3232/1920.,4026./72/2/3.,613/(6*4.)*1,-4723./1.8e2,-9763/120.,-2689/(-1+5*17.),1+138*.4*2])(numpy.arange(-12/3,13%9))])
print "".join([dir(numpy)[int(i)][  0] for i in numpy.poly1d([-1  43 /2  e1,-3    1    ,               1     4    ,       1         3 1   ,  6     1       ,1   8  4  ])(numpy.arange(-   3, 3  ))])

मुझे बहुत सारे मज़ेदार हल मिले जो छपे हुए थे Meedleऔर Needlfएक बहुपदीय को ढँक कर अंकों के सूचकांकों के मध्य में जो प्रत्येक अक्षर से शुरू होता है Needle। फिर मैंने हाथ से मूल कार्यक्रम के सबसेट के साथ समान गुणांक खोजने की कोशिश की, लेकिन मैंने एक वैध समाधान खोजने के लिए मजबूर करने के लिए जानवर का सहारा लिया।

— jacobly
स्रोत

वाह! अच्छा काम! मुझे उम्मीद नहीं थी कि यह जल्द ही टूट जाएगा।

— agtoever

मैं मूल रूप से चुनौती numpy 1.13 के आधार पर है, जो मैं किसी भी repl वातावरण में नहीं मिला विकसित तो मैं numpy 1.12 के लिए यह पुनर्लेखन के लिए था ... ;-)

— agtoever

2

जावास्क्रिप्ट, 91 बाइट्स

_=>(+{}+[])[+[]]+([][[]]+[])[3]+([][[]]+[])[3]+([][[]]+[])[2]+(![]+['t'])[2]+([][[]]+[])[3]

यह दरार । यह वास्तव में मजेदार था।

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

let f =

_=>(+{}+[])[+[]]+([][[]]+[])[3]+([][[]]+[])[3]+([][[]]+[])[2]+(![]+['t'])[2]+([][[]]+[])[3]

console.log(f())

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

— मेरा सर्वनाम monicareinstate है
स्रोत

2

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

जोनाथन एलन का जवाब क्रैक

“¡#ɦṢÞɠ»ḟ“¡pṄ»

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

तुलना:

“¿ọ⁽ṅ*FỊ⁼g£¡#!ʋzoɦṪ£ṢÞḲÐɠ`”m3⁾“»jVḟ“¡!pṄ»
“          ¡#    ɦ  ṢÞ  ɠ      »  ḟ“¡ pṄ»

मैं œcशाब्दिक तार के विभिन्न सबसेट के माध्यम से पुनरावृति करता था, tr -dप्रत्येक संभव फ़िल्टर के लिए उपयोग किया जाता था , और grepसुई के लिए एड। इस धारणा का उपयोग करते हुए कि पहले स्ट्रिंग में उपयोग किए गए वर्णों में से कोई भी उत्तर में उपयोग नहीं किया गया था, इसे 15 सेकंड से कम समय में उत्तर खोजने दें।

— jacobly
स्रोत

बिल्कुल मैं एक मन में था Nebbed+ rubleबिना किसी के rub।

— जोनाथन एलन

2

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

उपयोगकर्ता 71546 का जवाब क्रैक करता है ।

a,b,s=2707385038437,0b10000000,""
while a>0:
 s=chr(a%b)+s
 a//=b
print s

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

इस कार्यक्रम के साथ हल किया ।

— jacobly
स्रोत

2

जावा (ओपनजेडके 8), 191 बाइट्स

क्रैक ल्यूक स्टीवन का जवाब

String d(){int h=3905055,m=55,s=15443;String d="0"+h*2+""+m*20+""+s*7,x="",y;for(int g=0;g<d.length();g+=3){y="";for(int e=0;e<3;e++)y+=d.charAt(e+g);x+=(char)Integer.parseInt(y);}return x;}

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

हटाए गए वर्ण:

int h=3609000-5055+911,m=557558,s=15441301-157*10000
       xx  xxx    xxxx     xxxx       x xxxxxxxxxxxx

इससे dमूल्यांकन होता है कि 078101101100108101कौन सा मंत्र है Needle।

— दूध
स्रोत

2

रूबी , 149 बाइट्स

इसे क्रैक करें: /codegolf//a/144790/74216

मॉड्यूल काफी छोटा था, इसलिए मैंने एक बहु-थ्रेडेड जन्मदिन की बात लिखी और सर्वश्रेष्ठ की उम्मीद की।

संपादित करें: और उसके बाद एक और भी छोटा जवाब मिला।

x='hxDKFQOoqJLuVNW'
s="n=x.to_i 36;x.bytjs.jach_cons(3){|a,b,c|n+=n*b%c;n*=a^b};puts n%8675309==1388649 ?'Njjdlj':'Haystack'"
eval s.tr ?j,s.size.chr

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

परिवर्तन:

x='yGwztsPXhxDkBKlCYdFjQnpUROfoHvqmTgbaJSLcEiZrIAuMVNW'
x='        hxD  K    F Q    O o  q     J L       u VNW'

# and here's some more variants for extra pwnage:
x=' G  tsPx     KlCYd  Qn U   o v mT  a SLc    I u  NW'
x='  w  s    D BKl  dF QnpU O        ba SLcEiZrI  MV  '
x='yGwz s Xh Dk K C  F  npU O  Hvq   b   L    rIAu V W'

— cab404
स्रोत

2

डीसी , 34 बाइट्स

93 9 2*+432212+ 47*4242160 7 2++*P

यह दरार । TIO ।

मैंने हेडस्टैक (5215583380252484459) और सुई (86197399743589) का संख्यात्मक प्रतिनिधित्व प्राप्त करके शुरू किया। अगला, मैंने बाद का एक कारक किया, जो 47 * 432323 * 4242169 है। इससे, उन नंबरों को फिर से बनाना काफी आसान था।

उपयोग किए गए पात्रों को चिह्नित करना:

6 93 3 9 2 2**+*+483622 1 2 3 3*+3*+89 47*+*+3 5 2* 269 158 9**107 97*2 4*++2 3 3*+42 14 2**+*+5*+5 2148 1 6 2*+*+68262 5 280 7 2 3 3*+5 2**+*+*+*+P
  XXX  XXX   XX  X X XX X X     X     XXXX                              X   X      XX X                    X                XXXXX     X     XX     X

— agtoever
स्रोत

gg! मुझे पता था कि बहुत अधिक संख्या में यह एक बुरा विचार था)

— cab404

@ cab404 बस जिज्ञासु: आपने 86197399743589 पर प्राप्त करने के लिए एक बहुत अलग गणना का उपयोग किया?

— agtoever

हाँ, यह बहुत लंबा है

— cab404

वाह। यह उल्लेखनीय है। यह एक और कोडगॉल्फ सवाल हो सकता है: एक अभिव्यक्ति में पात्रों को हटाकर एक निश्चित परिणाम प्राप्त करने के लिए कितने तरीके हैं ...

— पूरी तरह से

मुझे लगता है कि आम तौर पर सभी

— गंभीरताओं की

2

हेक्सागोनी , 19 बाइट्स, मार्टिन एंडर

[@;(...e<l.a;./;N>;

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

मूल से तुलना

H[@;(...e<l.a;./$.>;\sN;\ac.>).;;;._y
 [@;(...e<l.a;./   ;  N     >  ;

अनकहा कोड

  [ @ ;
 ( . . .
e < l . a
 ; . / ;
  N > ;

इसलिए, मैंने हेक्सागोनी में कभी कुछ नहीं लिखा है, लेकिन मुझे केवल 37 बाइट्स के साथ पता चला है कि मैं दरार के साथ आ सकता हूं। मार्टिन, मुझे आशा है कि आप जानते हैं कि मैंने यह पता लगाने की कोशिश में बहुत समय लगाया। :)

मैं गलत हो सकता हूं, लेकिन मैं समझाऊंगा कि मुझे क्या लगता है कि यह कोड क्या कर रहा है:

कार्यक्रम के साथ शुरू होता है [, जो स्वचालित रूप से आईपी # 5 पर जाता है। यह आईपी पश्चिम कोने में शुरू होता है, [एक बार फिर से आगे बढ़ता है, जो इसे आईपी # 4 में ले जाता है। यहाँ से, यह N;eतब दक्षिण-पूर्व कोने में जाता है और क्रियान्वित होता है ;, दूसरे के लिए दाईं ओर उछलता है, ;फिर लपेटता है (जिससे करंट घटता eहै a d। यह तब जारी रहता है (एक लपेट के साथ) ...;.तब उछलता है lऔर [एक आखिरी बार आईपी # 3 पर जाता है। यह कार्यान्वित ;, >करने के लिए उत्तर-पश्चिम में रीडायरेक्ट .तो< पश्चिम में पुनर्निर्देश करता है, मारता है e, लपेटता है ;, और उस पर समाप्त होता है@ ।

वर्बोज़ संस्करण

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

[   We move to the previous instruction pointer (starting at the e and moving NE)
e   e is entered into the current memory cell
(   Decrements the memory cell to d
[   We move to the previous instruction pointer (starting at the N and moving NW)
N   N is entered into the current memory cell
;   Outputs N
e   e is entered into the current memory cell (IP now wraps to the SE corner)
;   Outputs e
/   Mirrors IP to the east
;   Outputs e (IP now wraps to ( on NW edge)
(   Decrements the memory cell to d
... No-ops (IP now wraps to ; on SW edge)
;   Outputs d
.   No-op
/   Mirrors IP to the NW
l   l is entered into the current memory cell
.   No-op
[   We move to the previous instruction pointer (starting at the ; and moving west)
;   Outputs l
>   Redirects the IP NW
.   No-op
<   Redirects the IP west
e   e is entered into the current memory cell (IP now wraps to ; on the NE corner)
;   Outputs e
@   Terminates the program

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

मुझे खुशी है कि आपने सुई कार्यक्रम के लिए एक सामान्य षट्भुज आकार का उपयोग किया; मैं आकार 19 कार्यक्रमों (एक लंबाई -3 पक्ष षट्भुज के लिए) की जाँच कर रहा था जब मुझे एहसास हुआ कि आप किसी भी वर्ण को हटा सकते हैं और यह स्वतः ही षट्कोण को भर देगा।. को अंत में एस के देगा, जिससे यह दरार करने के लिए नाटकीय रूप से अधिक कठिन हो जाएगा। जैसा कि यह है, हेक्सागोनी इस चुनौती के लिए एक बुरी भाषा है क्योंकि (ज्यादातर) किसी भी चरित्र को हटा दिया जाता है जो कार्यक्रम के पूरे निष्पादन पथ को बदल देता है। यह कहा जा रहा है, मुझे इसके साथ आने की कोशिश करने में मज़ा आया, भले ही मैंने अंत में इसे मजबूर करने के लिए क्रूरता को खत्म किया। :)

— Jo।
स्रोत

अगर मैंने कुछ गड़बड़ की है, तो कृपया मुझे बताएं।

— जो।

अच्छा काम, यह बहुत सटीक लगता है। मैं इसे सप्ताहांत में मूल रूप से मेरे साथ तुलना कर रहा हूँ।

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

1

जावा (ओपनजेडके 8) , 151 बाइट्स

क्रैक केविन क्रूज़सेन का जवाब

v->{String h="H";int x=7;return new String(new byte[]{(byte)((-~-~-~-~-~-~1^x++*x)+15),new Byte("10"+h.length())})+new StringBuffer("elde").reverse();}

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

तुलना:

v->{String h="Haystack";int x=-7;return x<0?h:new String(new java.math.BigInteger(new byte[]{(byte)((~-~-~-~-~-~-~-~-~-~1^-x++*x)+151),new Byte("2"+"1+\"0+\"".length()+(x=h.length()*4/x)+"-x-7")}).toByteArray())+(new StringBuffer("hidden".substring(++x%3^4,--x-x--).replaceFirst("dd","e"+(char)(x*211%+93))).reverse());}
v->{String h="H       ";int x= 7;return       new String(                         new byte[]{(byte)(( -~-~-~-~-~-~      1^ x++*x)+15 ),new Byte("    1   0  "          +   h.length()    )        })               + new StringBuffer("    e                                 l          d    e"      )             .reverse() ;}

मुझे लगता है कि पिछले भाग का इरादा नहीं था।

— jacobly
स्रोत

लोल ओके, यह "एडल" बनाने का एक स्मार्ट तरीका है। जब मैं पहले से ही सोच रहा था कि मैंने पहले ही बहुत कुछ कर लिया है और समाधानों का भार संभव हो जाएगा ..;) इच्छित समाधान था:

v->{String h="Haystack";int x=7;return new String(new java.math.BigInteger(new byte[]{(byte)((~-~-~-~-~-~-~-~1^-x++*x)+15),new Byte(""+10+((x=h.length()*4/x)+x-7))}).toByteArray())+(new StringBuffer("hidden".substring(++x%3,x).replaceFirst("d","e"+(char)(x*21+3))).reverse());}

(पता नहीं क्यों मैंने बिगइन्टेगर को शामिल किया है क्योंकि सिर्फ बाइट-एरे काफी है ..) , लेकिन मुझे तुम्हारा अच्छा लगता है .. :)

— केविन क्रूज़सेन

1

ब्रेन-फ्लैक , 102 बाइट्स

(((((((((()()()){}){}){}){}()){}()))()()<>)(()()()){}())<>((()((){}<>)))(({})[(((()()){}())(){}){}()])

दरारें H.PWiz का जवाब ।

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

((((((((((()()()){}){}()){}){}()){}()))<({}[(()()()()){}])(([[]]({})<>)<>)>((()()())){}{})[()]))<[[]()]>((()){}){}((){}[][(<>){}<>])(<>){}(({}<>()[()])[(((()()()){}<[()]>)<(()){}>{}){}()])
 (((((((((()()()){}){}  ){}){}()){}()))      ()()                   <>)     (()()()) {}    () ) <      >((()      ((){}    <>)     )   )  (({}        )[(((()()  ){}  ()  )  () {}   ){}()])

— Nitrodon
स्रोत

1

लाइ , 21 बाइट्स

(78)"e"sl(100)"l"l&o;

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

दरारें LyricLy का जवाब ।

— Nitrodon
स्रोत

1

जावा ने जॉनाथन एस।

import java.util.*;interface Main{static void main(String[]args){Stack<Hay>s=new Stack();s.add(new Needle());System.out.println(s.get(s.indexOf(new Hay())+1).a);}}class Needle extends Hay{{a="Needle";}}class Hay{String a="Haystack";public boolean equals(Object o){return getClass().equals(o.getClass());}}

TiO

बस हेप को जोड़ने वाले लूप को हटा दें और स्टैक पर सुई के अलावा कुछ भी नहीं छोड़ा जाएगा।

— टाइटस
स्रोत

हा, एक अच्छा - मैं वास्तव में बस लूप को हटाने के बारे में नहीं सोचा था! equalsविधि को हटाने के रूप में अच्छी तरह से काम करता है।

— जोनाथन एस।

0

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

Kr."Dn2û"2+Kr."EL8"Z

यह दरार ।

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

— लीक नन
स्रोत

बेशक, अच्छा है। यह सिर्फ पहली कोशिश थी, इसलिए दरार काफी तुच्छ थी ;-)

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

0

T-SQL , phroureo , 757 बाइट्स द्वारा

seleCT 'Needle'

किसी भी तरह मुझे नहीं लगता कि यह इच्छित समाधान था। घिरे हुए पात्रों का उपयोग करता है {}:

create table a(l int,c int)
in{se}rt into a va{l}u{e}s (1,10),(2,1),(3,8),(4,0)
go
;CREATE FUN{CT}ION b(@ varchar(max)) returns varchar(max) as
begin return{ '}char('+@+'),'''','end 
go
;CREATE FU{N}CTION h(@ varchar(max),@a varchar(max), @b varchar(max), @c varchar(max), @d varchar(max), @e varchar(max), @f varchar(max), @g varchar(max), @h varchar(max))
r{e}turns varchar(max) as 
b{e}gin
return replace(replace(replace(replace(@,@a,@b),@c,@d),@e,@f),@g,@h)
end
{d}ec{l}ar{e} @x varchar(max),@ int=1,@y varchar(99)={'}'
,@D varchar(4)='Ha',@O varchar(4)='ys'
,@T varchar(3)='ta',@A varchar(4)='ck'
WHILE @<=4
BEGIN
set @y+=(SELECT dbo.b(c+100)from a where l=@)+' '
set @+=1
END
SELECT @x='select
left(dbo.h('''+@D+@O+@T+@A+''','+ left(@y,len(@y)-1) +'),char(56))'
execute(@x)

— रॉबर्ट फ्रेजर
स्रोत

0

पीएचपी

क्रैक टाइटस का जवाब

for($i=1;$c=H_aNyesetdalcek[$i+=2];)echo$c;

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

— Cinaski
स्रोत

हेडस्टैक (लुटेरों) में सुई खोजें

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

उदाहरण

जावास्क्रिप्ट, 85 बाइट्स (ES6)

"सुई" डेमो

व्याख्या

हेडस्टैक , 82 बाइट्स

ब्रेन-फ्लैक , 96 बाइट्स

हास्केल

हेक्सागोनी , 17 बाइट्स, एच.पी.विज

मूल के साथ तुलना:

दृश्य:

व्याख्या

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

जावास्क्रिप्ट, 91 बाइट्स

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

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

जावा (ओपनजेडके 8), 191 बाइट्स

रूबी , 149 बाइट्स

डीसी , 34 बाइट्स

हेक्सागोनी , 19 बाइट्स, मार्टिन एंडर

मूल से तुलना

अनकहा कोड

जावा (ओपनजेडके 8) , 151 बाइट्स

ब्रेन-फ्लैक , 102 बाइट्स

लाइ , 21 बाइट्स

जावा ने जॉनाथन एस।

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

T-SQL , phroureo , 757 बाइट्स द्वारा

पीएचपी