Den Cops-Thread finden Sie hier: The Mystery String Printer (Cops)

Deine Herausforderung

• Wählen Sie eine Vorlage aus dem Cops-Thread und drucken Sie die Zeichenfolge aus einer Antwort in diesem Thread aus.
• Die von Ihnen gewählte Einreichung darf nicht sicher sein (sie muss neuer als 7 Tage sein).

• Ihr Programm, Ihre Funktion oder Ihr REPL-Skript müssen den gleichen Regeln wie der Cops-Thread folgen. Um es noch einmal zusammenzufassen:

  • Ihr Programm muss ≤128 Zeichen lang sein (wenn sich die Einreichung eines Polizisten in einem kleineren Bereich von Programmlängen befindet, muss sich auch Ihr Programm in diesem Längenbereich befinden. Wenn beispielsweise das Programm eines Polizisten ≤32 Byte ist, muss Ihr Programm ≤32 Byte sein ).
  • Das Programm muss bei jedem Start die gleiche Ausgabe erzeugen.
  • Keine kryptografischen Funktionen.
  • Das Programm darf keine Eingaben annehmen.
  • Keine Standardlücken.
• Alle neuen Beiträge müssen dieselbe Sprache verwenden. Einreichungen von vor dieser Regel sind in Ordnung, auch wenn sie dies nicht tun.

Wertung

Die Wertung funktioniert für Räuber ähnlich, ist jedoch etwas anders:

• Das Knacken eines Programms mit ≤8 Bytes ergibt 1 Punkt.
• Das Knacken eines 16-Byte-Programms ergibt 2 Punkte. ≤32 Bytes ergeben 4 Punkte und so weiter.
• Für jede weitere Einreichung, unabhängig von der Länge, erhalten Sie +5 Punkte
• Die Einsendung jedes Polizisten kann nur einmal geknackt werden - nur die erste Person, die jede Einsendung geknackt hat, erhält die Punkte.

Einreichungen

Jede Antwort muss enthalten

• Ein Link zur Einreichung des Polizisten.
• Ihr Programm und Ihre Programmiersprache.
• Geben Sie außerdem die Programmlänge des Polizisten (als Zweierpotenz) als letzte Zahl in Ihrem Header an.

Bitte kommentieren Sie außerdem die Einreichung des Polizisten mit einem Link zu Ihrer Antwort.

Hier ist ein Stack-Snippet, um Bestenlisten zu generieren. Bitte hinterlassen Sie einen Kommentar, wenn es ein Problem mit dem Snippet gibt. Wenn Sie alle offenen Cop-Einreichungen sehen möchten, lesen Sie den Ausschnitt in der Cops-Challenge.

/* 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>

Dieser Wettbewerb ist jetzt geschlossen.

Gesamtsieger: kennytm

Die meisten Einsendungen: Sp3000

(Beachten Sie, dass die Anzahl der Einsendungen nicht genau mit den Punkten übereinstimmt, da die Länge des geknackten Programms bei der Berechnung der Punktzahl berücksichtigt wird.)

Pyth, Dennis, ≤ 8

V./Tp*FN

Verdammt, das hat Spaß gemacht - das Schwierigste war, herauszufinden, wie man es in Pyth kurz genug macht.

Analyse

Das 1234am Anfang deutet darauf hin, dass es sich wahrscheinlich um eine Liste von Zahlen handelt, die ohne Trennzeichen gedruckt wurden. Versuchen wir, die Zahlen auf sinnvolle Weise aufzuteilen:

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

Es gibt ein paar Hinweise, dass wir auf dem richtigen Weg sind:

• Alle Zahlen haben Primfaktoren kleiner als 10
• Viele Zahlen liegen ziemlich nahe an ihrem Index in der Liste

Es gibt jedoch einige Besonderheiten. Die Zahl am Index 23 ist 24 und ist der einzige Fall, in dem die Zahl am Index größer als der Index selbst ist. Der größere Hinweis ist jedoch, dass einige Zahlen deutlich kleiner als ihre Nachbarn sind, insbesondere die 7 bei Index 15, die 8 bei Index 22 und die 9 bei Index 30.

Wenn wir feststellen, dass dies ein 7-8-9-Muster ist, können wir auch sehen, dass die letzte Zahl bei Index 42 eine 10 ist. Angesichts der jüngsten Frage von @Dennis zu abelschen Gruppen zeigt eine schnelle Überprüfung von OEIS, dass 15, 22, 30, 42es sich um eine Untersequenz der Partition handelt zahlen . Pyth verfügt über eine integrierte Partitionsfunktion, die zwei von acht Zeichen enthält:./

Beachten Sie jedoch, dass die letzte Zahl 10 ist, was verdächtig ist, da 10 in Pyth as eine vorinitialisierte Variable ist T. ./Tgibt eine vollständige Liste der 42 Partitionen der Nummer 10 an, die sich als nützlich erweisen könnten.

Jetzt wird ohne Trennzeichen gedruckt, dies weist also auf eine Verwendung von hin p. Vielleicht durchlaufen wir jede Partition, tun etwas daran und drucken dann mit p? Dies gibt uns die folgende Vorlage:

V./Tp??N

Dabei Vhandelt es sich um eine for-Schleife, die eine Iteration durchläuft und jedes Element in der Variablen speichertN .

Ein kurzer Blick auf die vorletzte Partition (5, 5) sollte klar machen, dass wir ein Produkt nehmen wollen. Der naive Weg, eine Liste durch Multiplikation zu reduzieren, ist

u*GHd1

woher d ist die fragliche Liste. Dies ist jedoch viel zu lang.

Leider musste ich hier einen rohen Forcer herausziehen. Ich habe eine Weile nicht mehr mit Pyth Schritt gehalten, daher kannte ich viele der neueren Funktionen nicht. Es waren nur noch zwei Charaktere übrig, was völlig machbar schien.

Der Brute Forcer kehrte dann zurück:

V./Tp*FN

wo *Fist falten durch *(multiplikation). Kein Wunder, dass ich es bei meiner Suche nicht gefunden habe - ich habe das Schlüsselwort "Reduzieren" nachgeschlagen und nicht "Falzen"!

Mathematica, alphalpha, ≤ 32

GroupOrder[MonsterGroupM[]]

Ich hasse es, das zu sagen, aber ich habe die Nummer sofort erkannt.

> <>, VTCAKAVSMoACE, ≤ 64

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

Ironischerweise liegt dies nicht nur viel unter der Bereichsgrenze, sondern ist auch portabel und funktioniert mit dem Online-Dolmetscher .

Analyse

Beginnen wir mit der Zielzeichenfolge:

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

> <> schiebt Zeichen mit 'oder auf den Stapel" im Zeichenkettenmodus , aber mit 63 Zeichen zum Drucken und nur 64 Byte zum Arbeiten, das Vorhandensein von Großbuchstaben (ungültige Anweisungen in> <> für den Standard-Looparound-Trick) führt zum direkten Drucken unmöglich. Daher müssen wir etwas mit den Codepunkten tun.

Das Konvertieren in Codepunkte ergibt (ich verwende hier Python):

>>> 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]

Beachten Sie, dass die letzten drei Zahlen mit den ersten drei übereinstimmen. Dies deutet auf eine mögliche Modulo-Schleife hin.

Schauen wir uns an, wie viele verschiedene Elemente wir haben:

>>> len(set(L))
60

Wir haben 63 Elemente in L, von denen die ersten drei mit den letzten drei übereinstimmen. Dies bedeutet, dass abgesehen von dieser Kollision alle anderen Elemente eindeutig sind. Dies deutet auf etwas hin, bei dem Potenzen modulo als Primzahl genommen werden. In der Tat 60 + 1 = 61ist Prime, was ein gutes Zeichen ist.

Versuchen wir das kleinste Element zu finden

>>> min(L)
65

und skaliere damit alle Elemente so, dass das min-Element 1 ist:

>>> 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]

Beachten Sie, wie das Element danach 1ist 51. Wenn es irgendetwas mit Potenzen / Multiplikation gibt, ist dies eine gute Vermutung für unseren Multiplikator.

Probieren wir es aus:

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

Bingo! Wir können jetzt zurückgehen und den folgenden Code eingeben:

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

welches dann übersetzt wurde in> <>

Pyth, Maltysen, ≤4

C.ZG

Brute Force hat so lange gedauert, dass ich es manuell schneller gemacht habe.

Analyse

C(konvertiere String in Base 256 int) ist der einfachste Weg, eine große Zahl in Pyth zu generieren, es ist also wahrscheinlich das erste Zeichen. Wenn wir von der Basis 256 konvertieren, erhalten wir:

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

Hmm ... nicht sehr aufschlussreich.

Jetzt Gist da die alphabetische Zeichenfolge "abc...z", die als Quelle für eine lange Zeichenfolge dienen könnte C. Durchsuchen Sie die Dokumente, die ich finde:

.Z    Compresses or decompresses a string.

Wenn wir uns hier mit Komprimierung beschäftigen, wäre es nicht verwunderlich, alle möglichen erweiterten ASCII-Zeichen zu erhalten. Der Versuch C.ZGgab dann die Antwort.

Fourier, Beta-Zerfall, ≤ 32

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

Oder alternativ in CJam:

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

Analyse

Zu Beginn sehen wir viele Potenzen von 2:

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

Wenn wir die logarithmische Basis 2 dieser Zahlen nehmen, erhalten wir:

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

Das ist die Fibonacci-Serie, beginnend mit 1, 0.

Schnecken, Feersum, ≤2 Bytes

z

Das sind eigentlich 2 Bytes; das Zeichen, zgefolgt von einem Zeilenumbruch \n.

Ich habe keine Ahnung, wie es funktioniert oder was es tut, aber nachdem ich alle möglichen Eingaben abgesehen von ~+und getestet hatte ~,, war dies das einzige 2-Byte-Programm, das 8als Ausgabe erstellt wurde.

Und es dauerte Ewigkeiten , um dieses Ergebnis zu erzielen. Kein Wunder, dass es "Schnecken" heißt :-D

^{Hinweis für sich selbst: Wenn Sie das nächste Mal unbekannte Software testen, tun Sie dies in einer VM.}

Rust, Liam Noronha, ≤128 Bytes

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

Einfach Ausdruck der Zeichenfolge wörtlich ist 120 Bytes ...

Makkaroni 0.0.2, Türknauf, ≤64

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

Python 2, Klare Frage mit Beispielen, <= 64

Eine mögliche Lösung:

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

( 9**2139, 27**1426Und 729**713gibt auch das gleiche Ergebnis)

CoffeeScript, user2428118, ≤64

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

(Funktioniert nur auf Chrome 46.0.2490.71, wie vom Cop beschrieben.)

Die Ausgabe ist offensichtlich eine Verkettung kurzer base64-codierter Zeichenfolgen aufgrund des "=". Nach dem Entschlüsseln finden wir eine Liste von 2-Zeichen-Strings wie

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

das scheint nicht sinnvoll zu sein. Aber ich finde ein paar seltsame Dinge darin, wie nXund tY. Nachdem wir diese herausgefiltert haben, erhalten wir

>>> # 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']

Diese X und Y scheinen den ursprünglichen Quellcode anzugeben, wie die verwendeten Positionseigenschaften offsetX/Y. Besonders interessant ist der nZArtikel. Um meine Annahme zu überprüfen, habe ich nach allen Eigenschaften gesucht, die mit "Z" enden:

// 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

die Tonnen von zeigt CSSStyleDeclaration, "webkitTransformOriginZ". Hieraus ergibt sich ein deutlicher Hinweis darauf, dass die Liste aus den letzten beiden Zeichen aller Schlüssel eines styleObjekts besteht, was der obige Test in der Tat bestätigt.

Lua <= 4, Egor Skriptunoff

Viele Benutzer waren über diese Antwort im Chat aufgeregt, deshalb muss ich sie von ihrem Elend befreien. Ich kenne Lua nicht und konnte es nicht testen, aber ich wäre sehr überrascht, wenn das nicht funktioniert.

4^~9

Dies wäre ziemlich offensichtlich, aber wahrscheinlich hat es niemand verstanden, da bitweise Operatoren nur in Version 5.3 hinzugefügt wurden. ideone.com hat nur Version 5.2.

Python 2, Histokrat, ≤16

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

Der größte Hinweis ist das Versprechen, dass es in Python 3 nicht funktioniert. Was hat sich in Python 3 geändert ? Der größte Verdacht ist, dass der Divisionsbetreiber a zurückgibtfloat in Python 3 a .

Also habe ich die Lösung übernehmen von der Form ⌊α ^{& bgr;} / n⌋ = c = 22111101102001, als Potenzierung der einzige kurze Weg ist riesig Zahlen zu erstellen.

Wenn {α, β, n} tatsächlich eine Lösung bildet, dann ist (cn) ^{1 / β} ≈ α einer ganzen Zahl sehr nahe kommen. Deshalb benutze ich folgendes, um zu versuchen, die {α, β} für jedes n zu brachialisieren:

(* 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.

*)

Das tatsächliche Ergebnis kommt schnell heraus, wenn n = 6 ist.

MATLAB, StewieGriffin, ≤ 16

[36;87]*' |'*5

Drucke:

ans =
        5760       22320
       13920       53940

Matlab, Luis Mendo, ≤16

Ich habe es gefunden, yay!

fix(peaks(9).^2)

Ich wusste nicht, dass Octave das auch kann.

Mathematica, LegionMammal978, ≤64

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

Python, Spacemanjosh, ≤ 64

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

Herrlicher umgekehrter symbolischer Taschenrechner. Nicht gut golfen, aber hey es passt.

Edit: Ich habe Golf gespielt.

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

JavaScript ES6, Cᴏɴᴏʀ O'Bʀɪᴇɴ, ≤128 Bytes

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

Ich bezweifle, dass dies genau richtig ist, da ich nicht annähernd 128 Bytes benötigte, aber eine sich wiederholende Sequenz zu finden war eine lustige Herausforderung.

Thue, ppperry, <= 64

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

Zerlegt das Jahr 2016 im Wesentlichen in seine Hauptfaktoren. 62 Zeichen, also denke ich, das ist ähnlich wie das, was Sie wollten.

Python, DLosc, ≤32

(Diese Lösung verwendet Python 2)

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

> <>, Sp3000, <= 8

'l(?; o>

Der Anweisungszeiger wird umgebrochen und die folgenden Schritte werden ausgeführt:

• 'l(?; o>'schiebt die ASCII-Werte von l(?; o>in den Stack
• l Schiebt die Größe des Stapels auf den Stapel
• (Vergleichen Sie die beiden obersten Stapelelemente: size of stackundord('>')
• ?; stoppt das Programm, wenn der Stapel größer war
• ogibt das oberste Element des Stapels als Zeichen aus (dies wird immer sein o)
• > Setzt die IP-Richtung, hier ist es No-Op
• Wir gehen zurück zum ersten Schritt

Ausgabe ist oooooooooooo.

Wir können viele verschiedene Ausgaben erhalten, indem wir [space]zu etwas wechseln , das auf den Stapel drückt oder knallt, und stattdessen ein anderes gültiges Zeichen verwenden >, das auch drückt oder knallt .

JavaScript, ev3commander, ≤ 32

console.log(0.1411200080598672)

OK, das war einfach.

CJam, Reto Koradi, ≤ 4

HJK#

Drückt 17 , dann 19 ²⁰ = 37589973457545958193355601 .

Probieren Sie es online aus.

Es gibt nur so viele Dinge, die Sie in vier Bytes tun können. Eine so große Ganzzahl musste irgendwie Potenzen oder Fakultäten beinhalten, und eine Fakultät hätte nachgestellte Nullen.

Pyth <= 4, Dennis

ljyG

Das ist die Länge des Joins in Zeilenumbrüchen aller Untergruppen des Alphabets.

Testlauf:

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

Ich habe herausgefunden, 2^27 * 7 - 1dass es sich bei der Zahl um einen starken Hinweis handelt, auf dem die Zahl basiert yGund die 2^26Elemente lang sind. Ich vermutete dann, dass es in einen String umgewandelt und seine Länge gedruckt werden musste. Der einzige Weg, dies zu tun, den ich mir für eine Weile vorstellen konnte, war ``, repr. Dann habe ich mir überlegt j, was perfekt passt.

C, tucuxi, ≤ 64

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

Die Ausgaben sind alle 0 und 1, aber C kann keine Binärdateien direkt drucken. Es ist also sehr wahrscheinlich, dass dies boolesche Ergebnisse sind.

Es gibt mehr 1 als 0s, also habe ich die Positionen von 0s aufgezeichnet (3, 9, 13, 19, … ) , was sich als OEIS A075318 herausstellt . Dies ist jedoch nicht sinnvoll. Es gibt keine einfache Formel, um zu bestimmen, wo sich eine Zahl in dieser Reihenfolge befindet.

Wir stellen jedoch fest, dass es alle ungeraden Zahlen gibt, sodass wir möglicherweise (x-1)/2 = {1, 4, 6, 9, 12, …}nützlichere Informationen haben. Und das ist A003622 .

A003622 kann als "Position von 1 in A003849 " definiert werden. Genau das müssen wir hier knacken. Und A003849 ist als " A003714 " definiert mod 2", wobei A003714 einfach alle ganzen Zahlen sind, die x & (2*x) == 0. Damit haben wir die Lösung.

OEIS rox.

Dyalog APL, Dennis, ≤4

*⍨⍟8

Berechnet ln (8) ^ ln (8). Würde StackExchange die Konvertierung meiner Antworten stoppen? Ich gebe hier ein paar Sachen ein, damit daraus kein Kommentar wird.

Feststecken, @quartata, ≤8

Das folgende Pyth- Programm:

^33 9

erzeugt die gewünschte Ausgabe

46411484401953

Cracking-Methode: Google nach der Nummer durchsucht.

Pyth, xnor, ≤ 4

C`CG

CG(konvertiere die alphabetische Zeichenkette "abc...z"von der Basis 256) ist die typische Pyth-Methode, um eine wirklich große Zahl zu erzeugen. Danach wird nur noch stringifiziert und erneut von der Basis konvertiert.

Python 3, Mego, ≤ 128

(Mit Python 3.5.0, nicht in früheren Versionen getestet. 105 98 Bytes.)

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

Rubin, Türknauf, ≤64

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

Matlab / Octave, Wauzl, ≤16

"234"'*"567"

Dieselbe Idee wie die Antwort von Tom Carpenter

(Wenn es nicht geklappt hat, probiere das :)

[50;51;52]*'567'