Finde die Nadel im Heuhaufen (Räuber)

18

Dies ist Teil einer Herausforderung für Polizisten und Räuber . Gehen Sie hier für die Polizisten.

Die Herausforderung der Räuber

Die Antwort eines Polizisten kann geknackt werden, indem eine beliebige Teilmenge von Zeichen aus dem Haystack-Programm entfernt wird, sodass sie ausgegeben Needlewird Haystack(obwohl sie immer noch in derselben Sprache gültig ist). Sie müssen nicht genau die gleiche Lösung finden, die der Polizist beabsichtigt hat, solange Ihre Lösung unter den oben genannten Bedingungen gültig ist.

Wenn du das schaffst, poste eine Antwort mit der Lösung, verlinke die Antwort des Polizisten und hinterlasse einen Kommentar zu der Antwort des Polizisten, die zurück zu deiner führt.

Der Räuber, der die meisten Cop-Antworten knackt, gewinnt. Die Krawatten werden durch die Summe der Größen der geknackten Antworten der Polizisten gebrochen (zugunsten des Räubers, der längere Einreichungen knackt).

Jede Antwort eines Polizisten kann nur einmal geknackt werden, und natürlich dürfen Sie Ihre eigene Antwort nicht knacken. Wenn sich herausstellt, dass die Antwort des Polizisten vor oder nach dem Knacken ungültig ist, wird sie nicht auf die Punktzahl des Räubers angerechnet.

Beispiele

Hier einige einfache Beispiele in verschiedenen Sprachen:

Ruby

Haystack: puts 1>0?"Haystack":"Needle"
Delete:        XXXXXXXXXXXXXXX
Needle:   puts "Needle"

Python 2

Haystack: print "kcatsyaHeldeeN"[-7::-1]
Delete:          XXXXXXXX        XX
Needle:   print "eldeeN"[::-1]

Beachten Sie, dass die Teilmenge der entfernten Zeichen nicht zusammenhängend sein muss.

code-golf  source-layout  cops-and-robbers 
— Martin Ender
quelle
Wenn Räubergebrauch hashing, encryption or random number generationist es erlaubt? (Obwohl Möglichkeit winzig)
— l4m2

Antworten:

11

JavaScript, 85 Byte (ES6)

Knackt Arnauld's Antwort

f=(k=b=x=35)=>x--?f(k*4853461&268435455):k&2?'N'+(k^12408877).toString(b):'Haystack'

Demo "Needle"

Code-Snippet anzeigen

Erläuterung

Die ursprüngliche Funktion war:

f=(k=b=x=35)=>x--?f(k*74837258394056219&268435455):k&2?'N'+(k^124038877).toString(b):'Haystack'

was besser lesbar ist als:

f = (k=b=x=35) => {
    if (x--) {
        return f(k*74837258394056219&268435455);
    } else {
        if (k&2) {
            return 'N'+(k^124038877).toString(b);
        } else {
            return 'Haystack';
        }
    }
}

Beachten Sie, dass wenn n=21625674, dann n.toString(35)ist 'eedle'.

Die 35 in der Eingabe kann wahrscheinlich nicht in eine Teilmenge geändert werden (weil wir eine Basis wollen, die groß genug ist, um alle Buchstaben 'del' zu enthalten, brauchen wir eine Basis, die mindestens 22 ist). So sind die Zahlen sind zu ändern 74837258394056219, 268435455und 124038877. Wir wollen sie durch die Zahlen a, b, c ersetzen, die jeweils aus einer Teilmenge der Ziffern der ursprünglichen Zahlen bestehen, sodass die Funktion g(k) = (k * a & b), beginnend mit k=35und 35-mal iteriert und dann mit c XOR-verknüpft, ergibt 21625674.

Für diesen, nachdem ein wenig zu denken, da die Längen klein sind (die maximale aLänge 17, bund chat Länge 9), I nur brute-force verwendet :-) Schrieb eine C ++ Programm alle möglichen Zahlen zu erzeugen a, b, cals Teilmengen gebildet iterieren Sie von den ursprünglichen Nummern durch alle aund bund prüfen Sie, ob die erforderlichen cim Satz waren. Läuft in etwa 15 Sekunden, und die einzige Ausgabe ist a=4853461, b=268435455, c=12408877(Umdrehungen aus der Anzahl bmuss nicht geändert werden). Ich bin mir nicht sicher, ob es eine klügere Art gibt, diese Funktion zu invertieren.

— ShreevatsaR
quelle
5

Brain-Flak , 96 Bytes

Knackt die Antwort von Funky Computer Man .

([((((()()())){}){}){}](()[()]({}([(((()()()){}))[]])[]({}({}()(((()(({}){}){}){}){}())))[]))())

Probieren Sie es online!

Das war eine lustige Herausforderung.

Die -24 am Anfang y, ain die im Original konvertiert wird , wird jetzt zum Konvertieren ein verwendet M, das dann an NOrt und Stelle konvertiert wird, indem die gesamte Endschleife in geändert wird ()). Der erste Push- Brief kwurde geändert, eindem einfach ein Push-Pop entfernt wurde, der 6 hinzufügt. Der Rest ist meistens einfach zusammengebrochen, mit einigen humorvollen Fehlern auf dem Weg (einschließlich eines Programms, dessen Ausgabe war Meddle).

Vergleich der beiden Programme:

Haystack: ([((((()()())){}){}){}](()([()](()({}([((((()()()){})))[]])[]({}({})[{}]()({}((()(({}){}){}){}){}())))[][][][][][]))[]))(((()[]){}){({}[()()])}{})
Needle:   ([((((()()())){}){}){}](() [()]   ({}([ (((()()()){})) []])[]({}({}     ()(  ((()(({}){}){}){}){}())))[]              ))   ()  )
— Nitrodon
quelle
Ich war sicher , dass es wie enden würde dies
— H.PWiz
Das funktioniert auf jeden Fall , aber ich hatte mich irgendwie davon überzeugt, dass Nes 77 statt 78 war, also habe ich es nicht verstanden.
— Nitrodon
Deine ist sowieso kürzer.
— H.PWiz
Interessante Lösung! Ich habe meine beabsichtigte Lösung zum ursprünglichen Beitrag hinzugefügt, wenn Sie es sehen möchten.
— Weizen-Assistent
5

Haskell

Risse @ Laikonis Antwort .

s=map;hay=zipWith;a=head;h=s a.(hay(scanr id).s a<*>s(succ<$))$words"Haysta ayst ackH ays k ayst"

Probieren Sie es online!

Originalcode:

hays=map;hay=zipWith;stack=head;h=stack{-
 hay.(hays.(stackany hay$or id).stack hay
<*>hays(sum$stack haystack<$>hay))-}$words
 "Haystack Hayst ackH aysta ckH aystac k"

entfernte Zeichen durch Unterstriche ersetzen:

___s=map;hay=zipWith;__a__=head;h=s______
 _a_.(hay__(s__c_an_______r id).s____ _a_
<*>___s(su_____c________c_<$____))__$words
 "Haysta__ _ayst ackH ays__ _k_ ayst____"

Wie Needle konstruiert ist: die Zeichenfolge am Ende des Codes in Worte aufgeteilt wird. Das erste Zeichen jedes Wortes wird so oft erhöht, wie es Zeichen im Wort gibt, z. B. Haysta-> Hplus 6 Zeichen -> N.

— nimi
quelle
5

Hexagony , 17 Bytes, H.PWiz

]; N @ cl; e ;; (\. S.; _

Probieren Sie es online!

Vergleich mit Original:

];N.@cl;e@;;(\H/;ya;_.>s.;t//<._  original
];N @cl;e ;;(\       . s.;     _  modified

Visualisierung:

  ] ; N
 @ c l ;
e ; ; ( \
 . s . ;
  _ . .

Erläuterung

Bonusmarken - verwendet alle 6 IPs und alle bis auf eine der Zellen!

Farbige Pfade

Die IP # 0 beginnt, indem Sie rechts entlang des schwarzen Pfads in die ].
Wir gehen dann zu IP # 1 über, das sich entlang des roten Pfades bewegt, druckt Nund sich N;dann wieder in das ]wieder einwickelt .
Wir gehen dann zu IP # 2 über, das sich entlang des blauen Pfads bewegt, ein der aktuellen Speicherzelle speichert und dann entlang des grünen Pfads, wobei ausgeführt wird (mit einer Reflexion bei \), von ;;(;welcher gedruckt wird ee, die Speicherzelle dekrementiert eund ddann gedruckt wird d.
Die IP fährt auf dem orangefarbenen Pfad fort und führt aus, Nl;sewas gedruckt lund ein der aktuellen Speicherzelle gespeichert wird. Es geht weiter entlang des braunen Pfades und druckt das emit;. Zu diesem Zeitpunkt haben wir bereits gedruckt Needle, sodass der Rest gerade fertig ist. Die IP speichert c, dann trifft ].
Farbige Wege 2
Wir gehen dann zu IP # 3 über, die sich auf dem blauen Pfad entlangbewegt \und aufprallt, in _den hineinprallt ].
Wir wechseln dann zu IP Nr. 4, die sich auf dem grünen Pfad entlangbewegt _, dann springt \und zu verzweigt ](da cpositiv ist).
Schließlich übergehen wir zu IP # 5, die speichert edann Ausfahrten mit @.

— Boboquack
quelle
Nett! Das war die beabsichtigte Lösung.
— H.PWiz
4

Python 2 , 123 Bytes

Cracks agtoever's Answer

import numpy
print "".join([dir(numpy)[int(i)][0] for i in numpy.poly1d([-143/2e1,-31,14,131,61,184])(numpy.arange(-3,3))])

repl.it

Vergleich:

print "".join([dir(numpy)[int(i)][1-0] for i in numpy.poly1d([-1*1433/252e1,-3232/1920.,4026./72/2/3.,613/(6*4.)*1,-4723./1.8e2,-9763/120.,-2689/(-1+5*17.),1+138*.4*2])(numpy.arange(-12/3,13%9))])
print "".join([dir(numpy)[int(i)][  0] for i in numpy.poly1d([-1  43 /2  e1,-3    1    ,               1     4    ,       1         3 1   ,  6     1       ,1   8  4  ])(numpy.arange(-   3, 3  ))])

Es hat mir sehr viel Spaß gemacht, Lösungen zu finden, die gedruckt Meedleund Needlfdurch Anpassen eines Polynoms an den Median der Indizes der Zahlensymbole, die mit jedem der Buchstaben in beginnen, erstellt wurden Needle. Ich habe dann versucht, ähnliche Koeffizienten mit Teilmengen des ursprünglichen Programms von Hand zu finden, aber ich musste darauf zurückgreifen, um eine gültige Lösung zu finden.

— jacobly
quelle
Wow! Gut gemacht! Ich hatte nicht erwartet, dass es so bald geknackt wird.
— voraussichtlich
Ich habe die Challenge ursprünglich auf der Basis von NumPy 1.13 entwickelt, das ich in keiner Repl-Umgebung gefunden habe. Deshalb musste ich sie für NumPy 1.12 umschreiben ... ;-)
— bis zum
2

Gelee , 14 Bytes

Knackt Jonathan Allans Antwort

“¡#ɦṢÞɠ»ḟ“¡pṄ»

Probieren Sie es online!

Vergleich:

“¿ọ⁽ṅ*FỊ⁼g£¡#!ʋzoɦṪ£ṢÞḲÐɠ`”m3⁾“»jVḟ“¡!pṄ»
“          ¡#    ɦ  ṢÞ  ɠ      »  ḟ“¡ pṄ»

Früher habe ich œcverschiedene Teilmengen der Literalzeichenfolgen durchlaufen, die tr -dfür jeden möglichen Filter und grepfür Needle verwendet wurden. Unter der Annahme, dass keines der in der ersten Zeichenfolge verwendeten Zeichen in der Antwort verwendet wurde, wird in weniger als 15 Sekunden eine Antwort gefunden.

— jacobly
quelle
Genau das, was ich im Sinn hatte , Nebbed+ rubleohne von rub.
— Jonathan Allan
2

Java (OpenJDK 8), 191 Byte

Knackt die Antwort von Luke Steven

String d(){int h=3905055,m=55,s=15443;String d="0"+h*2+""+m*20+""+s*7,x="",y;for(int g=0;g<d.length();g+=3){y="";for(int e=0;e<3;e++)y+=d.charAt(e+g);x+=(char)Integer.parseInt(y);}return x;}

Probieren Sie es online!

Gelöschte Zeichen:

int h=3609000-5055+911,m=557558,s=15441301-157*10000
       xx  xxx    xxxx     xxxx       x xxxxxxxxxxxx

Dadurch wird dausgewertet 078101101100108101, zu welchen Zaubersprüchen Needle.

— Milch
quelle
2

Rubin , 149 Bytes

Knackt dies: /codegolf//a/144790/74216

Das Modul war ziemlich klein, also schrieb ich ein Multithread-Geburtstagsgeschenk und hoffte auf das Beste.

Edit: Und danach eine noch kürzere Antwort gefunden.

x='hxDKFQOoqJLuVNW'
s="n=x.to_i 36;x.bytjs.jach_cons(3){|a,b,c|n+=n*b%c;n*=a^b};puts n%8675309==1388649 ?'Njjdlj':'Haystack'"
eval s.tr ?j,s.size.chr

Probieren Sie es online!

Änderungen:

x='yGwztsPXhxDkBKlCYdFjQnpUROfoHvqmTgbaJSLcEiZrIAuMVNW'
x='        hxD  K    F Q    O o  q     J L       u VNW'

# and here's some more variants for extra pwnage:
x=' G  tsPx     KlCYd  Qn U   o v mT  a SLc    I u  NW'
x='  w  s    D BKl  dF QnpU O        ba SLcEiZrI  MV  '
x='yGwz s Xh Dk K C  F  npU O  Hvq   b   L    rIAu V W'
— cab404
quelle
2

Gleichstrom , 34 Bytes

93 9 2*+432212+ 47*4242160 7 2++*P

Knackt das . TIO .

Ich begann mit der numerischen Darstellung von Haystack (5215583380252484459) und Needle (86197399743589). Als nächstes habe ich eine Faktorisierung des letzteren durchgeführt, nämlich 47 * 432323 * 4242169. Daraus war es ziemlich einfach, diese Zahlen zu rekonstruieren.

Kennzeichnung der verwendeten Zeichen:

6 93 3 9 2 2**+*+483622 1 2 3 3*+3*+89 47*+*+3 5 2* 269 158 9**107 97*2 4*++2 3 3*+42 14 2**+*+5*+5 2148 1 6 2*+*+68262 5 280 7 2 3 3*+5 2**+*+*+*+P
  XXX  XXX   XX  X X XX X X     X     XXXX                              X   X      XX X                    X                XXXXX     X     XX     X
— wie auch immer
quelle
gg! Ich wusste, dass es eine schlechte Idee ist, so viele Zahlen zu setzen)
— cab404
@ cab404 Nur neugierig: hast du eine ganz andere Rechnung benutzt um zu 86197399743589 zu kommen?
— Am
Ja, es ist viel länger
— cab404
Wow. Das ist bemerkenswert. Das könnte eine weitere codegolf Frage sein: Wie viele Möglichkeiten gibt es , um ein bestimmtes Ergebnis zu erhalten , indem Zeichen in einem Ausdruck zu löschen ...
— agtoever
Ich schätze, das würde im Allgemeinen einige ernsthafte Berechnungen erfordern, um alle
— Möglichkeiten
2

Hexagony , 19 Bytes, Martin Ender

[@;(...e<l.a;./;N>;

Probieren Sie es online!

Vergleich mit Original

H[@;(...e<l.a;./$.>;\sN;\ac.>).;;;._y
 [@;(...e<l.a;./   ;  N     >  ;

Entfalteter Code

  [ @ ;
 ( . . .
e < l . a
 ; . / ;
  N > ;

Also, ich habe noch nie etwas in Hexagony geschrieben, aber ich habe mit nur 37 Bytes herausgefunden, dass ich mit dem Riss kommen könnte. Martin, ich hoffe du weißt, dass ich viel Zeit investiert habe, um das herauszufinden. :)

Ich kann falsch sein, aber ich werde erklären, was ich denke, dass dieser Code tut:

Das Programm startet mit [, das automatisch auf IP # 5 wechselt. Diese IP beginnt in der Westecke und geht wieder in Richtung [, wodurch sie auf IP Nr. 4 verschoben wird. Von hier aus führt es N;edann in die südöstliche Ecke und führt aus ;, springt nach rechts, um einen anderen ;zu erhalten, auf (den der Strom ezu einem dekrementiert wird d. Weiter geht es dann (mit einem Wrap) bis ...;.dann prallt auf die lund wird zum [letzten Mal, um IP zu bewegen # 3. Sie führt ;, >Umleitungen nach Nordwesten .dann <Umleitungen im Westen, Schlagen e, Umwicklung ;und zur Einstellung auf dem @.

Ausführliche Version

Code-Snippet anzeigen

Ich bin so froh, dass Sie für das Nadelprogramm eine normale Sechskantgröße verwendet haben. Ich habe Programme der Größe 19 (für ein 3-seitiges Sechseck) überprüft, als mir klar wurde, dass Sie beliebig viele Zeichen entfernen können und das Sechseck .am Ende automatisch mit s gefüllt wird , was das Knacken erheblich erschwert. So wie es ist, ist Hexagony eine böse Sprache für diese Herausforderung, da (meistens) jedes entfernte Zeichen den gesamten Ausführungspfad des Programms verändert. Davon abgesehen hat es mir Spaß gemacht, dies zu versuchen, auch wenn ich es am Ende brutal erzwungen habe. :)

— Jo.
quelle
Wenn ich etwas vermasselt / verpasst habe, lass es mich bitte wissen.
— Jo.
Gute Arbeit, das sieht ziemlich genau aus. Ich werde es mit dem vergleichen, was ich ursprünglich über das Wochenende hatte.
— Martin Ender
1

Java (OpenJDK 8) , 151 Byte

Risse Kevin Cruijssen Antwort-

v->{String h="H";int x=7;return new String(new byte[]{(byte)((-~-~-~-~-~-~1^x++*x)+15),new Byte("10"+h.length())})+new StringBuffer("elde").reverse();}

Probieren Sie es online!

Vergleich:

v->{String h="Haystack";int x=-7;return x<0?h:new String(new java.math.BigInteger(new byte[]{(byte)((~-~-~-~-~-~-~-~-~-~1^-x++*x)+151),new Byte("2"+"1+\"0+\"".length()+(x=h.length()*4/x)+"-x-7")}).toByteArray())+(new StringBuffer("hidden".substring(++x%3^4,--x-x--).replaceFirst("dd","e"+(char)(x*211%+93))).reverse());}
v->{String h="H       ";int x= 7;return       new String(                         new byte[]{(byte)(( -~-~-~-~-~-~      1^ x++*x)+15 ),new Byte("    1   0  "          +   h.length()    )        })               + new StringBuffer("    e                                 l          d    e"      )             .reverse() ;}

Ich habe das Gefühl, dass der letzte Teil nicht beabsichtigt war.

— jacobly
quelle
Lol ok, das ist eine clevere Art, "edle" zu machen. Während um ich das Hantieren schon dachte , dass ich ein bisschen zu viel getan und viele Lösungen möglich wäre ..;) Die beabsichtigte Lösung war: v->{String h="Haystack";int x=7;return new String(new java.math.BigInteger(new byte[]{(byte)((~-~-~-~-~-~-~-~1^-x++*x)+15),new Byte(""+10+((x=h.length()*4/x)+x-7))}).toByteArray())+(new StringBuffer("hidden".substring(++x%3,x).replaceFirst("d","e"+(char)(x*21+3))).reverse());}(weiß nicht , warum ich das BigInteger aufgenommen haben , da nur Byte-Array genug ist ..) , aber ich mag deine besser .. :)
— Kevin Cruijssen
1

Brain-Flak , 102 Bytes

(((((((((()()()){}){}){}){}()){}()))()()<>)(()()()){}())<>((()((){}<>)))(({})[(((()()){}())(){}){}()])

Risse H.PWiz Antwort .

Probieren Sie es online!

((((((((((()()()){}){}()){}){}()){}()))<({}[(()()()()){}])(([[]]({})<>)<>)>((()()())){}{})[()]))<[[]()]>((()){}){}((){}[][(<>){}<>])(<>){}(({}<>()[()])[(((()()()){}<[()]>)<(()){}>{}){}()])
 (((((((((()()()){}){}  ){}){}()){}()))      ()()                   <>)     (()()()) {}    () ) <      >((()      ((){}    <>)     )   )  (({}        )[(((()()  ){}  ()  )  () {}   ){}()])
— Nitrodon
quelle
1

Java von Johnathan S.

import java.util.*;interface Main{static void main(String[]args){Stack<Hay>s=new Stack();s.add(new Needle());System.out.println(s.get(s.indexOf(new Hay())+1).a);}}class Needle extends Hay{{a="Needle";}}class Hay{String a="Haystack";public boolean equals(Object o){return getClass().equals(o.getClass());}}

TiO

Entfernen Sie einfach die Schlaufe, die das Heu hinzufügt, und nichts bleibt auf dem Stapel außer der Nadel.

— Titus
quelle
Ha, nette - ich hatte eigentlich nicht daran gedacht, einfach die Schleife zu entfernen! Das Entfernen der equalsMethode funktioniert genauso gut.
— Jonathan S.
0

T-SQL von phroureo , 757 Bytes

seleCT 'Needle'

Irgendwie glaube ich nicht, dass das die beabsichtigte Lösung war. Verwendet die Zeichen, die umgeben sind von {}:

create table a(l int,c int)
in{se}rt into a va{l}u{e}s (1,10),(2,1),(3,8),(4,0)
go
;CREATE FUN{CT}ION b(@ varchar(max)) returns varchar(max) as
begin return{ '}char('+@+'),'''','end 
go
;CREATE FU{N}CTION h(@ varchar(max),@a varchar(max), @b varchar(max), @c varchar(max), @d varchar(max), @e varchar(max), @f varchar(max), @g varchar(max), @h varchar(max))
r{e}turns varchar(max) as 
b{e}gin
return replace(replace(replace(replace(@,@a,@b),@c,@d),@e,@f),@g,@h)
end
{d}ec{l}ar{e} @x varchar(max),@ int=1,@y varchar(99)={'}'
,@D varchar(4)='Ha',@O varchar(4)='ys'
,@T varchar(3)='ta',@A varchar(4)='ck'
WHILE @<=4
BEGIN
set @y+=(SELECT dbo.b(c+100)from a where l=@)+' '
set @+=1
END
SELECT @x='select
left(dbo.h('''+@D+@O+@T+@A+''','+ left(@y,len(@y)-1) +'),char(56))'
execute(@x)
— Robert Fraser
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.