Trova l'ago nel pagliaio (ladri)

18

Questo fa parte di una sfida di poliziotti e ladri . Vai qui per la parte degli sbirri.

La sfida dei ladri

La risposta di un poliziotto può essere decifrata rimuovendo qualsiasi sottoinsieme di caratteri dal programma Haystack, in modo che venga emesso Needleinvece di Haystack(pur essendo un invio valido nella stessa lingua). Non devi trovare la stessa identica soluzione del poliziotto previsto, a condizione che il tuo sia valido per i vincoli di cui sopra.

Se lo gestisci, pubblica una risposta con la soluzione, collegandoti alla risposta del poliziotto e lascia un commento sulla risposta del poliziotto che rimanda alla tua.

Vince il ladro che incrina il maggior numero di poliziotti. I legami sono spezzati dalla somma delle dimensioni delle risposte del poliziotto incrinato (a favore del ladro che rompe gli invii più lunghi).

Ogni risposta del poliziotto può essere decifrata una sola volta e, naturalmente, non ti è permesso di decifrare la tua risposta. Se la risposta del poliziotto risulta non valida prima o dopo il crack, non viene conteggiata per il punteggio del ladro.

Esempi

Ecco un paio di semplici esempi in diverse lingue:

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]

Nota che il sottoinsieme di caratteri rimossi non deve essere contiguo.

code-golf  source-layout  cops-and-robbers 
— Martin Ender
fonte
Se hashing, encryption or random number generationè consentito l' uso di un ladro ? (Anche se possibilità minuscola)
— l4m2

Risposte:

11

JavaScript, 85 byte (ES6)

Crepa la risposta di Arnauld

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

Demo "Needle"

Mostra snippet di codice

Spiegazione

La funzione originale era:

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

che è più leggibile come:

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

Nota che quando n=21625674, allora lo n.toString(35)è 'eedle'.

Il 35 nell'input probabilmente non può essere cambiato in un sottoinsieme (perché vogliamo una base abbastanza grande da contenere tutte le lettere 'del', quindi abbiamo bisogno di una base che sia almeno 22). Così i numeri per cambiare sono 74837258394056219, 268435455e 124038877. Vogliamo sostituirli con i numeri a, b, c, ciascuno formato con un sottoinsieme delle cifre dei numeri originali, in modo che la funzione g(k) = (k * a & b), iniziando con k=35e ripetendo 35 volte, e poi XORed con c, dia 21625674.

Per questo, dopo aver pensato un po ', le lunghezze sono piccole (la massima aha lunghezza 17, be cavere una lunghezza 9), ho solo usato forza bruta :-) giallo un programma C ++ per generare tutti i numeri possibili a, b, cformata come sottoinsiemi dei numeri originali, scorrere tra tutti ae be verificare se cil set era necessario . Viene eseguito in circa 15 secondi, e l'unica uscita è a=4853461, b=268435455, c=12408877(scopre il numero bnon ha bisogno di essere cambiato). Non sono sicuro che esista un modo più intelligente di invertire questa funzione.

— ShreevatsaR
fonte
5

Brain-Flak , 96 byte

Crack La risposta di Funky Computer Man .

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

Provalo online!

Questa è stata una sfida divertente.

Il -24 all'inizio che converte ya anell'originale è ora utilizzato per convertire ea M, che viene poi convertito Nin luogo cambiando l'intero anello fine ()). La prima lettera push è kstata cambiata in esemplicemente rimuovendo un push-pop che ne aggiunge 6. Il resto per lo più è appena andato a posto, con alcuni passi falsi lungo la strada (incluso un programma il cui output era Meddle).

Confronto tra i due programmi:

Haystack: ([((((()()())){}){}){}](()([()](()({}([((((()()()){})))[]])[]({}({})[{}]()({}((()(({}){}){}){}){}())))[][][][][][]))[]))(((()[]){}){({}[()()])}{})
Needle:   ([((((()()())){}){}){}](() [()]   ({}([ (((()()()){})) []])[]({}({}     ()(  ((()(({}){}){}){}){}())))[]              ))   ()  )
— Nitrodon
fonte
Ero sicuro che sarebbe andata a finire come questo
— H.PWiz
Funziona certamente , ma in qualche modo mi ero convinto che Nfosse 77 anziché 78, quindi non l'ho preso.
— Nitrodon,
Il tuo è comunque più breve.
— H.Piz,
Soluzione interessante! Ho aggiunto la mia soluzione prevista al post originale se desideri vederlo.
— Wheat Wizard
5

Haskell

Cracks @ Laikoni's answer .

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

Provalo online!

Codice originale:

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"

sostituzione dei caratteri rimossi con caratteri di sottolineatura:

___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____"

Come Needleè costruito: la stringa alla fine del codice è divisa in parole. Il primo carattere di ogni parola viene incrementato tante volte quante sono i caratteri presenti nella parola, ad es. Haysta-> Hpiù 6 caratteri -> N.

— Nome del modello
fonte
5

Esagonia , 17 byte, H.PWiz

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

Provalo online!

Confronto con l'originale:

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

visualizzazione:

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

Spiegazione

Punti bonus: utilizza tutti e 6 gli IP e tutte le celle tranne una!

Percorsi colorati

L'IP # 0 inizia andando a destra lungo il percorso nero in ].
Passiamo quindi a IP # 1, che procede lungo il percorso rosso, stampando Ne N;ricoprendo ]nuovamente.
Passiamo quindi a IP # 2, che procede lungo il percorso blu, memorizzando enella cella di memoria corrente, quindi lungo il percorso verde, eseguendo (con un riflesso su \) ;;(;che stampa ee, decrementa la cella di memoria eper dpoi stampare d.
L'IP continua lungo il percorso arancione, eseguendo ciò Nl;seche stampa le memorizza enella cella di memoria corrente. Continua lungo il percorso marrone, stampando il econ;. A questo punto abbiamo già stampato Needle, quindi il resto è appena finito. L'IP memorizza c, quindi colpisce ]. Passiamo quindi a IP # 3, che procede lungo il percorso blu, colpendo , rimbalzando in cui rimbalza . Passiamo quindi a IP # 4, che procede lungo il percorso verde, rimbalzando , quindi e ramificando (poiché è positivo). Infine, passiamo a IP # 5, che memorizza e quindi esce .
Percorsi colorati 2
\_]
_\]c
e@

— boboquack
fonte
Bello! Questa era la soluzione prevista.
— H.Piz,
4

Python 2 , 123 byte

Cracks agtoever di risposta

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

Confronto:

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

Mi sono divertito molto a trovare soluzioni stampate Meedlee Needlfadattando un polinomio alla mediana degli indici dei simboli intorpiditi che iniziano con ciascuna delle lettere Needle. Ho quindi cercato di trovare manualmente coefficienti simili con sottoinsiemi del programma originale, ma alla fine ho dovuto ricorrere al bruto costringendo uno a trovare una soluzione valida.

— jacobly
fonte
Wow! Ottimo lavoro! Non mi aspettavo che si spezzasse così presto.
— agtoever,
Inizialmente ho sviluppato la sfida basata su numpy 1.13, che non ho trovato in nessun ambiente di sostituzione, quindi ho dovuto riscriverla per numpy 1.12 ... ;-)
— agtoever
2

Gelatina , 14 byte

Crepa la risposta di Jonathan Allan

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

Provalo online!

Confronto:

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

Ho usato œcper scorrere vari sottoinsiemi delle stringhe letterali, usati tr -dper ogni possibile filtro, ed greped per Needle. Partendo dal presupposto che nessuno dei caratteri utilizzati nella prima stringa è stato utilizzato nella risposta, consente di trovare una risposta in meno di 15 secondi.

— jacobly
fonte
Esattamente quello che avevo in mente Nebbed+ rublesenza nessuno dei rub.
— Jonathan Allan,
2

Java (OpenJDK 8), 191 byte

Infrange la risposta di 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;}

Provalo online!

Caratteri eliminati:

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

Questo fa dvalutare a 078101101100108101quali incantesimi Needle.

— latte
fonte
2

Rubino , 149 byte

Crack questo: /codegolf//a/144790/74216

Il modulo era piuttosto piccolo, quindi ho scritto una cosa di compleanno multi-thread e ho sperato per il meglio.

Modifica: E dopo che ha trovato una risposta ancora più breve.

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

Provalo online!

I cambiamenti:

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
fonte
2

dc , 34 byte

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

Si rompe questo . TIO .

Ho iniziato ottenendo la rappresentazione numerica di Haystack (5215583380252484459) e Needle (86197399743589). Successivamente, ho fatto una fattorizzazione di quest'ultimo, che è 47 * 432323 * 4242169. Da questo, è stato abbastanza facile ricostruire quei numeri.

Contrassegnare i caratteri utilizzati:

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
— agtoever
fonte
gg! sapevo che mettere così tanti numeri era una cattiva idea)
— cab404
@ cab404 Solo curioso: hai usato un calcolo molto diverso per arrivare a 86197399743589?
— agtoever,
— cab404,
Wow. È notevole. Potrebbe essere un'altra domanda di codegolf: quanti modi ci sono per ottenere un certo risultato eliminando i caratteri in un'espressione ...
— agtoever,
Immagino che generalmente richiederebbe un serio calcolo matematico per calcolare tutte le possibilità e dimostrare che ce n'è solo quel numero)
— cab404,
2

Esagonia , 19 byte, Martin Ender

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

Provalo online!

Confronto con l'originale

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

Codice non spiegato

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

Quindi, non ho mai scritto nulla in Hexagony, ma ho pensato che con solo 37 byte avrei potuto risolvere il problema. Martin, spero che tu sappia che ho dedicato molto tempo a cercare di capirlo. :)

Potrei essere errato, ma spiegherò cosa penso stia facendo questo codice:

Il programma inizia con [, che si sposta automaticamente su IP # 5. Questo IP inizia nell'angolo ovest, dirigendosi ancora verso quello [, che lo sposta su IP # 4. Da qui, esegue N;equindi si dirige verso l'angolo sud-est ed esegue ;, rimbalza a destra per un altro ;quindi si avvolge a (cui diminuisce la corrente ea d. Quindi continua (con un giro) a ...;.rimbalzare su le arriva [all'ultima volta, passando a IP # 3. Esegue ;, >reindirizza a nord-ovest per .poi <reindirizzare a ovest, colpendo e, avvolgendosi ;e terminando su @.

Versione dettagliata

Mostra snippet di codice

Sono così felice che tu abbia usato una dimensione esagonale normale per il programma Needle; Stavo controllando i programmi di dimensioni 19 (per un esagono laterale di lunghezza 3) quando mi sono reso conto che potevi rimuovere qualsiasi numero di caratteri e avrebbe riempito automaticamente l'esagono con .s alla fine, il che avrebbe reso drammaticamente più difficile decifrare. Così com'è, Hexagony è un linguaggio malvagio per questa sfida perché (principalmente) qualsiasi personaggio che viene rimosso cambia l'intero percorso di esecuzione del programma. Detto questo, mi è piaciuto provare a trovare questo, anche se alla fine ho finito per forzarlo. :)

— Jo.
fonte
Se ho incasinato / perso qualcosa, per favore fatemelo sapere.
— Jo.
Bel lavoro, questo sembra abbastanza accurato. Lo confronterò con quello che avevo originariamente durante il fine settimana.
— Martin Ender,
1

Java (OpenJDK 8) , 151 byte

Cracks risposta di Kevin Cruijssen

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();}

Provalo online!

Confronto:

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() ;}

Sento che l'ultima parte non era prevista.

— jacobly
fonte
Lol ok, è un modo intelligente di creare "edle". Mentre armeggiavo già pensavo di aver fatto un po 'troppo e un sacco di soluzioni sarebbe stato possibile ..;) La soluzione prevista era: 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());}(non so perché ho incluso BigInteger poiché solo byte-array è sufficiente ..) , ma mi piace di più il tuo .. :)
— Kevin Cruijssen,
1

Brain-Flak , 102 byte

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

Cracks risposta di H.PWiz .

Provalo online!

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

Java di 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

Basta rimuovere il cappio che aggiunge il fieno e nulla sarà lasciato in pila se non l'ago.

— Titus
fonte
Ah, bello - non avevo davvero pensato di rimuovere semplicemente il loop! Anche la rimozione del equalsmetodo funziona.
— Jonathan S.
0

T-SQL di phroureo , 757 byte

seleCT 'Needle'

In qualche modo non penso che fosse la soluzione prevista. Utilizza i personaggi circondati da {}:

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
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.