Questa sfida ha due thread. Questo è il filo della polizia. Il thread dei ladri si trova qui .

La tua sfida è scegliere una sequenza OEIS e scrivere due programmi completi in due lingue diverse che producano l'ennesimo elemento nella sequenza quando viene dato un n tramite STDIN, o altre forme di input standard, dove n è un numero positivo. Tuttavia i tuoi due programmi devono essere anagrammi, il che significa che ognuno può essere riorganizzato dalle lettere dell'altro.

I programmi devono generare il decimale del numero seguito dallo spazio bianco opzionale su STDOUT. I programmi possono essere inviati a STDERR, tuttavia dovrebbe essere ignorato e se il caso nascosto lo fa, deve essere chiaramente indicato che è così.

Se lo desideri, puoi anche generare un codice carattere. Tuttavia, se lo fai nella tua soluzione nascosta, devi dichiararlo nel corpo della tua richiesta.

Presenterai quindi il numero OEIS, il codice sorgente e il nome di una lingua in cui si trova.

I ladri decifreranno la tua richiesta se trovano un anagramma della presentazione originale che corre in una lingua diversa da quella che hai già presentato. Per decifrare una risposta devono solo trovare qualsiasi linguaggio e programma che produca la sequenza ed è un anagramma dell'originale, non necessariamente la risposta a cui stavi pensando.

Quindi sei incentivato a rendere il più difficile possibile trovare qualsiasi lingua che svolga il compito usando la loro lista di simboli.

punteggio

Si tratta di code-golf, quindi il programma non crackato più breve è il vincitore.

Le lingue

Le lingue saranno considerate diverse se le due soluzioni proposte non completano l'attività in entrambe le lingue. Ciò includerà versioni diverse della stessa lingua purché né la soluzione del poliziotto né la soluzione del ladro producano l'output corretto nella lingua dell'altro.

cioè se ci sono due soluzioni 1 e 2 che sono rispettivamente nella lingua A e B, la soluzione 2 non deve produrre l'output corretto nella lingua A e la soluzione 1 non deve produrre l'output corretto nella lingua B.

Sicurezza

Una volta che l'invio è stato archiviato per una settimana, è possibile pubblicare la soluzione e dichiarare sicuro il post. Se dopo una settimana scegli di non pubblicare una soluzione, la tua risposta potrebbe ancora essere risolta.

Python 2, 118 byte, A042545 Incrinato

i=input();s=1/(801**.5-28);a=[0,1]
for p in range(i):a+=[a[-2]+a[-1]*int(s)];s=1/(s-int(s))
print a[i]#,,,.//000fhlmo|

Non avevo voglia di implementare una sequenza banale, quindi ho deciso di utilizzare il mio ID utente PPCG. L'ho scritto prima nell'altra lingua, il che dovrebbe darti un indizio su quale sia quella lingua, anche se scommetterei 100 dollari che questo sarà craccato in una lingua da golf prima che sia craccato nell'altra lingua desiderata.

Nota: a causa di errori di precisione in virgola mobile, questo è accurato solo fino a un input di 14. La soluzione prevista è allo stesso modo.

Soluzione prevista, JavaScript (ES7)

for(i=prompt(),s=1/(801**.5-28),a=[1,0];i--;s=1/(s-n))
  n=s|0,a.unshift(a[1]+a[0]*n);
alert(a[0])  //#+2:[]giiiiinnpt

Funziona più o meno allo stesso modo della soluzione Python, anche se la sequenza viene memorizzata più grande per prima piuttosto che per prima, poiché JS non supporta l'indicizzazione negativa.

Brain-Flak, 24 byte, A000290 , Sicuro

Ancora un'altra soluzione quadrata. Questa volta non c'è nient'altro che parentesi

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

La soluzione prevista era in Brain-Flueue , una versione di brain-flak che utilizza le code anziché le pile. Il programma era:

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

Le lingue sono considerate distinte perché nessuno dei due programmi si interrompe quando viene eseguito in un'altra lingua.

Python 2, 38 byte, A000290 Incrinato da Emigna

def e(X):return X*X
print e(input())##

Questo sarà probabilmente molto facile da decifrare. Sto pubblicando principalmente questo come punto di partenza.

Soluzione originale in CJam:

ri:XX*e#def ()return X
e#pnt (input())

CJam , 7 byte, A005843 Incrinato!

ri2*e#^

Questa è una 2*nsequenza di base .

Spiegazione:

r          e# read input
 i         e# convert to integer
  2*       e# multiply it by 2
    e#^    e# this is a comment that is ignored by the interpreter

Provalo online!

Soluzione originale, carota

#^i*2er

Carrot è un esolang creato da me. Ho smesso di svilupparlo molto tempo fa. Il motivo per cui ho scelto questo è perché speravo che sarebbe difficile per altre lingue commentare le parti non necessarie del codice.

Spiegazione:

#^            This pushes the input to the stack (anything before the ^ is the stack)
  i           Convert stack to integer
   *2         Multiply it by 2
     er       These are ignored because they are not Carrot commands
              Implicit output

Provalo online!

2 file , 15 byte, A000290 , Cracked!

Salto sullo stesso treno n ² : p.

*?"!#$&<=@\^{|}

Provalo online!

Brain-Flak, 44 byte, A000290 Incrinato

<({({})({}[()])}{}))()()()turpentine/"*"*4splint>

Provalo online!

Soluzione originale, Python 2

print(input()**(len(set("{}{}{}[]()<>"))/4))

Excel, 12 byte, A000012 Incrinato

=IF(1=1,1,1)

Forse non il più duro, ma divertente da decifrare.

Python 2, 25 byte, A000583 , incrinato

Y=input("");print`Y**4`,X

Questo programma si chiude con un errore dopo aver stampato l'output.

Il mio codice nascosto (sostanzialmente diverso dalla soluzione crackata!):

In realtà , 25 byte

4,n`*`Y")ii(*nppruttY;="X

Provalo online!

Spiegazione:

4,n`*`Y")ii(*nppruttY;="X
4,n                        input, repeat 4 times
   `*`Y                    do * until the stack stops changing (fixed-point combinator)
       ")ii(*nppruttY;="X  push this string and immediately pop and discard it

Python, 118 byte, A042545 , Sicuro

i=int(input());s=pow(801.0,0.5);a=[0|0,1]
for Moshprtflmah in range(i):s=1./(s%1);a+=[a[-2]+a[-1]*int(s)];
print(a[i])

Questa volta funziona sia in 2 che in 3. E non ci sono commenti! Cosa farai?

Nota: come con la vecchia soluzione, questo perde precisione dopo i primi 15 termini a causa di errori aritmetici in virgola mobile.

Soluzione prevista, JavaScript (ES6)

giiiiinnnnprt:
i=prompt([n=+2]);s=Math.pow(801,.5);for(a=[1,0];i--;a.unshift(a[1]+a[0]*(s|0)))s=1/(s%1)
alert(a[0])   

Anche se ho conservato diverse versioni precedenti, in qualche modo sono riuscito a perdere questa copia, ma fortunatamente metterlo insieme dagli altri non è stato troppo difficile. Vedo ora che ho avuto un estraneo prtin entrambi i programmi che avrebbe potuto essere golfato. Oh bene.

Python 2, 124 byte, A144945 , [Sicuro]

Crollare questo ti avrebbe fatto guadagnare una ricompensa di 500 rappresentanti! Troppo tardi!

Numero di modi per posizionare 2 regine su una scacchiera in modo da attaccarsi a vicenda.

Spero non sia troppo facile. Ho organizzato il mio codice in modo che lo spazio bianco sia chiaramente visibile. Questi sono solo spazi e newline.

_{Nota: output della soluzione prevista tramite codice carattere}

n=input();print((3+2)*n*n+~0*6*n+1)*n/3;            +6;



























+7+7+7+7+7+7+7+7+7;+++++++++++++++9+9*9*9

Provalo online

Soluzione prevista , Headsecks :

r2=ni***p**
(


p((0 ;3+++3;+;/


)





i+++nn
 +)7
n

n+++ 


17+~
 +)7;97++++7


69+9n+ ++7+n 69
 +7+ ++7


**7+++tut

Ciò equivale al seguente programma BF:

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

Fuzzy Octo Guacamole, 26 byte, A070627 [Sicuro]

49++*5^pm#]%:"?:.=:#,|"1:@

Casi test:

1 -> 1
3 -> 23
5 -> 1

Soluzione:

^::::|*?1=#@]","%.#49++5pm

Funziona in Magistack.

Pyth, 75 byte, A004526 Cracked, latte

Più di un test giocoso che altro, ma:

/Q/////////////////****22222 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2;;;;;

Provalo online!

Soluzione di latte (convessa):

2/Q2 2/2/2/2/2/2/2/2/2/2/2/2/2/2/2/2/2/2*2*2*; 2*;                 2; 2; 2;

Provalo online

Soluzione prevista (///):

/*///;2/;// ///22/Q//2;///;//;***2222222222222222222222                    

Provalo online

Accetta l'input sotto forma di 2 prima dell'ultimo punto e virgola e genera il numero corretto di Q.

La sequenza è 0-indicizzata (ovvero 0 è 0, 1 è 0, 2 è 1, ...)

Abbiamo trovato lievi errori sintattici nel ///, quindi ho modificato tutte le soluzioni.

MATL, 7 byte, A000217 , incrinato

:sp{1}x

La sequenza è n(n+1)/2(numeri triangolari), da ingresso n=1come specificato dalla sfida: 1, 3, 6, 10, ... (uscita per l'ingresso 0non è garantito essere lo stesso nei due programmi).

Il programma nell'altra lingua esce con un errore (dopo aver prodotto l'output corretto in STDOUT).

Provalo online!

:            % Push [1 2 ... n], where n is implicit input
 s           % Sum of that array. Gives the desired result
   p         % Product of that. Gives the same number
    {1}      % Push a cell array containing number 1
       x     % Delete it

Python 2, 37 byte, A000290 Incrinato

print(input()**(1+1))
"'10°3¢','m'"

Python 3, 27 byte, A000012 , Cracked

Nessun input questa volta!

if 1:
    if 1:
        print( '1' )

I rientri sono tabulazioni, ma non per salvare i byte: sono necessari per gli spazi bianchi.

Non penso che abbia bisogno di un link TIO o di una spiegazione!

(Probabilmente non ci vorrà molto a rompersi in qualche modo)

Risposta prevista (spazio bianco):

-Start-


    if1:if1:print('1')
-End-

(L'inizio e la fine non fanno parte del programma)

Siamo spiacenti, ho dimenticato di aggiungere che stampa su STDERR:

Provalo online!

Fuzzy Octo Guacamole , 11 byte, A001844 [Sicuro!]

hha02^d+**+

Una crepa che funziona in questo modo dh*h++^2*0a, in Pyth. Tuttavia, non è il formato di output corretto.

Il mio codice è ancora là fuori! (e non è in Pyth)

Casi test:

0 -> 1
1 -> 5

Soluzione:

^++d0ah*2*h

In Jolf.

WinDbg, 39 byte, A000007 Cracking di jimmy23013

~e.block{j(0>=@$t0)?@$t0+(1<7);??0}t":"

La difficile sequenza di 0**n.

L'input viene eseguito passando un valore nello pseudo-registro $t0.

La mia soluzione originale era C #:

@t=>(object)(0<@t?0:1)??"$$700~lk.{}+";

JavaScript ES6, 38 byte, A000290 , Cracked

J=>eval(Array(J).fill(J).join`+`)|2-2;

Questo treno quadrato è piuttosto elegante, ma non sta andando da nessuna parte veloce. (Prendilo? Treno quadrato ? Come in, ruote? No? Ok, bene. Critici .)

Risposta prevista: reticolare ( provalo online! ),

in2Jo;=>eval(Array(J).fill(J).j`+`)|-2
in      take input, convert to number
  2J    raise to the second power
    o;  output and terminate; ignores following chars

MATL , 13 byte, A002275 Incrinato!

i:"@ax'1']
v!

Provalo online!

Spiegazione:

i           % Grab input
 :          % Push (range(1,input))
  "         % For each element in this range:
   @        %   Push it
    a       %   Is is truthy?
     x      %   Delete it
      '1'   %   Push '1'
         ]  %   End loop
v           % Join all of these '1's together
 !          % Transpose and display

2 file , 13 byte, A002378 , Cracked!

Sperando di non aver perso qualcosa. Calcola a (n) = n × (n + 1) :

>*?"!&)<=@\\}

La mia versione:

?"\>@&*})<\=!

O la versione spiegata:

  ? " \
 > @ & *
} ) < \ =
 ! . . .
  . . .

Si noti che >nell'angolo in alto a sinistra non è utilizzato (ad eccezione del programma 2sable). L'ho fatto per confondere i ladri (ma ovviamente non ha funzionato ahah).

Provalo online!

2 file, 15 byte, A087156

D1QiA0*<}.;2->>

Provalo online

La sequenza di numeri non negativi, tranne 1.

Befunge 93 , 14 byte, A121377 , incrinato dal latte !

&52* %68*+ .@Q

Curiosità: la soluzione prevista è la prima volta che uso questa lingua.

La mia soluzione in Pyth. & @ stampa un errore, ma questo va a STDERR che secondo l'OP viene ignorato.

+%Q*5 2*6 8.&@

Python 2, 35 byte, A048735 , Sicuro

print(lambda u:u&u<<1)(input())>>1

La soluzione originale era nel mio linguaggio di programmazione Wise .

:<<>&>print(lambda uuu1)(input())1

La maggior parte dei personaggi sono operazioni irrilevanti. I personaggi importanti sono i primi sei. :crea due copie del primo oggetto in pila. <<>il bit si sposta due volte a sinistra e una volta a destra, il che equivale allo spostamento del bit una volta a sinistra. &prende l'elemento bit a bit e quello superiore e il secondo (l'originale e la copia spostata in bit). Infine, il >bit si sposta una volta verso destra.

05AB1E, 5 byte, A000012 , Sicuro

$;$1?

Sequenza di 1. Provalo online

Soluzione prevista: Arcyou

1;$$?

Provalo online . Non sono riuscito a trovare documentazione per questa lingua, quindi non ho una spiegazione di come funzioni esattamente.

Python 2, 70 byte, A000217 Cracked!

Ho la sensazione che questo non si spezzerà nella lingua che ho usato per l'altra versione, vedremo :)

o=input()
v=0
i=1
while o:
 v+=i
 i+=1
print v


#|  d00->1@@@++-^,,[

Mi sono reso conto in seguito di aver erroneamente offuscato il codice (non modifica la validità della risposta postata). Ecco il codice con cui ho iniziato a Haystack:

v
0
v
0
i
1
-
>      d0[v
^-1@+@d+1@?,,o|

05AB1E , 9 byte, A000042 Incrinato!

1×,1*-^$)

Questa è la rappresentazione unaria dei numeri naturali (OEIS). Quindi, se l'input fosse 3, per esempio, allora sarebbe output 111.

Spiegazione:

                    # implicit input
1                   # pushes 1 to the stack   
 ×                  # pushes "1" × (the input)
  ,                 # outputs the stack
   1*-^$)           # irrelevant

Provalo online!

Soluzione originale, carota

1^*$-1×^)

Spiegazione

1^             Push "1" to the stack
  *            Multiply the string by
   $-1         ...the input (as an integer) minus 1 times
      ×,)      Ignored by the interpreter

I *moltiplica la stringa (n+1)volte, in modo che a^*3si traduce in aaaae non aaa. Ecco perché ho sottratto 1dall'input.

Solo ora mi rendo conto che )è stato irrilevante in entrambe le lingue: D

Provalo online!

J, 2 byte, A000290 , Incrinato

*~

Bene, potrebbe anche iniziare ad andare per quei due byters. Resa n × n o n ² .

soluzione prevista, Jolf, 2 byte

*~

Bene. Si. Questa è la mia lingua e penso che funzioni perché ~cerca un carattere esteso, ma non ne trova uno, quindi lo ignora. ¯ \ _ (ツ) _ / ¯ Oops.

ABCR , 24 byte, A023443 Incrinato!

70: Quit xi. Classy queue!

C'è un sacco di no-ops. Calcola n - 1.

05AB1E, 8 byte, A000042 , Cracking

F1}J,(1&

Casi test:

1 -> 1
2 -> 11
3 -> 111

Ouroboros , 6 byte, A000012 Incrinato

)49.o(

Emette sempre 1.