द मिस्ट्री स्ट्रिंग प्रिंटर (लुटेरे)

Question

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

आपकी चुनौती

• पुलिस थ्रेड से एक सबमिशन चुनें, और उस थ्रेड में एक उत्तर से स्ट्रिंग प्रिंट करें।
• आपके द्वारा चुना गया जमा सुरक्षित नहीं होना चाहिए (यह 7 दिनों की तुलना में नया होना चाहिए)।

• आपके प्रोग्राम, फ़ंक्शन, या REPL स्क्रिप्ट को समान नियमों का पालन करने की आवश्यकता है क्योंकि पुलिस थ्रेड। बस फिर से बनाने के लिए:

  • आपका प्रोग्राम (128 अक्षर का होना चाहिए (यदि पुलिस का सबमिशन प्रोग्राम की लंबाई की एक छोटी श्रेणी में है, तो आपका प्रोग्राम भी उस लंबाई की सीमा में होना चाहिए। उदाहरण के लिए, यदि पुलिस का प्रोग्राम by32 बाइट्स है, तो आपका प्रोग्राम tes32 बाइट्स का होना चाहिए। )।
  • हर बार चलने पर प्रोग्राम को एक ही आउटपुट का उत्पादन करना चाहिए।
  • कोई क्रिप्टोग्राफिक फ़ंक्शन नहीं।
  • प्रोग्राम को इनपुट नहीं लेना चाहिए।
  • कोई मानक खामियां नहीं हैं।
• सभी नए सबमिशन को एक ही भाषा का उपयोग करना चाहिए। इस नियम से पहले प्रस्तुतियाँ ठीक थीं, भले ही वे न हों।

स्कोरिंग

स्कोरिंग लुटेरों के लिए समान काम करता है, लेकिन यह थोड़ा अलग है:

• ≤8 बाइट्स के किसी भी प्रोग्राम को क्रैक करने से 1 अंक मिलता है।
• By16 बाइट प्रोग्राम क्रैक करने से 2 अंक मिलते हैं। ≤32 बाइट्स 4 अंक देता है, और इसी तरह।
• प्रत्येक अतिरिक्त सबमिशन, कोई फर्क नहीं पड़ता लंबाई, +5 अंक कमाता है
• प्रत्येक पुलिस के सबमिशन को केवल एक बार ही क्रैक किया जा सकता है- प्रत्येक सबमिशन क्रैक करने वाला पहला व्यक्ति अंक प्राप्त करता है।

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

प्रत्येक उत्तर में शामिल होना चाहिए

• पुलिस की अधीनता की एक कड़ी।
• आपका कार्यक्रम और प्रोग्रामिंग भाषा।
• अपने हेडर में अंतिम संख्या के रूप में पुलिस के कार्यक्रम की लंबाई (2 की शक्ति के रूप में) भी रखें।

इसके अतिरिक्त, कृपया अपने उत्तर की लिंक के साथ पुलिस के प्रस्तुतिकरण पर टिप्पणी करें।

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

/* Configuration */

var QUESTION_ID = 60329; // 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";

/* 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 POINTS_REG = /(?:<=|≤|&lt;=)\s?(?:<\/?strong>)?\s?(\d+)/
var POINTS_REG_ALT = /<h\d>.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\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;

    var points = body.match(POINTS_REG);
    if (!points) points = body.match(POINTS_REG_ALT);

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

      valid.push({
        user: getAuthorName(a),
        numberOfSubmissions: 1,
        points: crackedpoints

      });
    }
  });

  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++;
    }

  });

  pointTotals.forEach(function(a) {
    a.points += +((a.numberOfSubmissions - 1) * 5);
  });

  pointTotals.sort(function(a, b) {
    var aB = a.points,
      bB = b.points;
    return (bB - aB != 0) ? bB - aB : b.numberOfSubmissions - a.numberOfSubmissions;
  });

  pointTotals.forEach(function(a) {


    var answer = jQuery("#answer-template").html();
    answer = answer
      .replace("{{NAME}}", a.user)
      .replace("{{SUBMISSIONS}}", a.numberOfSubmissions)
      .replace("{{POINTS}}", a.points);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);


  });

}

body {
  text-align: left !important
}
#answer-list {
  padding: 20px;
  width: 240px;
  float: left;
}
#open-list {
  padding: 20px;
  width: 450px;
  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>Robber's Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr>

        <td>Author</td>
        <td>Submissions</td>
        <td>Score</td>
      </tr>
    </thead>
    <tbody id="answers">

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

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

यह प्रतियोगिता अब बन्द हो चुकी है।

कुल मिलाकर विजेता: kennytm

अधिकांश प्रस्तुतियाँ: Sp3000

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

Comments

नोट: प्रत्येक अतिरिक्त सबमिशन 5 अंक अर्जित करता है

— डैनियल एम।

Answer 1

पायथ, डेनिस,, 8

V./Tp*FN

लानत है कि मज़ेदार था - सबसे कठिन हिस्सा यह पता लगा रहा था कि इसे पायथ में कैसे कम किया जाए।

विश्लेषण

1234शुरू संकेत है कि हम शायद नंबरों की सूची के साथ काम कर रहे हैं पर, एक विभाजक के बिना मुद्रित। आइए कोशिश करते हैं और संख्याओं को एक तरह से विभाजित करते हैं जो समझ में आता है:

1 2 3 4 4 6 5 8 8 9 6 12 10 12 7 16 16 18 12 15 16 8 24 20 24 14 27 18 20 9 32 32 36 24 30 32 16 36 21 24 25 10

कुछ संकेत हैं कि हम सही रास्ते पर हैं:

• सभी संख्याओं में 10 से कम कारक होते हैं
• सूची में बहुत सारे नंबर उनके सूचकांक के बहुत करीब हैं

हालांकि, कुछ ख़ासियतें हैं। सूचकांक 23 पर संख्या 24 है, और एकमात्र ऐसा मामला है जहां सूचकांक में संख्या सूचकांक की तुलना में अधिक है। हालांकि, बड़ा सुराग यह है कि कुछ संख्या उनके पड़ोसियों की तुलना में स्पष्ट रूप से छोटी है, विशेष रूप से सूचकांक 15 पर 7, सूचकांक 22 पर 8 और सूचकांक 30 पर 9।

यह देखते हुए कि यह 7-8-9 पैटर्न बनाता है, हम यह भी देख सकते हैं कि अंतिम संख्या सूचकांक 42 पर एक 10 है। @ @ डेनिस ने एबेलियन समूहों पर हाल के प्रश्न को देखते हुए , OEIS पर एक त्वरित जांच से पता चलता है कि विभाजन के15, 22, 30, 42 बाद की स्थिति है संख्या । पायथ में विभाजन के लिए एक बेसिन है, जो हमें आठ में से दो अक्षर देता है:./

लेकिन ध्यान दें कि अंतिम संख्या 10 है, जो संदेहास्पद है, क्योंकि 10 पायथ में एक पूर्व-निर्धारित चर है, जैसा कि T। ./T10 के 42 विभाजन की पूरी सूची देता है, जो ऐसा लगता है कि यह काम में आ सकता है।

अब मुद्रण एक विभाजक के बिना किया जाता है, इसलिए यह उपयोग के संकेत देता है p। शायद हम प्रत्येक विभाजन के माध्यम से लूप करते हैं, इसके लिए कुछ करते हैं, फिर प्रिंट करते हैं p? यह हमें निम्नलिखित टेम्पलेट देता है:

V./Tp??N

Vलूप के लिए कहां है जो चर में प्रत्येक तत्व को संग्रहीत करते हुए, एक पुनरावृत्त पर लूप करता है N।

दूसरे अंतिम विभाजन पर एक त्वरित नज़र (5, 5)यह स्पष्ट कर देना चाहिए कि हम एक उत्पाद लेना चाहते हैं। गुणन द्वारा किसी सूची को कम करने का भोला तरीका है

u*GHd1

dप्रश्न में सूची कहां है हालाँकि, यह बहुत लंबा है।

दुर्भाग्य से, यह वह जगह है जहां मुझे एक ब्रूट फॉरेसर को बाहर निकालना पड़ा। मैंने कुछ समय के लिए पायथ के साथ नहीं रखा है, इसलिए मुझे कई नई विशेषताओं के बारे में पता नहीं था। केवल दो पात्र बचे थे, जो पूरी तरह से उल्लेखनीय थे।

ब्रूट फॉरेसर फिर लौटा:

V./Tp*FN

जहां *Fगुना *(गुणा) है। कोई आश्चर्य नहीं कि मैं इसे अपनी खोज में नहीं मिला - मैं "गुना" के बजाय "कम" कीवर्ड को देख रहा था!

Comments

7 में भी संभव:jk*M./T

— जकूबे

@ जकुब ओह वाह, अगर रेंज <= 7होती तो मैं बर्बाद हो जाता। जब से मैंने भाषा की जाँच की है, यह सुनिश्चित हो गया है।

— Sp3000

Answer 2

गणितज्ञ, अल्फाल्फा, alp 32

GroupOrder[MonsterGroupM[]]

मुझे यह कहने से नफरत है, लेकिन मैंने मौके पर संख्या को पहचान लिया।

Comments

और भी छोटा:31!10!27079205916672

— kennytm

दमयन्ती, मुझे पता था कि वह संख्या परिचित लग रही थी।

— डेनिस

Answer 3

> <>, VTCAKAVSMoACE, TC 64

'9?':?!;1-$:'@'+o'3'*'='%$30.

विडंबना यह है कि न केवल यह सीमा की सीमा से बहुत कम है, यह पोर्टेबल भी है और ऑनलाइन दुभाषिया के साथ काम करता है ।

विश्लेषण

चलो लक्ष्य स्ट्रिंग से शुरू करते हैं:

yh[cPWNkz^EKLBiQMuSvI`n\Yw|JVXDUbZmfoRC_xrq{TlpHjGt]OadFAsgeyh[

> <> स्टैक के साथ 'या "स्ट्रिंग मोड में स्टैक पर धकेलता है, लेकिन प्रिंट करने के लिए 63 चार्ट के साथ और केवल 64 बाइट्स के साथ काम करने के लिए, कैपिटल लेटर्स की मौजूदगी (मानक निर्देश में> <>, स्टैंडर्ड लूपअरेक्शन ट्रिक के लिए) डायरेक्ट प्रिंटिंग करें असंभव। इसलिए, हमें कोड बिंदुओं के साथ कुछ करना चाहिए।

कोड बिंदुओं में परिवर्तित करना (मैं यहां पायथन का उपयोग कर रहा हूं):

>>> L = [ord(c) for c in "yh[cPWNkz^EKLBiQMuSvI`n\Yw|JVXDUbZmfoRC_xrq{TlpHjGt]OadFAsgeyh["]
>>> L
[121, 104, 91, 99, 80, 87, 78, 107, 122, 94, 69, 75, 76, 66, 105, 81, 77, 117, 83, 118, 73, 96, 110, 92, 89, 119, 124, 74, 86, 88, 68, 85, 98, 90, 109, 102, 111, 82, 67, 95, 120, 114, 113, 123, 84, 108, 112, 72, 106, 71, 116, 93, 79, 97, 100, 70, 65, 115, 103, 101, 121, 104, 91]

ध्यान दें कि पिछले तीन नंबर पहले तीन के समान हैं। यह एक संभव modulo पाश पर संकेत देता है।

आइए एक नजर डालते हैं कि हमारे पास कितने अलग-अलग तत्व हैं:

>>> len(set(L))
60

हमारे पास 63 तत्व हैं L, जिनमें से पहले तीन अंतिम तीन के साथ मेल खाते हैं। इसका मतलब है कि, इस टकराव से अलग, अन्य सभी तत्व अद्वितीय हैं। अब यह संकेत देता है कि शक्तियां मोडुलो को एक प्रमुख संख्या में ले जा रही हैं। दरअसल, 60 + 1 = 61प्राइम, जो एक अच्छा संकेत है।

आइए सबसे छोटे तत्व को खोजने का प्रयास करें

>>> min(L)
65

और सभी तत्वों को नीचे रखने के लिए इसका उपयोग करें ताकि न्यूनतम तत्व 1:

>>> M = [x-64 for x in L]
>>> M
[57, 40, 27, 35, 16, 23, 14, 43, 58, 30, 5, 11, 12, 2, 41, 17, 13, 53, 19, 54, 9, 32, 46, 28, 25, 55, 60, 10, 22, 24, 4, 21, 34, 26, 45, 38, 47, 18, 3, 31, 56, 50, 49, 59, 20, 44, 48, 8, 42, 7, 52, 29, 15, 33, 36, 6, 1, 51, 39, 37, 57, 40, 27]

ध्यान दें कि तत्व कैसा 1है 51। यदि किसी प्रकार की शक्तियाँ / गुणन बात चल रही है, तो यह हमारे गुणक के लिए एक अच्छा अनुमान है।

चलो इसे एक शॉट दें:

>>> (57*51)%61
40
>>> (40*51)%61
27
>>> all((x*51)%61 == y for x,y in zip(M, M[1:]))
True

बिंगो! अब हम निम्नलिखित कोड दे सकते हैं:

x = 57
for _ in range(63):
    print(chr(x + 64), end="")
    x = (x*51)%61

जो तब> <> में अनुवादित किया गया था

Comments

दिलचस्प है, यह मेरे द्वारा किए गए कई तरीकों से भिन्न है - मैंने 37 और 112 का उपयोग किया (मतलब 101 का उपयोग करने के लिए, लेकिन कोड में एक गलती की। महाकाव्य असफल) 63 के साथ एक जारी गुणा सेट और modulo'd के रूप में, फिर 64 जोड़ा। एक पठनीय ASCII रेंज में मिलता है। +1 अच्छा किया।

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

बहुत अच्छा, काश मैं ऐसा कर पाता;)

— जे एटकिन

Answer 4

पायथ, माल्टीसेन, sen4

C.ZG

ब्रूट बल में इतना समय लगा कि मैंने इसे तेजी से मैन्युअल रूप से किया।

विश्लेषण

C(Convert string to base 256 int) पायथ में एक बड़ी संख्या उत्पन्न करने का सबसे आसान तरीका है, इसलिए यह संभवतः पहला चरित्र है। यदि हम आधार 256 से परिवर्तित करते हैं, तो हमें यह मिलता है:

xÚKLJNIMKÏÈÌÊÎÉÍË/(,*.)-+¯¨¬ 

हम्म ... बहुत रोशन नहीं।

अब Gवर्णमाला स्ट्रिंग है "abc...z", जो ऐसा लगता है कि यह एक लंबी स्ट्रिंग के लिए स्रोत हो सकता है C। मेरे द्वारा खोजे गए डॉक्स के माध्यम से:

.Z    Compresses or decompresses a string.

यदि हम यहां संपीड़न से निपट रहे हैं, तो सभी प्रकार के विस्तारित ASCII वर्ण प्राप्त करना आश्चर्यजनक नहीं होगा। C.ZGफिर कोशिश करके जवाब दिया।

Answer 5

फूरियर, बीटा क्षय, Dec 32

2~x1~y20(xoy~z*x~yz~xq^~q)

या वैकल्पिक रूप से, CJam में:

X0I{_2$+}*]2\f#

विश्लेषण

शुरुआत में हम 2 की बहुत सारी शक्तियाँ देख सकते हैं:

2
1
2
2
4
8
32
256
8192
2097152
...

यदि हम इन नंबरों के लॉग बेस 2 को लेते हैं, तो हमें यह मिलता है:

1 0 1 1 2 3 5 8 13 21 ...

जो फिबोनाची श्रृंखला है, जो शुरू होती है 1, 0।

Answer 6

घोंघे, feersum, ≤2 बाइट्स

z

यह वास्तव में 2 बाइट्स है; zएक नई लाइन के बाद चरित्र \n।

मुझे नहीं पता कि यह कैसे काम करता है या क्या कर रहा है, लेकिन इसके अलावा सभी संभावित आदानों का परीक्षण करने के बाद ~+और ~,यह केवल 2-बाइट प्रोग्राम था जो 8आउटपुट के रूप में उत्पन्न हुआ था ।

और इस परिणाम को प्राप्त करने में उम्र लग गई । कोई आश्चर्य नहीं कि इसे "घोंघे" कहा जाता है :- डी

---

^{स्वयं पर ध्यान दें: अगली बार जब आप अज्ञात सॉफ़्टवेयर का परीक्षण करते हैं, तो इसे वीएम के अंदर करें।}

Answer 7

जंग, लियाम नोरोन्हा, ,128 बाइट्स

fn main(){print!("AACAAEGAAACIIMOAAACAAEGQQQSYYDFAAACAAEGAAACIIMOHHHJHHLNXXXAGGKMAAACAAEGAAACIIMOAAACAAEGQQQSYYDFOOO");}

बस स्ट्रिंग वर्बेटिम को प्रिंट करना 120 बाइट्स है ...

Comments

जब मैंने ऐसा किया तो वाह, देर हो गई। तो सॉरी सॉरी। मैं बिना किसी प्रयास के पाठ को अधिक लंबा बना सकता था। मैं वास्तविक स्रोत पोस्ट करूँगा।

— लियाम

Answer 8

मैकरोनी 0.0.2, डोरकनॉब, ob64

set x "................................."print x print x print x

Answer 9

पायथन 2, उदाहरणों के साथ स्पष्ट प्रश्न, <= 64

एक संभव समाधान:

print ''.join([" `{.~{{~||"[int(c)] for c in str(3**4278)])

( 9**2139, 27**1426और 729**713भी वही परिणाम दें)

Answer 10

CoffeeScript, user2428118, ,64

alert 0+(btoa k.substr -2 for k of document.body.style).join ''

(कॉप द्वारा वर्णित के रूप में केवल क्रोम 46.0.2490.71 पर काम करता है।)

---

उत्पादन स्पष्ट रूप से सभी "=" के कारण छोटे बेस 64-एन्कोडेड स्ट्रिंग्स का एक संयोजन है। उन्हें डिकोड करने के बाद, हमें 2-वर्ण स्ट्रिंग्स की एक सूची मिलती है जैसे

['nt', 'ms', 'lf', 'ne', 'll', 'on', 'ay', 'on', …

जो समझ में नहीं आता है। लेकिन मुझे इसमें कुछ अजीब चीजें पसंद हैं, जैसे nXऔर tY। इन्हें छानने के बाद हमें मिलता है

>>> # Python
>>>
>>> [i for i in tt if not re.match('[a-z]{2}$', i)]
['nX', 'nY', 'tX', 'tY', 'wX', 'wY', 'r', 'nX', 'nY', 'tX', 'tY', 'nX', 'nY', 'nX', 'nY', 'nZ', 'x', 'y']

ये X और Y मूल स्रोत कोड का उपयोग करते हैं जैसे स्थिति गुण का संकेत देते हैं offsetX/Y। एक विशेष रूप से दिलचस्प nZआइटम है। मेरी धारणा की जांच करने के लिए, मैंने "Z" के साथ समाप्त होने वाली सभी संपत्तियों की खोज की:

// CoffeeScript
checked = []
f = (o) ->
    if !(o in checked) 
        for k of o
            if /Z$/.test(k)
                console.log(o, k)
            if o[k] instanceof Object
                f o[k]
f window

जो टन दिखाता है CSSStyleDeclaration, "webkitTransformOriginZ"। इससे हमें एक मजबूत संकेत मिलता है कि सूची किसी styleवस्तु की सभी कुंजियों के अंतिम 2 पात्रों द्वारा बनाई गई है , जो कि उपरोक्त परीक्षण वास्तव में सही है।

Comments

आपको यह मिल गया, बधाई! मूल स्रोत कोड

— user2428118

Answer 11

लुआ <= 4, ईगोर स्क्रीप्टुनॉफ़

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

4^~9

यह बहुत स्पष्ट होगा, लेकिन शायद किसी को भी नहीं मिला क्योंकि बिटवाइज़ ऑपरेटरों को केवल संस्करण 5.3 में जोड़ा गया था; ideone.com में केवल संस्करण 5.2 है।

Comments

फेसपालम I ने बिटवाइज़ ऑपरेटरों की अनदेखी की क्योंकि वे केवल पूर्णांक का उपयोग करते हैं।

— लेजियन मम्मल 978

Answer 12

अजगर 2, हिस्टोक्रेट, h16

[[[51002**3/6]]] 

---

सबसे बड़ा संकेत यह वादा है कि यह पायथन 3 में काम नहीं करेगा। पायथन 3 में क्या बदला है ? सबसे बड़ा संदेह यह है कि डिवीजन ऑपरेटर floatपायथन 3 में रिटर्न करता है।

तो मुझे लगता है समाधान फार्म की है ⌊α ^बीटा / n⌋ = c = 22111101102001, घातांक के रूप में केवल छोटे रास्ते बड़ी संख्या बनाने के लिए है।

यदि {α, β, n} वास्तव में एक समाधान बनाता है, तो (cn) ^{1 / β β} α एक पूर्णांक के बहुत करीब होना चाहिए। इसलिए मैं निम्नलिखित का उपयोग प्रत्येक n के लिए {α,-} को भंग करने की कोशिश करने के लिए करता हूं:

(* Mathematica *)
n=2; Sort[Table[{N[Abs[k - Round@k] /. k -> (22111101102001*n)^(1/b), 12], b}, {b, 2, 50}]]

(* Output: {{0.00262542213622, 7}, ...}

   The first number is the "quality" of the solution, lower is better.
   the second number is β.
   Thus α ≈ (nc)^(1/β) = 89
   But (89^7)/2 = 22115667447764, which is still far away from the answer.

*)

वास्तविक परिणाम जल्दी से बाहर आता है जब n = 6।

Comments

बहुत बढ़िया! यही इच्छित समाधान है, और मैं कैसे उम्मीद करता हूं कि कोई इसे हल करेगा (हालांकि मुझे समय से पहले एहसास नहीं हुआ कि यह कैसे मंच पर निर्भर था)।

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

Answer 13

MATLAB, StewieGriffin, ew 16

[36;87]*' |'*5

प्रिंटों:

ans =
        5760       22320
       13920       53940

Comments

अच्छा! खुशी है कि आपको यह पसंद आया :-) मैंने इसे जिस तरह से किया था 5*'$W'.'*' |':।

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

मैं इसे .735 से करने के बजाय उदाहरण के लिए गुणा करके बहुत कठिन बनाने पर विचार कर रहा था +5, या इसे एक 3x3मैट्रिक्स बना दिया था, लेकिन लगा कि यह अधिक मजेदार था। शेष तीन बाइट्स के साथ बहुत कुछ किया जा सकता था।

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

@StewieGriffin .'पहले कभी नहीं आया , लेकिन पूरी तरह समझ में आता है - सोच रहा था कि ब्रैकेट्स का सहारा लिए बिना किसी स्ट्रिंग को कैसे स्थानांतरित किया जाए।

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

Answer 14

मतलाब, लुइस मेंडो, .16

मैंने पाया, याय!

fix(peaks(9).^2)

मुझे नहीं पता था कि ऑक्टेव भी ऐसा कर सकता है।

Comments

कैसे? आपने सुना था peaks()?

— 14

हाँ मेरे पास है। मैं खतरे के साथ खेल रहा हूं peaks।

— वुज़ल

Answer 15

गणितज्ञ, लीजनमोनमल 978, Leg64

Print@Nest[Compress,ExampleData[{"Text","ToBeOrNotToBe"}],13]

Answer 16

पायथन, स्पेसमैनजॉश, on 64

n=0;d=1;L=[]
exec("L+=[10/(100-n)**.5];n+=d;d+=2;"*10)
print(L)

गौरवशाली विलोम प्रतीकात्मक कैलकुलेटर। अच्छी तरह से गोल्फ नहीं है, लेकिन यह फिट बैठता है।

संपादित करें: मैंने इसे गोल्फ दिया।

print([10/(100-n*n)**.5for n in range(10)])

Answer 17

जावास्क्रिप्ट ES6, C ES O'Bʀɪᴇɴ, tes128 बाइट्स

var x=122,s='0037122342526683102122';for(var i=23;i<=505;i+=2)s+=(x+=i);s;

मुझे संदेह है कि यह बिल्कुल सही है क्योंकि मुझे 128 बाइट्स के पास कहीं भी ज़रूरत नहीं थी, लेकिन एक दोहराए गए अनुक्रम को खोजना मजेदार चुनौती थी।

Comments

वाह। मैंने पूरी तरह से अलग तरीके का इस्तेमाल किया। क्या अब भी गिनती है? : 3

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

@ C @O'Bʀɪᴇɴ आमतौर पर करता है। मैं वास्तव में मूल के बारे में उत्सुक हूं और उन 22 बाइट्स का उत्पादन करता हूं, हालांकि, मैं लूप

— इनिट

समय मिलने पर पोस्ट कर दूंगा। मुझे लगता है कि इसके फ़ंक्शंस की फ़्लोरिंग s * s - s / (5-s)

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

Answer 18

थ्यू, पपीरी, <= 64

0::=11
1::=22
2::=33
3::=44
4::=55
a::=bbb
b::=000
::=
aaaaaaa

अनिवार्य रूप से 2016 को अपने प्रमुख कारकों में शामिल करता है। 62 अक्षर, इसलिए मेरा अनुमान है कि यह वैसा ही है जैसा आप लिए जा रहे थे।

Comments

आप कुछ बाइट्स को बचाने के लिए 0 :: = 2222 कर सकते हैं।

— २०:१५ पर २०

निष्पक्ष बिंदु, हालांकि थोड़ा कम सुंदर लगता है।

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

Answer 19

पायथन, DLosc, .32

(यह समाधान पायथन 2 का उपयोग करता है)

a=97
while a<4e31:a^=a*2;print a

Answer 20

> <>, Sp3000, <= 8

'l(?; o>

निर्देश सूचक चारों ओर लपेटता है और निम्न चरण होते हैं:

• 'l(?; o>'l(?; o>स्टैक के ASCII मान को धकेलता है
• l स्टैक पर स्टैक का आकार बढ़ाता है
• (शीर्ष दो स्टैक तत्वों की तुलना करें: size of stackऔरord('>')
• ?; स्टैक का आकार बड़ा होने पर प्रोग्राम को रोक देता है
• oचरित्र के रूप में स्टैक के शीर्ष तत्व का उत्पादन (यह हमेशा होगा o)
• > IP दिशा सेट करता है, यहाँ यह no-op है
• हम पहले चरण पर वापस जाते हैं

आउटपुट है oooooooooooo।

हम कुछ अलग-अलग आउटपुट प्राप्त कर सकते हैं [space]जो कि स्टैक पर धक्का या चबूतरे के बजाय किसी अन्य वैध चरित्र का उपयोग करके बदल >सकते हैं, जो धक्का या पॉप भी हो सकता है।

Comments

अच्छा! संदर्भ के लिए, मेरे पास था:'l=?;o*

— Sp3000

Answer 21

जावास्क्रिप्ट, ev3commander, ander 32

console.log(0.1411200080598672)

ठीक है, यह आसान था।

Answer 22

सीजाम, रेटो कोराडी, o 4

HJK#

धक्का 17 , फिर 19 ²⁰ = 37589973457545958193355601 ।

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

केवल चार बाइट्स में बहुत सी चीजें हैं जो आप कर सकते हैं। इस पूर्णांक में किसी शक्तियां या फैक्टरियल को किसी तरह शामिल करना था, और एक फैक्टरियल के पीछे शून्य होना चाहिए।

Comments

यह सही है। मैं आज बाद में आधिकारिक पोस्ट अपडेट को संभालूंगा।

— रेटो कोराडी

Answer 23

पायथ <= 4, डेनिस

ljyG

वर्णमाला के सभी सबसेट की नई लाइनों में शामिल होने की लंबाई है।

परीक्षण चालन:

$ pyth -cd 'ljyG'
==================== 4 chars =====================
ljyG
==================================================
imp_print(Plen(join(subsets(G))))
==================================================
939524095

मुझे पता चला 2^27 * 7 - 1कि यह संख्या एक मजबूत संकेत थी जो कि इस पर आधारित है yG, जो कि 2^26तत्व लंबा है। मैंने तब अनुमान लगाया कि इसे एक स्ट्रिंग में परिवर्तित किया जाना था और इसकी लंबाई मुद्रित की गई थी। हालांकि, ऐसा करने का एकमात्र तरीका मैं कुछ समय के लिए सोच सकता था ``, रिप। फिर मैंने सोचा j, जो पूरी तरह से फिट बैठता है।

Answer 24

सी, ट्यूक्सी, i64

main(i){for(i=0;i<11000;++i)if(!(i&2*i))printf("1%d",!(i&1));}

---

आउटपुट सभी 0 और 1 हैं, लेकिन C सीधे बाइनरी प्रिंट नहीं कर सकता है, इसलिए यह संभावना है कि ये बूलियन परिणाम हैं।

0 से अधिक 1 हैं, इसलिए मैंने 0s ( 3, 9, 13, 19, …) की स्थिति दर्ज की , जो OEIS A075318 निकला । यह उपयोगी नहीं है, हालांकि, यह निर्धारित करने के लिए कोई सरल सूत्र नहीं है कि कोई संख्या इस क्रम में कहां है।

लेकिन हम ध्यान दें कि सभी विषम संख्याएं हैं, इसलिए शायद (x-1)/2 = {1, 4, 6, 9, 12, …}अधिक उपयोगी जानकारी हो। और यह A003622 है ।

A003622 को " A003849 में 1 की स्थिति" के रूप में परिभाषित किया जा सकता है , जो कि वास्तव में हमें यहां दरार करने की आवश्यकता है। और A003849 को " A003714 mod 2" के रूप में परिभाषित किया गया है , जहां A003714 सभी पूर्णांक हैं x & (2*x) == 0। इस प्रकार हमें समाधान मिल गया है।

OEIS rox।

Comments

वास्तव में प्रभावशाली - मैं इस साइट के उपयोगकर्ताओं द्वारा हैरान होने से कभी नहीं

— बचता

Answer 25

डायलाग एपीएल, डेनिस, og4

*⍨⍟8

कंप्यूट ln (8) ^ ln (8)। क्या StackExchange मेरे उत्तरों को बदलना बंद कर देगा? मैं यहाँ सामान का एक गुच्छा टाइप करूँगा ताकि यह एक टिप्पणी में बदल न जाए।

Comments

मेरे पास था, 8*⍟⍟8लेकिन मैं नहीं जानता था ⍨। अच्छा काम :)

— Sp3000

Answer 26

अटक, @ कर्ता, .8

निम्नलिखित पायथ कार्यक्रम:

^33 9

वांछित उत्पादन करता है

46411484401953

क्रैकिंग विधि: संख्या के लिए Google की खोज की।

Answer 27

अजगर, xnor, or 4

C`CG

CG( "abc...z"आधार 256 से वर्णमाला स्ट्रिंग में परिवर्तित करें ) वास्तव में बड़ी संख्या में उत्पन्न करने का विशिष्ट पायथ तरीका है। उसके बाद यह केवल कठोर है और फिर से आधार से परिवर्तित होता है।

Answer 28

पायथन 3, मेगो, on128

(पायथन 3.5.0 का उपयोग करके, पिछले संस्करणों पर परीक्षण नहीं किया गया। 105 98 बाइट्स।)

import sys
a=sys.stdout
sys.stdout=None
from this import*
a.write(s.translate(s.maketrans(d))[4:])

Comments

बहुत अच्छा! मैंने इसे 94 में किया था, कोड के लिए मेरी पुलिस पोस्ट देखें।

— मेगो

Answer 29

रूबी, डॉर्कनोब, .64

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

Answer 30

मतलाब / ऑक्टेव, वुज़ल, ave16

"234"'*"567"

टॉम कारपेंटर के उत्तर के समान विचार का उपयोग करना

(अगर यह काम नहीं किया, यह कोशिश :)

[50;51;52]*'567'

Comments

@NaN अपडेट देखें। दोनों ≤16 बाइट्स हैं और ideone पर काम करते हैं।

— kennytm

अच्छा लगा। मेरे (1*'234')'*'567'मन में था, क्योंकि आपका पहला जवाब मतलाब में काम नहीं करता।

— वुज़ल