रहस्य स्ट्रिंग प्रिंटर (पुलिस)

Question

डाकू धागा यहाँ पाया जा सकता है: रहस्य स्ट्रिंग प्रिंटर (लुटेरे)

आपकी चुनौती

• एक प्रोग्राम, फ़ंक्शन या REPL स्क्रिप्ट लिखें जो एक स्ट्रिंग को STDOUT में प्रिंट करता है।
• लुटेरे एक प्रोग्राम बनाने की कोशिश करेंगे जो एक ही स्ट्रिंग को प्रिंट करता है।
• यदि वे सफलतापूर्वक 7 दिनों के भीतर कार्यक्रम बना सकते हैं, तो आपका सबमिशन क्रैक हो जाता है।
• यदि कोई भी ऐसा प्रोग्राम नहीं बना सकता है जो 7 दिनों के भीतर एक ही स्ट्रिंग प्रिंट करता है, तो आपका सबमिशन सुरक्षित है। आप अपने कार्यक्रम को प्रकट करने के लिए चुन सकते हैं, या भविष्य के लुटेरों को चुनौती देने के लिए इसे छोड़ सकते हैं। हालांकि, यदि आप इसे प्रकट नहीं करते हैं, तो आप अपने सबमिशन से कोई अंक प्राप्त नहीं कर सकते हैं (यदि आप ऐसा करने के लिए चुनते हैं तो अपने उत्तर शीर्षक में "सुरक्षित" न रखें)।

प्रतिबंध

• कार्यक्रम कुल 128 बाइट्स से कम या बराबर होना चाहिए (बाद में इस पर अधिक)।
• यदि प्रोग्राम प्रोग्राम के नाम, या बाहरी फ़ाइल के नाम / सामग्री पर निर्भर करता है, तो आपको यह कहना होगा कि यह ऐसा करता है, और इसे आपकी कुल बाइट गिनती में शामिल करें।
• मुद्रित स्ट्रिंग 2048 बाइट्स से कम या बराबर होनी चाहिए।
• मुद्रित स्ट्रिंग में केवल मुद्रण योग्य ASCII वर्ण (नई पंक्तियों को शामिल किया जा सकता है) शामिल होना चाहिए।
• कार्यक्रम को हर बार उसी आउटपुट का उत्पादन करना चाहिए जो इसे चलाया जाता है।
• अंतर्निहित क्रिप्टोग्राफ़िक प्रिमिटिव (किसी भी आरएनजी, एन्क्रिप्शन, डिक्रिप्शन और हैश शामिल हैं) की अनुमति नहीं है।
• प्रोग्राम को इनपुट नहीं लेना चाहिए।
• कोई मानक खामियां नहीं हैं।

स्कोरिंग

• यदि सात दिनों से पहले सबमिशन क्रैक किया जाता है, तो सबमिशन 0 अंक अर्जित करता है।
• Of128 अक्षरों का एक सुरक्षित जमाव 1 अंक अर्जित करता है।
• Characters64 अक्षरों का एक सुरक्षित सबमिशन 2 अंक अर्जित करता है। यदि यह 32 बाइट्स से कम या बराबर है, तो यह 4 अंक कमाता है, और इसी तरह।
• प्रत्येक सुरक्षित सबमिशन एक अतिरिक्त 3 पॉइंट बोनस (लंबाई से स्वतंत्र) भी अर्जित करता है।
• आपके पहले वाले के बाद फटे हुए प्रत्येक के लिए एक छोटा (1/2 बिंदु) जुर्माना है।
• ध्यान दें कि डाकू का समाधान प्रोग्राम लंबाई में समान सीमा में होना चाहिए।
• प्रत्येक व्यक्ति प्रति भाषा प्रति बाइट रेंज में अधिकतम 1 कार्यक्रम प्रस्तुत कर सकता है (अलग-अलग संस्करण और एक ही भाषा के मनमाने ढंग से प्रतिस्थापन अलग-अलग भाषाओं के रूप में नहीं गिने जाते हैं)। उदाहरण: आप 32 बाइट और 64 बाइट पाइथ प्रोग्राम पोस्ट कर सकते हैं, लेकिन आप जावा 7 और जावा 8 दोनों में 128 बाइट प्रोग्राम पोस्ट नहीं कर सकते।
• उच्चतम बिंदु कुल जीत वाला व्यक्ति।

प्रस्तुतियाँ

प्रत्येक सबमिशन में निम्नलिखित जानकारी होनी चाहिए:

• भाषा का नाम। सभी नए लुटेरों का समाधान एक ही भाषा होना चाहिए।
• कार्यक्रम के आकार की सीमा (यह कार्यक्रम के आकार से दो अधिक की निकटतम शक्ति है; उदाहरण के लिए, यदि आपका कार्यक्रम 25 बाइट्स है, तो यह "≤32" होगा)।
• वास्तविक स्ट्रिंग का प्रिंट आउट लिया जाएगा।
• यदि सबमिशन सुरक्षित है, तो अपने हेडर में "सेफ" और प्रोग्राम की लंबाई (2 के निकटतम पावर) डालें। यदि आपके हेडर में कई नंबर हैं, तो 2 की शक्ति लगाएं।

यह स्टैक स्निपेट लीडरबोर्ड उत्पन्न करता है और सभी खुले सबमिशन को सूचीबद्ध करता है। यदि स्निपेट के साथ कोई समस्या है, तो कृपया एक टिप्पणी छोड़ दें।

/* Configuration */

var QUESTION_ID = 60328; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 167084; // This should be the user ID of the challenge author.

var SECONDSINDAY = 86400;
var SAFECUTOFFDAYS = 7;
var SORTBYTIME = true;
var SUBTRACTCRACKEDPOINTS = true;
var EXPIREDTIME = 1446336000;


/* App */

var answers = [],
  answers_hash, answer_ids, answer_page = 1,
  more_answers = true,
  comment_page;



function answersUrl(index) {
  return "//api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "//api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {

  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function(data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });

}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function(data) {
      data.items.forEach(function(c) {

        answers_hash[c.post_id].comments.push(c);

      });

      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });
}

getAnswers();


var SAFE_REG = /<h\d>.*?[sS][aA][fF][eE].*<\/\h\d>/;
var POINTS_REG = /(?:<=|≤|&lt;=)\s?(?:<\/?strong>)?\s?(\d+)/
var POINTS_REG_ALT = /<h\d>.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;
var CRACKED_HEADER_REG = /<h\d>.*[Cc][Rr][Aa][Cc][Kk][Ee][Dd].*<\/h\d>/;
var CRACKED_COMMENT_REG = /(.*[Cc][Rr][Aa][Cc][Kk][Ee][Dd].*<a href=.*)|(.*<a href=.*[Cc][Rr][Aa][Cc][Kk][Ee][Dd].*)/
var OVERRIDE_REG = /^Override\s*header:\s*/i;
var LANGUAGE_REG = /<h\d>\s*(.+?),.*<\/h\d>/;
var LANGUAGE_REG_ALT = /<h\d>\s*(<a href=.+<\/a>).*<\/h\d>/
var LANGUAGE_REG_ALT_2 = /<h\d>\s*(.+?)\s.*<\/h\d>/;
var LANGUAGE_REG_ALT_3 = /<h\d>(.+?)<\/h\d>/;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {

  var valid = [];
  var open = [];



  answers.forEach(function(a) {

    var body = a.body;
    var cracked = false;

    a.comments.forEach(function(c) {
      var was_safe = (c.creation_date + (SECONDSINDAY * SAFECUTOFFDAYS) > a.creation_date);
      if (CRACKED_COMMENT_REG.test(c.body) && !was_safe)
        cracked = true;
    });

    if (CRACKED_HEADER_REG.test(body)) cracked = true;

    // if (SUBTRACTCRACKEDPOINTS||!cracked) {

    var createDate = a.creation_date;
    var currentDate = Date.now() / 1000;
    var timeToSafe = (createDate + (SECONDSINDAY * SAFECUTOFFDAYS) - currentDate) / SECONDSINDAY;
    var SafeTimeStr = (timeToSafe > 2) ? (Math.floor(timeToSafe) + " Days") :
      (timeToSafe > 1) ? ("1 Day") :
      (timeToSafe > (2 / 24)) ? (Math.floor(timeToSafe * 24) + " Hours") :
      (timeToSafe > (1 / 24)) ? ("1 Hour") :
      "<1 Hour";

    var expired = createDate > (EXPIREDTIME);

    var safe = timeToSafe < 0;
    var points = body.match(POINTS_REG);
    if (!points) points = body.match(POINTS_REG_ALT);
    safe = safe && !cracked

    isOpen = !(cracked || safe);

    if (points) {
      var length = parseInt(points[1]);
      var safepoints = 0;
      if (length <= 4) safepoints = 32;
      else if (length <= 8) safepoints = 16;
      else if (length <= 16) safepoints = 8;
      else if (length <= 32) safepoints = 4;
      else if (length <= 64) safepoints = 2;
      else if (length <= 128) safepoints = 1;



      valid.push({
        user: getAuthorName(a),
        numberOfSubmissions: (safe && !expired) ? 1 : 0,
        points: (safe && !expired) ? safepoints : 0,
        open: (isOpen && !expired) ? 1 : 0,
        cracked: (cracked && !expired) ? 1 : 0,
        expired: (expired) ? 1 : 0
      });

    }

    if ((isOpen || expired) && points) {

      var language = body.match(LANGUAGE_REG);
      if (!language) language = body.match(LANGUAGE_REG_ALT);
      if (!language) language = body.match(LANGUAGE_REG_ALT_2);
      if (!language) language = body.match(LANGUAGE_REG_ALT_3);



      open.push({
        user: getAuthorName(a),
        length: points ? points[1] : "???",
        language: language ? language[1] : "???",
        link: a.share_link,
        timeToSafe: timeToSafe,
        timeStr: (expired) ? "Challenge closed" : SafeTimeStr
      });
    }
    // }
  });


  if (SORTBYTIME) {
    open.sort(function(a, b) {
      return a.timeToSafe - b.timeToSafe;
    });
  } else {
    open.sort(function(a, b) {
      var r1 = parseInt(a.length);
      var r2 = parseInt(b.length);
      if (r1 && r2) return r1 - r2;
      else if (r1) return r2;
      else if (r2) return r1;
      else return 0;
    });
  }

  var pointTotals = [];
  valid.forEach(function(a) {

    var index = -1;
    var author = a.user;
    pointTotals.forEach(function(p) {
      if (p.user == author) index = pointTotals.indexOf(p);
    });

    if (index == -1) pointTotals.push(a);
    else {
      pointTotals[index].points += a.points;
      pointTotals[index].numberOfSubmissions += a.numberOfSubmissions;
      pointTotals[index].cracked += a.cracked;
      pointTotals[index].expired += a.expired;
      pointTotals[index].open += a.open;
      if (SUBTRACTCRACKEDPOINTS && a.cracked && pointTotals[index].cracked > 1) pointTotals[index].points -= .5;
    }

  });

  pointTotals.forEach(function(a) {
    a.points += (a.numberOfSubmissions) ? ((a.numberOfSubmissions) * 3) : 0;
  });

  pointTotals.sort(function(a, b) {
    if (a.points != b.points)
      return b.points - a.points;
    else if (a.numberOfSubmissions != b.numberOfSubmissions)
      return b.numberOfSubmissions - a.numberOfSubmissions;
    else if (a.open != b.open)
      return b.open - a.open;
    else if (a.cracked != b.cracked)
      return a.cracked - b.cracked;
    else return 0;
  });



  pointTotals.forEach(function(a) {


    var answer = jQuery("#answer-template").html();
    answer = answer
      .replace("{{NAME}}", a.user)
      .replace("{{SAFE}}", a.numberOfSubmissions)
      .replace("{{OPEN}}", a.open)
      .replace("{{CLOSED}}", a.expired)
      .replace("{{CRACKED}}", a.cracked)
      .replace("{{POINTS}}", a.points);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);


  });



  open.forEach(function(a) {
    var answer = jQuery("#open-template").html();
    answer = answer
      .replace("{{NAME}}", a.user)
      .replace("{{LENGTH}}", a.length)
      .replace("{{LANGUAGE}}", a.language)
      .replace("{{TIME}}", a.timeStr)
      .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#opensubs").append(answer);
  });



}

body {
  text-align: left !important
}
#answer-list {
  padding: 10px;
  width: 350px;
  float: left;
}
#open-list {
  padding: 10px;
  width: 470px;
  float: left;
}
table thead {
  font-weight: bold;
  vertical-align: top;
}
table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr>

        <td>Author</td>
        <td>Safe</td>
        <td>Open</td>

        <td>Cracked</td>
        <td>Late Entry</td>
        <td>Score</td>
      </tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>

<div id="open-list">
  <h2>Open submissions</h2>
  <table class="open-list">
    <thead>
      <tr>
        <td>Author</td>
        <td>Length</td>
        <td>Language</td>
        <td>Time Remaining</td>
        <td>Link (open in new tab)</td>
      </tr>
    </thead>
    <tbody id="opensubs">
    </tbody>
  </table>
</div>

<table style="display: none">
  <tbody id="answer-template">
    <tr>
      <td>{{NAME}}</td>
      <td>{{SAFE}}</td>
      <td>{{OPEN}}</td>

      <td>{{CRACKED}}</td>
      <td>{{CLOSED}}</td>
      <td>{{POINTS}}</td>


    </tr>
  </tbody>
</table>

<table style="display: none">
  <tbody id="open-template">
    <tr>
      <td>{{NAME}}</td>
      <td>{{LENGTH}}</td>
      <td>{{LANGUAGE}}</td>
      <td>{{TIME}}</td>
      <td><a target="_parent" href="{{LINK}}">Link</a>
      </td>
    </tr>
  </tbody>
</table>

प्रविष्टियों के लिए निम्नलिखित स्वरूपों का उपयोग करें:

Language, (any text with the program size as the last number)
=

या

Language
=
Length <= 16

ध्यान दें कि स्निपेट केवल हेडर में पहले शब्द को भाषा के रूप में रखेगा यदि वह अल्पविराम का पता नहीं लगाता है।

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

क्रैक सबमिशन के लिए, अपने हेडर में क्रैक डालें।

कार्यक्रम को यह भी पहचानने में सक्षम होना चाहिए कि क्या कोई टिप्पणी "फटा" कहती है और एक लिंक है; हालाँकि, यह गारंटी नहीं है।

टाईब्रेकिंग ऑर्डर: पॉइंट्स -> # ऑफ सेफ सबमिशन -> कम से कम क्रैक सबमिशन की राशि।

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

यह चुनौती अब बंद हो गई है।

अधिकांश अंक समग्र विजेता: डेनिस

सबसे सुरक्षित प्रस्तुतियाँ: DLosc

(ध्यान दें कि सुरक्षित सबमिशन की संख्या एक बिंदु राशि में परिवर्तित नहीं होती है, क्योंकि स्कोर की गणना में कार्यक्रमों के आकार पर विचार किया जाता है)।

Comments

हमें पुलिस को याद दिलाना चाहिए कि कोडगॉल्फ.स्टैकएक्सचेंज. com

— a/

@bmarks भाषा को निष्पादित करने का एक तरीका मौजूद है, और भाषा को ASCII वर्णों की एक स्ट्रिंग प्रदर्शित करने में सक्षम होना चाहिए। यदि आप HQ9 + का उपयोग करना चाहते हैं, तो बधाई हो, आपने अपने आप को एक फटा सबमिशन दिया है।

— डेनियल एम।

@ चिह्न मैं पसंद नहीं करूंगा , लेकिन मैं आपको रोकने वाला नहीं हूं।

— डैनियल एम।

सभी नंबर-केवल आउटपुट सुपर बोरिंग हैं।

— mbomb007 20

कृपया अगली बार सैंडबॉक्स का उपयोग करने पर विचार करें । अधिमानतः, एक चुनौती के नियम पोस्ट किए जाने के बाद बिल्कुल नहीं बदलना चाहिए । मैंने यहाँ कितनी बार नियम बदले हैं ...

— डेनिस

Answer 1

पायथ, सेफ, रेंज Range 8

['ashva', 'cxedo', 'ecckc', 'hhzsq', 'jmwze', 'lrths', 'nwrog', 'pbowu', 'rgldi', 'uljlw', 'wpgsk', 'yuday'

कोड:

%^T6`^G5

व्याख्या:

यह स्पष्ट करने के लिए कि यह कैसे काम करता है: मैंने लोअरकेस अक्षरों के सभी संभव 5 वर्ण तार उत्पन्न किए ( ^G5)। फिर, मैंने इस सूची का स्ट्रिंग प्रतिनिधित्व उत्पन्न किया: ( `^G5)। अंत में, मैंने उस सूची के प्रत्येक 1,000,000 वें चरित्र को लिया ( %^T6)। परिणाम कुछ ऐसा है जो तार की एक सूची की तरह दिखता है, लेकिन संदिग्ध रूप से अपने अंतिम ब्रैकेट को याद कर रहा है।

Comments

क्या कोई करीबी नहीं है ]?

— माल्टसेन

@ मैलेटसेन नोप।

— isaacg

दूसरे आइटम को "xCode" के रूप में तले हुए देखा, सोचा कि यह आईडीई की एक सूची है जो तले हुए हो सकते हैं लेकिन मैं दूसरों में से किसी की पहचान करने में सक्षम नहीं था: ओ

— अल्बर्ट रेनशॉ

मजबूत! मुझे स्ट्रिंग्स में पैटर्न मिला, लेकिन यह पता नहीं है कि इसे <= 8 बाइट्स में कैसे उत्पन्न किया जाए।

— फैबियन शेंगलर

Answer 2

VBA, [सुरक्षित]

रेंज <= 128 बाइट्स

संकेत के लिए जहां उत्पादन करने के लिए

एक्सेल 2007 में रन, डिबग.प्रिंट का आउटपुट था। इसके VBA सौभाग्य को चलाने के लिए 128 बाइट्स के तहत कुछ भी मिल रहा है।

आउटपुट 255 बाइट्स

 This array is fixed or temporarily locked THIS ARRAY IS FIXED OR TEMPORARILY LOCKED this array is fixed or temporarily locked This Array Is Fixed Or Temporarily Locked I n v a l i d   p r o c e d u r e   c a l l   o r   a r g u m e n t  ?????????????????

उपाय

वैसे मुझे उम्मीद है कि किसी को इस एक को क्रैक करने में मज़ा आया था। मैं कह सकता हूं कि यह सबसे खराब त्रुटि-हैंडलिंग है जो मैंने कभी किया है और यह कोड कितना बुरा है इसके लिए बुरा महसूस करता हूं।

कोड

    Sub e()
    On Error Resume Next
    Err.Raise 10
    For i = 0 To 128
    b = b & " " & StrConv(Err.Description, i)
    Next
    Debug.Print b
    End Sub'

व्याख्या की

पहले कोड VBA के प्रमुख पापों में से एक से शुरू होता है। On Error Resume next।
एक बार जब हम उस डरावनी हरकत को अंजाम दे देते हैं तो हम आगे बढ़ जाते हैं और बस फेंक देते हैं और गलती हो जाती है। यह वह This array is fixed or temporarily lockedत्रुटि है जो हम जल्द ही आउटपुट में देखेंगे।

अगला लूप है। हम त्रुटि विवरण को बदलने के लिए 128 बार लूप करते हैं, लेकिन इसके लिए केवल मान्य इनपुट i are 1,2,3,64,128। इसकी वजह से पहले 4 लूप विभिन्न फॉर्मेट्स के साथ एरर प्रिंट करते हैं। फिर जब i = 4कोड एक नई त्रुटि फेंकता है Invalid callतो उस लूप और कुछ भी नहीं सौंपा जाता है bक्योंकि strconvफ़ंक्शन हर बार त्रुटि करता है।

यह वह जगह है जहां किसी भी सामान्य कार्यक्रम को रोक दिया जाना चाहिए, लेकिन क्योंकि हमारे पास On Error Resume Nextहर त्रुटि को नजरअंदाज किया जाता है और कोड खराब त्रुटि से अप्रभावित रहता है।

अब हम हिट करते हैंi=32और हम bयूनिकोड में परिवर्तित होने के लिए नई त्रुटि जोड़ते हैं और तब तक लूपिंग जारी रखते हैं जब तक i = 128कि हम अपनी त्रुटि को यूनिकोड से परिवर्तित नहीं कर लेते हैं जिसके परिणामस्वरूप ?????????????????स्ट्रिंग में जोड़ा जा रहा है b

अंत में त्रुटियों की गड़बड़ी को प्रिंट करें जिसे हमने एक साथ समाप्‍त किया है

Answer 3

गणितज्ञ, सुरक्षित, सीमा safe 64

आउटपुट:

CGTAGGCCCATTTTGTGTGAATTGCGGTGCAGCGAGCGATATGTTGTCTGGGCACGGACGCAGAGTTAGGGTAGCTGGTG

स्रोत:

Print@@Characters["GATC"][[1+First@RealDigits[Pi,4,80]]]

Comments

अब मुझे GenomeLookupसब कुछ करना होगा ...

— LegionMammal978

वास्तव में! यह क्या दिया?

शायद मुझे चिट्ठियाँ बदलनी चाहिए थीं!

योग्य, कई दोहराए जाने वाले पात्रों और 64 बाइट्स के साथ काम करने के लिए आप आसानी से एक फंक्शन बना सकते हैं, उस स्ट्रिंग को बहुत आसानी से प्रिंट कर सकते हैं। xD

— अल्बर्ट रेनशॉ

मैंने स्रोत जोड़ा है। यह निश्चित रूप से जीनोम से संबंधित कुछ भी नहीं है, लेकिन बेस 4 में पाई के 80 अंकों के साथ, लोगों को दोहरे हेलिक्स के बारे में सोचने के लिए "जीएटीसी" का उपयोग करके एन्कोड किया गया है।

Answer 4

ngn APL (सुरक्षित)

0.675640430319848J0.8376870144941628

रेंज ≤ 8

उपाय

*3○⍟⍣=42

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

यह काम किस प्रकार करता है

• ⍟⍣=42एक निश्चित बिंदु तक पहुंचने तक ( ) 0.31813150520476413J1.3372357014306895 की पैदावार होने तक प्राकृतिक लॉगरिदम ( ⍟) को 42 तक बार-बार लागू होता है ।⍣=

  प्रारंभिक मूल्य वास्तव में यहाँ मायने नहीं रखता है, जब तक कि यह न तो 1 है और न ही 0 है ।

• 3○अपने सही तर्क पर लागू होता है, 0.07343765001657206J0.8920713530605129 की उपज देता है ।

• * वांछित आउटपुट के लिए, अपने सही तर्क के लिए प्राकृतिक घातीय फ़ंक्शन को लागू करता है।

Comments

पूर्ण मान काफी नहीं है। दिलचस्प है।

— lirtosiast

Answer 5

Py3, Sp3000 द्वारा फटा

1234465889612101271616181215168242024142718209323236243032163621242510

रेंज ≤ 8

Comments

फटा :)

— Sp3000

Answer 6

> <> (सुरक्षित)

ऑनलाइन और आधिकारिक दुभाषियों पर परीक्षण किया गया।

रेंज: <= 16

स्ट्रिंग: 4621430504113348052246441337820019217490490

यह सुंदर है 1337, हुह?

व्याख्या:

यहाँ स्रोत कोड (15 बाइट्स) है:

f1-:0(?;::0g*n!

fस्टैक पर 15 (हमारे काउंटर) को धकेलता है (यह !अंत में छोड़ दिया जाता है ताकि एक से अधिक काउंटर को धक्का न दें)

1- काउंटर से 1 घटाता है

:0(?; फ्रॉनी चेहरे का परीक्षण करता है यदि काउंटर 0 से कम है, तो बाकी प्रोग्राम समाप्त हो जाता है यदि यह है

:: काउंटर को दो बार दोहराता है

0g(c,0)स्रोत कोड में उस बिंदु पर वर्ण को पकड़ता है जहां cकाउंटर है

* पहले पकड़े गए चरित्र के ASCII प्रतिनिधित्व द्वारा काउंटर के दूसरे डुप्लिकेट को गुणा करता है

n परिणाम प्रिंट करता है।

तो, विभाजित है, आउटपुट है [462, 1430, 504, 1133, 480, 522, 464, 413, 378, 200, 192, 174, 90, 49, 0]। यह कोड की ASCII व्याख्या से संबंधित संख्या 14 से 0 (यानी [!*14, n*13, ... f*0]) से गुणा होती है ।

संभवतः इसे क्रैक करने के बारे में सबसे कठिन हिस्सा यह पता लगाना होगा कि संख्याओं को सही तरीके से कैसे विभाजित किया जाए, लेकिन अगर आपको सही तरीके से प्राप्त होता है तो यह केवल चीजों की कोशिश करने की बात है जब तक कि आपको कुछ ऐसा नहीं मिलता है जो काम करता है।

Answer 7

स्नोमैन 1.0.2

रेंज ≤32।

110110111011011001111100111111111101111110101000101000100001100001100011100011101110110111011011111011111011101011101111101111110111110111111011110101111010111100101100101001111001111111011111011010111010111000000100000011111001111100

समाधान है:

"mO~(!#]/.}{k2'=+@|":2nBspsP;aE

Comments

यह ऐसी अजीब भाषा है ... दरार की कोशिश करने से पहले इसका पता लगाने की जरूरत है ...

— GamrCorps

लगभग वहाँ ... हालांकि एक segfault 11 हो रही है ...

— GamrCorps

Answer 8

मतलाब, .16। वुज़ल से टूट गया

रेंज ≤16 ।

यह ऑक्टेव में भी काम करता है।

मुद्रित स्ट्रिंग निम्नानुसार है:

ans =

     0     0     0     0     0     0     0     0     0
     0     0     0     0     9     4     0     0     0
     0     0     0     0    32    18     0     0     0
     0     0     0     9     1     0     3     0     0
     0     0     7     0     0     2    10     0     0
     0     0     3     0     2     2     3     0     0
     0     0     0    19    63    22     1     0     0
     0     0     0     4    13     4     0     0     0
     0     0     0     0     0     0     0     0     0

Comments

अच्छी नौकरी, मैंने कुछ इस तरह से आने की कोशिश की, लेकिन यह वास्तव में अच्छा है, मुझे वास्तव में कोई सुराग नहीं है कि यह कैसे काम करना चाहिए =)

— निर्दोष

फटकारा

— वुज़ल

Answer 9

पर्ल (सुरक्षित)

84884488488444224424428844884884884488488444224424428844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442442244244244224424422211221221221122122144224424424422442442221122122144224424424422442442221122122144224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212218844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442884488488488448848844422442442442244244288448848848844884884442244244288448848848844884884442244244244224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212218844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442884488488488448848844422442442442244244288448848848844884884442244244288448848848844884884442244244244224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212212212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422442442442244488488448848848844882442442244488488448848848844882442442244244244224448848844884884884488244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448812212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422442442442244488488448848848844882442442244488488448848848844882442442244244244224448848844884884884488244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448812212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422441221221122244244224424424422441221221122244244224424424422441221221122122122112224424422442442442244244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448824424422444884884488488488448824424422444884884488488488448824424422442442442244488488448848848844882442442244488488448848848844882442442244488488448

रेंज ≤ 32

उपाय

print 2**y/124589//for-951..1048

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

यह काम किस प्रकार करता है

• for-951..1048 इस श्रेणी में प्रत्येक पूर्णांक के लिए पूर्ववर्ती कमांड निष्पादित करता है, इसे अंतर्निहित चर में सहेजता है।

• y/124589// निहित चर से निर्दिष्ट अंकों को हटाकर, लिप्यंतरण करता है।

  y/// समाप्त होने की संख्या, यानी, अंतर्निहित चर में उन अंकों की घटनाओं की संख्या वापस आ जाएगी।

• print 2**2 को खत्म करने की शक्ति को प्रिंट करता है ( 1 , 2 , 4 या 8 )।

Answer 10

अजगर, <= 16 ( kennytm द्वारा फटा )

[[[22111101102001]]]

इसका निर्माण REPL (पायथन शेल में एक कमांड चलाने) के माध्यम से किया गया था।

जब मैं इसे संपादित कर रहा हूं, तो मैं भविष्य के बिगाड़ने वाले लुटेरों के लिए टिप्पणियों को भी संक्षेप में प्रस्तुत करूंगा: यह सभी पायथन में काम नहीं करता है। यह Python 2.7 के निर्माण में काम करता है जहां sys.maxint = 9223372036854775807।

Comments

यह बहुत कठिन है।

— J Atkin

क्या यह पायथन 2 और पायथन 3 दोनों में काम करता है?

— DLosc

खें। अजगर 2 केवल, क्षमा करें।

— हिस्टोक्रेट

इसका मतलब यह स्पष्ट रूप से पायथन 3 में काम नहीं करता है ?

— DLosc

यही कारण है कि एक संकेत है, लेकिन हाँ, मैं वादा करता हूँ कि यह अजगर 3. में काम नहीं करता

— histocrat

Answer 11

> <> , [8 [ फटा ]

oooooooooooo

वह कुल 12 oएस है। कार्यक्रम त्रुटि के बिना रुकता है, और आधिकारिक दुभाषिया और ऑनलाइन दुभाषिया दोनों के साथ काम करता है ।

Comments

फटा।

— रैंडम

Answer 12

टीआई-बेसिक, ≤4 बाइट्स, रेटो कोराडी द्वारा फटा

इस दरार में 5 दिन 23 घंटे लगे। बहुत करीब...

आउटपुट (10 बाइट्स):

.495382547

कार्यक्रम:

³√(tanh(7°

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

ऐसा करने के लिए, मैंने आईएससी को दिखाने से आउटपुट, या इन उलटा कार्यों में से एक के साथ आउटपुट को रोका । ISC में अतिशयोक्तिपूर्ण स्पर्शरेखा नहीं है, और मुझे लगा कि कोई समान उपकरण नहीं होगा tanh(7°।

जानवर बल के खिलाफ कुछ सुरक्षा जोड़ने के लिए, मैंने डिग्री-से-रेडियन रूपांतरण, थोड़ा अस्पष्ट सुविधा का उपयोग किया, लेकिन यह पर्याप्त नहीं था।

Comments

@Conor O'Brien आपको केवल 10 बाइट्स की जरूरत है ताकि दशमलव खुद लिखा जा सके!

— आर्कटिकस

यहां सभी TI-84 + BASIC कमांड्स की सूची है, साथ ही पूरी तरह से प्रलेखन भी है।

— lirtosiast

बस इसलिए यह भी स्पष्ट है, थॉमस (और मुझे लगता है कि ज्यादातर लोग) sin(टीआई-बेसिक पर 1 बाइट जैसी चीजों पर विचार करेंगे । तो ऐसा कुछ sin(sin(sin(eकेवल 4 बाइट्स होगा।

— अल्बर्ट रेनशॉ

वास्तव में, हम सभी जानते हैं, वह उपयोग कर सकता है fPart(।

— लेजिओनमाला 978

@AlbertRenshaw हाँ, मैंने उस पर उठाया था। थॉमस ने जिस दस्तावेज़ को जोड़ा था, वह प्रत्येक ऑपरेटर के लिए "टोकन आकार" को सूचीबद्ध करता है। मुझे लगता है कि हम जो गिनती कर रहे हैं, और यह कि वह जिन ऑपरेटरों का उपयोग करता है, वे इस सूची से सबसे अधिक संभावना प्राप्त करेंगे: tibasicdev.wikidot.com/one-byte-tokens ।

— रेटो कोराडी

Answer 13

सीजाम, [8 [सुरक्षित]

379005901358552706072646818049622056

मुझे लंबी संख्या पसंद नहीं है इसलिए यहाँ एक छोटा है। ऑफ़लाइन और ऑनलाइन दोनों को बेझिझक महसूस करें ।

चूंकि मुझे नंबर-केवल प्रस्तुतियाँ बहुत उबाऊ लगती हैं, इसलिए मैं धीरे-धीरे क्षतिपूर्ति करने के लिए कुछ संकेत दे रहा हूं।

संकेत 1: कार्यक्रम ढेर की एक संख्या के साथ समाप्त होता है, और कोई भी A-Kचर का उपयोग नहीं किया जाता है।
संकेत 2: यदि आप प्रक्रिया को उलट देते हैं तो संख्या पूरी तरह से पुनर्प्राप्त करने योग्य होती है (यानी कोई जानकारी नहीं खो गई है)।
संकेत 3: संकेत 2 से "सूचना" एक एकल स्ट्रिंग है जो पहले चार वर्णों के बाद बनाई गई है।

---

उपाय

कार्यक्रम था

0W#sWcib

0W#है 0^-1, जो बदले में देने के बजाय देता है Infinity। sफिर इसे एक स्ट्रिंग (नोट जो इसके बदले `देता है 1d0/) में डाल देता है ।

अन्य आधे के लिए, Wc-1 को एक चार्ट में परिवर्तित करता है, जो कि चार्ट्स के लिए रैपराउंड के कारण कोड बिंदु 65535 हो जाता है (देखें " टिप" )। iफिर चार को एक इंट यानी 65535 पर वापस धर्मान्तरित करता है।

अंत में, उपरोक्त संख्या देने के लिए bस्ट्रिंग Infinityको आधार 65535 में परिवर्तित करता है ।

Answer 14

जावास्क्रिप्ट (कंसोल), <= 32 ( सम्मिलन द्वारा टूटा हुआ )

"a,a,0,a,b,a,a,b,a,a,4,a,b,a,a,a,a,6,a,b,a,a"

क्रोम और फ़ायरफ़ॉक्स वेब कंसोल में परीक्षण किया गया। वह 43 कैरेक्टर की स्ट्रिंग है।

मेरा इरादा समाधान जुड़ा हुआ की तुलना में थोड़ा अधिक विस्तृत था (अभिशाप, ईएस 6!)।

'क, ख, एक, a'.replace (/ (क) / जी, सरणी)

व्याख्या:

जब आप ध्वज और एक फ़ंक्शन के replaceसाथ एक नियमित अभिव्यक्ति के साथ कॉल /gकरते हैं, तो यह इन तर्कों के साथ फ़ंक्शन को कॉल करने के परिणामस्वरूप रेगेक्स से मेल खाती सब कुछ बदल देता है: मिलान किए गए स्ट्रिंग, मिलान किए गए स्ट्रिंग में प्रत्येक कैप्चर समूह, सूचकांक से मिलान स्ट्रिंग है। पूरी स्ट्रिंग, और पूरी स्ट्रिंग। इस स्थिति में, यह "ए", "ए", 0 या 4 या 6 और "ए, बी, ए, ए" होगा। इन सभी तर्कों को ऐरे कंस्ट्रक्टर में पारित किया जाता है, जो बस पास की गई हर चीज़ की एक सरणी बनाता है। फिर replaceउसे एक स्ट्रिंग में परिवर्तित करता है, जैसे "a, a, 0, b, a, a" और "a" को प्रतिस्थापित करता है। इसके साथ चरित्र।

Comments

यह 37 बाइट्स के लिए नीचे चला गया। यह हेक्स की तरह दिखता है, इसलिए आशा है कि मदद करता है।

— mbomb007 22

फटा? :)

— ०१

मैं फिर से आगे नहीं बढ़ सकता, लेकिन यह एक बहुत अच्छा कार्यक्रम है।

— इंसर्टसर्नमीयर

Answer 15

अजगर, <= 32 ( फटा Egor Skriptunoff द्वारा)

आउटपुट में 1832 बाइट्स हैं, जिनमें न्यूलाइन भी शामिल हैं:

163
485
559
1649
2707
8117
8415
24929
41891
124133
142639
423793
694675
2075317
2162655
6357089
10682531
31785445
36635183
108070513
177408659
531963829
551493855
1633771873
2745410467
8135173349
9347869999
27774121841
45526653331
136007297717
141733920735
416611827809
700079669411
2083059139045
2400886719023
7082401072753
11626476472979
34862249549749
36142149804255
107069239746913
179920475038627
533147175478501
612629840276783
1820177075697521
2983606407043475
8913418645908149
9288532499693535
27303489359118433
45881121294188707
136517446795592165
157346912904610351
464159319105013361
761964388609624723
2284767248741900213
2368648071721459935
7016996765293437281
11791448172606497699
34940303480791033061
40148795925132553519
119288945009988433777
195535487181321247123
584146895667469134517
608742554432415203295
1789334175149826506849
3006819284014656913571
8946670875749132534245
10311729937203639353903
30418680977547050616433
49935336207531756227219
149732221646300430475189
155229351380265876857055
459858883013505412260193
772752555991766826787747
2289849682101787770873061
2631225127929856733097263
7817601011229592008423281
12814491939404182769539475
38282841570818685533137589
39893943304728330352263135
117267593836794179779362913
197057915416468570144702627
586337969183970898896814565
675799844894514912336740911
1993549095225501056249169521
3272612129033008707863251603
9813000610033591312052461493
10173266001408484771580813535
30137771616056104203296268641
50643884262032422527188575139
150067460764265635881358255333
172437765505860562200296238383
512342117472953771456036566897
839818522529453467650609486227
2508891813142320379359897758389
2614529362361980586296269078495
7685131765672974922140201517153
12914190492831906312462400487587
38425658828364874610701007585765
44288542855785494654395594310191

Comments

मैं 4 के पैटर्न को देखता हूं।

— जे एटकिन

फटा?

— ईगोर स्क्रीप्टनऑफ

@EgorSkriptunoff Yep - मैंने एक अलग लूपिंग संरचना का उपयोग किया, लेकिन अन्यथा यह एक ही तर्क है।

— DLosc

@ लॉक्स - क्या इसे दूसरे लूप से भी छोटा बनाया जा सकता है?

— ईगोर स्क्रीप्टुनॉफ

@EgorSkriptunoff मैंने पायथन गोल्फिंग तकनीक का उपयोग किया - मैं अपना कोड पोस्ट नहीं करने जा रहा हूं क्योंकि हो सकता है कि मैं किसी अन्य उत्तर में भी ऐसा ही करूं, लेकिन आप पायथन टिप्स पेज पर इस अवधारणा को पा सकते हैं ।

— DLosc

Answer 16

सीजाम ( डेनिस द्वारा फटा )

लंबाई <= 4

1737589973457545958193355601

मैं इसे जीवित रहने का बहुत अधिक मौका नहीं देता, लेकिन मैं वैसे भी 4 बाइट समाधान का प्रयास करना चाहता था।

मेरा कोड वास्तव में डेनिस रिवर्स इंजीनियर था:

H     Push 17
J     Push 19.
K     Push 20.
#     Power.

CJam तब स्टैक कंटेंट के सभी को प्रिंट करता है, संक्षिप्त किया जाता है। तो आउटपुट के 17साथ सहमति थी 19^20।

Comments

फटा।

— डेनिस

@ डेनिस ठीक है, आधिकारिक तौर पर फटा के रूप में चिह्नित। मैं वास्तव में उम्मीद नहीं करता था कि यह पकड़ में आएगा, लेकिन मुझे वैसे भी दिलचस्पी है: क्या आपने इसे बल दिया? या क्या आपने मेरे बारे में अच्छा अनुमान लगाया है?

— रेटो कोराडी

आउटपुट बहुत बड़ा है, लेकिन एक फैक्टरियल या पावर के रूप में कुछ भी हो सकता है, और इस बड़े फैक्टर्स में कुछ ट्रेलिंग जीरो होंगे। मैंने शुरुआत की KK#, कुछ और शक्तियों की कोशिश की, और अंत में पाया JK#।

— डेनिस

Answer 17

लुआ, ua 4 ( झटके से फटा )

आउटपुट:

9.5367431640625e-07

आपको लुआ आरईपीएल के लिए एक स्ट्रिंग खोजने की आवश्यकता है जिसके परिणामस्वरूप "1 / एम" स्थिर है।
यह सरल है, लेकिन बहुत तुच्छ नहीं है।

Comments

@ LegionMammal978 - संकेत: Lua 5.3 REPL में कोई भी =अभिव्यक्ति से पहले छोड़ सकता है ।

— ईगोर स्क्रीप्टुनॉफ

मुझे क्या करना जानते हैं, तथापि, वहाँ कोई जवाब नहीं है कि है यहाँ ...

— LegionMammal978

@ LegionMammal978 - हां, आपने जो लिंक दिया है वह पढ़ने के लिए सही जगह है। आपके पास पहले से ही वह सभी जानकारी है जो आपको चाहिए। बस इसे हल करें।

— ईगोर स्क्रीप्टनऑफ

फटा

— feersum

दिलचस्प नॉन-सॉल्यूशन:0x2p-21

— ड्यूरिनेटर

Answer 18

पिप , <= 16 (सुरक्षित)

यह मेरा अंतिम पिप प्रस्तुत है, मैं वादा करता हूं। :)

0123456789
0        9
0        9
0        9
0        9
0        9
0        9
0        9
0        9
0        9
0        9
0123456789

मुझे आश्चर्य होगा अगर किसी को भी यह 16 बाइट्स तक हो जाए - यह मुझे काफी हद तक फिट बनाने की कोशिश करता है। (यदि आप चाहें तो इसे चुनौती के रूप में लें!)

---

उत्तर:

Px:J,tLtP09JsX8x

यह कोड पूर्वनिर्धारित चर t= 10 और s= स्थान का उपयोग करता है।

    ,t            Range(10)
   J              Join into string: "0123456789"
Px:               Assign to x and print
      Lt          Loop 10 times:
         09         This is a numeric literal, but it can act like a string "09" because
                    strings and numbers are the same data type in Pip
            sX8     8 spaces
           J        Join left arg on right arg: "0        9"
        P           Print
               x  Last expression in a program is autoprinted: "0123456789"

Comments

यह बहुत अच्छा है।

— जे एटकिन

हम्म ... प्रत्येक संख्या कॉलम संख्या, 0-अनुक्रमित है। : - /

— ev3commander

@JAtkin मुझे भी ऐसा लगता है। ^ _ ^ स्पष्टीकरण जोड़ा गया।

— DLosc

बहुत अच्छा, एक +1;)

— जे एटकिन

Answer 19

रूबी, kennytm द्वारा फटा

रेंज: ≤64

#<MatchData "@@" 1:"@" 2:"@">
"#<ArgumentError: unknown command \"\\x00\">\nu#<ArgumentError: unknown command \"\\x00\">\nn#<ArgumentError: unknown command \"\\x00\">\nk#<ArgumentError: unknown command \"\\x00\">\nn#<ArgumentError: unknown command \"\\x00\">\no#<ArgumentError: unknown command \"\\x00\">\nw#<ArgumentError: unknown command \"\\x00\">\nn#<ArgumentError: unknown command \"\\x00\">\n #<ArgumentError: unknown command \"\\x00\">\nc#<ArgumentError: unknown command \"\\x00\">\no#<ArgumentError: unknown command \"\\x00\">\nm#<ArgumentError: unknown command \"\\x00\">\nm#<ArgumentError: unknown command \"\\x00\">\na#<ArgumentError: unknown command \"\\x00\">\nn#<ArgumentError: unknown command \"\\x00\">\nd#<ArgumentError: unknown command \"\\x00\">\n #<ArgumentError: unknown command \"\\x00\">\n\"#<ArgumentError: unknown command \"\\x00\">\n\\#<ArgumentError: unknown command \"\\x00\">\nx#<ArgumentError: unknown command \"\\x00\">\n0#<ArgumentError: unknown command \"\\x00\">\n0#<ArgumentError: unknown command \"\\x00\">\n\"#<ArgumentError: unknown command \"\\x00\">\n@#<ArgumentError: unknown command \"\\x00\">\n@#<ArgumentError: unknown command \"\\x00\">\n"

(और हां, सभी आउटपुट STDOUT के लिए है।)

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

test'@@'=~/(.)(.)/ rescue p"#{$!}#{p$~}".gsub(//,$!.inspect+$/)

Comments

फटा

— kennytm

@kennytm वाह, मैं प्रभावित हूं। आपने इसे मेरे मूल कोड से एक वर्ण छोटा बनाने में भी कामयाबी हासिल की!

— दरवाज़े

Answer 20

TI-बेसिक ( फटा द्वारा थॉमस Kwa )

TI-89 प्रकार
रेंज: Output8
आउटपुट लंबाई: 460

1257286521829809852522432602192237043962420111587517182185282167859393833998435970616540717415898427784984473447990617367563433948484506876830127174437083005141539040356040105854054119132085436114190914221684704295353373344661986220406465038338295680627940567692710933178603763184382721719223039895582218462276317539764129360057392146874652124017927952151332902204578729865820715723543552685154087469056000000000000000000000000000000000000000000000000000000000

मुझे नहीं लगता कि आप इस पर RIES का उपयोग कर सकते हैं लेकिन मुझे संदेह है कि यह वैसे भी 7 दिन तक जीवित रहेगा। ओह अच्छा।

कोड:

236!

Comments

फटा

— lirtosiast

"REIS" क्या है?

— mbomb007

@ mbomb007 mrob.com/pub/ries

— DankMemes

Answer 21

MATLAB, टॉम बढ़ई द्वारा फटा

रेंज <= 16

ans =

        5760       22320
       13920       53940

Comments

जीआरआर, 17 निकटतम है जो मुझे मिल सकता है!

— टॉम कारपेंटर

वास्तव में मैंने अब तक इसे 17 बाइट्स में करने के 8 तरीके ढूंढे हैं!

— टॉम कारपेंटर

फटकारा: codegolf.stackexchange.com/a/60436/42295

— टॉम बढ़ई

आदमी है कि एक मजेदार चुनौती थी!

— टॉम कारपेंटर

Answer 22

Mathematica, Sp3000 द्वारा क्रैक किया गया

रेंज: <= 32

808017424794512875886459904961710757005754368000000000

Comments

फटा

— 3:

Answer 23

थू - <= 64 बाइट्स, हिस्टोक्रैट द्वारा फटा।

555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555

वह 2016 5 एस है; वैसे।

Comments

फटा

— histocrat

Answer 24

CJam, (8 (सुरक्षित)

\"3.341594\43181\

मूल कोड:

P`_`_`er

अर्थात्, 3.141592653589793प्रत्येक वर्ण "3.141592653589793"को उसी वर्ण के साथ शुरू करना और प्रतिस्थापित करना"\"3.141592653589793\"" । हटाए गए डुप्लिकेट के साथ, यह वास्तव में के ".123456789साथ बदल रहा है ""35\.49831।

Answer 25

अजगर 2 (सुरक्षित 16)

(1.06779146638-0.024105112278j)

रेंज printing 16. यदि संस्करण मामले में (मुद्रण परिशुद्धता के लिए?), मैं उपयोग कर रहा हूं आइडोन ।

मुझे कंप्यूटर खोज के बिना कोड का अनुमान लगाने का एक तरीका नहीं दिखता है, लेकिन आप सभी ने मुझे पहले प्रभावित किया है।

---

उत्तर:

print.7j**8j**2j

Comments

क्या यह REPL या एक पूर्ण कार्यक्रम है?

— lirtosiast

@ThomasKwa पूर्ण कार्यक्रम।

— xnor

dir(complex)यह देखने के लिए उपयोग किया जाता है कि कॉम्प्लेक्स संख्याओं के लिए ऑप्स क्या परिभाषित किए गए हैं। मुझे नहीं पता था कि आप एक मापांक का उपयोग कर सकते हैं। ध्यान दें कि यह उपयोगी नहीं होगा, लेकिन शायद ...

— mbomb007

Answer 26

जावास्क्रिप्ट ईएस 6, by128 बाइट्स - क्रैक

आउटपुट (1124 बाइट्स):

00371223425266831021221451701972262572903253624014424855305776266777307858429019621025109011571226129713701445152216011682176518501937202621172210230524022501260227052810291730263137325033653482360137223845397040974226435744904625476249015042518553305477562657775930608562426401656267256890705772267397757077457922810182828465865088379026921794109605980210001102021040510610108171102611237114501166511882121011232212545127701299713226134571369013925141621440114642148851513015377156261587716130163851664216901171621742517690179571822618497187701904519322196011988220165204502073721026213172161021905222022250122802231052341023717240262433724650249652528225601259222624526570268972722627557278902822528562289012924229585299303027730626309773133031685320423240132762331253349033857342263459734970353453572236101364823686537250376373802638417388103920539602400014040240805412104161742026424374285043265436824410144522449454537045797462264665747090475254796248401488424928549730501775062651077515305198552442529015336253825542905475755226556975617056645571225760158082585655905059537600266051761010615056200262501630026350564010

मज़ा करो और अच्छी किस्मत पाओ!

मूल कोड:

new Array(254) .fill(0).map((x,s)=>s*s-s/((5-s)||3)).map(Math.floor).join``

Comments

Still safe :3

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

मुझे इसमें मजा आया। फटा

— SLuck49

@ SLuck49 मैंने कोड पोस्ट किया।

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

Answer 27

TI-BASIC (थॉमस क्वा द्वारा क्रैक)

रेंज: <= 2

स्ट्रिंग: -10

कोड: Xmin

बस इस आदमी को कोई बेवकूफ नहीं बना रहा है ...

Comments

आप पहले से ही फटा नहीं है यह आपके पास है?

— एक

अगर आप यह बहुत चतुर imo है मैं गंभीर रूप से दुखी हो जाएगा।

— एक

पायथन में यह ~9(थोड़ा उलटा) है

— user193661

ज़रूर, लेकिन आपको इसका जवाब TI-BASIC में देना होगा। किसी भी दर पर यह वास्तव में मायने नहीं रखता है; थॉमस ने पहले ही इसे क्रैक कर लिया। मुझे लगता है कि वह सिर्फ अच्छा (?) होने की प्रतीक्षा कर रहा है।

— एक spaghetto

फटा

— lirtosiast

Answer 28

AppleScript, Script 2 बाइट्स क्रैक किए गए

"जानवर मजबूर ... बड़बड़ाना ..."

यह क्या है? एक छोटा AppleScript जवाब? : ओ

अनुपस्थित मान

(हाँ, यह स्टडआउट के लिए प्रिंट करता है)

Comments

a=या a- 1=या 1-? मुझे कोई पता नहीं है) =

— त्रुटी

नहीं। वे त्रुटि # -2741 के रूप में STDERR को फेंक देंगे।

— एडिसन क्रम्प

ऑसस्क्रिप्ट-'' 'क्रैक' 'कहो

— स्क्वीश ऑस्फीफ्रेज

@squeamishossifrage आप एक बाइट का उपयोग करके इसे छोटा कर सकते हैं say"Cracked.", और, अगर आपको व्याकरण से कोई मतलब नहीं है, तो एक और बाइट के साथ say"Cracked"। c:

— Addison Crump

Answer 29

> <> (मछली) , Sp3000 द्वारा क्रैक किया गया

लंबाई <= 8

>>>>>>>>>>>>>>>>>>>>>>>

उत्पादन 23 है >और कार्यक्रम कोई त्रुटि पैदा करता है।

Comments

फटा

— Sp3000

Answer 30

गोल्फस्क्रिप्ट (सुरक्षित)

44460233687688399109436699097976761322375660878906252846699686946304

रेंज ≤ 8

उपाय

{9?7*}.%

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

यह काम किस प्रकार करता है

• {9?7*} स्टैक पर उस ब्लॉक को धकेलता है।

• .% ब्लॉक को डुप्लिकेट करता है और इसे मैप करता है ... खुद पर।

  GolfScript टाइप कास्टिंग करता है जैसे कल नहीं है। इस मामले में, दुभाषिया एक पुनरावृत्ति की उम्मीद करता है, इसलिए मूल ब्लॉक को सरणी में डाला जाता है, निम्न वर्ण कोड की उपज: [57 63 55 55 42] ।

• ब्लॉक स्वयं प्रत्येक वर्ण कोड को नौवीं शक्ति ( 9?) तक बढ़ाता है, फिर परिणाम को सात ( 7*) से गुणा करता है ।

  सरणी में चार वर्ण कोड के लिए, यह धक्का देता है

  44460233687688399
  109436699097976761
  32237566087890625
  2846699686946304
  

  बाहर निकलने से पहले, दुभाषिया चार पूर्णांक प्रिंट करता है, विभाजक के बिना।