Hinweis: Diese Herausforderung ist beendet. Einsendungen sind immer noch willkommen, können aber nicht gewinnen.

Das ist der Faden der Bullen. Der Räuberfaden geht hier .

Schreiben Sie einen Code, der die Ganzzahl ausgibt 1. Wenn Sie ein einzelnes Zeichen (nach Ihrer Wahl) hinzufügen, entfernen oder ersetzen, sollte der Code die Ganzzahl ausgeben 2. Ändern Sie ein weiteres Zeichen (das gleiche oder ein anderes), und der Code sollte ausgegeben werden 3. Fahren Sie so weit wie möglich fort, maximal jedoch bis zu 10. Standardausgabeformate wie ans = 1werden akzeptiert. Sie können die Ausgabe nach STDERR (oder eine gleichwertige Angabe) ignorieren.

Sie müssen die Sprache, die Anzahl der Bytes Ihres Anfangscodes, die Anzahl der Ganzzahlen, für die es funktioniert, sowie eine optionale Anzahl von Zeichen des Anfangscodes angeben. Hinweis: Sie müssen keine Charaktere aufdecken, aber denken Sie daran, dass das Aufdecken von Charakteren für die Räuber schwieriger sein kann, da dieselben Charaktere an derselben Position verwendet werden müssen. Sie können auswählen, mit welchem ​​Zeichen Sie nicht aufgedeckte Zeichen kennzeichnen (z. B. Unterstriche). Achten Sie jedoch darauf, dies anzugeben.

Cops können den ungeknackten Code nach einer Woche zur Verfügung stellen und die Einreichung "SAFE" nennen. Die gewinnende Einsendung ist die kürzeste ungerissene Einsendung, die die Zahl 10 ergibt. Wenn keine ungerissenen Einsendungen die Zahl 10 drucken können, gewinnt der kürzeste Code, der 9 ergibt, und so weiter. Beachten Sie, dass die Räuber nicht dieselben Änderungen vornehmen müssen wie Sie und auch nicht den genauen Code reproduzieren müssen (es sei denn, Sie enthüllen alle Zeichen). Sie müssen nur die Ausgabe reproduzieren.

Später als am 24. November eingereichte Beiträge sind willkommen, aber nicht für den Gewinn qualifiziert (da es wahrscheinlich weniger Räuber geben wird).

Beispielbeitrag:

Der folgende Beitrag ist eine Einreichung in der Sprache MyLang, er ist 9 Byte lang und funktioniert für die Nummern 1 - 8.

MyLang, 9 Bytes, 8 Zahlen

Diese Vorlage arbeitet für 1 - 8. Unrevealed Zeichen werden mit einem Unterstrich angegeben: _.

abc____i

Bestenliste

Haftungsausschluss: Die Bestenliste wurde nicht getestet und ungerissene Beiträge werden möglicherweise nicht in der Liste angezeigt.

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

Hexagony , 18 Bytes, 10 Zahlen, SAFE

Diese Vorlage arbeitet für 1 - 10. Unrevealed Zeichen werden mit einem Unterstrich angegeben: _.

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

Sie können Hexagony hier online ausprobieren.

Meine Lösung:

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

Hex für Ausgang 1:

Probieren Sie es online!

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

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

1. An der <Gedächtniskante liegt 0, also taucht es auf.
2. Hits 1
3. Springt zu 5
4. Springt über 8, kehrt aber um <und holt den 8auf dem Rückweg.
5. Hits 5nochmal
6. Springt vorbei 1
7. Hits der <an dieser Stelle der Speicherwert ist 1585, die 256 mod, geschieht ASCII zu sein1
8. Endlich druckt und beendet sich mit ;@.

Hex für Ausgang 2:

Probieren Sie es online!

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

Dies folgt demselben Pfad, aber auf dem Rückweg trifft es einen, )der die Speicherflanke auf 1586 erhöht, oder 2.

Hex für Ausgang 3-9:

Probieren Sie es online!

Important parts:
  2 < [
 . . ] .
. $ . ) .
 . @ . !
  . 1 .

1. Trifft die 2
2. Jetzt ist die Speicherflanke positiv, wenn sie erreicht wird <, so dass sie nach unten dreht.
3. Das ]ändert den Anweisungszeiger, kommt aber sofort wieder mit[
4. ) Inkremente zu 3
5. ! Druckt 3
6. $bleibt von den ersten beiden Zahlen übrig, so dass wir über das Ende springen ( @)
7. 1 ändert den Speicherrand, aber das spielt jetzt keine Rolle.
8. < spiegelt den Zeiger zurück.
9. Auch hier 1spielt es keine Rolle, weil wir @das Programm beenden.

Netzhaut , 2 Bytes, 10 Zahlen, Gebrochen

_1

Funktioniert für 1 bis 10, _ist ein verstecktes Zeichen. Dies sollte nicht zu schwer sein, aber ich hoffe, es bietet ein etwas interessantes Rätsel. :)

Sie können Retina hier online ausprobieren.

Oktave, 55 Bytes, 10 Zahlen, geknackt

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

_ ist das unbekannte Zeichen.

Lösung

(o=@(O,o)(@(O,o)o{2-O}())(0<O,{@()o(O-1)+1,@()1}))(0,o)% ändert dann das allerletzte 0in 1,2,3etc.

Gegeben x, dies wird rekursiv berechnet x+1. Es besteht hauptsächlich aus zwei anonymen Funktionen. Eine ifAussage zur Verankerung der Rekursion ist:

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

Dies missbraucht nur die Tatsache, dass ein boolescher Wert zu 0oder ausgewertet wird 1. Diese Funktion akzeptiert einen Booleschen Wert und ein Zellenarray mit zwei Funktionen und wertet die eine oder andere dieser beiden Funktionen in Abhängigkeit vom Booleschen Wert aus. Der zweite Teil ist die eigentliche Rekursion:

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

Da eine beliebige Funktion anonym ist, können Sie über itsefl nicht direkt darauf zugreifen. Deshalb brauchen wir ein zweites Argumentfzuerst. Später werden wir ein Handle für die Funktion instelf als zweites Argument bereitstellen, sodass eine endgültige Funktion folgendermaßen aussieht:

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

In dieser Notation lautet meine Übermittlung also :

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

Ich habe vor einiger Zeit beim Stackoverflow nach Rekursionsankern für anonyme Funktionen in MATLAB gefragt .

Python 2, 9 Bytes, 10 Zahlen, geknackt

print 8/8

Keine versteckten Zeichen. Kannst du es knacken, ohne etwas zu erzwingen?

Perl, 12 Bytes, 10 Zahlen, Cracked!

Unterstriche stehen für unbekannte Zeichen.

____;say__-9

Wahrscheinlich ziemlich einfach, und es würde mich nicht überraschen, wenn es mehrere Lösungen gäbe. Trotzdem könnte es Spaß machen, zu knacken.

(Die beabsichtigte Lösung war die gleiche wie der Riss. Dies ist im Grunde genommen nur ein Problem beim Zuweisen von 10 zu einer Variablen mit vier Zeichen, was in Perl überraschend schwierig ist 10.)

Perl, 46 Bytes, 10 Zahlen, sicher

Das Problem

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

Die kürzeren Probleme neigen dazu, schnell geknackt zu werden, deshalb dachte ich, ich würde es mit einem längeren Problem versuchen. Die längeren neigen auch dazu, geknackt zu werden, wenn die Leute genug Lücken lassen, um etwas Unartiges wie sayoder hereinzuschleichen exit, so dass alle Lücken hier kurz sind. Versteckte Zeichen werden mit dargestellt _.

Meine Lösung

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

Zum Drucken 2, 3, usw., bis zu 9, halten , die Anzahl Wechsel zugewiesen $b{0} in der zweiten Zeile (dh $b{0}=2, $b{0}=3usw.). Das Programm für 9 sieht folgendermaßen aus:

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

Um dann 10 zu erzeugen, kommentieren Sie die erste Zeile aus, indem Sie ihr ein #Zeichen voranstellen .

Erläuterung

Das erste, was zu beachten ist, ist, dass die Lösung nicht wirklich gut ist, außer das Entfernen von Leerzeichen: Wenn wir sie mit besser lesbaren Leerzeichen auslegen, erhalten wir Folgendes:

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

Wenn Sie in Perl auf die Argumente eines Unterprogramms zugreifen, kopieren Sie diese normalerweise aus @_. Dafür gibt es einen guten Grund: @_Aliase die Argumente, denen die Unterroutine gegeben ist (die zum Beispiel (sub { $_[0] = 3 })->($x)zugewiesen werden $x), was normalerweise nicht wünschenswert ist.

Obwohl @_es magisch erscheinen mag, verwendet es tatsächlich nur eine Standardfunktion der Perl-Interna (die in XS leicht verfügbar ist, aber in reinem Perl nur in einigen komischen Fällen auftritt, wie z. B. in sich @_selbst): Ein Array speichert seine Elemente nicht direkt , sondern durch Bezugnahme. Wenn wir also bin der zweiten Zeile unten aufrufen, generiert Perl ein Array (das es aufruft @_), dessen erstes Element auf denselben Speicher verweist, der auch $b{0}verwendet wird. (Hash-Werte werden auch als Referenz gespeichert; $ _ [0] und $ b {0} verweisen zu diesem Zeitpunkt beide auf denselben Speicher.) Da @_aus interner Sicht nichts Besonderes zu tun ist, können wir eine Referenz heranziehen dazu, wie wir es mit jedem anderen Array tun könnten, was dazu führt, dass es die Subroutine überlebt, in der es definiert ist.

Perl Variablen auch auf die Datenspeicherung durch Bezugnahme verwiesen. Vor langer Zeit verwendeten die Leute Code *x = *y;, um ihn $xals Alias ​​zu setzen $y(indem sie ihn auf dasselbe verweisen ließen), ebenso @xals Alias ​​zu @y, %xals Alias ​​zu %yund so weiter. Dies unterbricht eher die Invariante, dass Variablen mit ähnlichen Namen nicht ähnlich funktionieren müssen, weshalb modernes Perl eine Alternative bietet. Ein Verweis auf eine Typeglob überschreibt die Zuordnung nur die Variable, die den Typ des Referenz entspricht (so *x = \%ywürde alias %xzu Punkt auf denselben Speicher wie %yaber verlassen, sagen wir, $xallein). Bei dieser Syntax spielt es keine Rolle, ob der Speicher, für den Sie einen Aliasnamen verwenden, einen Namen hat. Wenn wir also den Rückgabewert von zuweisen, ist dies nicht der Fallb(das ist eine Array - Referenz, die das Array zu halten ist früher als @_lebendig) zu *b, was passiert ist , dass @bzu alias der Argumentliste auf den Aufruf zu geändert wird b(während verlassen %bunverändert). Dies bedeutet insbesondere, dass $b[0]und $b{0}jetzt auf denselben Speicher verwiesen wird und die Zuordnung zu einem Speicher den anderen ändert. Von da an ist alles ganz einfach.

Die Perl-Dokumentation spricht nicht wirklich über diese Art von Detail. Die Natur, @_nicht ganz wie andere Arrays zu sein, wird nicht wirklich betont, und die meisten Codierungsstile zielen darauf ab, die Auswirkungen zu minimieren, anstatt sie zu verstärken.

JavaScript, 30 Bytes, 10 Zahlen, geknackt

alert(Array(_)________.length)

Sollte nicht zu schwer sein, aber hoffentlich ist es gerade schwer genug, eine Herausforderung zu bieten. :) Nicht aufgedeckte Zeichen sind mit gekennzeichnet _.

Perl, 14 Bytes, 10 Zahlen, Gebrochen

say_!"___"%""_

Werke für 1 bis 10 _sind versteckte Zeichen.

Ich denke, das sollte nicht zu schwer zu knacken sein. Ich habe eine härtere, für 22 Bytes, ich werde es posten, wenn diese geknackt ist.

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

Und ersetzen die "!"durch eine Reihe von der Länge der Nummer , die Sie drucken möchten, zum Beispiel !, !!, !!!etc.

Allerdings ais523 fand eine andere Art und Weise:

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

JavaScript, 22 Bytes, 10 Zahlen, geknackt

Wahrscheinlich ziemlich leicht zu knacken.

alert(__14_337__xc_de)

_ ein versteckter Charakter sein

Oktave, 17 Bytes, 10 Zahlen, Gebrochen

_od(3_13_13_7_1_)

Originelle Lösung

mod(3*1361357,10)
...
mod(3*1361357,17)
mod(3*1361397,17)
mod(9*1361397,17)

_ ist der versteckte Charakter.

Jelly , 7 Bytes , 10 Zahlen, geknackt

“1‘ỌȮḊ‘

Keine Platzhalter.

Der erreichte Riss (um ein Eval mit einem Argument zu verwenden) war, wie viele in diesem Thread zu sein scheinen, nicht der beabsichtigte.

Der beabsichtigte Riss war:

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

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

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

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

Befunge-93, 11 Bytes, 10+ Zahlen, Gebrochen

Diese Einreichung funktioniert für mindestens 1 - 10. Nicht aufgedeckte Zeichen sind mit gekennzeichnet □.

□□5:**-□-.@

Probieren Sie es online aus

Ich muss sagen, ich war beeindruckt, dass zwei Personen unabhängige Lösungen dafür finden konnten, von denen keine das war, was ich erwartet hatte. Während Martin zuerst dort ankam , gebe ich Sp3000 den "Gewinn", da ihre Lösung portabler ist.

Dies war jedoch meine beabsichtigte Lösung:

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

Weil ein Stapelunterlauf in Befunge als 0 interpretiert wird, der gliest nur von 0,0 den ASCII - Wert von ‚g‘ Rückkehr, nämlich 103 45:**-subtrahiert 100, geben Sie 3. Dann 2-gibt Ihnen 1.

Für die dritte Iteration, die -(subtrahieren ) wird in einen \(Swap-) Befehl geändert , sodass die 3 zum obersten Stapeleintrag wird. Und in vier Iteration, a +(add) Anweisung eingefügt wird, wodurch die Zugabe von 3 bis 4 gibt die 1.

R, 21 Bytes, 10 Zahlen Gebrochen

__i___________i______

Funktioniert für 10 Nummern. _ist versteckter Charakter.

Ursprüngliche Lösung:

which(letters%in%"a")
which(letters%in%"b")
etc.

Ruby, 16 Bytes, 10 Zahlen, geknackt von xsot

x=##/=#%#
)
###x

# ist ein beliebiges Zeichen.

Oktave, 32 Bytes, 10 Zahlen. Geknackt

_n_(isprime(floor(s____i__ i____

_ ist ein versteckter Charakter.

Sie können Octave online testen hier testen .

Ursprüngliche Lösung:

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

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

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

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

...

Oktave, 17 Bytes, 10 Zahlen, Gebrochen

_i_(__i__(2_5_))

Nicht aufgedeckte Zeichen sind mit gekennzeichnet _ .

Beabsichtigte Lösung:

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

Oktave, 19 Bytes, 10 Zahlen, geknackt

__sca__1_)___'-_6_'

_ ist der versteckte Charakter.

Beabsichtigte Lösung:

Pascal (10) ('a'-96)'

05AB1E , 5 Bytes, 10 Zahlen, geknackt!

Nicht sehr schwer, aber lustig :)

_[==_

_ist ein zufälliger Charakter. Verwendet die CP-1252- Codierung. Probieren Sie es online!

05AB1E , 6 Bytes, 10 Zahlen, geknackt

Versuch 2, diesmal ohne die Zeichenfolge mit drei Zeichen: p.

_ [==_

_ist ein zufälliger Charakter. Verwendet die CP-1252- Codierung. Probieren Sie es online!

JavaScript, 22 Bytes, 10 Zahlen, geknackt

alert(0_6_4_>_0_2_0_7)

_ ist der versteckte Charakter.

Hinweis auf die beabsichtigte Lösung

Das Zeichen, das geändert werden muss, um alle Zahlen zu generieren, ist immer dasselbe.

JavaScript 21 Bytes, 10 Zahlen geknackt

alert(b_oa_"3____1"))

Nicht aufgedeckte Zeichen sind mit gekennzeichnet _

Geknackt

Meine Version:

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

Python 3, 19 Bytes, 10 Zahlen, geknackt

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

Nicht aufgedeckte Zeichen sind mit gekennzeichnet ?. Getestet in Python 3.5.2.

Python 3, 16 Bytes, 10 Zahlen, geknackt

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

Nicht aufgedeckte Zeichen sind mit gekennzeichnet ?. Das ist wahrscheinlich ein bisschen einfach, da es nur fünf Fragezeichen gibt, aber ich hoffe, dass es Spaß macht.

C #, 90 Bytes, 10 Zahlen, geknackt

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

Ich habe ehrlich gesagt keine Ahnung, wie schwer das zu knacken ist.

Edit: Ups, Transkriptionsfehler. Eins _zu wenig danachusing .

Jetzt geknackt von Hedi , die die beabsichtigte (mit Ausnahme des Klassennamens) Lösung fand.

JavaScript 33 Bytes, 10 Zahlen geknackt x2

Hoppla, ich poste meine Zeile für das Generieren von 10, die Hedi geknackt hat, als wäre es für 1

alert(_to__"_Xc0__0_B6____Zp=="))

Version, die zum Generieren von 1 veröffentlicht werden soll

alert(_to__"_Xc0__0_Bf____Zp=="))

Nicht aufgedeckte Zeichen sind mit gekennzeichnet _

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

Python, 10+ Zahlen, 61 Bytes, Cracked!

Hier war der Code, den ich gepostet habe:

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

Der ursprüngliche Code war:

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

Grundsätzlich wird ein Fehler ausgegeben ( 'x' is not defined) und anschließend die Zeile ausgegeben, in der der Fehler gefunden wurde. Fügen Sie einfach am Anfang neue Zeilen hinzu, um die Zahl zu erhöhen.

Ich wusste, dass es nicht schwer sein würde zu knacken - ich wollte nur eine lustige Art, Zahlen zu drucken -, aber ich hatte nicht erwartet, dass Sp3000 es so schnell bekommt, das sind einige professionelle Fähigkeiten!

05AB1E, 11 Bytes, Gebrochen!

3628801__0_

Funktioniert von 1-10. _ist ein versteckter Charakter.

Vorgesehene Lösung:

3628801R¬0+ # 1
3628801R¬1+ # 2
3628801R¬2+ # 3
3628801R¬3+ # 4
3628801R¬4+ # 5
3628801R¬5+ # 6
3628801R¬6+ # 7
3628801R¬7+ # 8
3628801R¬8+ # 9
3628801R¬9+ # 10

Oktave, 24 Bytes, 9 Zahlen, geknackt

_a__repmat(__one___,__)_

_ ist ein versteckter Charakter.

(Inspiriert von der Herausforderung von @ LuisMendo .)

JavaScript, 9 Bytes, 10 Zahlen, Gebrochen

alert(__)

_ ist der versteckte Charakter.

Oktave, 25 Bytes, 9 Zahlen. Geknackt

__a__repmat(__one___,__)_

_ ist ein versteckter Charakter.