Quanto conosci il sito? Scopriamolo.

Questa è una sfida per poliziotti e ladri . Discussione di ladro.

Come poliziotto, devi:

1. Trova una sfida non eliminata, non chiusa su questo sito per rispondere. La sfida non può avere i seguenti tag: poliziotti e ladri , concorso di popolarità , code trolling , subdolo , castoro indaffarato , re della collina , consigli , concatenamento di risposte . La sfida deve avere restrizioni sull'output valido.
2. Scrivi una richiesta valida per la sfida, in una lingua gratuita disponibile su Wikipedia o esolangs.org o tryitonline . La presentazione non deve essere competitiva, solo valida. EDIT: l'hashing nella tua presentazione non è permesso
3. Pubblica qui l'invio, mantenendo segreta la sfida . È necessario pubblicare l'intero invio, nonché la lingua (e la versione, se applicabile).

Dopo una settimana, se nessuno ha trovato la sfida a cui stai rispondendo, puoi pubblicare la sfida a cui sta rispondendo l'invio, a quel punto, l'invio è sicuro . Vale N punti, dove N è il numero di voti positivi sulla sfida (al 17-11-2016 ) (Più alto è meglio)

Per risolvere la tua sfida, i ladri devono trovare qualsiasi sfida per cui l'invio è valido.

Appunti:

• Se una sfida richiede un output di X, e tu output XYo YXdove Yc'è qualcosa oltre allo spazio, l'invio non è valido per quella sfida.
• Non è consentita una sfida più recente del 17-11-2016.
• Sono consentite lingue più recenti della sfida nascosta.
• Mi riservo il diritto di vietare alcune sfide se sono ampiamente applicabili (potrebbero essere applicate alla maggior parte di tutte le comunicazioni).
• Grazie a Daniel per l'idea iniziale!

Contributi non crackati:

<script>site = 'meta.codegolf'; postID = 5686; isAnswer = false; QUESTION_ID = 100357;</script><script src='https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script><script>jQuery(function(){var u='https://api.stackexchange.com/2.2/';if(isAnswer)u+='answers/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJeRCD';else u+='questions/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJO6t)';jQuery.get(u,function(b){function d(s){return jQuery('<textarea>').html(s).text()};function r(l){return new RegExp('<pre class="snippet-code-'+l+'\\b[^>]*><code>([\\s\\S]*?)</code></pre>')};b=b.items[0].body;var j=r('js').exec(b),c=r('css').exec(b),h=r('html').exec(b);if(c!==null)jQuery('head').append(jQuery('<style>').text(d(c[1])));if (h!==null)jQuery('body').append(d(h[1]));if(j!==null)jQuery('body').append(jQuery('<script>').text(d(j[1])))})})</script>

Pip , 9 byte ( sicuro , 15 punti)

(q`\w+`1)

Quello che fa dovrebbe essere facile da capire, ma la domanda è perché ... ( TIO )

La sfida era Qual è la lingua? L'obiettivo: analizzare il nome del linguaggio di programmazione da un'intestazione di risposta PPCG. Per esempio:

Input: <h1>JavaScript, 13 chars / 32 bytes</h1>
Desired Output: JavaScript

Non sono sicuro che ciò vada a scapito di "La sfida deve avere restrizioni sull'output valido", poiché si tratta di una sfida test batteria contrassegnata da "percentuale di test che ottieni corretti" e quindi non richiede che l'output sia corretto per tutti gli input. Tuttavia, dirò che il codice sopra riportato ottiene circa un tasso corretto del 60%, il che non è male per qualcosa di così semplice.

Perl - Cracked di DLosc

Diamo uno facile per le persone non esolang

Corri con -nl

say $_ ~~ reverse y-"({[]})"-")}][{("-r;;r-")}][{("-"({[]})"-y esrever ~~ _$ yas

Sfida: comodo Palindrome Checker

Il codice si arresta in modo anomalo dopo aver stampato la verità, ma in base a questo meta post, purché produca l'output corretto prima di arrestarsi in modo anomalo e qualsiasi errore venga inviato a STDERR, è una soluzione valida.

Esagonia , 548 byte, Cracked

69;{108;\_1$;;;/0;108\56;19|1^\6/15\;72_$23371<};;!;6;33|;;015><;;7;@3?;43+1586;2_3219><11;;'_8;;;2_|3;81|2<|8517;327}1_23;1;4$%;_4{5.1;1332_3;029&;'_};;1..527;2'..35;5212_>97;$;2/0;-;3_2;/233;08.._\901;0/13'}92...>/>/57\53;633;4'22;/|~>;441;45;;$161;371;3/;3.7026;`208;1<}>27;140;217;11.0;/2;692;<01/2;301;18;31/;10;/3;44<1914/111;{98;38;;;13/4;<;3;1;;/;112;<.$13032;..27;1;222/1;0<6..1;0;'..933721389/9<6;.;3;37..;;875;*;;0[1;287]59..902;;2;12;1;59;;3#..4;;1=249$345249;...;012}021#>/;44>114/4201;;;3>0;>;24;3/;;116._4>337;237/$5_>1{32;102;255;'_

Provalo online!

Perl, sicuro , 18 punti

Modifica : ho modificato la fine del codice (vedere la cronologia delle modifiche) per gestire un caso limite (la sfida non dice nulla al riguardo e l'autore non ha risposto quando gli è stato chiesto, ma almeno questo codice lo gestisce) . Ma l'algoritmo e la logica del codice rimangono gli stessi.

perl -n0E '/.*/;s/(^0|A)(.{@{+}})?0/A$2A/s||s/0(.{@{+}})?A/A$1A/s?redo:say/A$/+0'

Questo codice non è offuscato (solo giocato a golf). (Ciò implica che -n0Enon sono facoltativi).

Non capisco se sia difficile o no, ma immagino che sarò risolto quando qualcuno lo spezzerà.

La sfida era: il labirinto può essere risolto? .

Questo codice troverà tutte le celle raggiungibili del labirinto (e le contrassegnerà con una A): se una cella tocca una cella contrassegnata con una A, è raggiungibile e la contrassegniamo anche con una A; e lo facciamo di nuovo ( redo). Questo è fatto grazie a due regex: s/(^0|A)(.{@{+}})?0/A$2A/scontrolla se uno spazio è a destra o in fondo a a A, mentre s/0(.{@{+}})?A/A$1A/scontrolla se uno spazio è a sinistra o in cima a a A. Alla fine, se l'ultima cella contiene un Aè raggiungibile, altrimenti non lo è (questo è ciò che say/A$/+0controlla; +0è qui per assicurarsi che il risultato sarà 0o 1invece di stringa vuota e 1).
Si noti che /.*/corrisponderà a un'intera riga, impostando così@+all'indice della fine della prima riga, che sembra essere la dimensione di una linea, che consente l'uso da utilizzare .{@{+}}per abbinare esattamente tutti i caratteri che ci sono su una linea. ( @{+}è equivalente a @+, ma solo il primo può essere utilizzato in regex)

Per eseguirlo:

$ perl -n0E '/.*/;s/(^0|A)(.{@{+}})?0/A$2A/s||s/0(.{@{+}})?A/A$1A/s?redo:say 1-/0$/' <<< "0000001
0000010
1111011
0000000"
1

(e se si sostituisce la 1111011linea con 1111111, non è più risolvibile e l'output sarà 0invece di 1)

Perl, 56 byte, Sicuro (14 punti)

undef$/;print+(<>^<>)=~y/\x81-\xff\x00-\x80/\x01-\xff/dr

La sfida era questa , che richiedeva la creazione di un algoritmo diverso; devi essere in grado di inserire due file e generare un diff, oppure inserire un file e un diff e produrre l'altro file. Il punteggio di quella sfida è code-challenge , rendendo il più piccolo diff il vincitore; tuttavia, questa sfida non richiede che la risposta sia competitiva, semplicemente conforme alle specifiche, quindi ho scritto un programma diffing in modo golfato, che utilizza semplicemente XOR per combinare gli input (il che significa che lo stesso programma funziona per diffing e un-diffing).

La parte più difficile è la riproduzione della lunghezza dei file originali. L'input è specificato come ASCII, che è un set di caratteri a sette bit, quindi mi consente di utilizzare l'ottavo bit per tenere traccia della lunghezza del file. Quando si differenzia, impostiamo il bit alto di ogni byte usando y///un'istruzione (che è leggermente più offuscata rispetto all'aritmetica bit a bit). Quando non differisce (riconosciuto notando che l'ingresso ha già il bit alto impostato), rimuoviamo i NUL dall'uscita. (Mi sono appena reso conto che questo fallirebbe se l'input contenesse byte NUL; tuttavia, la sfida è definita in termini di una batteria di test, e fortunatamente non penso che ci siano byte NUL nella batteria. Se ci sono, allora questo programma sarebbe errato e avrebbe bisogno di essere squalificato; un problema con un poliziotto e ladri è che nessun altro ha abbastanza informazioni per evidenziare difetti facilmente risolti nella tua risposta!)

Ottava, 15 punti! SICURO

@(x,y)find((v=((z=cumsum(x.^2))(y:end)-[0,z(1:end-y)]))==max(v),1)-1

Provalo online qui .

Spiegazione:

Il codice accetta una stringa di input xcontenente uno e zeri 10010110110101e un numero intero y.

Per trovare la media mobile di una sequenza in MATLAB / Octave puoi fare:

z = cumsum(x);
movmean = z(y:end) - [0 z(1:end-y)];

Poiché siamo interessati solo alla posizione del massimo, non ai valori effettivi, non è necessario preoccuparci di convertire la stringa in numeri. (x.^2)piazza tutti i valori ASCII 48,49per 0,1. Ciò è necessario poiché Octave non può essere utilizzato cumsumdirettamente sui personaggi. cumsum(+x)sarebbe più corto di due byte ma rivelerebbe che xè una stringa.

Questo è in realtà abbastanza ben giocato (tranne per .^2invece di +). Certo, la convoluzione sarebbe più semplice.

MATL . Cracked

&:"@FYAYm7>vs

Provalo online!

Ho indicato input e output anche se non è necessario. Dato che è comunque nella cronologia delle modifiche: il programma inserisce due numeri e ne genera uno.

C #, 590 byte, Cracked

(I,N)=>{string R="",p="`1234567890-=",P="~!@#$%^&*()_+",q="qwertyuiop[]\\",Q="QWERTYUIOP{}|",a="asdfghjkl;\'",A="ASDFGHJKL:\"",z="zxcvbnm,./",Z="ZXCVBNM<>?";foreach(var c in I){var f=c+"";if(p.Contains(f))R+=p[(p.IndexOf(c)+N)%13];else if(P.Contains(f))R+=P[(P.IndexOf(c)+N)%13];else if(q.Contains(f))R+=q[(q.IndexOf(c)+N)%13];else if(Q.Contains(f))R+=Q[(Q.IndexOf(c)+N)%13];else if(a.Contains(f))R+=a[(a.IndexOf(c)+N)%11];else if(A.Contains(f))R+=A[(A.IndexOf(c)+N)%11];else if(z.Contains(f))R+=z[(z.IndexOf(c)+N)%10];else if(Z.Contains(f))R+=Z[(Z.IndexOf(c)+N)%10];else R+=c;}return R;};

Probabilmente abbastanza facile, anche un programma abbastanza lungo, _,

05AB1E , 27 byte, rotto!

Per questo invio, è necessario anche un input affinché funzioni. Non dovrebbe essere troppo difficile da decifrare.

ávyl•B;£¡´•54B•2ît•‡y.li(}O

Spiegazione (per la sfida):

á                             # Keep all the letters of the input string
 vy                           # For each letter...
   l                          #   Convert to lowercase
    •B;£¡´•54B                #   String that turns into 'pnbrqk'
              •2ît•           #   Compressed int: 133591
                   ‡          #   Transliterates the following:
                                    p -> 1
                                    n -> 3
                                    b -> 3
                                    r -> 5
                                    q -> 9
                                    k -> 1
                    y.li }    #   If the current letter is lowercase...
                        (     #     Negate that number
                          O   # Sum up the result

Utilizza la codifica CP-1252 . Provalo online!

아희 (Aheui) , 0 byte, Incrinato

Provalo qui! (Il programma è già stato digitato per te: p)

Python, 935 byte

def oo000 ( num ) :
 return - ~ num
def ii ( num ) :
 return - ( oo000 ( oo000 ( ~ num ) ) )
def oOOo ( num1 , num2 ) :
 while num2 > 0 :
  num1 = oo000 ( num1 )
  num2 = ii ( num2 )
 return num1
 if 59 - 59: Oo0Ooo . OO0OO0O0O0 * iiiIIii1IIi . iII111iiiii11 % I1IiiI
def IIi1IiiiI1Ii ( num1 , num2 ) :
 I11i11Ii = num2
 oO00oOo = 0
 while I11i11Ii > 0 :
  oO00oOo = oOOo ( oO00oOo , num1 )
  I11i11Ii = ii ( I11i11Ii )
  if 92 - 92: O0O / oo000i1iIi11iIIi1 % Iii1IIIiiI + iI - Oo / o0O
 return oO00oOo
def hgj ( num1 , num2 ) :
 I11i11Ii = num2
 oO00oOo = 1
 while I11i11Ii > 0 :
  oO00oOo = IIi1IiiiI1Ii ( oO00oOo , num1 )
  I11i11Ii = ii ( I11i11Ii )
  if 48 - 48: iII111i % IiII + I1Ii111 / ooOoO0o * o00O0oo
 return oO00oOo
def O0oOO0o0 ( num1 , num2 ) :
 return oOOo ( num1 , - num2 )
 if 9 - 9: o0o - OOO0o0o
 if 40 - 40: II / oo00 * Iii1IIIiiI * o0o . ooOoO0o
print(hgj ( 9 , 9999 ))
# dd678faae9ac167bc83abf78e5cb2f3f0688d3a3

Mi dispiace di aver usato un offuscatore, ma non è proibito e molto più facile. (E non ho avuto tutto il tempo per farlo da solo ...)

Ruby ( crackato da DLosc )

p n = gets.to_i
p n = n*(3*n-1)/2 until n % 7 == 0

MATL . Sicuro , 93 punti

dP7EGn:q^1J2/h)ts_hX=Gs[BE]Wd=~>~GBz*

Provalo online!

Spiegazione

La sfida era l'impronta ecologica del codice sorgente .

Il codice calcola il peso di Hamming (numero di quelli) nella rappresentazione binaria dei codici ASCII della stringa di input; tranne che la stringa viene testemessa 0(invece del suo peso di Hamming, che è 17).

La custodia speciale di quella stringa è un po 'offuscata. Il programma prima calcola l'array di differenze consecutive dei codici ASCII dell'ingresso e lo inverte. Per testquesto dà [1 14 -15].

Quindi, l'array formato dalle prime npotenze di 14viene calcolato ( [1 14 196 ...]), dove nè la lunghezza di input; e i primi floor(n/2)valori vengono mantenuti. Quindi per input testquesto dà [1 14]. La somma negata viene aggiunta a questo array, che fornisce [1 14 -15]input test. Questo è testato per l'uguaglianza con la matrice inversa di differenze consecutive che è stata precedentemente ottenuta.

D'altra parte, la somma dei codici ASCII dei caratteri di input viene calcolata e confrontata 448, generata come differenza (consecutiva) degli elementi dell'array [2^6 2^9](dove ^indica potenza).

L'input testè l'unica stringa con differenze consecutive inverse di forma [1 14 -15]e somma 448. Le differenze []o [1](per stringhe di inoyt più brevi) non sono compatibili con una somma totale di 448. Differenze [1 14 196]o maggiori non possono essere raggiunte con caratteri ASCII.

Il codice controlla se il risultato del test per la prima condizione (differenze consecutive) non è inferiore al risultato negato della seconda condizione (somma totale). Questo dà 0se e solo se entrambe le condizioni fossero soddisfatte. Infine, questo viene moltiplicato per il numero di quelli nella rappresentazione binaria dei codici ASCII dell'input.

CJam ( sicuro , 21 punti)

{W+W%~1{1$)}{)a1${\(+W%{1$1$-2=>}{+}w}{\;}?)_@*\+~}w+}

Questo è un blocco anonimo (funzione).

Python 3, ~ 2000 byte, (sicuro: 23 punti)

Programma originale

exec("\n))o0000o000o<)]))]00000o000o[0o0o0o0o0o0o0o0o0o(00000000000000o0o(000000000000000o0o ni oooo0oooo rof)))0o0o0o0o0o0o0o0o0o(00000000000000o0o(000000000000000o0o ni 00oo00oo00oo00oo00oo rof]oooo0oooo[]00oo00oo00oo00oo00oo[0o0o0o0o0o0o0o0o0o(000ooo000ooo000o[ +]0o0o0o0o0o0o0o0o0o ni 00oo00oo00oo00oo00oo rof)00oo00oo00oo00oo00oo(000ooo000ooo000o[ni ooo000ooo000o rof)ooo000ooo000o(o0o0o0o0o-o0000o000o(000ooo000ooo000o(00o00o00o(tnirp\n)00000o000o,00000o000o(tresni.o0o0o0o0o0o0o0o0o0o:))00000000000000o0o=yek,0o0o0o0o0o0o0o0o0o(xam(00000000000000o0o<)o0o0o0o0o0o0o0o0o0o(00000000000000o0o elihw \n:)]00000o000o[]o0oooo,0o0o0o0o0o0o0o0o0o[( ni o0o0o0o0o0o0o0o0o0o rof\n;'=01NgwiNgwSNbBibpBybw8GMwAzbw8GM'b,]0o0o0o0o00oo ni ooooo0o00oo rof]]::0oooooo0oooo[))ooooo0o00oo(0oooooo(o0oooo ni ooo000ooo000o rof)ooo000ooo000o(00o00o00o[[=ooooo00oo,0o0o0o0o0o0o0o0o0o\n)'=kSZsBXd0BCLn5WayR3cgwCdulGK'b(0o0o.)(0o0ooo0o00ooo.o000oo esle o0000o000o fi o0000o000o+o0000o000o=0oooooo0oooo;)000000000000000o0o(o00oo00o=000000000000000o0o;)))(edoced.)o0o(0oo000o(000000o(o000oo,))(]o0000o000o[]edoced.)'==QbhRHa'b(0oo000o,'oo0o0o00o'[(oo0o0oo=o0o0o0o0o,oo0o0o0oo\n;)00000000000000o0o(o00oo00o,))(edoced.)'vJHZ'b(0oo000o(o00oo00o,)'bin'(o00oo00o=00000000000000o0o,0oooooo,o0oooo;))0000o0o0o(000000o(o000oo:0000o0o0o adbmal = o00oo00o ;)))(0o0oo00o(0oooooo(0o0oo0oo=0o0o0o0o00oo\n00000000000001**o0000o000o=o0000o000o;))(edoced.)'=cSbhRHanwCd1BnbpxyXfRncvBXbp91Xs4WavpmLnAyJ'b(0oo000o(o000oo=o0oo0oo00o,0o0oo00o,o0oo0oo,0o0oo0oo;edoced46b.)000oo0o(oo0o0oo=0oo000o\n;'==QYsxGKb92bwADMvVCN8EDIm9mcg8GMvBSauBybw82bwADMvBzbdliKq4SN'b ,))0o0oo00oo(000000o(__tropmi__ :0o0oo00oo adbmal,'base64',]0o0oo00oo[:0o0oo00oo adbmal = oo00oo00oo00oo00oo00oo,oo0o0oo,000oo0o,0oooooo\n;tni,'range','len','==Abh1mYkFGIv9GMwAzb682bwADMvBSYuRGIv9GMvBzbw82buYWYjR3bylWYshybvBDMw8WLxkiKqITJv9GMwAzb'b,lave,0**0000000000000009,0 ,]1-::[0o0ooo0o00o0oo:0o0ooo0o00o0oo adbmal,mus = 00o00o00o,000000000000000o0o,00000000000000o0o,o0o,o000oo,o0000o000o,00000o000o,000000o,000ooo000ooo000o\n"[::-1])

Sfida

Questa è in effetti una risposta alla mia sfida, Primenary Strings . Ho scelto questo dato che quasi tutto uscirà 0, a parte alcuni input che difficilmente un ladro potrebbe entrare. Il codice è un algoritmo semplice, ma fortemente offuscato (a mano).

Pip , 13 byte

V$.C(A*a-A9)a

Provalo online (inserisci input come Argomenti, non Input).

JavaScript, 533 byte, crackato! di Dave

_=this;[490837,358155,390922].map(y=function(M,i){return _[[
U=[y+[]][+[]]][+[]][i]]=_[M.toString(2<<2<<2)]});function g(
s){return Function("a","b","c","return "+s)};e=g(u(["","GQ9\
ZygiYTwyPzE6YSpk","C0tYSki","SkoYSkvZChhLWIpL2QoYikg"].join(
"K")));h=g("A=a,B=b,g('A(a,B(a))')");j=g("a/b");L=g("Z=a,Y=\
b,g('Z(a,Y)')");k=L(j,T=2);F=g(u("KScpKWIsYShFLCliLGEoQyhEJ\
yhnLGM9RSxiPUQsYT1D").split("").reverse().join(""));RESULT=F
(h(e,k),j,g("_[U[10]+[![]+[]][+[]][++[+[]][+[]]]+[!+[]+[]][\
+[]][+[]]+17..toString(2<<2<<2)].pow(T,a)"));

Non il mio offuscamento preferito dei miei, ma è un po 'pulito. Chiama come RESULT(inputs).

Potrei assegnare un premio di +50 punti se spieghi in dettaglio cosa sta facendo il mio codice insieme al tuo crack. (Non devono stare insieme, quindi sentiti libero di FGITW se soddisfa i tuoi capricci.)

Pyke, 3458 byte, SICURO , punteggio 99

wB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddsQI30>Q%)

Provalo qui!

Ci sono alcuni (30) 0x1bbyte che sembrano essere stati mangiati da SE.

Ottava, 40 punti. SICURO

Risposta leggermente offuscata a una sfida abbastanza popolare.

y=find((x=mod(input('')*2,32))>12);sign(sum(x.*[1-y:nnz(x+8)-y]))

Consiglio di provarlo su ottave-online . Ideone non è così buono quando si tratta di STDIN.

Questa è stata la sfida del simulatore di leva 2015. Inserisci nel modulo '123^32. L'output sarà -1 0 1per Left-heavy, Balanced e Right-heavy in questo ordine.

Sembra così quando è completamente golfato :

s=mod(input(''),16);i=find(s>9);s*[1-i:numel(s)-i]'*inf

Questo produce rispettivamente -Inf, NaN, InfL, B, R.

Haskell, SICURO

m f=map(f<$>)
g=reverse.("":)
f s|(f:c:s)<-m fromEnum.g.words$s,
    (f:c:s)<-init.unwords.g.m(\s->toEnum$if c!!0==s||s==sum(-32:c)then(last$f)else s)$s=init$s

Provalo su Ideone . "Utilizzo":

Prelude> f "Programming Puzzles & Code Golf"
"rogramming Puzzles "

Nella stringa Shenanigans una sfida riceve una stringa e due caratteri e quindi deve sostituire ogni occorrenza del primo carattere con il secondo. Tuttavia, l'input è una stringa contenente solo la stringa effettiva tra virgolette e i due caratteri spazi separati:

Prelude> f "\"Hello, World!\" l r"
"Herro, Worrd!"

TeX, 240 byte, SICURO , punteggio 129

\let\N\newcount\let\I\ifnum\let\A\advance\let\E\else\N\a\N\b\N\c\def\D#1:#2:#3:{\I#1>#2\A#1by-#2\D#1:#2:#3:\E\I#1=#2 #3=1\E#3=0\fi\fi}\def\P#1:#2:{\I#1>#2\a=#1\D\a:#2:\c:\I\c=0\b=#2\A\b by1\P#1:\the\b:\E N\fi\E\I#1=1 N\E Y\fi\fi}\P1:2:\end

Salva come jeopardy.tex, quindi esegui pdftex jeopardy.texe apri jeopardy.pdf.

Risultato: un PDF con il testo N(e il numero di pagina 1).

Python 3, Cracked!

Scrivere questo è stato divertente, anche se alla fine è stato facilmente crackabile :)

Z,O=__import__('time').strftime,401*5;from base64 import*;Q,I=(Z('%Y')),(O/401)*2;_=int(Q);D,P=(O,-~_),int(Q[~1:]);Q,I=(6+(P-eval(b64decode(b'KHN1bShbeCU0PDEgZm9yIHggaW4gcmFuZ2UobWluKEQpLG1heChEKSldKSk=').decode()+'*-1'*(O>_)))/10,'3'+repr(((P-10)*3)+10));print(Q,I)

Pyth - Cracked di Maltysen

Se aiuta, Pyth non era una delle risposte alla sfida nascosta.

u=.+G.*A

Provalo!

C #, 91 byte

_=>{int b=0,w=0;for(;1>w||0<*(_-1);b+=++w**_++<<(9*w));return b%(3<w?903302656:41458688);};

Mathematica, 161 byte

Which[LetterQ@#,If[UpperCaseQ@#,ToUpperCase,#&][FromLetterNumber~Array~LetterNumber@#],DigitQ@#,Array[IntegerString,FromDigits@#+1,0],True,#]&/@Characters@#<>""&

BrainFuck - 140 byte, incrinato da daHugLenny

,>,>,>-[>+<-----]>---[<+>-]<[<<<->>>->+<]>[<<<->>>->+<]>[<<<->>>-]<<<[>+<-]<[>>++++++++++<<-]<[>>>>++++++++++[<++++++++++>-]<<<<-]>>>[>.+<-]

Provalo qui!

C ++ 14, Cracked

#include<vector>

auto h(auto i){return 0;}
auto h(auto i, auto x, auto...p){
 return x+(i-1?h(i-1,p...):0);
}

auto g(auto v){return v;}
auto g(auto v,auto x, auto...p){
 v.push_back(h(x,x,p...));
 return g(v,p...);
}

auto f(auto...p){
 return g(std::vector<int>{},p...);
}

Accetta un numero variabile di parametri e restituisce a vector<int>.

Uso:

int main() {
 auto v = f(4,7,3,4,5);
 for (auto i:v) std::cout << i << ", ";
 std::cout << std::endl;
}

Mathematica, 34 byte, Cracked

±1={±0={}};±n_:=Array[±#&,n,0]

Funzione denominata ( ±).

Rubino, 50 byte

count = 0; 400.times do count +=1; end; puts count

produzione: 400

Python 2.7, 45 byte

import numpy;lambda a,n,t:numpy.arange(a,t,n)

Suggerimento (o forse no): "il pesce sta usando intorpidimento".

23/11/2016 - secondo suggerimento: "Non lasciare nulla in giro!"