11

यह लुटेरों का धागा है। पुलिस का धागा यहाँ है ।

आपकी चुनौती यह है कि पुलिस के थ्रेड से अनियंत्रित सबमिशन लेना और ढूंढना है कि किस इनपुट या इनपुट के लिए प्रोग्राम प्रिंट करेगा Hello, World!और एक नई लाइन। पूंजीकरण, रिक्ति और विराम चिह्न सटीक होना चाहिए।

जब आपने उनका कोड क्रैक किया है तो कृपया पुलिस के सबमिशन पर टिप्पणी करें।

code-challenge cops-and-robbers hello-world

— एमडी एक्सएफ
स्रोत

12

बैसे Sisyphus द्वारा

मूल कोड:

[[ ! "${1////x}" =~ [[:alnum:]] ]]&&[[ $# = 1 ]]&&bash -c "$1"

इनपुट:

__=; (( __++, __-- ));
(( ___        = __,        ___++));
(( ____       = ___,       ____++));
(( _____      = ____,      _____++));
(( ______     = _____,     ______++));
(( _______    = ______,    _______++));
(( ________   = _______,   ________++));
(( _________  = ________,  _________++));

${!__##-} <<<\$\'\\$___$______$_______\\$___$______$_____\\$___$_______$__\\$___$_______$_________\'\ \$\'\\$___$___$__\\$___$______$_______\\$___$_______$______\\$___$_______$______\\$___$_______$_________,\ \\$___$____$_________\\$___$_______$_________\\$___$________$____\\$___$_______$______\\$___$______$______\\$__$______$___\'

स्पष्टीकरण:

यह एन्कोडिंग "इको हैलो, वर्ल्ड!" ऑक्टल एस्केप सीक्वेंस (\ xxx) के रूप में।

सिवाय आप भी संख्याओं का उपयोग नहीं कर सकते हैं, इसलिए पहला भाग संख्या 0-4 के लिए चर बनाता है। आप उन लोगों का उपयोग कर सकते हैं जो अष्टक अनुक्रमों के साथ एक स्ट्रिंग का निर्माण करते हैं जो आपको वास्तविक कमांड देने के लिए मूल्यांकन करेंगे।

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

लेकिन वैसे भी, आप $0सीधे नहीं कह सकते । इसके बजाय, $__शामिल नाम की $0( "0"), और आप का उपयोग करने अप्रत्यक्ष विस्तार यह (उपयोग कर सकते हैं ${!__}की सामग्री को संदर्भित करता है $0)।

और वह, आखिरकार, आपको आपकी ज़रूरत के सभी टुकड़े देता है।

— ArchDelacy
स्रोत

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! मैंने पुलिस के जवाब पर एक टिप्पणी छोड़ दी है। इच्छुक के लिए टीआईओ

— डेनिस

अच्छा! मेरा समाधान अलग दिख रहा था, लेकिन एक ही विचार का इस्तेमाल किया - एक ऑक्टल स्ट्रिंग का निर्माण करना और डॉलर के एकल उद्धरण वाक्यविन्यास का उपयोग करना, और अप्रत्यक्ष का उपयोग करना। अच्छी तरह से किया =)

— शोरशीफ

4

05AB1E , अदनान

•GG∍Mñ¡÷dÖéZ•2ô¹βƵ6B

-107

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

कैसे?

•GG∍Mñ¡÷dÖéZ•        - big number
             2ô      - split into twos (base-10-digit-wise)
               ¹β    - to base of input
                   B - convert to base (using 012...ABC...abc...):
                 Ƶ6  -   107 (ToBase10(FromBase255(6))+101 = 6+101 = 107)

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

नकारात्मक आधार ... सुंदर ...

— आउटगॉल्फ

3

पूरी तरह से , अजगर 2

एक समाधान है

'Uryyb, Jbeyq!'

— एड हॉक गार्फ हंटर
स्रोत

स्पष्टीकरण? ----

— एमडी XF

3

पायथ : मिस्टर एक्सकोडर

"abcdefghijklmnopqrstuvwxyz"

Gनिर्मित में निचली वर्णमाला के लिए है। कोड उस के खिलाफ समानता के लिए जाँच करता है।

— totallyhuman
स्रोत

1

अच्छी दरार :)))

— श्री एक्सकोडर

3

जेली: EriktheOutgolfer

〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ

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

sLÆ½$Xṙ5O½Ọ

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

व्याख्या

मूल कोड को इस तरह समझाया जा सकता है:

sLÆ½$Xṙ5O½Ọ  Main link; argument is z
s            Split z into n slices, where n is:
    $
  Æ½         The integer square root of
 L                                      the length of z
     X       Random of a list. Returns a random row of the input put into a square
      ṙ5     Rotate the list left 5 times
        O    Get codepoints
         ½   Floating-point square root
          Ọ  From codepoints

तो, बस "हैलो, वर्ल्ड!" और कोडपाइंट प्राप्त करें, उन्हें वर्ग करें, कोडपॉइंट पर वापस जाएं, दाएं 5 बार घुमाएं, और फिर वर्ग को परिणाम दें और समतल करें।

— HyperNeutrino
स्रोत

3

स्टेवी ग्रिफिन द्वारा ओक्टेव

निश्चित नहीं है कि यह सही समाधान है (TIO पर यह \00चरित्र को प्रिंट करता है), लेकिन मेरे octave-cliशेल में यह इस तरह दिखता है:

मूल चुनौती में भी यह कहा गया है कि प्रिंट नथिंग (या अशक्त-वर्ण) है , इसलिए यदि कुछ भी समान नहीं है \00तो यह ठीक होना चाहिए।

[72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33, 0]

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

— ბიმო
स्रोत

खोजें, किस इनपुट या इनपुट के लिए, प्रोग्राम हैलो, वर्ल्ड प्रिंट करेगा! और एक नई

— पंक्ति

लेकिन ऐसा नहीं है कि चुनौती क्या दिखती है, अगर ऐसा है तो मुझे बहुत आसान होगा (अंतिम 0को प्रतिस्थापित करें 10)।

— ।

@BruceForte यही है क्या चुनौती पूछता है: "आपका चुनौती एक प्रोग्राम या समारोह है कि, एक निश्चित इनपुट के साथ, सटीक स्ट्रिंग प्रिंट लिखना है Hello, World!और एक नई पंक्ति।" चुनौती से एक सटीक उद्धरण है। और वास्तव में, यह उत्तर को तुच्छ बनाता है।

— hvd

@hvd हाँ, लेकिन अगर आप ओपी की छवि को देखते हैं तो उसका समाधान नहीं होता, यहीं से मुख्य भ्रम होता है।

— ।

1

@HyperNeutrino FWIW यह वही है जो मुझे लगता है कि समाधान की इच्छित शैली है।

— जोनाथन एलन

3

रेक्स्रोनी द्वारा पायथन 3

print("Hello, World!") or __import__('sys').exit(0)

जल्दी निकलने से किसी भी त्रुटि को रोकें।

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

— Sisyphus
स्रोत

3

जावास्क्रिप्ट (ईएस 6) एपिलॉन डांटलर द्वारा

{length:1, charCodeAt:()=>(e='Hello, World!', String.fromCharCode=()=>'')}

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

यह बहुत आसान था।

मैंने देखा कि कोई भी स्ट्रिंग इनपुट आउटपुट के लिए संभव नहीं होगा Hello, World!क्योंकि अंदर की पूरी चीज String.fromCharCodeकेवल 4 के गुणकों को लौटाएगी, और !इसमें 33 का चार्ट कोड होगा। इसलिए स्पष्ट रूप से हमें सिर्फ पूरे प्रोग्राम को हैक करना होगा। जावास्क्रिप्ट में अंतर्निहित हैकिंग तुच्छ है यदि कोई उन्हें रोकने की कोशिश नहीं करता है (और यहां तक कि अगर कोई ऐसा करता है, तो आमतौर पर बहुत सारे वर्कअराउंड होते हैं ...)।

— voile
स्रोत

3

जावास्क्रिप्ट (ES6), Voile

सरल प्रॉक्सी जो केवल वांछित चरित्र को हर 3 बार लौटाता है जिसे यह कहा जाता है।

var i = 0;
var string = "Hello, World!";
var proxy = new Proxy([], {
  get: function(target, property) {
    if (!(++i%3)) {
      return string[property];
    }
    return [1];
  }
});

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

— Birjolaxew
स्रोत

2

हाँ, यह इच्छित उपाय है :) प्रॉक्सी को और अधिक प्यार की आवश्यकता है।

— वॉयल

3

रूबी, हिस्टोक्रेट द्वारा

जादू इनपुट है: 1767707618171221 30191World!

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

स्पष्टीकरण:

संख्या 1767707618171221एक प्रमुख है, और, बेस 36 में लिखा है "hello"। जब पूंजी लगाई जाती है, तो यह उत्पादन होता है"Hello" , जिसका उपयोग करके मुद्रित किया जाता है$><<
लाइन इनपुट में $><<", #$'"if/30191/संख्या 30191की तलाश करती है और एक कॉमा, एक अंतरिक्ष से बना एक स्ट्रिंग को रोकने के लिए लिखती है, और इनपुट के बाद जो कुछ भी है 30191(का उपयोग करते हुए $POSTMATCH, जो इसके लघु संस्करण द्वारा यहां संदर्भित है $')।

— क्रिस्टियन लुपस्कू
स्रोत

3

लुआ 5.1 तहमी द्वारा

इसे पहले तर्क के रूप में पास करें:

C=("").char;_G[C(112,114,105,110,116)](C(72,101,108,108,111,44,32,87,111,114,108,100,33))

मूल कोड मानते हुए tehtmi.lua, फ़ाइल में , चलाएं (बैश या इसी तरह के शेल में):

lua tehtmi.lua 'C=("").char;_G[C(112,114,105,110,116)](C(72,101,108,108,111,44,32,87,111,114,108,100,33))'

यह Lua 5.3 पर भी काम करता है, जो कि TIO का उपयोग करता है, तो आप इसे ऑनलाइन क्यों नहीं आज़माते ? मैंने "PUC-Rio's Lua 5.1" कोर का उपयोग करने वाले कार्यान्वयन पर परीक्षण नहीं किया है (क्योंकि मुझे वास्तव में कोई जानकारी नहीं मिल सकती है), लेकिन मेरा समाधान शायद वहां भी काम करता है।

कैसे?

यह कोड के रूप में पहला तर्क चलाता है, लेकिन केवल अगर इसमें 5 से कम लोअरकेस वर्ण हों।

चाल चलनी है print("Hello, World!")। दूसरा तरीका यह चलाया जा सकता है _G["print"]("Hello, World!"), जो केवल स्ट्रिंग्स का उपयोग करता है।

लेकिन हम लोअर-काउंट प्रतिबंध के कारण सीधे स्ट्रिंग का उपयोग नहीं कर सकते हैं, हालांकि, आप ("").charफ़ंक्शन प्राप्त करने के लिए चला सकते हैं string.char, जो बाइट्स की एक श्रृंखला से स्ट्रिंग में बदल सकते हैं। मैंने इसे एक अपरकेस वैरिएबल में असाइन किया है (इसलिए हम सीमा नहीं मारते हैं) इसलिए हम इसका उपयोग ऊपर printऔर दोनों तरह के Hello, World!स्ट्रिंग्स के निर्माण के लिए कर सकते हैं।

— Neui
स्रोत

आह, अच्छा किया! मैं nextइसके बजाय का उपयोग करने के बारे में सोच रहा था charजो पुनरावृत्ति क्रम के यादृच्छिकरण के कारण Lua 5.3 पर काम नहीं करता है।

— तेहमती

3

Voile द्वारा जावास्क्रिप्ट (ES6)

इनपुट में यह स्ट्रिंग होना चाहिए:

e(
`\
_\
=\
>\
"\
H\
e\
l\
l\
o\
,\
 \
W\
o\
r\
l\
d\
!\
"\
+\
\`
\`
`)

इसे प्रयोग करके देखें:

const e=eval,p=''.split,c=''.slice,v=[].every,f=s=>(t=c.call(s),typeof s=='string'&&t.length<81&&v.call(p.call(t,`\n`),l=>l.length<3)&&e(t)(t))

input='e(\n`\\\n_\\\n=\\\n>\\\n\"\\\nH\\\ne\\\nl\\\nl\\\no\\\n,\\\n \\\nW\\\no\\\nr\\\nl\\\nd\\\n!\\\n\"\\\n+\\\n\\`\n\\`\n`)'
console.log(f(input))

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

यदि आप आउटपुट के लिए अनुगामी न्यूलाइन आवश्यकता के बारे में परवाह नहीं करते हैं, तो आप इसकी जगह अंतिम 6 लाइनों को बदल सकते हैं:

!"
`)

मैंने यह कैसे किया

इनपुट पर प्रतिबंध यह है कि यह एक स्ट्रिंग है, प्रत्येक पंक्ति दो बाइट्स लंबी या कम है, और कुल लंबाई 80 बाइट्स या उससे कम है। सही ढंग से समझने के बाद मेरा पहला प्रयास यह था:

_
=>
`\
H\
e\
l\
l\
o\
,\
 \
W\
o\
r\
l\
d\
!
`

^{नोट: \s इनपुट में स्ट्रिंग में नईलाइन्स को अनदेखा कर रहे हैं। यह उत्तर के लिए अविश्वसनीय रूप से महत्वपूर्ण है, और मैं विश्वास नहीं कर सकता कि मैं दुर्घटना पर इस पर ठोकर खाई। (मैं इससे पहले परिचित था लेकिन इसके बारे में भूल गया था)}

लेकिन यह काम नहीं किया, क्योंकि =>तर्क के रूप में एक ही पंक्ति पर होना चाहिए। शुक्र है, मुझे एक स्ट्रिंग में कुछ इसी तरह लपेटने और एक इनपुट में इसे कम करने के लिए अपने इनपुट में एक सांचा डालने का विचार था, जिसके परिणामस्वरूप मेरा अंतिम उत्तर मिला। इनपुट में eval होने के बाद, निम्नलिखित एक स्ट्रिंग के रूप में उत्पन्न होता है (जो तब किसी कार्य के लिए eval'd और फिर रन होता है):

_=>"Hello, World!"+`
`

यह दरार करना वास्तव में कठिन था, लेकिन मैं अंत में सफल रहा।

^{इसके अलावा, पहले कभी दरार!}

— DanTheMan
स्रोत

3

मूल रूप से एमडी एक्सएफ द्वारा

मुझे लगता है कि यह हमेशा खतरनाक होता है, लेकिन मुझे लगता है कि मेरे पास एक दरार है, लंबित है कि मैं सही हूं कि दुभाषिया में एक बग है (जो मैंने अभी संकलित किया है)।

मेरा इनपुट

0 1 0 1 0 1 0 1 1 0 0 0 0

आउटपुट Hello, World!\n\n\n\n\n\n\n\n\n\n.....नई लाइनों के साथ है।

लेकिन मैंने कोड का अंतिम भाग देखा:

:1/1+1$(@6)7

नोटपैड को 0x0A(न्यूलाइन) एक डरावने तरीके से सेट करता है , 7 (इनपुट फेस) का सामना करने के लिए इनपुट पढ़ता है, और फिर 6 चेहरे (नोटपैड फेस) को बार-बार प्रिंट करता है जब तक कि 7 चेहरा शून्य न हो। यदि आप चेहरे को 7 से शून्य पर सेट करते हैं, तो आपको केवल एक न्यूलाइन मिलना चाहिए। हालाँकि, मुझे अनंत नई ख़्वाहिशें मिलीं और मेरा 13 वां इनपुट एक शून्य था, और मैं यह सत्यापित कर सकता हूं कि लूप में "7 नंबर से प्रिंट नंबर" डालने से 7 चेहरा हमेशा शून्य होता है:

:1/1+1$(@6%7)7

फिर यह \n0जोड़े को प्रिंट करता है ।

मैं मूल रूप से गिथब पृष्ठ पर चश्मा देख रहा हूं और यह व्यवहार एक बग की तरह एक भयानक लग रहा है। एक से मूल कार्यक्रम के अंतिम वर्ण बदलने 7एक करने के लिए 0अपेक्षित व्यवहार में परिणाम है। TIO दुभाषिया एक ही गलत व्यवहार प्रदर्शित करता है।

— rexroni
स्रोत

अब तय किया जाना चाहिए, जैसे ही डेनिस क्यूबिक रूप से खींचता है यह टीआईओ पर तय किया जाएगा।

— एमडी एक्सएफ

2

सीजाम , एरिक द आउटगोलर

q5/:i:c

00072001010010800108001110004400032000870011100114001080010000033

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

कैसे?

q       - Take input (string)
 5/     - split into chunks of five
   :i   - cast to integers
     :c - cast to characters

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

2

सी # (.NET कोर) , ग्रेज़गोरज़ पुलावस्की

मैंने जो समाधान पाया, वह अप्रमाणित पात्रों का बहुत उपयोग करता है, इसलिए इसे यहाँ पेस्ट करने का प्रयास अच्छा नहीं हुआ। इनपुट के लिए बाइट मान हैं:

109, 89, 4, 121, 3, 11, 8, 29, 37, 38, 27, 25, 72, 4, 4, 4, 3, 3, 3, 4, 4, 37, 3, 27, 4, 3

या स्ट्रिंग संस्करण TIO लिंक के इनपुट क्षेत्र में उपलब्ध है।

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

मूल कार्यक्रम इनपुट में अलग-अलग पात्रों को ले जाएगा, फिर इनपुट को उल्टा कर दो सूचियों के तत्वों को गुणा करें। इस प्रकार मैंने एक स्ट्रिंग 26 वर्णों का निर्माण किया, जहां पहले 13 अक्षर अलग थे, पिछले 13 अक्षर सभी पहले 13 में भी दिखाई दिए, और प्रत्येक जोड़े के सूचकांक [i, 26-i]को i-th वर्ण के बाइट मान से गुणा किया गया Hello, World!।

— कामिल दकरी
स्रोत

अच्छा काम! आप टेक (ए। फ़र्स्ट () - 33) ट्रैप को छोड़ने में कामयाब रहे। इसने मुझे यह भी महसूस कराया कि मैं रिवर्स पर डिसक्टिक्ट को भूल गया, लेकिन ओह अच्छा है, फिर भी मुझे लगता है कि एक अच्छी चुनौती के लिए बनाया गया था। इसके अलावा इसमें 255% था ताकि आप उच्च संख्या का उपयोग कर सकें, मुद्रण योग्य ASCII में।

— ग्रेज़गोरज़ पुलावस्की

2

Ly , LyricLy

n[>n]<[8+o<]

2 25 92 100 106 103 79 24 36 103 100 100 93 64

इसे यहाँ आज़माएँ (हालाँकि पेज नईलाइन को प्रस्तुत नहीं करता है)।

nइनपुट लेता है, रिक्त स्थान पर विभाजित करने की कोशिश करता है और चींटियों को कास्ट करता है, ये स्टैक पर डाल दिया जाता है। oअध्यादेशों को इंगित 8+करता है , और वही करता है जो कोई सोचता है। तो रिक्त स्थान से विभाजित क्रम में कोडपॉइंट्स की तुलना में इनपुट 8 कम होना चाहिए।

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

यह एक अनुगामी न्यूलाइन नहीं छापता है, क्या यह?

— LyricLy

आह उफ़, आसानी से सुधारने योग्य!

— जोनाथन एलन

... वास्तव में यह है? मुझे लगता है कि 2यह काम करेगा - क्या सिर्फ हरोकू पेज इसका प्रतिपादन नहीं कर रहा है?

— जोनाथन एलन

1

हाँ, 2 कामों को जोड़ना। पृष्ठ केवल अनुगामी newlines को प्रस्तुत नहीं करता है।

— LyricLy

2

फेलिक्स पालमेन द्वारा सी (जीसीसी)

मूल कोड:

#define O(c)(((char**)v)+c)
#define W(c)*(O(c)-**O(2)+x)
main(x,v){puts(W(42));}

तर्क:

"Hello, World!" ","

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

स्पष्टीकरण:

W(c)तर्क सूची से एक स्ट्रिंग के पते की गणना कर रहा है। यह cth तर्क ( O(c)) के पते से शुरू होता है , जो इस मामले में 42 वां तर्क है, और फिर **O(2)पूर्णांक के रूप में दूसरे तर्क ( ) के पहले वर्ण को घटाता है , और फिर जोड़ता हैx , जो कि तर्कों की संख्या है।

W(c)दूसरे तर्क का उपयोग करता है, इसलिए आपको पता है कि उनमें से कम से कम 3 (0, 1, 2) होने की आवश्यकता है। फिर "हैलो, वर्ल्ड!" पहले तर्क में जा सकते हैं, और फिर उस तर्क को संबोधित करने के लिए आपको एक ऐसे चरित्र की आवश्यकता होती है, जिसका ASCII मान "42-x + 3 = 1" समीकरण में फिट बैठता है। ऐसा होता है ","।

— ArchDelacy
स्रोत

महान स्पष्टीकरण, मैं अपने पद को जल्द से जल्द संपादित करूँगा जैसे ही मैं पीसी पर आता हूँ :)

— फेलिक्स पालमेन

2

जावास्क्रिप्ट: ThePirateBay

मैं पार्स की गई वस्तुओं के तरीकों valueOf()और toString()तरीकों को ओवरराइड करता हूं ताकि जबरदस्ती विफल हो जाए TypeError।

{"valueOf": 7, "toString": 7}

— Maltysen
स्रोत

12

उम्म, मैं समझ नहीं पा रहा हूं। कृपया विस्तृत करें या कुछ और? विशेष रूप से dalksdjalkdjaS djalksdjalksdja हिस्सा, यह कुछ हद तक मुझे भ्रमित करता है।

— आउटगॉल्फ

@EriktheOutgolfer मैंने स्पैम भाग को संपादित किया, लेकिन मुझे नहीं पता कि यह वहां क्यों था।

— NoOneIsHere

@EriktheOutgolfer ओह लोल। वह मेरे जवाब को ऑटो-कॉन्वेंट से एक टिप्पणी तक रोकने के लिए पारित कर रहा था।

— माल्टीसेन

1

@ माल्टीसन वैसे तो एक एडिट बटन वहीं है जो अगली बार उपयोगी हो सकता है;)

— एरिक आउटलेगर

2

6502 असेंबली (C64) - फेलिक्स पालमेन

सही उत्तर है, 52768,23

स्पष्टीकरण थोड़ा शामिल है।

00 c0                          ;load address
20 fd ae      jsr $aefd        ; checks for comma
20 eb b7      jsr $b7eb        ; reads arguments

कोड पहले एक अल्पविराम (वाक्यविन्यास आवश्यकता) के लिए जाँच करता है और फिर दो तर्कों में पढ़ता है, जिनमें से पहला एक WORD है, मेमोरी लोकेशन 0014 और 0015 में थोड़ा-एंडियन संग्रहित है, जिसका उत्तरार्द्ध एक्स रजिस्टर में संग्रहीत है।

8a              TXA            ;Store second argument into A (default register)
0a              ASL            ; bitshifts the second argument left (doubles it)
45 14           EOR $14        ; XOR that with the low byte of first argument
8d 21 c0        STA $c021      ; Drop that later in the program

कार्यक्रम को फिर से लिखने के लिए हमारे इनपुट का उपयोग करते हुए यह बहुत चालाक है। यह अंततः कार्यक्रम के अंत में आउटपुट लूप के लिए काउंटर को फिर से लिखता है।

45 15           EOR $15        ; XOR that with the high byte of the first argument
85 15           STA $15        ; Put the result in $15
49 e5           EOR #$e5       ; XOR that with the number $e5
85 14           STA $14        ; Put that in $14

यहाँ कुटिल भाग आता है:

8e 18 d0        STX $d018      ; stores the original second argument in d018

C64 पर, d018 एक बहुत ही महत्वपूर्ण बाइट है। यह स्क्रीन के आउटपुट से जुड़ी चीजों के लिए संदर्भ बिंदुओं को संग्रहीत करता है। अधिक जानकारी के लिए यहाँ देखें । यदि यह गलत मान लेता है, तो यह आपके C64 को क्रैश कर देगा। अपेक्षित मिश्रित ऊपरी और निचले अक्षरों को प्रिंट करने के लिए, यह $ 17 होना चाहिए।

अब हम अपना आउटपुट लूप शुरू करते हैं:

a0 00               ldy #$00       ; zeroes out the Y register
b1 14               lda ($14),y    ; puts the memory referenced by the byte
                                   ;   starting at $14 (remember that byte?)
                                   ;   into the default register
20 d2 ff            jsr $ffd2      ; calls the kernal routine to print the char stored in A
c8                  iny            ; increment Y
c0 0e               cpy #$0e       ; test for equality with the constant $0e

वह स्थिरांक जो पहले लिखा गया है। यह स्पष्ट रूप से निर्धारित करता है कि लूप कितनी देर चलता है। यह पहले से ही सही मूल्य होने के लिए होता है, लेकिन हमें फिर से 0e छड़ी करने की आवश्यकता है।

d0 f6                   bne *-8        ; jump back 8 bytes if y and that constant weren't equal
60                      rts            ; ends the program

बाकी सिर्फ जानकारी है जिसे हमें प्रिंट करना है, मेमोरी एड्रेस c025 से शुरू करना है।

तो यह वहाँ से गणित का अनुसरण कर रहा है।

— ए गोल्ड मैन
स्रोत

बिलकुल सही, बधाई। मेरी पोस्ट को ठीक से संपादित करने में मुझे थोड़ा समय लग सकता है, मैं अभी मोबाइल पर हूं।

— फेलिक्स पैलमेन

D018 बहुत चालाक था, और मुझे पसंद है कि आपने गुप्त रूप से एक संकेत कैसे पोस्ट किया।

— एक गोल्ड मैन

d018 का उद्देश्य डोर-ओपनर था ... संकेत आकस्मिक था, मेरा मतलब $FFवहां था, लेकिन फिर इसे छोड़ने का फैसला किया।

— फेलिक्स पालमेन

2

6502 मशीन कोड (C64) - फेलिक्स पालमेन

सही जवाब है

8bitsareenough

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

यह समझने के लिए कि क्या हुआ था, यह समझने के लिए कि यह कोड का थोड़ा और उपयोगी डिससेप्शन है। सिंटैक्स KickAssembler के लिए है।

*=$c000       // LOAD ADDRESS
jsr $aefd     //checks for a comma
jsr $ad9e     /*Reads in an argument. Stores length of it into
                $61, with the address of the stored arg in $62-3*/
jsr $b6a3     /*Evaluates the string, leaving the pointer on $22-3
                and the length on A*/ //I think

ldy #$00
loop: lda thedata,y   
cpy #$01
beq shuffle
cpy #$07
beq shuffle
cpy #$0b
beq shuffle
tricks: jsr output
iny
bne loop
output: eor ($22),y      //XOR's A with the y-eth letter of our input
jmp $ffd2               //good old CHROUT, returns to tricks above
thedata: .byte $f0,$48,$fa,$a2, $1c,$6d,$72,$30
.byte $06,$a9,$03,$48,$7c,$a3
shuffle: sta $c048      //drops A in mystery+4, over the constant
lda $c026,y
sta $c045               //overwrites the low byte of mystery
lda $c027,y
sta $c046               //overwrites the high byte of mystery
ldx #$00
mystery: lda $aefd,x              
eor #$23
jsr output
iny
inx
cpx #$03
bne mystery
cpy #$0e
bne loop
eor #$1a
sta $d018                
rts

इसे इस तरह से लेबल करना मेरे लिए यह देखने के लिए पर्याप्त था कि कोड XORs का एक समूह है जो हमारे आसपास की जरूरतों को जानने के लिए छिपा हुआ है। चूंकि XOR प्रतिवर्ती है, यदि आप वांछित आउटपुट को इनपुट करते हैं, तो यह आपको बताएगा कि कुंजी क्या है।

इसलिए मैंने अंतिम पंक्ति को बदल दिया

/*from sta $d018 
to*/ jsr $ffd2

इसलिए यह गलत इनपुट पर दुर्घटनाग्रस्त होने के बजाय पिछले आवश्यक इनपुट को प्रिंट करेगा।

और वही जो है!

यदि कोई रुचि है, तो मैं कोड को और अधिक क्रैक करूंगा।

— ए गोल्ड मैन
स्रोत

वाह, यह वास्तव में एक विशाल शॉर्टकट है, मुझे संभवतः प्रसंस्करण में पहले गलत इनपुट पर एक दुर्घटना को मजबूर करना चाहिए था । डीबगर के उपयोग से एक और शॉर्टकट संभव btw था vice। लेकिन जो भी हो, यह सही समाधान है।

— फेलिक्स पालमेन

मुझे नहीं पता था कि वाइस में एक डिबगर है। यह वही है जो मुझे उत्तर सीखने के लिए एक भाषा सीखने के लिए मिलता है।

— एक गोल्ड मैन

कुछ स्पष्टीकरण के साथ मेरी पोस्ट को संपादित किया। अच्छा काम, बस कार्यक्रम को संशोधित करने के लिए क्रैश नहीं एक बहुत ही स्पष्ट तरीका है, मैंने ऐसा नहीं सोचा था।

— फेलिक्स पालमेन

नाइटपिक: " drops A in mystery+1, over the constant" <- यह वास्तव mystery+4में आपके लेबल के साथ है। अपराध बाइट्स में हैं :) और FWIW, स्व-संशोधन गंभीर 6502 कोड में भी सामान्य है , जब तक कि कोड रैम से चलता है।

— फेलिक्स पाम्स

1

विस्फोट , कदम मुर्गी

@_?&4_-j>5&f^~c>&6\|4>7

आरएच / क्यूई?, WCR + डु

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

काम करने की कोशिश कर रहा है कि सभी "खोजकर्ता" वास्तव में किसी के सिर को बहुत अधिक चोट पहुंचा रहे हैं, इसलिए मैंने बस इसे उल्टा कर दिया (शाब्दिक रूप से: पी - सबसे सही चरित्र से शुरू करके मैं प्रत्येक को बारी-बारी से [और आसपास] प्रिंट करने योग्य चरित्र श्रेणी में शामिल करता हूं) ।

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

अच्छी नौकरी :) मैं कुछ घंटों में एक स्पष्टीकरण

— स्टीफन

1

जोशुआ द्वारा सी (tcc)

int puts(const char *s)
{
    printf("Hello, World!%s", s);
}

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

— डेनिस
स्रोत

अरे। मेरे पास यह सटीक दरार थी, लेकिन यह टीआईओ पर काम नहीं कर सका। +1

— एमडी एक्सएफ

उसके लिए क्षमा चाहता हूँ। Fwiw यह अब तय हो गया है।

— डेनिस

क्या आप जानते हैं कि समस्या क्या थी?

— एमडी एक्सएफ

मुझे पता है कि मैंने इसे कैसे तय किया (tcc को SELinux सपोर्ट के साथ बनाया जाना था), लेकिन मुझे यकीन नहीं है कि यह क्या करता है या पहली जगह में इसकी आवश्यकता क्यों थी।

— डेनिस

1

MATL लुइस मेंडो द्वारा

tsZp?x

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

— डेनिस
स्रोत

1

जोनाथन एलन द्वारा जेली

मूल कोड:

œ?“¥ĊɲṢŻ;^»œ?@€⁸ḊFmṪ⁷

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

इनपुट:

1,2586391,2949273,3312154,3312154,1134001,362881,2223505,766081,1134001,1497601,3312154,1860601,140

स्पष्टीकरण:

मुख्य रूप से, यह समझना आवश्यक है कि कोड क्या करता है। पहली बात यह है कि यह स्ट्रिंग लेता है"!,Word Hel"(न्यूलाइन को छोड़कर सभी आवश्यक पात्रों के साथ) और उनमें से क्रमपरिवर्तन का एक गुच्छा बनाता है। इनपुट क्रमपरिवर्तन संख्या निर्दिष्ट करते हैं, और इनपुट से क्रमपरिवर्तन के प्रत्येक जोड़े को स्ट्रिंग बहिष्कृत जोड़े पर लागू किया जाता है जहां पहले क्रमपरिवर्तन पहले लागू होता है। मूल रूप से, पी 2 (पी 1 (एस)), पी 2 (पी 2 (एस), पी 2 (पी 3 (एस)), ..., पी 2 (पीएन (एस)), पी 3 (पी 1 (एस)), ..., पी 3 (पीएन (एस)), ..., पीएन (पी 1 (एस)), ..., पीएन (पीएन (एस))। इन सभी को एक साथ समाहित किया गया है। फिर हर पींथ को लेने के लिए अंतिम इनपुट का पुन: उपयोग किया जाता है। इस बड़ी स्ट्रिंग से चरित्र। तो, मैं PN = len (S) * N = 10 * N लेता हूं। इसका मतलब है कि हम P3 (P1 (S)) का पहला वर्ण, P3 (P1 (S) का पहला वर्ण लेंगे। )), पीएन (पी 1 (एस)) के पहले चरित्र तक सभी तरह से। आगे सरलीकरण करने के लिए, मैंने पी 1 = 1 को पहचान की अनुमति देता हूं। फिर यह किसी भी पी 2 को चुनने के लिए पर्याप्त है जो "एच" को पहले में अनुमति देता है। स्थान, एक पी 3 जो "ई" को पहली स्थिति में और इतने पर अनुमति देता है। सौभाग्य से, पीएन के लिए पहले से ही चुने गए छोटे क्रमचय संख्या स्ट्रिंग में पहले के पात्रों को प्रभावित नहीं करते हैं, इसलिए पीएन छोड़ देता है "!" स्ट्रिंग की शुरुआत में। (यदि यह सच नहीं था, तब भी एक अलग P1 चुनकर हल करना संभव होगा।)

— tehtmi
स्रोत

यह 14 क्रमपरिवर्तन की सूची के 14 क्रमांकन, चपटा, छल और फिर प्रत्येक 140 वें वर्ण को लेता है।

— जोनाथन एलन

1

एमडी एक्सएफ द्वारा सी (जीसीसी ऑन टीआईओ)

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

कैसे?

यह एक स्ट्रिंग के रूप में दूसरे तर्क को प्रिंट करने की कोशिश करता है, जो कि एक सूचक है जिसे हम इनपुट पर निर्धारित कर सकते हैं। यह सिर्फ इतना होता है कि स्थान पर स्मृति स्ट्रिंग 4195875शुरू करता "Hello, World!\n"है।

संख्या को print("%p", "Hello, World!");इससे पहले जोड़कर निर्धारित किया गया था printf, हेक्साडेसिमल संख्या को दशमलव में परिवर्तित करके मूल TIO पर इसे आज़माया गया था। हालाँकि, इसने मुझे printfप्रारूप स्ट्रिंग दिखाया । कुछ संख्याओं को आज़माकर, मुझे पता चला कि स्ट्रिंग प्रारूप स्ट्रिंग से पहले स्थित है।

तो स्मृति में, यह इस तरह दिखेगा (सी स्ट्रिंग के रूप में):

Hello, World!\n\0%2$s\0

इसका मतलब यह भी है कि संकलक के किसी भी अद्यतन से समाधान टूट सकता है।

— Neui
स्रोत

1

जावास्क्रिप्ट (Node.js) Voile द्वारा

['Hello, World!','','','','','','','','','','','','']

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

— DG3
स्रोत

1

फर्ग्यूस्क द्वारा रोदा

[1, "HH", 1, "eellloo", 1, ",,", 1, "  WWoo", 1, "rr", 1, "ll", 1, "dd", 1, "!!"]

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

स्पष्टीकरण एक सा आ रहा है ...

— user41805
स्रोत

1

जावास्क्रिप्ट (ES6), Voile

var i = 0;
var string = `"${t}"`;
var answer = "i++?0:q=string";
console.log( f(answer) );

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

— Birjolaxew
स्रोत

यह इच्छित समाधान नहीं है :) मैं इसे ठीक कर दूंगा और बाद में वापस आऊंगा।

— Voile

1

PHP, LP154 द्वारा

PDO,FETCH_CLASSTYPE

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

(TIO में PDO वर्ग परिभाषित नहीं है, इसलिए उपरोक्त डेमो एक कोडपैड का उपयोग करता है जो करता है)

एक और समाधान:

ReflectionFunction,IS_DEPRECATED

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

— nickb
स्रोत

1

जावास्क्रिप्ट (ES6), Voile

81 वर्णों की सीमा को देखते हुए, यह संभवतः अभीष्ट समाधान नहीं है

global.g = ()=>"Hello, World!";
var str = "g";

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

— Birjolaxew
स्रोत

जिनियस। वैश्विक हेरफेर के साथ एक चार स्ट्रिंग पास करना। लगता है, कि यह इरादा समाधान है

— вгений Новиков

इसका अभीष्ट समाधान नहीं है :(

— Voile

अब जब मैं इसके बारे में सोच रहा हूं, तो मुझे नहीं लगता कि किसी फ़ंक्शन में इनपुट पास करने से पहले इस तरह का सामान रखने की अनुमति है, जब तक कि सामान को इनपुट के भाग के रूप में भी नहीं बनाया जा सकता है (जैसे फ़ंक्शन के अंदर जो होगा अंदर मूल्यांकन किया गया), चूंकि चुनौती के लिए आपको एक इनपुट बनाने की आवश्यकता होती है, जिसका परिणाम 'हैलो, वर्ल्ड!' होगा, न कि पूरा प्रोग्राम। अन्यथा बहुत कुछ सुरक्षित नहीं हो सकता। तो मुझे लगता है कि यह दरार अमान्य हो सकती है?

— Voile

@ वॉयल यह बहुत अच्छी तरह से हो सकता है। मुझे लगता है कि यह कार्य को पढ़ने के लिए उचित है जैसे कि इनपुट अकेले खड़े होना चाहिए (यानी बाहरी सिस्टम में परिवर्तन के बिना) - खासकर अगर यह इच्छित समाधान नहीं है :) तो अपने पुलिस वाले को फटा हुआ चिह्नित करने की आवश्यकता नहीं है।

— बिरजोलक्सेव

1

मैंने इस बारे में चर्चा करते हुए एक मेटा पोस्ट बनाया है । बेझिझक कुछ चर्चाएँ वहाँ छोड़ दें।

— Voile

"नमस्ते दुनिया!" (लुटेरों का धागा)

05AB1E , अदनान

कैसे?

पूरी तरह से , अजगर 2

पायथ : मिस्टर एक्सकोडर

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

व्याख्या

स्पष्टीकरण:

कैसे?

मैंने यह कैसे किया

मूल रूप से एमडी एक्सएफ द्वारा

सीजाम , एरिक द आउटगोलर

कैसे?

सी # (.NET कोर) , ग्रेज़गोरज़ पुलावस्की

Ly , LyricLy

6502 मशीन कोड (C64) - फेलिक्स पालमेन

विस्फोट , कदम मुर्गी

कैसे?