Entschlüsseln Sie den Quellcode [Räuber-Thread für Cracking-Versuche]

44

Dies ist der Begleitthread für die Hauptaufforderung zum Entschlüsseln des Quellcodes . Wenn Sie der Meinung sind, dass es Ihnen gelungen ist, eine der Antworten der Polizei zu entschlüsseln, sollten Sie Ihre Lösung als Antwort auf diesen Thread posten.

Zur Erinnerung, Sie haben einen Versuch, jede Einsendung zu knacken. Ihr Cracking-Versuch wird eine unverschlüsselte Version des Quellcodes sein. Wenn Ihre Vermutung mit der Beschreibung übereinstimmt (gleiche Zeichen, Ausgabe und natürlich Sprache) und Sie die erste richtige Vermutung sind, dann gewinnen Sie einen Punkt. Es ist wichtig zu beachten, dass Ihr Programm nicht exakt mit dem Original übereinstimmen muss, sondern einfach dieselben Zeichen und dieselbe Funktionalität verwenden muss. Dies bedeutet, dass es mehr als eine richtige Antwort geben kann.

Der Räuber mit den meisten Punkten (erfolgreiche Risse) gewinnt.

Bestenliste

Zu viele Lösungen

20 löst

15 löst

10 löst

7 löst

5 löst

4 löst

3 löst

2 löst

1 lösen

cops-and-robbers 
— PhiNotPi
quelle
1
Perl 5, Größe 27, von Morot - print'pin '= ~ tr (a-za) (za-z) r
@ WumpusQ.Wumbley Wir waren alle da ...;)
— Martin Ender
3
Ich weigere mich, meine Zeit damit zu verschwenden, es zu beschwichtigen.
Angesichts der beiden Fragekörper scheint es, dass die verwürfelten / nicht verwürfelten Antworten umgekehrt sind
— Mooing Duck
Ruby, 23 von MegaTom = p% ++. Methods [80] [1 ..- 1]
— Histokrat

Antworten:

32

CJam, Größe 20, von Martin Büttner

Hi "petStorm!", mame

Probieren Sie es online aus.

Wie es funktioniert

Hi                      "           int(17)                     ";
   "petStorm!",         "                    len('petStorm!')   ";
                ma      "     atan2(       ,                 )  ";
                  me    " exp(                                ) ";
                        " exp(atan2(int(17), len('petStorm!'))) ";

Den Code knacken

Die gewünschte Ausgabe 2.956177636986737ist entweder ein Double oder ein Double, gefolgt von einem Long.

Wenn Sie nur die Zeichen in verwenden "Stop, Hammer time!", gibt es vier integrierte Operatoren, die nicht ganzzahlige Doubles zurückgeben:

  • mS, welches ist asin
  • ma, welches ist atan2
  • me, welches ist exp
  • mt, welches ist tan

Alle von ihnen enthalten ein m, so dass wir höchstens drei von ihnen verwenden können. Es gibt nur eins Sund eins a.

Alle diese Operatoren benötigen Eingaben und masind die einzigen, die zwei Eingaben verbrauchen. Wir haben nur drei Möglichkeiten, Longs zu pushen:

  • "...",, was die Länge der Saite drückt (streng unter 18).
  • H, was 17 drückt.
  • ...!, was das logische NICHT von drückt ....

Wir haben keine Möglichkeit, etwas Falsches zu pushen ..., so dass die letzte Option immer 0 pusht .

Die Ausgabe beginnt oder endet nicht mit 17oder 0. Da 15 Dezimalstellen die übliche Anzahl von Stellen für ein Double sind, schien es wahrscheinlich, dass die Ausgabe ein einfaches Double war.

Angenommen, der Code muss in eine der folgenden Kategorien fallen:

  • <Long> <mS|me|mt>{1,3}
  • <Long> <mS|me|mt>{x} <Long> <mS|me|mt>{y} ma <mS|me|mt>{z}.
  • Beliebige der oben genannten Optionen, wobei ein Teil auf Long ( i) oder Rounding ( mo) für ein Double angewendet wird.

Im zweiten Fall x + y + zist entweder 1 oder 2 und einer der Longs ist 0 oder 17.

Der Rest war im Grunde rohe Gewalt. Nach ein paar Versuchen,

18 , {H \ ma me 2.956177636986737 =} =

zurückgekehrt 9, das heißt

H 9 ma me

erzeugt die gewünschte Ausgabe.

Alles, was übrig bleibt, ist, alle bis auf 9 Zeichen aus der Zeichenfolge zu entfernen. Leerzeichen sind Noops und iein Noop bei Longs. Dies "petStorm!"ist eine der möglichen Optionen.

— Dennis
quelle
1
Das ist verrückt - wie haben Sie herausgefunden, wie hoch die Zahl war?
— Sp3000
1
Ich habe den Logarithmus (und andere) dieser Zahl durchsucht, aber keine Ergebnisse erhalten. Jetzt stellte ich fest, dass ich zu hohe Präzision verwendete.
— Jimmy23013
2
@ Sp3000: Ich habe meine Antwort bearbeitet.
— Dennis
1
Sehr schön! Ich hätte zwei weitere Zeichen aus der Zeichenkette herausnehmen sollen, denke ich. In meinem Original hatte ich eigentlich die Leerzeichen noch in der Zeichenkette, aber mrvorher die Länge genommen. Nicht, dass Sie das irgendwann nicht auch herausgefunden hätten. ;)
— Martin Ender
25

Python 3, Größe 12, von xnor

()and bciprt

Tut nichts (Ausdruck erzeugt ein leeres Tupel, das nicht gedruckt wird). Dies funktioniert aufgrund der Kurzschlussauswertung.

— Matsjoyce
quelle
1
In Python 3 IDLE wird dies ausgegeben ().
— Hosch250
@ hosch250 Da es sich um ein Programm (eine Python-Datei) handelt, wird nichts ausgegeben, da es keine gibt print.
— Matsjoyce
Aha. Ich rannte von der Kommandozeile aus.
— Hosch250
47
.... "Ding" ....
— TheDoctor
4
@Imray Wegen eines Kurzschlusses - Python lädt das Tupel und prüft, ob der Wert des Tupels wahr ist, da er leer ist, ist er falsch. Der Code zum Laden der Variablen bciprtwird niemals ausgeführt, daher wird niemals ein NameError erzeugt.
— Mateon1
20

Python, Größe 74, von xnor

any(print(set is
set)for i in oct(chr is
map))and aeeeeeggiilnnpprrrrrstvw

Na das war ein Spaß. Vielen Dank an FryAmTheEggman, hosch250 und isaacg für Anregungen / Hilfe.

— Sp3000
quelle
1
Gute Arbeit! Meine Lösung war ganz ähnlich: list(\nprint(range is range)for aacdeeeeehmppprrrrssvwy in\noct(int is int)).
— Xnor
@xnor LOL diesen Variablennamen. Ist es schlimm, dass ich nie daran gedacht hätte? : P
— FryAmTheEggman
2
@FryAmTheEggman Ich glaube, jeder erwartete, dass ich den Trick von meinem ersten Polizisten verwende .
— 7.
@FryAmTheEggman Keine Sorge, du bist nicht der einzige: P
— Sp3000
13

Python 2, Größe 50, von Geobits

print 2**2**2*2**2-22-2**2**2**2/2**2**2**2**2/2/2

Ausgänge 42.

— Ypnypn
quelle
1
Haben Sie einen Punkt :) Als Referenz, Original war print 2**2**2**2/2**2**2/2**2**2/2-2**2**2*2**2-22, aber es ist überhaupt nicht überraschend, dass mehr als eine Option richtig ist.
— Geobits
13

GolfScript, Größe 13, von Peter Taylor

,22,{.4&?+.}/

Teste es hier.

Eine andere, die ich nur mit großer Hilfe von Sp3000 geknackt habe. Vielen Dank!

So kamen wir dorthin. Sp3000 bemerkte eine Reihe von Läufen von fortlaufenden Nummern in der Ausgabe:

1,2,3,4,[2608852181],4582,4583,4584,4585,4586,[253225388392299],
142924,142925,142926,142927,142928,[302928],497409,497409

Ausgehend davon gingen wir davon aus, dass dies eine zunehmende Reihenfolge war, die nur eine mögliche Aufteilung der verbleibenden Zahlen zuließ:

1,2,3,4,260,885,2181,4582,4583,4584,4585,4586,25322,53883,92299,
142924,142925,142926,142927,142928,302928,497409,497409

Das sind 23 Zahlen, ein starker Indikator für die 22-fache Wiederholung des Blocks sowie für das Beenden des Blocks mit .(oberes Stapelelement duplizieren), sodass das vorherige Ergebnis auf dem Stapel zurückbleibt und die endgültige Iteration angezeigt wird der Stapel zweimal. Das ist 22,{____.}/.

Wenn wir uns nun die Lücken ansehen, stellen sich diese als 4. Potenzen heraus (was schön ist, weil wir 4und haben ?). Genauer gesagt sind sie die vierte Potenz des Index der aktuellen Zahl. Als nächstes haben wir uns angesehen, welche Indizes eine Lücke geschaffen haben:

4,5,6,7, 12,13,14,15, 20,21,..?

In binärer Form sind das

00100
00101
00110
00111
01100
01101
01110
01111
10100
10101

Sie haben alle das dritte Bit gesetzt, was bedeutet, dass der Index wahrscheinlich nur bitweise gesetzt ist 4(was wieder schön ist, weil wir einen anderen 4mit .und ein haben können &). Dies funktioniert besonders gut, da diese Operation entweder 0oder ergibt 4, und wenn wir dies als Exponenten verwenden, erhalten wir entweder 1eine vierte Potenz, was genau das ist, was wir brauchen. Also lassen Sie uns das zusammenfassen:

22,{.4&?+.}/

Hier ist was der Block macht:

.      # Duplicate current index
 4     # Push a 4
  &    # Bitwise and
   ?   # Raise index to resulting power
    +  # Add to previous result
     . # Duplicate for use in next iteration

Jetzt blieben zwei Probleme übrig: Wir hatten eine Streuung, die ,wir noch nicht verwendet haben, und die erste Iteration ist ein Sonderfall, da es von einer vorherigen Iteration keinen Wert gibt, den wir bei der Begegnung ergänzen könnten +. Wir fanden das dank eines unabhängigen Kommentars von User23013, der beiläufig erwähnte, dass GolfScript mit einer leeren Zeichenfolge auf dem Stack beginnt (wenn STDIN nichts enthält). Wir könnten also ,gleich zu Beginn die andere verwenden , um diese Zeichenfolge in eine zu verwandeln 0, was genau das war, was wir als Start der Iteration brauchten.

— Martin Ender
quelle
Spot on. Dies wurde durch eine Sequenz in OEIS inspiriert, die ich jetzt nicht finden kann.
— Peter Taylor
3
Und deshalb ist es eine gute Idee, einen eigenen Thread für Räuber zu haben. Gute Arbeit!
— Dennis
11

Ruby, Größe 17, von Doorknob

p 2,%r~n~i=~'*tN'

Das hat sehr viel Spaß gemacht. Vielen Dank an Sp3000, der mir dabei geholfen hat! Und ich habe gelernt, dass %r?...?Literale beliebige Begrenzer haben können. :)

— Martin Ender
quelle
10
Props to Doorknob für die Irreführung print, nur um sie pfür den Druck, %rfür Regexes und ifür den Vergleich zwischen Groß- und Kleinschreibung aufzuteilen.
— Sp3000
11

PHP, Größe 49, von Bwoebi

print@substr(new exception,+~$$a+=++$$m+$$i+2+n);

Das war absolut mental .

Es muss

print@substr(new exception,);

ziemlich schnell, an welchem ​​Punkt ich etwas brauchte, das -6nach dem Komma gibt, nachdem ich $++$++$++$+=$~main$2gegangen war.

Der Haupt Haken ist , dass $a, $mund $isind alle NULLzu verwenden, da sie indirekt in veränderlichen Variablen , Mittel , die sie alle auf die gleiche Variable. PHP scheint jedoch einige seltsame Dinge zu tun, um variable Variablen aufzulösen. Mit normalen Variablen können Sie Dinge tun wie

echo $a+$a=2;

welche druckt 4(die 2wird zugewiesen $aund dann zu sich selbst hinzugefügt). Aber wenn ich dasselbe mit variablen Variablen mache:

echo $$a+$$a=2;

Ich bekomme 2, weil jetzt die erste $$avor der Zuordnung zu bewerten.

Am Ende habe ich es geschafft, eine Reihenfolge zu erzwingen, indem ich ein paar Inkremente auf die RHS von gesetzt +=habe, die vor dieser Additionszuweisung ausgewertet werden mussten. Auf diese Weise kam ich zu 5dem , was ich dann nur ein bisschen ergänzen konnte. Trotzdem ... sind einige mysteriöse Dinge im Gange, und ich habe keine Ahnung, warum die Hälfte der Dinge, die ich versucht habe, funktionierte und nicht funktionierte.

— Martin Ender
quelle
Als Referenz mein Original:print@substr(new exception,~$$mn+=2+$$a+++$$i++);
— Bwoebi
Btw. Ich hoffe, dass alle Dollarzeichen und die Tatsache, dass alle Buchstaben für mainin der Zeichenfolge waren, Sie viel irreführen. Auch eine eher ungewöhnliche Methode zum Extrahieren {main}, denke ich
— ;-)
@bwoebi Das mainhat verleiten mich nicht wirklich, nach Spek exception, newund substr. Ich dachte, das wären nur Variablennamen. Ich brauchte ein wenig, um variable Variablen zu verwenden, und verbrachte dann die meiste Zeit damit, eine Reihenfolge von Operationen zu finden, die tatsächlich eine ergeben würde, 5die ich ergänzen könnte, ohne einen anderen Satz von Klammern zu verwenden.
— Martin Ender
Nun, für das nächste Mal, wenn es mehr Dollars als Zeichen gibt, sind es normalerweise variable Variablen. (In diesem Fall habe ich auch varvars missbraucht, um die Auswertung von links nach rechts zu erzwingen.) Wie lange haben Sie dann gebraucht, um die neue Ausnahme des Substrats zu erkennen? Übrigens habe ich tiefere Kenntnisse über die Zend-Engine, so dass ich mir perfekt erklären kann, warum die Dinge in welcher Reihenfolge ausgewertet werden und das ist gut für diese Herausforderungen ;-) Ich erkläre es Ihnen gerne.
— Bwoebi
@bwoebi Komm morgen in den Chat und wir können darüber reden, aber ich habe heute genug Zeit dafür aufgewendet. ;) Was deine erste Frage angeht, exceptionwar klar, dass hier streunende Charaktere herumliegen substrund newherumliegen. Es war buchstäblich das erste, was ich sah, als ich anfing, daran zu arbeiten.
— Martin Ender
9

Ruby, Größe 38, von Doorknob

[$><<(!$pece60).to_s[rand($win)].succ]

Ich bin mir ziemlich sicher, dass dies bei weitem nicht die ursprüngliche Quelle ist. Es ist trotz der Verwendung deterministisch rand.

Hier ist, wie dieser funktioniert. $><<wird nur ausgegeben. $pece60und $winsind undefinierte globale Variablen, die daher gerecht sind nil(und es mir ermöglichten, einige fremde Zeichen loszuwerden). !$pece60macht ein trueund to_sgibt die Zeichenfolge "true".

Lange habe ich versucht, ein 2oder -2zu bekommen, um darauf zuzugreifen u, aber dann wurde mir klar, dass ich einfach das nehmen tund .succ(essor) anrufen konnte, um ein zu machen u.

randmit einem nilParameter wird ein zufälliger Gleitkommawert im Intervall [0,1) zurückgegeben. Wenn Sie Floats zum Indizieren in Strings verwenden, werden diese auf Ganzzahlen gekürzt, sodass immer das erste Zeichen zurückgegeben wird.

Schließlich hatte ich ein Ersatzpaar, []also habe ich einfach alles darin eingewickelt, denn zum Glück ist alles ein Ausdruck in Ruby.

Danke an Sp3000 für die Ideen im Chat.

— Martin Ender
quelle
8
Ruby ist eine beängstigend aussehende Sprache.
— Feersum
8

C, 51 von es1024

c=0xf.cp9,hhtaglfor;main() {;; printf("%d",(++c));}

Nach 20 Jahren C-Programmierung habe ich heute etwas über hexadezimale Gleitkommakonstanten gelernt.

— Kunst
quelle
8

Rubin, 45 (Histokrat)

%q[zyfnhvjkwudebgmaclprs x].to_i(36)/51074892

Woohoo! Dies ist mein erster Riss bei einem Code-Golf-Problem, und ich habe nicht genug Repräsentanten, um den ursprünglichen Beitrag zu kommentieren. Ich habe den verwendeten Trick sofort erkannt, da ich ihn im Produktionscode häufig verwendet habe. Es dauerte ungefähr 5 Minuten, um den größten Teil der Struktur herauszufinden, und ein paar Stunden, um die vollständige Antwort zu finden.

Erläuterung:

  • %q[]ist eine alternative Methode zum Erstellen von Zeichenfolgen. Klammern und geschweifte Klammern können ebenfalls verwendet werden.
  • String#to_i in Ruby akzeptiert Zahlen in einer beliebigen Basis von 2 bis 36. Das erste Zeichen in der Zeichenfolge, das nicht Teil der Zahl ist, wird ignoriert, sodass zusätzliche Zeichen nach dem Leerzeichen "weggeworfen" werden können.

Und hier ist der Code, mit dem ich es geknackt habe:

require 'set'

# return true if the string is made up of unique characters
def uniq(s)
  a = s.each_char.to_a
  return a == a.uniq
end

def uniq_while_same(a,b)
  s = Set.new
  a.each_char.zip(b.each_char).each do |ai, bi|
    return true if ai != bi
    return false if s.include? ai
    s << ai
  end
  return true
end

def ungolf(answer)
  # For each base that even makes sense
  [            36, 35, 34,     32, 31, 30,
   29, 28, 27, 26, 25, 24, 23,     21, 20,
   19, 18, 17, 16, 15, 14, 13, 12,     10].each do |base|
    # Ignore bases where it is not possible to create a unique-string number greater than answer
    next if answer > base ** base
    # Pick digits for the denominator that are not duplicates of the digits in base
    denominator_digits = ('1234567890'.each_char.to_a - base.to_s.each_char.to_a)
    # For each permutation of those digits for the denominator
    (1..10).each do |denominator_length|
      denominator_digits.permutation(denominator_length) do |denominator_s|
        # Maybe the denominator is in octal
        denominator_base = 10
        if denominator_s[0] == '0'
          next if denominator_s.include?('8') || denominator_s.include?('9')
          denominator_base = 8
        end
        denominator_s = denominator_s.join
        denominator = denominator_s.to_i denominator_base
        print "#{"\b"*64}(%q[#{(answer * denominator).to_s(base).ljust(36)}].to_i #{base})/#{denominator_s.ljust(10)}" if rand < 0.01
        # Ignore denominators that are definitely impossible to have answers for
        next unless uniq_while_same "qtoi#{base}#{denominator_s}#{(answer * denominator).to_s(base)}",
                                    "qtoi#{base}#{denominator_s}#{((answer + 1) * denominator).to_s(base)}"

        # For each numerator that gives answer when divided by the denominator
        (answer * denominator...(answer + 1) * denominator).each do |numerator|
          print "#{"\b"*64}%q[#{numerator.to_s(base).ljust(36)}].to_i(#{base})/#{denominator_s.ljust(10)}" if rand < 0.01
          # Remove any that are still not unique
          s = "#{numerator.to_s(base)}#{base}#{denominator_s}qtoi"
          next unless uniq s
          # Done. Compute which characters need to be thrown away to fill the remaining space
          remains = ('0123456789abcdefghijklmnopqrstuvwxyz'.each_char.to_a - s.each_char.to_a).join
          print "#{"\b"*64}#{" "*64}#{"\b"*64}"
          return "%q[#{numerator.to_s(base)} #{remains}].to_i(#{base})/#{denominator_s}"
        end
      end
    end
  end
  print "#{"\b"*64}"
  puts "\nnone"
  return nil
end


print ungolf 9410663329978946297999932

So können Sie ein NP-Problem in ein Rätsel einbetten. Ich wurde gründlich von Nerds beschnitten. Gut gemacht!

— verkohltes Utensil
quelle
Ich habe der ursprünglichen Antwort einen Kommentar hinzugefügt.
— FireFly
Das ist großartig (und nahe an der beabsichtigten Antwort), aber technisch nicht gültig, weil es keine Ausgabe hat.
— Histokrat
* facepalm Naja ich hatte immer noch Spaß.
— CharredUtensil
2
@charredUtensil Wenn es Ihnen nichts ausmacht, Ihr Skript noch einige Male auszuführen, wird beim Drucken wahrscheinlich nur das Symbol pvor dem Ausdruck verschoben . Vermutlich können die verbleibenden Zeichen verwendet werden, um die Konstanten zu bilden, wie Sie es getan haben.
— FireFly
Ich muss es nicht noch einmal ausführen. Die letzten Zeichen des Strings können ohne Änderung das Ergebnisses neu geordnet werden - p %q[zyfnhvjkwudebgmaclrsx].to_i(36)/51074892ich weiß , dass ich meinen eigentlichen Krack Versuch brach aber :)
— charredUtensil
7

Python [any] Shell Größe 44, von Caridorc

__name__[3]  or (enfin_____[42], manager[1])

Ich bin mir sicher, dass mehr dahinter stecken sollte, aber da dies __name__gleichbedeutend ist, __main__wird das vierte Zeichen "a" ausgewählt und der Rest der Zeile wird nie ausgewertet.

— zimperliches Ossifrage
quelle
Nur als Referenz ist das ursprüngliche Programm[__name__ for ___name__ in range(1,4)][2][3]
— Caridorc
7

CJam, Größe 13, von user23013

G,Cf#If/sE*K%

Teste es hier.

Von Hand gelöst, so:

Zunächst einige Hintergrundinformationen für Nicht-CJammer:

  • CEGIKwerden alle Variablen, die vor-initialisiert werden 12, 14, 16, 18, 20, respectively.
  • s konvertiert das oberste Stapelelement in eine Zeichenfolge.
  • Strings sind technisch gesehen nur Arrays von Zeichen.
  • fist ziemlich magisch. Für die Zwecke dieser Antwort ist die vereinfachte Version dass, für ein Array a, einen anderen Wert bund einem Operator g, die Sequenz abfgabbildet g(_,b)auf a(wobei jedes Element ageht in den _Schlitz).
  • / ist Teilung und Aufteilung von Arrays (unter anderem).
  • * ist Multiplikation und Array-Wiederholung (unter anderem).
  • %ist Modulo und eine seltsame Operation, die in der Form ad%für Array aund Integer djedes dElement von a(wie Pythons Slice mit Schrittweite d) annimmt .
  • # ist Potenzierung (unter anderem).
  • ,wandelt Zahlen in Bereiche (von 0bis n-1) um und gibt die Länge eines Arrays zurück.

Okay, das ist aus dem Weg ...

Es war ziemlich offensichtlich, dass wir ,eine Zahl in einen Bereich umwandeln mussten, da der einzige andere Weg, ein Array zu erhalten, darin bestanden hätte, eine größere Zahl zu erstellen und in ein Zeichenarray mit zu verwandeln s- aber dann hätten wir nichts tun können weitere Arithmetik darauf. Und wir brauchen ein Array, um etwas mit dem fs zu tun .

Ich habe zuerst angenommen, dass die fs mit #und verwendet werden %, aber das würde bedeuten, dass wir eine Zahl um 90 benötigt hätten, um am Ende die richtige Anzahl von Ziffern zu erhalten. Und das erklärte auch nicht, was ich tun sollte s, und da die Antwort wirklich golferisch aussah, bezweifelte ich, dass user23013 einfach sirgendwo ein effektives No-Op anhängt, um Leute abzustoßen .

Also dachte ich mir, vielleicht hält er die Zahlen nicht einmal klein %, sondern baut stattdessen ein Array von riesigen Zahlen auf, verkettet ihre String-Darstellung mit s, wählt dann aber nur ein ungerades Stück daraus aus %. Also habe ich ein bisschen mit folgendem Framework rumgespielt:

__*,_f#_f/s_%

(Das können Sie nicht _f/zuerst tun , da dies für mindestens die ersten 12 Elemente Null ergeben würde.)

Wo _sind einige Permutation der Variablen. Ich habe nicht alle ausprobiert, bevor mir langweilig wurde, und das Hauptproblem dabei war, dass die resultierende Ziffernfolge wie immer viel zu lang war.

Irgendwann kam mir der Gedanke, dass wir keinen so großen Bereich (dh das Produkt aus zwei Zahlen) benötigen würden, wenn wir stattdessen *die resultierende Zeichenfolge mit dem wiederholen würden. Aufgrund der Nichtübereinstimmung der Parameter von *und %würde dies keine Wiederholung im Ergebnis ergeben:

_,_f#_f/s_*_%

Dies ergab Ergebnisse von einer Länge, die sehr nahe an dem lag, wonach ich suchte. Ich hätte eigentlich alle 240 ausprobiert, aber ziemlich schnell (dritter oder vierter Versuch) bin ich darauf gestoßen

E,Cf#If/sG*K%

was ergibt

03081942753650251594592190492275006661328850322159030034930530649722385533653290754678977

Und ich dachte, eine Übereinstimmung mit den ersten sechs Ziffern wäre kein Zufall. Die Frage war also, wie man es neu anordnet, ohne die eigentliche Berechnung zu stören:

  • Ich konnte mich nicht ändern, Kweil das insgesamt verschiedene Ziffern aussuchen würde.
  • Ich konnte nicht ändern Coder Iweil dies die Zahlen ändern würde, die sich aus den beiden Kartenoperationen ergeben.
  • Wenn ich das ändere G, ändert sich nur die Anzahl der Wiederholungen, was nur die Länge des Ergebnisses ändert. (Was gut ist.)
  • Wenn ich das ändere E, ändert sich der Bereich des Arrays, aber der Bereich beginnt immer noch mit [0 1 2 3 ...], sodass die Berechnung davon nicht beeinflusst wird. Dies würde sich auf die Länge der von zurückgegebenen Basiszeichenfolge auswirken. Dies swürde auch bedeuten, dass K%bei zusätzlichen Wiederholungen andere Ziffern ausgewählt werden.

Also habe ich gerade versucht zu tauschen Eund Gund voila:

030819828850379075460427536222159187897761502517030034671154875945928930530907551421904962649729

Zusammenfassend ist hier, was der Code tut:

G,            "Push [0 1 2 3 ... 13 14 15].";
  Cf#         "Raise each element to the 12th power.";
     If/      "Divide each element by 18.";
        s     "Concatenate all numbers into a string.";
         E*   "Repeat 14 times.";
           K% "Pick every 20th digit.";
— Martin Ender
quelle
6

Pyth, Größe 11, von Isaacg

:\\w$ ",d,N

Das ist ein böser Bug-Missbrauch. Dies kompiliert zu:

Pprint("\n",at_slice("\",input(), ",d,N))

Der relevante Fehler ist, dass anstelle von \\kompiliert wird , wodurch Sie Pyth in einen String kompilieren können."\""\\"

— Martin Ender
quelle
Sollte das Pprintsein print, oder zumindest pprint?
— FireFly
@FireFly Genau das wurde in der Debug-Ausgabe angegeben. Vielleicht definiert der Pyth-Interpreter seinen eigenen Pprint?
— Martin Ender
Oh, okay, egal dann.
— FireFly
6

Python, Größe 69, von Sp3000

print(sum(list(map(ord,str((dict(((str(dict()),list()),)),str()))))))

Das war hart...

— grc
quelle
1
Nett! Als Referenz diente das Original print(sum(map(ord,str((dict(list(((str(),str(dict())),))),list()))))), aber offensichtlich würden viele verschiedene Permutationen von Schlüsselwörtern funktionieren.
— Sp3000
2
Das ist ein LISP-Level von Parens!
— 7.
6

Python 3, 37 Bytes, von Sp3000

print(sum(b"a".zfill(len(str(...)))))

Peinlicherweise war es bei weitem das Schwierigste, die Zeichenfolge in Bytes umzuwandeln. Ich musste darauf schlafen, und in der Nacht wurde mir klar, dass es ein buchstäbliches Byte ist!

— Blake Walsh
quelle
Ahaha, gut gemacht, ich dachte, die Ellipse könnte die Leute aus der
— Ruhe bringen
Ich habe die Auslassungspunkte und die Füllzeichen gesehen, wusste aber nichts über die Bytes-Objekte. Diese könnten beim Golfen von Arrays von ganzen Zahlen nützlich sein!
— Feersum
Gut gemacht! Ich habe nur den Abdruck und die .zfill gesehen, und ich wusste, dass die Summe ein Teil davon sein könnte, aber ich konnte es nicht lösen. Habe eine +1.
— Hosch250
6

PHP, 53, von PleaseStand

Hat es endlich geknackt:

for($d=57,$o=35;$o+$d<999;)$o+=printf("$d%o",$d+=$o);

Die Lösung kam ziemlich schnell, als ich bemerkte, dass die Sequenz aus alternierenden Dezimal- und Oktalzahlen besteht:

Dec: 57...92...132...177...228...285...348...417...492....573....661....756....858....
     571349220413226117734422843528553434864141775449210755731225661136475615328581707
Oct: ..134..204...261...344...435...534...641...754...1075...1225...1364...1532...1707
==Dec:  92  132   177   228   285   348   417   492    573    661    756    858    967

Außerdem nahmen die Intervalle zwischen den einzelnen Zahlengruppen mit einer Geschwindigkeit zu, die dem von zurückgegebenen Wert printf()(dh der Anzahl der geschriebenen Zeichen) entsprach.

— zimperliches Ossifrage
quelle
3
Wow, nette Detektivarbeit!
— Sp3000
6

Python 2, Größe 132, von Vi.

exec('from string import printable as e\nprint "cqance"\x2Ereplace("q",e[len("fgiillmmooprrsstt")])or ",,,\016:::S[]____tuuvyy" ""')

Danke für all die Backslashes und Anführungszeichen :)

Bearbeiten: Die aktualisierte 96-Zeichen-Version:

exec "try:exec'from __future__ import braces\\nt(12)'\nexcept SyntaxError as q:print(q[0][6:])"

Dies stammt vollständig aus Alex 'Lösung in https://codegolf.stackexchange.com/a/41451/32353

— kennytm
quelle
Heh nett Ich frage mich, was die Lösung war ...
— FireFly
Dies ist keine beabsichtigte Lösung. Die ursprüngliche Lösung hat keine "Wegwerf" -Dinge wie fgiillmmooprrssttoder ,,,\016:::S[]____tuuvyy.
— Vi.
exec? Mein Code hätte kürzer sein können ... Ich habe ihn mit compile+ emuliert, evalweil ich vergessen habe exec...
— Vi.
Implementiert die kürzere Version. Versuchen Sie, den ursprünglichen Trick herauszufinden.
— Vi.
5

CJam, Größe 15, von Ypnypn

98,{7%}%{6+}%:+

Aufgrund der angegebenen Zeichen musste es sich vermutlich um eine der drei folgenden Formen handeln:

__,{_%}%{_+}%:+
_,{_%}%{__+}%:+
__,{_+}%{_%}%:+

Dadurch wird ein zweistelliger Bereich erstellt. Anschließend werden dem Bereich vor dem Summieren eine Addition und eine Modulo-Operation (in beliebiger Reihenfolge) zugeordnet. Also habe ich gerade mit dem ersten angefangen und systematisch versucht, 6789die Lücken zu vertauschen .

— Martin Ender
quelle
Verdammt, ich habe es gerade auch gelöst: /
— Optimizer
5

Python 2, Größe 61, von FryAmTheEggman

print(dir('~s]l.c:st_''-p_tp.l]-~.:o:Te[_u[.i_')[10][2:][:3])

Ich wäre sehr überrascht, wenn dies dem Original entspricht.

— grc
quelle
Das tut es nicht, aber trotzdem herzlichen Glückwunsch! Mein Code war:print''.__doc__[::2][::3].split()[1].split('.')[0][:-~-~True]
— FryAmTheEggman
Im Nachhinein hätte ich die Zitate nicht
— einfügen
@FryAmTheEggman Oh wow - schönes Programm! Ich war überzeugt, dass Sie zumindest dir()das "Get" gefunden hatten. Und ja, ohne die Anführungszeichen wäre es sehr schwierig gewesen.
— Grc
5

Python 3, Sp3000, Größe 44

print(~(~(()<((),))<<(()<((),))))<<((()<()))

Python 3 hat mir hier geholfen, da ich Nonenach dem Drucken der Antwort einen Fehler (Linksverschiebung ) verursachen konnte .

— Feersum
quelle
Hmm ... sieht so aus, als wäre ich ziemlich verschwenderisch mit meinen Eltern. Hatte print(~(~(()<())<<((()<((),))<<(()<((),)))))ursprünglich.
— Sp3000,
5

PHP, Größe 52, von Kenorb

_:@print_r(chr(@++$i+pow(3<<5,1)));if($i<2*4)goto _;

(Gott, wie lange habe ich gebraucht, um herauszufinden, was ich mit dem verbleibenden _rSuffix anfangen sollte. Bis ich merkte, dass es nicht so war print, aber print_r...)

— Bwoebi
quelle
Und ich weiß nicht , wie hast du es heraus :) Original - Figur: _:print_r(chr(3*pow(2,5)+@++$i));if(@$i<4<<1)goto _;.
— Kenorb
3
@kenorb a) du musst etwas drucken, also echonicht möglich; printblieb; b) Sie brauchen eine Schleife, aber für eine forSchleife gab es nicht genug Semikolons, und nun, es gibt einen Doppelpunkt ... also wahrscheinlich eine Bezeichnung in Kombination mit goto; c) dann braucht es ein if, um die goto-Schleife abzubrechen. Jetzt haben X:print($Y);if($Y)goto X;(X und Y sind Platzhalter); d) es gibt a ++, aber nein =, also wahrscheinlich einige ++$Zvon 1 bis 8; e) um Buchstaben von einer ganzen Zahl zu bekommen, brauchen wir chr()(normalerweise) - es war da; f) Jetzt musste ich nur noch die Nummern 96 und 8 für chr und if finden. Dann füllen Sie Platzhalter und Volià.
— Bwoebi
5

C, es1024, Länge 70

e='C',f;main(g){Chorkil:f=printf("40%.d",e+e-  -g);}hAx;*hotpoCkats();

Der schwierige Teil bestand darin, alle nicht benötigten Charaktere im Auge zu behalten ... im Ernst ... ich musste sie ungefähr zehnmal wiederholen. Das Einzige, was mich beunruhigte, war das, .aber irgendwie habe ich es in die Mitte des printfFormatstrings gesteckt und es wurde unsichtbar!

— Feersum
quelle
5

Haskell, Größe 34, von Petr Pudlák

main=print(0xb2f3d5^0x7f1f27::Int)

Beachten Sie, dass dieses Programm auf einem 32-Bit-Computer ausgeführt werden muss. Wenn Sie überprüfen möchten, ob dies das richtige Programm ist und Sie über einen 64-Bit-Computer verfügen, können Sie stattdessen Folgendes verwenden:

import Data.Int
main=print(0xb2f3d5^0x7f1f27::Int32)

Es war ziemlich einfach, den "Rahmen" des Programms zu erraten main=print(0x<hex digits>^0x<hex digits>::Int). Die ganze Magie bestand darin, nach dem richtigen Weg zu suchen, um die Ziffern zu unterteilen und zu ordnen. Ich habe hier nicht viel gescheites getan, nur eine Brute-Force-Suche ... obwohl ich darauf geachtet habe, die Tatsache zu missbrauchen, dass einige Ziffern dupliziert wurden, gab es wahrscheinlich ungefähr die gleiche Anzahl von Ziffern in der Basis und im Exponenten und Die letzte Ziffer der Basis war mit ziemlicher Sicherheit nicht gerade. Der vollständige Suchcode ist unten angegeben. Es wird das Multiset-Comb- Paket verwendet. Die vollständige Suche dauert auf meinem Computer ungefähr 10:33 (und liefert natürlich nur eine richtige Antwort).

{-# LANGUAGE NoMonomorphismRestriction #-}
import Control.Monad
import Data.Int
import Data.List (inits, tails, group)
import Numeric
import Math.Combinatorics.Multiset

main = print (searchFor (-1121766947))

searchFor n = do
    nl <- [6,5,7,4,8,3,9,2,10,1,11]
    (l_, r_)  <- chooseSubbag nl digits
    l <- perms l_
    guard (last l /= '2')
    r <- perms r_
    guard ((fromString l :: Int32) ^ (fromString r :: Integer) == n)
    return (l, r)

chooseSubbag n = chooseSubbag' n . group
chooseSubbag' n xss = go (drop (n-1) (concat xss)) n xss where
    go _  n xss | n < 0 = []
    go _  0 xss = [([],concat xss)]
    go [] n xss = []
    go m  n (xs:xss) = do
        (kx, tx) <- zip (tails xs) (inits xs)
        (k , t ) <- go (drop (length tx) m) (n-length kx) xss
        return (kx++k, tx++t)

digits = "1223577bdfff"
fromString = fst . head . readHex
perms = permutations . fromList
— Daniel Wagner
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.