कोड सीढ़ी, पुलिस


36

नोट: यह चुनौती समाप्त हो गई है। प्रस्तुतियाँ अभी भी स्वागत योग्य हैं लेकिन जीत नहीं सकती हैं।

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

एक कोड लिखें जो पूर्णांक को आउटपुट करता है 1। यदि आप किसी एकल वर्ण (अपने चयन के) को जोड़ते, हटाते या प्रतिस्थापित करते हैं, तो कोड को पूर्णांक का उत्पादन करना चाहिए 2। एक और चरित्र (समान या अन्य) बदलें, और कोड आउटपुट होना चाहिए 3। इस तरह से जारी रखें जहां तक ​​आप कर सकते हैं, लेकिन अधिकतम 10 तक। डिफ़ॉल्ट आउटपुट प्रारूप जैसे कि ans = 1स्वीकार किए जाते हैं। आप STDERR (या समतुल्य) के आउटपुट को अनदेखा कर सकते हैं।

आपको अपने प्रारंभिक कोड की भाषा, बाइट काउंट, इसके लिए काम करने वाले पूर्णांकों की संख्या, साथ ही प्रारंभिक कोड के वर्णों की एक वैकल्पिक संख्या को प्रकट करना होगा। नोट: आपको किसी भी वर्ण को प्रकट करने की आवश्यकता नहीं है, लेकिन याद रखें कि पात्रों को प्रकट करना लुटेरों के लिए कठिन हो सकता है क्योंकि उन्हें उसी स्थिति में उसी वर्ण का उपयोग करना चाहिए। आप चुन सकते हैं कि आप किस चरित्र का उपयोग unrevealed वर्णों (उदाहरण के लिए अंडरस्कोर) के लिए कर सकते हैं, लेकिन इसे निर्दिष्ट करना सुनिश्चित करें।

पुलिस एक सप्ताह के बाद अनियोजित कोड प्रदान कर सकती है और सबमिशन "सेफ" को कॉल कर सकती है। जीतने वाला सबमर्सन सबसे छोटा अनारकल्ड सबमिशन होगा जो नंबर 10 को प्रोड्यूस करता है। अगर कोई अनकमिंग सबमिशन 10 प्रिंट नहीं कर पा रहा है, तो सबसे छोटा कोड जो 9 का उत्पादन करेगा, वह जीत जाएगा, और इसी तरह। ध्यान दें कि लुटेरों को आपके द्वारा किए गए समान परिवर्तन करने की आवश्यकता नहीं है, और उन्हें सटीक कोड को पुन: पेश करने की आवश्यकता नहीं है (जब तक कि आप अपने पात्रों को प्रकट न करें)। उन्हें केवल आउटपुट को पुन: उत्पन्न करना होगा।

24 नवंबर के बाद पोस्ट किए गए सबमिशन स्वागत योग्य हैं, लेकिन जीत के योग्य नहीं हैं (क्योंकि आस-पास कम लुटेरे होंगे)।


उदाहरण पोस्ट:

निम्न पोस्ट भाषा में एक सबमिशन है MyLang, यह 9 बाइट्स लंबा है, और यह संख्या 1 - 8 के लिए काम करता है।

मायलैंग, 9 बाइट्स, 8 नंबर

यह सबमिशन 1 - 8 के लिए काम करता है। अनकवर्ड कैरेक्टर्स को अंडरस्कोर के साथ दर्शाया जाता है _:।

abc____i

लीडरबोर्ड

डिस्क्लेमर: लीडरबोर्ड का परीक्षण नहीं किया गया है और सूची में अनियंत्रित सबमिशन दिखाई नहीं दे सकता है।

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><style>table th,table td{padding: 5px;}th{text-align: left;}.score{text-align: right;}table a{display: block;}.main{float: left;margin-right: 30px;}.main h3,.main div{margin: 5px;}.message{font-style: italic;}#api_error{color: red;font-weight: bold;margin: 5px;}</style> <script>QUESTION_ID=99546;var safe_list=[];var uncracked_list=[];var n=0;var bycreation=function(x,y){return (x[0][0]<y[0][0])-(x[0][0]>y[0][0]);};var byscore=function(x,y){return (x[0][1]>y[0][1])-(x[0][1]<y[0][1]);};function u(l,o){jQuery(l[1]).empty();l[0].sort(o);for(var i=0;i<l[0].length;i++) l[0][i][1].appendTo(l[1]);if(l[0].length==0) jQuery('<tr><td colspan="3" class="message">none yet.</td></tr>').appendTo(l[1]);}function m(s){if('error_message' in s) jQuery('#api_error').text('API Error: '+s.error_message);}function g(p){jQuery.getJSON('//api.stackexchange.com/2.2/questions/' + QUESTION_ID + '/answers?page=' + p + '&pagesize=100&order=desc&sort=creation&site=codegolf&filter=!.Fjs-H6J36w0DtV5A_ZMzR7bRqt1e', function(s){m(s);s.items.map(function(a){var he = jQuery('<div/>').html(a.body).children().first();he.find('strike').text('');var h = he.text();if (!/cracked/i.test(h) && (typeof a.comments == 'undefined' || a.comments.filter(function(b){var c = jQuery('<div/>').html(b.body);return /^cracked/i.test(c.text()) || c.find('a').filter(function(){return /cracked/i.test(jQuery(this).text())}).length > 0}).length == 0)){var m = /^\s*((?:[^,;(\s]|\s+[^-,;(\s])+).*(0.\d+)/.exec(h);var e = [[n++, m ? m[2]-0 : null], jQuery('<tr/>').append( jQuery('<td/>').append( jQuery('<a/>').text(m ? m[1] : h).attr('href', a.link)), jQuery('<td class="score"/>').text(m ? m[2] : '?'), jQuery('<td/>').append( jQuery('<a/>').text(a.owner.display_name).attr('href', a.owner.link)) )];if(/safe/i.test(h)) safe_list.push(e);else uncracked_list.push(e);}});if (s.items.length == 100) g(p + 1);else{var s=[[uncracked_list, '#uncracked'], [safe_list, '#safe']];for(var i=0;i<2;i++) u(s[i],byscore);jQuery('#uncracked_by_score').bind('click',function(){u(s[0],byscore);return false});jQuery('#uncracked_by_creation').bind('click',function(){u(s[0],bycreation);return false});}}).error(function(e){m(e.responseJSON);});}g(1);</script><link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/Sites/codegolf/all.css?v=7509797c03ea"><div id="api_error"></div><div class="main"><h3>Uncracked submissions</h3><table> <tr> <th>Language</th> <th class="score">Score</th> <th>User</th> </tr> <tbody id="uncracked"></tbody></table><div>Sort by: <a href="#" id="uncracked_by_score">score</a> <a href="#" id="uncracked_by_creation">creation</a></div></div><div class="main"><h3>Safe submissions</h3><table> <tr> <th>Language</th> <th class="score">Score</th> <th>User</th> </tr> <tbody id="safe"></tbody></table></div>


यकीन नहीं होता कि मैं समझता हूं ... सीजेएम में एक मनमाना कोड दिया गया है 1, जो बाकी संख्याओं को उत्पन्न करने के लिए मैं लुटेरों को बार-बार जोड़ने) से कैसे रोक सकता हूं ? वही कुछ भाषाओं के लिए मान्य होगा
लुइस मेंडो

2
अगर ऐसा किसी भी कार्यक्रम के लिए संभव है जो आउटपुट करता है 1तो ऐसा प्रतीत होता है कि सीजेएम इस चुनौती के लिए भाषा का एक बुरा विकल्प है। लुटेरों को ऐसा करने से रोकने का कोई तरीका नहीं है।
स्टीवी ग्रिफिन

3
@LuisMendo खैर, यह निश्चित रूप से इसे और अधिक दिलचस्प बना देगा ...
LegionMammal978

1
@DanielJour यह किसी भी संख्या के लिए परिवर्तनीय हो सकता है, लेकिन लुटेरों को खोजने के लिए अधिकतम संख्या की आवश्यकता होती है 10। यह नियम लागू है क्योंकि कई प्रस्तुतियाँ शायद अनंत (सिद्धांत रूप में) तक बढ़ाई जा सकती हैं, इसलिए उच्चतम प्राप्त संख्या के आधार पर स्कोरिंग का कोई मतलब नहीं होगा।
स्टीवी ग्रिफिन

1
यदि कोई शीर्ष लेख crackedकिसी प्रकार का है तो आप केवल प्रविष्टि को अयोग्य ठहराने का प्रयास कर सकते हैं । यह वही है जो वर्तमान में रीडिज़ाइन उपयोगकर्ता नाम करता है।
ETHproductions

जवाबों:


1

हेक्सागोनी , 18 बाइट्स, 10 नंबर, सेफ

यह सबमिशन 1 - 10 के लिए काम करता है। अनकवर्ड कैरेक्टर्स को अंडरस्कोर के साथ दर्शाया जाता है _:।

.__{_]5[$@.;=@$!!1

आप यहां से ऑनलाइन हेक्सागोनी आजमा सकते हैं।

मेरा समाधान:

1:   .<[{8]5[$@.;=@$!!10
2:   .<[{8]5[$@);=@$!!10
3:   2<[{8]5[$@);=@$!!10
4:   3<[{8]5[$@);=@$!!10
5:   4<[{8]5[$@);=@$!!10
6:   5<[{8]5[$@);=@$!!10
6:   7<[{8]5[$@);=@$!!10
8:   7<[{8]5[$@);=@$!!10
9:   8<[{8]5[$@);=@$!!10
10:  9<[{8]5[$@);=@$!!10

उत्पादन 1 के लिए हेक्स:

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

Full Hex:
  . < [ 
 { 8 ] 5
[ $ @ . ;
 = @ $ ! 
  ! 1 0

Important parts:
  . < .
 . 8 . 5
. $ @ . ;
 . . $ .
  . 1 .
  1. पर <स्मृति बढ़त है 0, तो यह ऊपर हो जाता है।
  2. हिट्स 1
  3. को कूदता है 5
  4. कूदता है 8, लेकिन उलटा <हो जाता है और 8रास्ते में वापस आ जाता है।
  5. 5फिर से हिट करता है
  6. कूदता है 1
  7. <इस बिंदु पर हिट करता है , स्मृति मूल्य 1585 है, जो कि मोड 256, ASCII के रूप में होता है1
  8. अंत में प्रिंट करता है और बाहर निकलता है ;@

उत्पादन 2 के लिए हेक्स:

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

Important parts:
  . < .
 . 8 . 5
. $ @ ) ;
 . . $ .
  . 1 .

यह उसी पथ का अनुसरण करता है, लेकिन रास्ते में यह एक हिट करता है )जो 1586 तक मेमोरी बढ़त को बढ़ाता है, या 2


उत्पादन 3-9 के लिए हेक्स:

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

Important parts:
  2 < [
 . . ] .
. $ . ) .
 . @ . !
  . 1 .
  1. हिट करता है 2
  2. अब जब यह हो जाता है <तो मेमोरी एज पॉजिटिव हो जाती है , इसलिए यह बंद हो जाती है।
  3. ]अनुदेश सूचक बदलता है, लेकिन तुरंत के साथ वापस आता है[
  4. ) करने के लिए वेतन वृद्धि 3
  5. ! प्रिंटों 3
  6. $पहले दो नंबरों से बचा हुआ है इसलिए हम अंत में कूदते हैं ( @)
  7. 1 मेमोरी एज को बदलता है, लेकिन यह अब मायने नहीं रखता।
  8. < पॉइंटर वापस दर्शाता है।
  9. फिर 1से कोई फर्क नहीं पड़ता क्योंकि हम @कार्यक्रम को समाप्त करने के लिए मारा ।

11

रेटिना , 2 बाइट्स, 10 नंबर, फटा

_1

1 से 10 के लिए काम करता है, _एक छिपा चरित्र है। यह बहुत कठिन नहीं होना चाहिए, लेकिन मुझे आशा है कि यह कुछ दिलचस्प पहेली प्रदान करता है। :)

आप यहाँ से रेटिना को ऑनलाइन आज़मा सकते हैं।



@ LegionMammal978 :)
मार्टिन

2
FryAmTheEggman द्वारा क्रैक: codegolf.stackexchange.com/a/99560/32700
TheNumberOne

10

ऑक्टेव, 55 बाइट्स, 10 नंबर, फटा

(o__(O_o_(@(__o)o__-O}_)_(0<O,{_(_o_O-1)+1_@(_1}_)(__o_

_ अज्ञात चरित्र है।

समाधान

(o=@(O,o)(@(O,o)o{2-O}())(0<O,{@()o(O-1)+1,@()1}))(0,o)% तो आखिरी बदलते 0करने 1,2,3आदि

को देखते हुए x, इस रिकर्सिवली की गणना करता है x+1। यह मुख्य रूप से दो अनाम कार्यों से बना है। एक ifपुनरावृत्ति को लंगर देने के लिए एक बयान प्रदान करता है :

if_ = @( boolean, outcomes) outcomes{ 2 - boolean}();

यह सिर्फ इस तथ्य का दुरुपयोग है कि एक बूलियन मूल्यों का मूल्यांकन करता है 0या 1। यह फ़ंक्शन बूलियन मान, और दो फ़ंक्शन के सेल सरणी को स्वीकार करता है, और बूलियन मान के आधार पर इन दो फ़ंक्शनलिओसन में से एक या दूसरे का मूल्यांकन करता है। दूसरा भाग वास्तविक पुनरावृत्ति है:

plus_one = @(n,f) if_(0<n ,{@()f(n-1)+1, @()1})

जैसे कि एक अनौपचारिक कार्य अनाम है, आप इसे सीधे इटसेफ़ल से एक्सेस नहीं कर सकते। इसलिए हमें दूसरे तर्क की जरूरत हैfप्रथम। बाद में हम एक दूसरे तर्क के रूप में समारोह instelf करने के लिए एक संभाल प्रदान करेगा, इसलिए एक अंतिम समारोह दिखता है तो चाहते हैं:

plus_one_final = @(n)plus_one(n,plus_one);

तो यह अंकन में जमा करते हो जाता है:

(plus_one=@(n,f)(@(boolean,outcomes)outcomes{2-boolean}())(0<n,{@()f(n-1)+1,@()1}))(n,f)

मैं MATLAB में गुमनाम कार्यों के लिए प्रत्यावर्तन एंकर थोड़ी देर पहले पर के बारे में पूछा stackoverflow


19
o_O O____o O_O o_O
TuxCrafting

मुझे यकीन नहीं है कि क्या यह वास्तव में दरार करना मुश्किल है) =)
दोष

खैर, यह यकीन है कि नरक दरार करने के लिए आसान नहीं है ! शायद यह कलम और कागज (!) के साथ कर सकता है
स्टीवी ग्रिफ़िन

मैं इसे एक प्रशंसा के रूप में लेता हूं :) मुझे लगता है कि आप मेरे समाधान को पसंद करेंगे, लेकिन जब तक यह फटा नहीं है तब तक मैं कुछ भी प्रकट नहीं करूंगा / यह सुरक्षित है।
22


9

अजगर 2, 9 बाइट्स, 10 नंबर, फटा

print 8/8

कोई छुपी हुई बात नहीं। क्या आप इसे बिना किसी जबरदस्ती के क्रैक कर सकते हैं?


फटा - वह मज़ा था :)
Sp3000

8

पर्ल, 12 बाइट्स, 10 नंबर, फटा हुआ!

अंडरस्कोर अज्ञात पात्रों का प्रतिनिधित्व करता है।

____;say__-9

शायद काफी आसान है, और यह मुझे आश्चर्य नहीं होगा अगर कई समाधान थे। फिर भी, यह दरार करने के लिए मजेदार हो सकता है।

(इरादा समाधान दरार के समान था। यह मूल रूप से चार वर्णों में 10 से एक चर को असाइन करने के बारे में एक समस्या है, जो कि पर्ल में आश्चर्यजनक रूप से मुश्किल है। कई गोल्फिंग भाषाओं के विपरीत, इसमें एक चर नहीं है जो मददगार शुरू होता है 10)


1
फटा । पहले मुझे लगा कि यह कुछ ऐसा है $_=1;say;#-9, लेकिन मैं समझ नहीं पा रहा था कि
रिले

7

पर्ल, 46 बाइट्स, 10 नंबर, सुरक्षित

समस्या

__b_b_\__}_b_b_b_0_;
$b[0]=10;$b{0}=1;say$b[0]

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

मेरा समाधान

sub b{\@_}*b=b$b{0};
$b[0]=10;$b{0}=1;say$b[0]

9 के लिए 2, 3 मुद्रित करने के लिए, आदि, ऊपर, नंबर करने के लिए सौंपा बदल रहा रखने के $b{0} दूसरी पंक्ति (यानी में $b{0}=2, $b{0}=3, आदि)। 9 के लिए कार्यक्रम इस तरह दिखता है:

sub b{\@_}*b=b$b{0};
$b[0]=10;$b{0}=9;say$b[0]

फिर 10 का उत्पादन करने के लिए, एक #चरित्र को प्रस्तुत करके पहली पंक्ति पर टिप्पणी करें ।

व्याख्या

ध्यान देने वाली पहली बात यह है कि समाधान वास्तव में व्हाट्सएप को हटाने से अलग नहीं है: यदि हम इसे अधिक पठनीय व्हाट्सएप के साथ रखते हैं, तो हमें यह मिलता है:

sub b { \@_ }
*b = b $b{0};
$b[0] = 10;
$b{0} = 1;
say $b[0];

आम तौर पर, जब आप पर्ल में एक सबरूटीन के तर्कों का उपयोग करते हैं, तो आप उन्हें बाहर से कॉपी करके ऐसा करते हैं @_। इसके लिए एक अच्छा कारण है: @_उपनामों को उप-तर्क दिया जाता है (इसलिए, उदाहरण के लिए, (sub { $_[0] = 3 })->($x)असाइन करेगा $x), ऐसा कुछ जो सामान्य रूप से वांछनीय नहीं है।

यद्यपि @_यह जादुई लग सकता है, यह वास्तव में पर्ल इंटर्नल के एक मानक फीचर का उपयोग कर रहा है (जो कि आसानी से एक्सएस से उपलब्ध है, लेकिन केवल शुद्ध पर्ल में कुछ अजीब मामलों में आता है, जैसे कि @_): एक सरणी सीधे अपने तत्वों को संग्रहीत नहीं करती है , बल्कि संदर्भ द्वारा। इस प्रकार, जब हम bनीचे दूसरी पंक्ति में कॉल करते हैं, तो पर्ल एक सरणी उत्पन्न करता है (इसे कॉल करता है @_) जिसका पहला तत्व उसी स्टोरेज का संदर्भ होता है जो इसका $b{0}उपयोग करता है। (हैश मान भी संदर्भ द्वारा संग्रहीत किए जाते हैं; $ _ [0] और $ b {0} दोनों इस बिंदु पर एक ही संदर्भित कर रहे हैं।) क्योंकि @_एक आंतरिक दृष्टिकोण से कुछ खास नहीं कर रहा है, हम एक संदर्भ ले सकते हैं। जैसे कि हम किसी अन्य सरणी के साथ कर सकते हैं, जिससे यह उस उप-रेखा को रेखांकित कर सकता है जिसे इसमें परिभाषित किया गया है।

पर्ल चर भी संदर्भ द्वारा डेटा भंडारण को संदर्भित करते हैं। बहुत समय पहले, लोग एक उपनाम के रूप में *x = *y;सेट करने के लिए कोड का उपयोग करते $xथे $y(उन्हें उसी चीज़ का संदर्भ देते हुए), इसी @xतरह एक अन्य के रूप में @y, %xएक अन्य के रूप में %yऔर इसी तरह। इसके बजाय, अपरिवर्तनीय रूप से टूट जाता है कि समान नामों वाले चर को समान रूप से कार्य नहीं करना पड़ता है, इसलिए आधुनिक पर्ल एक विकल्प प्रदान करता है; एक टाइपग्लोब के संदर्भ को निर्दिष्ट करना केवल उस चर को संदर्भित करता है जो संदर्भ के प्रकार से मेल खाता है (इसलिए *x = \%yअन्य %xभंडारण के समान इंगित करने के लिए %yलेकिन छोड़ दें, कहते हैं, $xअकेले)। यह वाक्य रचना इस बात की परवाह नहीं करती है कि आप जिस स्टोरेज में नाम रख रहे हैं, इसलिए जब हम रिटर्न वैल्यू असाइन करते हैंb(जो एक सरणी संदर्भ है जो पूर्व में दिए गए सरणी को @_जीवित रखता है) को *b, क्या होता है जो @bतर्क सूची को कॉल करने के लिए बदल b( %bअपरिवर्तित छोड़ते समय ) बदल जाता है। इसका मतलब है, विशेष रूप से, यह $b[0]और $b{0}अब एक ही भंडारण की ओर इशारा करता है, और एक को असाइन करना इसलिए दूसरे को बदल देगा। तब से सब कुछ पूरी तरह से सीधा है।

पर्ल डॉक्यूमेंट वास्तव में इस प्रकार के विस्तार के बारे में बात नहीं करता है, इसलिए मुझे आश्चर्य नहीं है कि किसी को भी दरार मिल गई है; @_अन्य सरणियों की तरह काफी नहीं होने की प्रकृति ऐसी चीज नहीं है जिस पर वास्तव में जोर दिया जाता है, और अधिकांश कोडिंग शैलियों का उद्देश्य उन प्रभावों को कम से कम करना है जो उन्हें प्रवर्धित करने के बजाय करते हैं।


1
मैं इससे बहुत परेशान हूं। मैंने छद्म हैश के बारे में सीखा है और संदर्भित और डे-रेफ़रिंग पर अपनी स्मृति को ताज़ा किया है, लेकिन मुझे यह पता नहीं लग सकता है!
डोम हेस्टिंग्स

1
@DomHastings, ... और मुझे धोखा चारों ओर के लिए विभिन्न पात्रों के साथ सीमांकन किया गया है qऔर sऔर yऔर m(ज्यादातर के बाद समाप्त करने के लिए उन्हें प्राप्त करने की कोशिश $b[0]काम), लेकिन कुछ भी नहीं मेरे लिए काम कर (अभी तक)।
msh210

आप दोनों गलत रास्ते पर थे, लेकिन वास्तव में, भाषा या मेरे द्वारा प्रस्तुत की गई मदद से बहुत कुछ नहीं हो सकता है कि सही ट्रैक क्या है (मुझे बहुत बड़ा अंतर छोड़ने से बचने के लिए एक सुराग छोड़ना पड़ा, लेकिन बहुत सारे हैं कारण कि प्रोग्राम में बैकस्लैश हो सकता है, यह हमेशा संदर्भों से संबंधित नहीं होता है)।

मुझे लगता है कि मैं निराशा से करीब था। मैंने sub b{\@_}अपने दिमाग में सीमेंट डाला था , और, हालांकि मैंने प्रयोग किया, *bमैं इसे प्राप्त नहीं कर सका! स्पष्टीकरण के लिए धन्यवाद। हो सकता है कि मैंने आपके स्पष्टीकरण में इस पर प्रकाश डाला हो, लेकिन ऐसा क्यों sub b{\@_}*b=b$b[0]नहीं करता ?
डोम हेस्टिंग्स

आप ऐरे एलिमेंट और हैश एलिमेंट शेयर मेमोरी बनाने की कोशिश कर रहे हैं, इसलिए आपको दोनों का उल्लेख करना होगा। जब आप किसी ऐरे संदर्भ ( \@_) को असाइन करते हैं, तो एरे तत्व के निहितार्थ का उल्लेख किया जाता है *b, लेकिन आपको हैश तत्व का स्पष्ट रूप से उल्लेख करना होगा। इसके साथ *b=b$b[0], आप मूल रूप से केवल नए $b[0]को बदल रहे हैं (जहां @bअंक बदलने के बाद ) $b[0]उस कार्यक्रम की शुरुआत में मौजूद थे, जो बेकार है।

5

जावास्क्रिप्ट, 30 बाइट्स, 10 नंबर, फटा

alert(Array(_)________.length)

बहुत कठिन नहीं होना चाहिए, लेकिन उम्मीद है कि यह केवल एक चुनौती प्रदान करने के लिए पर्याप्त कठिन है। :) अपरिवर्तित वर्ण के साथ चिह्नित हैं _


अच्छा है! मेरे पास इस एक को हल करने के लिए एक प्रफुल्लित समय था, यह आसान था, फिर भी एक ही समय में चुनौतीपूर्ण था।
क्रिटिसी लिथोस

5

पर्ल, 14 बाइट्स, 10 नंबर, क्रैक

say_!"___"%""_

1 से 10. के लिए काम _छिपे हुए अक्षर हैं।

मुझे लगता है कि यह दरार करना बहुत कठिन नहीं होना चाहिए। मेरे पास 22 बाइट्स के लिए एक कठिन एक है, मैं इसे पोस्ट करूँगा अगर यह एक फटा है।


मूल कोड:

say"!"=~y"%""c

और की जगह "!"नंबर पर आप प्रिंट करना चाहते हैं की लंबाई के एक स्ट्रिंग द्वारा, उदाहरण के लिए !, !!, !!!, आदि

हालाँकि, ais523 को एक और तरीका मिला:

say"!"+1#"%""r

2
फटा । मुझे संदेह है कि यह वह नहीं है जो आप सभी के लिए जा रहे थे। (मैं regex का उपयोग करके कुछ करने की कोशिश कर रहा था, लेकिन यह बहुत सरल था।)



4

जेली , 7 बाइट्स , 10 नंबर, फटा

“1‘ỌȮḊ‘

कोई वाइल्डकार्ड नहीं।

प्राप्त की गई दरार (एक तर्क के साथ एक eval का उपयोग करने के लिए) थी, क्योंकि कई इस धागे में प्रतीत होते हैं, न कि इच्छित।

इरादा दरार था:

“1‘ỌȮḊ‘ - (prints 1)
“1‘     - code page index list of characters "1": [49]
   Ọ    - cast to ordinals: ['1']
    Ȯ   - print (with no line feed) and return input: effectively prints "1"
        -     (but if left at this would then implicitly print another "1")
     Ḋ  - dequeue: []
      ‘ - increment (vectorises): []
        - implicit print: prints ""

“1‘ỌŒḊ‘ - (prints 2)
“1‘Ọ    - as above: ['1']
    ŒḊ  - depth: 1
      ‘ - increment: 2
        - implicit print: prints "2"

“1‘ỌŒḊ‘‘ - (prints 3)
“1‘ỌŒḊ‘  - as above: 2
       ‘ - increment: 3
         - implicit print: prints "3"

... keep adding an increment operator to print 4 - 10.

यदि अगली पंक्ति में '' '' होता तो मैं इसे क्रैक कर सकता था। इतना करीब ... :)
क्रिस्ति लिथोस

फटा लेकिन क्या आप बता सकते हैं कि इसके लिए क्या होता है 10, क्योंकि मैं इस पर भाग्यशाली था जो काम कर सकता है।
हेदी

@ हेदी निंजा मुझे भी जल्दी से, मैं इस पर काम कर रहा था।
निकोलग्राफ

@ हेदी - तुम्हारी एक अनजानी दरार थी। जिस तरह 10से आप के लिए काम कर रहा है, मुझे विश्वास है, स्ट्रिंग में जेली कोड का मूल्यांकन करके (इनपुट के डिफ़ॉल्ट मूल्य) के 9तर्क के साथ 0, जिसे आप तब (कोई प्रभाव नहीं) और फिर वेतन वृद्धि करते हैं।
जोनाथन एलन

... वास्तव में मुझे लगता है कि जिस तरह 10से आप के लिए काम कर रहा है वह स्ट्रिंग में जेली कोड का मूल्यांकन करके 9है []- इनपुट का डिफ़ॉल्ट मान 0,, dequeued - जो आप तब वेतन वृद्धि।, जैसे“1‘‘‘‘‘‘‘‘‘Ọv0Ḋ¤‘
जोनाथन एलन

4

Befunge-93, 11 बाइट्स, 10+ नंबर, क्रैक

यह सबमिशन कम से कम 1 - 10 के लिए काम करता है। अनरेड्ड कैरेक्टर्स के साथ संकेत दिया जाता है

□□5:**-□-.@

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

मुझे कहना चाहिए कि मैं प्रभावित था कि दो लोग इसके लिए स्वतंत्र समाधान के साथ आ सकते हैं, जिनमें से न तो मैं उम्मीद कर रहा था। जबकि मार्टिन पहले वहां गया था, मैं Sp3000 को "जीत" दे रहा हूं क्योंकि उनका समाधान अधिक पोर्टेबल है।

हालांकि यह मेरा इच्छित समाधान था:

g45:**-2-.@
g45:**-1-.@
g45:**-1\.@
g45:**-1\+.@
g45:**-2\+.@
...
g45:**-7\+.@

क्योंकि Befunge में एक स्टैक अंडरफ्लो की व्याख्या 0 के रूप में की गई है, gबस 0,0 से 'g' के ASCII मान को लौटाता है, जिसका नाम है 103, जो 45:**-घटाता है 100, आपको 2-देता है 3. फिर आपको देता है 1.

तीसरे पुनरावृत्ति के लिए, -(घटाना) ) को एक \(स्वैप) निर्देश में बदल दिया जाता है , इसलिए 3 सबसे ऊपरी स्टैक प्रविष्टि बन जाता है। और पुनरावृति चार में, एक +(जोड़ें) निर्देश डाला जाता है, इस प्रकार 3 को 1 से 4 देते हुए।


फटा। मैं यह देखने के लिए उत्सुक हूं कि आपके मन में क्या समाधान था। :)
मार्टिन एंडर

@MartinEnder जैसा कि मैंने आपके उत्तर पर टिप्पणी की है, मैं चाहता हूं कि जब कोई और पोर्टेबल समाधान का प्रयास करना चाहे, तो मैं अपने इच्छित समाधान को थोड़ी देर के लिए छिपा कर रख दूं। क्या वह ठीक है?
जेम्स होल्डरनेस

बेशक, यह ठीक है। :)
मार्टिन एंडर

"15:**-6-.@1 देता है, लेकिन मुझे यकीन नहीं है कि तथ्य यह है कि "शीर्ष पर 32 धक्का देता है (अंतर्निहित रिक्त स्थान के कारण) TIO दुभाषिया या बेफुन्ज के हिस्से का एक गुण है, क्योंकि कुछ दुभाषियों की कोशिश करते हुए ऐसा लगता है कि सभी लोग ऐसा नहीं करते हैं। क्या आपका इच्छित समाधान इस व्यवहार पर निर्भर करता है?
Sp3000

@ Sp3000 यह मेरा इच्छित समाधान नहीं था, लेकिन यह पूरी तरह से मान्य है - दुभाषिए जो समर्थन नहीं करते हैं जो गलत हैं। यदि आप शेष अनुक्रम के साथ उत्तर पोस्ट करते हैं तो मैं निश्चित रूप से विचार करूंगा कि एक पूर्ण दरार।
जेम्स होल्डरनेस

4

आर, 21 बाइट्स, 10 नंबर क्रैक

__i___________i______

10 नंबर के लिए काम करता है। _छिपा हुआ चरित्र है।

मूल समाधान:

which(letters%in%"a")
which(letters%in%"b")
आदि।


@StewieGriffin इस साइट पर यह मेरी पहली पोस्ट है और मुझे मानदंडों की जानकारी नहीं है। मेरे पास एक और आर चुनौती है - थोड़ा मुश्किल, मुझे लगता है। क्या मैं एक और उत्तर जोड़ सकता हूँ? या यह इस एक करने के लिए?
22

एक नया जोड़ना यह पूरी तरह से ठीक है (एक अलग के रूप में) 😊 साइट पर आपका स्वागत है one
स्टीवी ग्रिफिन

क्या मैंने इसे यहाँ फटा ?
तेनसीबाई

@ तेंसिबाई क्रैक :)
ग्रेगर


3

ऑक्टेव, 32 बाइट्स, 10 नंबर। फटा

_n_(isprime(floor(s____i__ i____

_ एक छिपा हुआ पात्र है।

आप यहां ऑक्टेव ऑनलाइन कोशिश कर सकते हैं


मूल समाधान:

1: nnz(isprime(floor(sqrt(i):pi')))

2: nnz(isprime(floor('sqrt(i):pi')))

3: nnz(isprime(floor('sqrt(i):pia')))

4: nnz(isprime(floor('sqrt(i):piaa')))

...


बहुत अच्छा! फटा । सुनिश्चित नहीं हैं कि क्या मैंने आपका कोड पुन: पेश किया है?
स्टेवि ग्रिफिन

@StewieGriffin अच्छा हुआ! मुझे और चरित्रों का पता लगाना चाहिए था ...: -डॉ
लुइस मेंडू

1
धिक्कार है कि चालाक था :) बहुत बुरा आप यह नहीं कह सकते थे MATLAB ... एक और चरित्र शायद यह बहुत कठिन बना दिया है ... मैं हालांकि यह मज़ा आया ... मैं एक पूर्ण 25 मिनट का इस्तेमाल किया :)
स्टीवी ग्रिफिन

@Stewie हां, आपने नॉन-मैटलैब सुविधाओं का अच्छा उपयोग किया है! :-)
लुइस मेंडू

3

ऑक्टेव, 17 बाइट्स, 10 नंबर, क्रैक

_i_(__i__(2_5_))

अपरिवर्तित वर्णों के साथ चिह्नित हैं _

इरादा समाधान:


    fix(asind(2/59))
    fix(asind(3/59))
    fix(asind(4/59))
    fix(asind(5/59))
    fix(asind(6/59))
    fix(asind(7/59))
    fix(asind(8/59))
    fix(asind(9/59))
    fix(asind(9/55))
    fix(asind(9/50))


फटा (अंततः =) लेकिन शायद आपके मूल दृष्टिकोण के साथ नहीं, है ना?
23

नाइस, ने स्पॉइलर टैग में मेरा दृष्टिकोण जोड़ा :)
स्टीवी ग्रिफिन

2
ओह, आपका समाधान वास्तव में चतुर है !!!
23

3

ऑक्टेव, 19 बाइट्स, 10 नंबर, फटा

__sca__1_)___'-_6_'

_ छिपा चरित्र है।

इरादा समाधान:

पास्कल (10) ( 'A'-96)'



मैं किसी भी समारोह के साथ याद नहीं कर सका sca। आप से आ रहा है, मुझे मैट्रिक्स कार्यों के बारे में सोचना चाहिए था :-)
लुइस मेंडो

एक कारण है कि मैंने ऑक्टेव फ़ंक्शन नामों की पूरी सूची बनाई =)
त्रुटी

3

05AB1E , 5 बाइट्स, 10 नंबर, फटा!

बहुत मुश्किल नहीं है, लेकिन एक मजेदार एक :)

_[==_

_एक यादृच्छिक चरित्र है। CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!


मैं लगभग इसे काम करने के लिए मिल सकता है, लेकिन फिर यह एक अनंत लूप में प्रवेश करता है ...
कृति लिथोस


@daHugLenny Hahaha, यह साफ है! मैंने ऐसा नहीं सोचा था :)।
अदनान

3

05AB1E , 6 बाइट्स, 10 नंबर, फटा

प्रयास 2, इस बार तीन-चार स्ट्रिंग के बिना: पी।

_ [==_

_एक यादृच्छिक चरित्र है। CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!



@milk नाइस, वह इच्छित समाधान था :)
अदनान

3

जावास्क्रिप्ट, 22 बाइट्स, 10 नंबर, फटा

alert(0_6_4_>_0_2_0_7)

_ छिपा चरित्र है।

इच्छित समाधान के बारे में संकेत दें

सभी नंबरों को जेनरेट करने के लिए जिस चरित्र को बदलना होगा, वह हमेशा एक जैसा होता है।



@ ais523 शाबाश!
अरनौलद

3

जावास्क्रिप्ट 21 बाइट्स, 10 नंबर फटा

alert(b_oa_"3____1"))

अपरिवर्तित वर्णों के साथ चिह्नित हैं _

फटा

मेरा संस्करण:

alert(btoa|"3"&("1"))
alert(btoa|"3"^("1"))
alert(btoa|"3"^("0"))
alert(btoa|"3"^("7"))
alert(btoa|"2"^("7"))
alert(btoa|"1"^("7"))
alert(btoa|"0"^("7"))
alert(btoa|"0"^("8"))
alert(btoa|"0"^("8"))
alert(btoa|"2"^("8"))


3

पायथन 3, 19 बाइट्स, 10 नंबर, फटा

print(??bin()?????)

अपरिवर्तित वर्णों के साथ चिह्नित हैं ?। पायथन 3.5.2 में परीक्षण किया गया।



3

अजगर 3, 16 बाइट्स, 10 नंबर, फटा

print(?%??f?r?t)

अपरिवर्तित वर्णों के साथ चिह्नित हैं ?। यह शायद थोड़ा आसान है क्योंकि केवल पांच प्रश्न चिह्न हैं, लेकिन मुझे उम्मीद है कि यह एक मजेदार होगा।



3

C #, 90 बाइट्स, 10 नंबर, फटा

using ______________________________________________;class C{static void Main(){_______;}}

मुझे ईमानदारी से पता नहीं है कि यह दरार करना कितना कठिन है।

संपादित करें: उफ़, प्रतिलेखन त्रुटि। एक के _बाद एक बहुत कम using

अब फटा द्वारा Hedi , जो इरादा (वर्ग के नाम को छोड़कर) समाधान मिल गया।


डीओएच ... लिखने के लिए एक छोटा ()
मास्टरएक्स 244

Didnt मदद ... गलत अंतर। और पहले अंतराल के बाद उस अर्धविराम ने अभिषेक के विचार को विफल कर दिया
मास्टरएक्स 244


3

जावास्क्रिप्ट 33 बाइट्स, 10 नंबर फटा x2

उफ़ मैंने पोस्ट किया 10 के लिए अपनी लाइन पोस्ट की जो Hedi फटा हालांकि यह 1 के लिए था

alert(_to__"_Xc0__0_B6____Zp=="))

संस्करण 1 उत्पन्न करने के लिए पोस्ट करने का इरादा है

alert(_to__"_Xc0__0_Bf____Zp=="))

अपरिवर्तित वर्णों के साथ चिह्नित हैं _

alert(btoa|"0Xc0"-0xBf|!("Zp=="))
alert(btoa|"0Xc0"-0xBe|!("Zp=="))
alert(btoa|"0Xc0"-0xBd|!("Zp=="))
alert(btoa|"0Xc0"-0xBc|!("Zp=="))
alert(btoa|"0Xc0"-0xBb|!("Zp=="))
alert(btoa|"0Xc0"-0xBa|!("Zp=="))
alert(btoa|"0Xc0"-0xB9|!("Zp=="))
alert(btoa|"0Xc0"-0xB8|!("Zp=="))
alert(btoa|"0Xc0"-0xB7|!("Zp=="))
alert(btoa|"0Xc0"-0xB6|!("Zp=="))


मैंने इच्छित संस्करण के लिए एक दरार जोड़ दी। मैं 10 के लिए आपके समाधान के लिए एक रास्ता खोजने की कोशिश करूँगा: console.log(atob|"0Xc0"-0xB6|("Zp=="))मुझे लगता है
हेदी

मैंने अपना उत्तर अपडेट कर दिया कि इरादा दरार क्या होना चाहिए।
हेदी

3

अजगर, 10 + संख्या, 61 बाइट्स, फटा!

यहाँ मैं पोस्ट किया गया कोड था:

try:x
except:print(__import__('sys').??c??n??()[????b????e???

मूल कोड था:

try:x
except:print(__import__('sys').exc_info()[2].tb_lineno)

असल में, यह एक त्रुटि ( 'x' is not defined) फेंकता है और फिर उस रेखा को प्रिंट करता है जिस पर त्रुटि पाई गई थी। इसलिए, केवल संख्या बढ़ाने के लिए शुरुआत में नई कड़ियाँ जोड़ते रहें।

मुझे पता था कि यह दरार करना मुश्किल नहीं होगा - मैं सिर्फ संख्याओं को प्रिंट करने के लिए एक अजीब तरीका चाहता था - लेकिन मैं इसे इतनी तेजी से प्राप्त करने के लिए Sp3000 की उम्मीद नहीं कर रहा था, यह कुछ प्रो कौशल है!


फटा - मनोरंजक, लेकिन हाँ वहाँ वास्तव में कई विकल्प नहीं हैं: पी
Sp3000

@ Sp3000 हाँ, मैं यह सुनिश्चित करना चाहता था कि किसी को हटाने STDOUTऔर एक नंबर को प्रिंट करने में कोई निचोड़ न सके , लेकिन मुझे लगता है कि मैंने इसे बहुत कम कर दिया है। ठीक है।
FlipTack

खुलासा sysनिश्चित रूप से इसे बहुत सरल बना दिया, क्योंकि इसने खोज के लिए एक अच्छा प्रारंभिक बिंदु दिया: पी
Sp3000




2

ऑक्टेव, 25 बाइट्स, 9 नंबर। फटा

__a__repmat(__one___,__)_

_ एक छिपा हुआ पात्र है।


@StewieGriffin क्षमा करें !! केवल 9. मेरी गलती। मैं वास्तव में माफी चाहता हूँ। संपादित
लुइस मेंडो


1
क्षमा करें = P मैं एक प्रतिस्थापन पोस्ट करने जा रहा हूं =)
त्रुटी

@Stewie यह मेरी गलती है, क्षमा करें! मैं बाद में एक संशोधित संस्करण पोस्ट करूंगा, क्योंकि मेरा मूल समाधान अलग है
लुइस मेंडो

रिकॉर्ड के लिए, मेरी दरार त्रुटिपूर्ण के समान थी। मैंने यहां एक और ऑक्टेव पोस्ट किया है
स्टिव ग्रिफ़िन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.