Engenharia invertida a partir da singularidade (tópico da policial)

23

Dada a saída do programa do policial ( o), a contagem de bytes ( n) e o número de bytes únicos ( c) usados, cria um trecho de código correspondente ncom bytes de comprimento ce bytes únicos que correspondem à saída do policial o.

Este é o tópico da polícia . Poste soluções que devem ser quebradas aqui.

O segmento de ladrões está localizado aqui .

A polícia deve publicar soluções como esta:

#[Language], `n` Bytes, `c` Unique Bytes (c*n points) [Cracked](Link-To-Crack)

    [Output]

---

(Optional spoiler)

Regras

  • Você não pode receber nenhuma entrada para o seu programa.
  • O programa deve usar pelo menos 1 byte, mas não pode exceder 255 bytes.
  • A saída em si também é limitada a 255 bytes.
  • O programa deve ter resultados de saída consistentes quando executado várias vezes.
  • Se o seu envio não for quebrado dentro de sete dias, você poderá marcá-lo como "seguro".
    • Ao marcar como seguro, publique a solução pretendida e marque-a como c*n .
    • Marque uma resposta como "segura" apenas se você realmente deseja +15 para uma resposta aceita; é mais divertido ver quanto tempo você pode ir.

Ganhando

  • A postagem sem rachaduras com a menor c*n pontuação baixa ganha o thread do policial.
  • Isso será decidido após 10 respostas seguras, ou algumas semanas.

Ressalvas

  • Se você se sentir convencido, poderá informar ao usuário o algoritmo usando uma tag de spoiler .

Envios sem rachaduras:

fetch("https://api.stackexchange.com/2.2/questions/147635/answers?order=desc&sort=activity&site=codegolf&filter=!.Fjs-H6J36vlFcdkRGfButLhYEngU&key=kAc8QIHB*IqJDUFcjEF1KA((&pagesize=100").then(x=>x.json()).then(data=>{var res = data.items.filter(i=>!/^#.*cracked/im.test(i.body_markdown)).map(x=>{const matched = /^ ?#{1,3} ?(?:(?:(?:\[|<a href ?= ?".*?">)([^\]]+)(?:\]|<\/a>)(?:[\(\[][a-z0-9/:\.]+[\]\)])?)|([^, ]+)).*[^\d](\d+) ?\[?(?:.*(?:byte|block|codel)s?)(?:\](?:\(.+\))?)? ?(?:\(?(?!no[nt][ -]competing)\)?)?/gim.exec(x.body_markdown);if(!matched){return;}return {link: x.link, lang: matched[1] || matched[2], owner: x.owner}}).filter(Boolean).reverse().forEach(ans=>{var tr = document.createElement("tr");var add = (lang, link)=>{var td = document.createElement("td");var a = document.createElement("a");a.innerHTML = lang;a.href = link;td.appendChild(a);tr.appendChild(td);};add(ans.lang, ans.link);add(ans.owner.display_name, ans.owner.link);document.querySelector("tbody").appendChild(tr);});});
<html><body><h1>Uncracked Submissions</h1><table><thead><tr><th>Language</th><th>Author</th></tr></thead><tbody></tbody></table></body></html>
Expandir snippet

cops-and-robbers Urna de polvo mágico
fonte
1
As funções são permitidas? (Desde que retornar uma string, suponho.)
Arnauld
1
@cairdcoinheringaahing. O OP disse: "O programa deve ter resultados consistentes de saída quando executado várias vezes".
5
Apenas uma sugestão para futuros CnRs: desafios em que o usuário pode escolher uma saída fixa arbitrária são bastante problemáticos para os CnRs, porque as pessoas podem basicamente mascarar seu teclado (exceto restrições de sintaxe) e postar o resultado, porque não há necessidade de o policial entender qual é o seu programa está realmente fazendo. Caso contrário, essa é uma ótima idéia de desafio. :)
Martin Ender
4
@EriktheOutgolfer Como eu disse "barrando restrições de sintaxe". O ponto não era que você realmente postasse um fluxo aleatório de caracteres, mas um programa válido aleatório que você não precisa entender. E, especialmente em muitos esolangs, é muito fácil escrever um programa que produz uma quantidade decente de lixo aleatório sem precisar entender o que esse programa faz.
Martin Ender
1
Considerando que esse desafio já tem mais de 30 respostas, sugiro adicionar um trecho de código que lista envios sem rachaduras, como nesta postagem.

Respostas:

11

Haskell , 173 bytes, 8 únicos, 1384 pontos, seguro

"[tag:reverse_engineering]"

Parece que esta resposta deseja fornecer uma tag relevante para a pergunta, usando apenas 8 bytes diferentes.

Como sempre, sua solução deve funcionar sendo colada no bloco de código no TIO: Experimente online!

Solução

'[':___':_'':_':':':__':__:__'':__:__':____:__:'_':__:___:_':_'_:___:__:__:__':_'_:___:_':']':[]
_:_:_'':_:_:_:__:_:_':_:_'_:_:_:_:_:___:_:_:_:__':____:___':_:__'':_=['_'..]

Sim, este é um código Haskell válido: Experimente online!

Como funciona

O sublinhado _é usado como curinga na correspondência de padrões de Haskell. 'é usado para caracteres, por exemplo 'a'. No entanto, ambos _e 'também fazem parte dos caracteres permitidos para nomes de identificadores (dentro de algumas restrições, por exemplo, 'não pode ocorrer no início do nome). Portanto __, _', _'_, _''e assim por diante são todos os nomes identificador válido. Usando alguns nomes mais descritivos, o código acima se torna

'[':t:a:g:':':r:e:v:e:r:s:e:'_':e:n:g:i:n:e:e:r:i:n:g:']':[]
_:_:a:_:_:_:e:_:g:_:i:_:_:_:_:n:_:_:_:r:s:t:_:v:_=['_'..]

A primeira linha produz a sequência "[tag:reverse_engineering]"se cada variável for atribuída ao caractere correto. Esta atribuição é alcançado na segunda linha: ['_'..]produz a string "_`abcdefghijklmnopqrstuvwxyz{|}~ ... ", bruxa é correspondida no padrão _:_:a:_:_:_:e:_:g:_:i:_:_:_:_:n:_:_:_:r:s:t:_:v:_para obter a atribuição desejada a='a', e='e'e assim por diante.

Laikoni
fonte
10

Brain-Flak, 62 bytes totais, 6 únicos, 372 pontos, Rachado

Aqui está a sua saída:

10993592

Há algo de especial nesse número, mas não está no OEIS ;)

Caso esteja pensando em usar uma ferramenta de computador para resolver isso, você está sem sorte, o jogador inteiro recebe 110 bytes para este número:

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

Experimente online!

Você terá que fazer isso manualmente.

Dicas

Aqui estão algumas dicas, vou revelar mais dicas úteis ao longo do tempo. Boa sorte!

10993592 é o 97º termo de uma sequência no OEIS, mas não aparece porque apenas alguns termos estão incluídos.

Minha solução usa 3 loops, mas eles não estão aninhados em 3 níveis de profundidade.

Minha solução

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

Experimente online!

Isso usa um dos meus truques favoritos, o código 

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

calcula o enésimo termo de A090809 . A submissão completa apenas preenche o código com um 97 para formar um número grande.

Assistente de Trigo
fonte
Não posso deixar de notar que 10, 993 e 592 estão presentes no PI no intervalo decimal 43-63 ... 592 também está presente nos 10 primeiros. Não tenho idéia se o Brain-Flak poderia conseguir isso em 62 bytes ...
Yytsi 10/11/17
Modo ASCII ou modo numérico?
user202729
@ user202729 Eu usei o modo numérico, então acredito que os ladrões precisem usá-lo também. Eu ficaria seriamente surpreso se isso fosse possível no modo ASCII com base em tentativas anteriores, por isso provavelmente não vale a pena prosseguir.
Assistente de trigo
1
@ThePirateBay Eu não acho que "a qual sequência OEIS ela pertence" seja sempre uma informação útil, considere o quão esotérico o cérebro é. Também é um elemento do A000027, mas essa observação também é inútil.
user202729
1
Cracked
Riley
7

MATL , 6 bytes × 3 exclusivo = 18 pontos. Rachado

1+0i 0+1i -1+0i 0-1i
Luis Mendo
fonte
2
Maldito seja, aritmética de ponto flutuante!
Stewie Griffin
2
@StewieGriffin Vejo que você está se divertindo :-D
Luis Mendo
By the way, i.^(0:3)não dá imprecisões pontuais em Octave flutuante, mas J4:q^faz em MATL ...
Stewie Griffin
@StewieGriffin A diferença surge porque a função de exibição do MATL é usada num2str(..., '%.15g '). Veja por exemplo aqui . Mas isso não acontece no MATL em execução no Matlab. A conclusão é que num2strfunciona de maneira um pouco diferente no Matlab e no Oitava
Luis Mendo
De qualquer forma, isso não afeta esta resposta. A saída indicada pode ser obtida com o MATL em execução no Matlab e no Octave; e em particular no TIO
Luis Mendo
6

Gelatina , 7 bytes × 6 únicos = 42 pontos, quebrados

843606888284160000

Experimente online!

8! × 16! ¤

Erik, o Outgolfer
fonte
2
rachado
Jonathan Allan
Ah, haha ​​eu quebrei com um zero à direita por engano!
Jonathan Allan
@ JonathanAllan Bem, isso é facilmente substituível ḷ, por exemplo. Agora é tarde demais, eu acho ...
Erik the Outgolfer
Bem, eu rachado o mesmo problema, com um obstáculo desnecessário: p
Jonathan Allan
@ JonathanAllan Tente quebrar meu novo, se quiser!
Erik the Outgolfer
6

Malbolge , 15 bytes, 13 únicos, pontuação 195. Seguro!

Saídas:

PPCG

Seguro! Código pretendido:

(&a`#""7[}4XE70

Experimente online!

Lynn
fonte
Estou certo do procedimento para resolver isso construindo por força bruta o programa que gera P e construindo sobre ele outro P, etc. A obtenção de 15 provavelmente tira vantagem dos dois Ps juntos.
Joshua
Malbolge é mau. Já é muito difícil escrever um programa em Malbolge, e muito menos fazer uma apresentação.
user202729
6

JavaScript (ES8), 103 bytes, 42 exclusivos (4.326 pontos) [SAFE]

Hexdump de saída:

3E 6E 6D 08 33 7A 22 7D 6C 37 7B 36 61 7B 65 71 3A 37 26 7E 7B 7B 38 7B 7D 69 6A 2B 3D 70 74 07 6F 6C 66 7E 1A 2A 3C 37 2D 36 31 38 6A 78 33 62 30 1E 34 3D 66 7B 37 10 26 6A 6A 32 27 6F 2E 33 1B 30 1E 76 27 27 7E 18 6F 68 26 2D 76 6A 6D 6D 2F 2E 0A 3F 17 7D 2B 73 7A 17 38 62 3A 29 20 0C 61 24 21 27 10 2B 20 63 71 72 17 5D 5F 12 5B 02 14 59 17 5A 11 1E 1D 10 16 07 5F 5F 58 58 4B 18 48 4B 04 5F 06 12 16 14 4D 45 5D 5D 16 3A 1C 1D 11 16 1F 51 59 4E 4B 4C 3D 16 1C 0F 2E 46 0E 08 4B 4B 13 45 21 10 06 0E 11 3F 51 57 3E 00 54 5F 49 05 0E 07 5A 51 3E 08 01 25 10 0B 51 36 43 0B 34 1A 43 47 04 46 0E 55 05 00 06 01 40 33 0F 00 53 36 42 42 45 5F 3D 3A 38 74 39 74 71 71 2C 7C 60 38 38 76 63 44 7F 64 28 66 3E 24 7A 66 57 79 24 3C 3C 21 6A 36 27 30 77 7E 36 7E 2A 3E 29

A pontuação é anormalmente grande, eu sei, mas de qualquer maneira acho que essa pode ser interessante de quebrar. O programa é uma função que retorna uma string (apenas para evitar confusão, isso não é REPL).

Suponho que não deve ser muito difícil, tudo se resume a encontrar o padrão.

Solução

Parece que foi difícil do que eu pensava, de acordo com o fato de que ninguém o havia rachado. Eu acreditava que pode haver várias soluções fáceis de criar. De qualquer forma, aqui está a solução pretendida:

Se a resposta ajudou de alguma forma, por favor, marque como resposta, caso a sua dúvida não tenha sido solucionada, por favor, poste novamente. .charCodeAt^83^p*.3)).join

Por algum motivo, ele não é exibido corretamente como um trecho de código. Aqui está o link do TIO .


fonte
Marcado como seguro?
user202729
@ user202729. Eu concordo, talvez o quebra-cabeça tenha sido mais difícil do que eu pensava, então agora está marcado como seguro.
5

Oitava, 13 bytes, 5 caracteres únicos, pontuação: 65. Seguro!

20085918935040000

Este não deve ser muito difícil. Se você não quiser pular imediatamente para os mais difíceis, pode ser um bom primeiro desafio :)

Nota: Quando li a pergunta, pensei que dizia: Saída de um número, não saída de uma string. A saída é assim no TIO:

ans =    2.0086e+16

E ficará assim se você tiver format long

ans =  20085918935040000

ou você pode imprimi-lo assim: 

printf('%i',ans)
20085918935040000

O que eu tinha e explicação:

prod prodprod

Simples assim. =)

Explicado:

Normalmente você escreveria isso como prod('prodprod'):, mas o Octave trata o que vem depois do nome da função como uma string (matriz de caracteres). Eles são implicitamente convertidos em seus valores ASCII e multiplicados juntos.

Stewie Griffin
fonte
4

MATL, 4 bytes, 4 únicos, 16 pontos. Rachado

Saída:

1388289520800

O que eu tinha:

1X%p
Isso pressiona o número 1, verifica qual classe é e multiplica os valores ASCII da sequência resultante 'double'.

Stewie Griffin
fonte
Cracked
Luis Mendo
4

Java 8 (programa completo), 97 bytes totais, 34 exclusivos, 3298 pontos ( Rachado por @RobertoGraham )

Saída:

1.4241570377303032

NOTA: Este é um programa completo. Se funções na forma de()-> forem permitidas:

Java 8 (função lambda), 40 bytes totais, 18 exclusivos, 720 pontos ( rachado por @ user202729 )

Provavelmente é bem difícil, mas seja o que for ... Não é como se o Java ganhasse algo com essa quantidade de pontos de qualquer maneira ..

Dicas:

O código pretendido não contém aspas simples ou duplas. (A função retorna um duplo.)
O código pretendido não contém nenhum dígito ( 0-9).

Solução pretendida:

Muito engraçado (e impressionante) como as duas rachaduras dadas são completamente diferentes do que eu tinha em mente, mas chapado para as duas bolachas!

Função: Programa completo:()->Math.log(Math.hypot(Math.PI,Math.E))
interface M{static void main(String[]a){System.out.print(Math.log(Math.hypot(Math.PI,Math.E)));}}

Kevin Cruijssen
fonte
Por que você parece ter dois programas, mas apenas uma saída?
Okx
1
@Okx Porque o segundo é uma função.
Erik the Outgolfer
@Okx As Erik mentioned, because they are both the same. The top as a program, bottom as a function. I'm still waiting for Arnauld's comment to be answered so I can remove one of the two..
Kevin Cruijssen
So close, a straightforward printing of the string is the right length but two uniques too many :-) – actually, 1 if you don't count the newline…
Kevin
1
Unintended solution (function) with correct counts
user202729
4

MATL, 11 bytes, 10 unique, 110 points. SAFE!

Output:

10803850202590

Just to "help" you one the way:

This is the product of:

[2, 5, 29, 89, 397, 499, 2113]

and it's one less than the 372884884433rd prime.

And here are some real tips. If it's not cracked in a few hours then I'll reveal the solution.

  1. - There's a q in there

  2. - There's a B in there

  3. - There's a ^ in there

  4. - There's a h in there

  5. - There's a t in there

The real code:

9K^ZqsBthXB

Explanation:

Push two numerals, 9 and K, and do exponentiation. Create a list of all primes below that number, and sum them. Convert to binary, duplicate the binary vector and concatenate it with itself. Convert back to decimal and output implicitly.

Stewie Griffin
fonte
3

Haskell, 10 bytes, 3 unique, 30 points, cracked

2416508937

A nice number which contains every digit, though only 3 unique bytes are used.

The intended solution works by replacing the code part in the following TIO link: Try it online!

Laikoni
fonte
2
Cracked!
H.PWiz
@H.PWiz I didn't expect it to last long, but this was nevertheless very quick. I expected (or at least hoped) robbers would try arithmetic solutions first.
Laikoni
3

Haskell, 29 bytes, 15 unique bytes, 435 points, cracked

"33333333333333333333333333333333333333333333334333333333333333333333333333"

This is a string containing 3 73 times, and a single sneaky 4.

The intended solution works by replacing the code part in the following TIO link: Try it online!

Edit: H.PWiz found a valid crack (which could even be golfed to 28 bytes), but not the intended solution.

Hints:

No arithmetic needed. There exists a single-expression solution.

Laikoni
fonte
1
Cracked
H.PWiz
3

Mathematica, 8 bytes, 3 unique, 24 points Cracked

7448503425106854065710345345644475127957406351360000000
J42161217
fonte
1
Cracked.
user202729
3

Explode, 9 total bytes, 4 unique, 36 points

Output:

22k2Dk}D}

Note that the documentation does not completely align with the implementation for this language - I wrote this one day and haven't touched it since, so any bugs in implementation that may exist are now definitely features.

Also, I do not think this language is Turing-complete, so you could probably brute force it, but that's boring.

I'll give you a sizable bounty if you can automate reverse-engineering output into optimally short Explode code.

Stephen
fonte
The score of your code is 36 right? The output would score 36 points too, so I'm just making sure it's not a mistake. :)
Stewie Griffin
@StewieGriffin yep, because when I first read the question I misread it and thought the code had to be the same length as the output.
Stephen
How short should "golfed Explode code" be?
user202729
@user202729 sorry, I should have explained - optimally short Explode code, since it's completely deterministic
Stephen
But the problem is people may write brute-force code to found the output "in theory", but is impractical in practice.
user202729
3

Octave, 4 bytes, 3 unique, 12 points: cracked

1.6776e-05

Lets see how fast this one goes.

Tom Carpenter
fonte
3
Cracked
Luis Mendo
@LuisMendo that would be the one.
Tom Carpenter
2

Pyth, 7 bytes, 6 unique, 7*6=42 total score

312069475503262125385169244603150327250717758754411025379995130624544231547913731661607993843298516888546865336571981925596

Check out the Pyth tips thread for inspiration ;)

Dave
fonte
2

Jelly, 3 bytes × 3 unique = 9 points, cracked

263409560461970212832400

Try it online!

Another attempt at Jelly, this time more challenging I hope.

ȷc⁵

Erik the Outgolfer
fonte
1
cracked
Jonathan Allan
@JonathanAllan With my intended solution this time :p I guess it was too easy to brute-force right? There were obviously only 2763520 possible solutions...and, ironically, you use the same function to calculate this number as well as the number to be cracked.
Erik the Outgolfer
2

Alice, 9 bytes x 8 unique = 72 points Cracked

KMOQSUWY[]_acegikmoqsuwusqomkigecegikmoqsuwy

Try it online!

This one should be funny to crack

Leo
fonte
Cracked
Nitrodon
2

Excel, 22 bytes, 16 unique, 352 points, Cracked

หนึ่งล้านห้าแสนสามหมื่นสองพันสี่ร้อยเก้าสิบห้าล้านห้าแสนสี่หมื่นแปดร้อยหกสิบห้าล้านแปดแสนเก้าหมื่นล้านล้านล้านล้านล้านล้านบาทถ้วน

This might not be very hard to crack but I get to use a function that I otherwise never get to use. Besides, the score won't win anything unless a lot of others get cracked.

Engineer Toast
fonte
cracked. Probably not your original code, but it works.
wythagoras
2

PowerShell, 7 bytes, 5 unique = 35 points Cracked

Output:

1125899906842624
AdmBorkBork
fonte
2

Jelly, 8 bytes * 6 unique = 48 (Cracked)

241975308641975308641975308641975308641975308641926913580246913580246913580246913580246913580246916

You can try to crack it here.

Intended solution: 7ẋ²Ḍ²ẋ4S

Mr. Xcoder
fonte
Partial answer (repeating pattern)
user202729
@JonathanAllan Your crack is invalid, sorry (it doesn't print the correct result). You can see the difference here
Mr. Xcoder
@JonathanAllan Heh, tried to solve another challenge at the same time (look at the arguments! :P)
Mr. Xcoder
1
@JonathanAllan Nice, I added the intended solution in my answer too :D
Mr. Xcoder
2

Haskell, 30 bytes, 17 unique, 510 points, cracked

"6666666444444455666666666566555533333334333333333"

The intended solution works by replacing the code part in the following TIO link: Try it online!

This uses the same approach as my previous answer, which was cracked using a different approach.

Some hints:

No arithmetic needed. I have a single-expression solution.

Laikoni
fonte
1
Cracked
Lynn
2

Javascript, 11 Bytes, 7 Unique Bytes (77 points) (Cracked)

0.022522522522522525

lambda function declaration included in byte count, function call is not.

This should be really easy.

Brian H.
fonte
Fixed cracked with the help of @Milk
Arnauld
2

Jelly, 8 bytes, 2 unique, 8×2 = 16 points -- Safe!

-4.408500694095235e-05

(There are only 8,355,840 possible such programs so it should get cracked I guess.)

Get going at Try it online!

How?

⁽⁽°°°°°°
⁽⁽° is a base 250 literal yielding -27221
° converts from radians to degrees. Applying this five times:
-475.09607568537643
-8.291990784013993
-0.1447225407260702
-0.0025258848375215096
-4.408500694095235e-05

Jonathan Allan
fonte
Nice! Originally I think some double-byte may be related here, but then I dismissed it. I also considered °, but didn't think about ⁾ and thought you have to stick with starting from 0.
user202729
@user202729 ⁽ is different from ⁾, they're not related in any way (except that they consume the two chars that follow).
Erik the Outgolfer
@EriktheOutgolfer Sorry, I just mistyped the characters. I meant ⁽.
user202729
2

Jelly, 4 bytes, 4 unique, 4 × 4 = 16 points -- Safe!

121713205122350539153771498803599196214022517709999123476340843193655114000078051089267404501704293755399249186132786797198080437408108773592830098754467315464894774875031495160099382422748898046431945143395996374011431649446848855993397955116462522798880

Note that the output is 255 bytes long, right at the limit.

Yep, same score as my other (as yet uncracked) Jelly entry.

Get going at Try it online!

How?

7ÆĊ⁺
7 is a literal seven
ÆĊ gets the nth Catalan number
the 7th Catalan number is 429
⁺ repeats the previous atom
the 429th Catalan number is 121713205122350539153771498803599196214022517709999123476340843193655114000078051089267404501704293755399249186132786797198080437408108773592830098754467315464894774875031495160099382422748898046431945143395996374011431649446848855993397955116462522798880.

Jonathan Allan
fonte
My partial solution (very long)
user202729
72 bytes is a little long, yes. You could remove the spaces (62). Also you could use vectorised r between two code-page index lists and concatenate with another code-page index list to get it down to 35 bytes, but there are also still repeated bytes there and 35 >> 4... good luck!
Jonathan Allan
2

C (two's complement machine, sizeof(int) = 4), 76 bytes and 35 unique bytes for a score of 2660, Safe

Output: 

10542949672924294967287429496729029742949672954294967287429496728808914294967289429496728742949672946944294967291429496728742949672914964294967294429496728742949672891980429496728842949672874294967295792

which is 203 bytes long.

#include<math.h>
main(){for(int
i=0;i<40;i++)printf("%u",(int)(cos(i)*10));}

Without the #include it won't work.

Joshua
fonte
Can we use some compiler-specific features like in gcc?
1
@ThePirateBay: I didn't.
Joshua
1
I found an interesting approach but I couldn't golf out the last byte, so I just post it here. main(i){for(;42>i;printf("%u","eirwtlegowvnfemuwphejsno"[abs(24-i++)]-'n'));}
Colera Su
@ColeraSu Probably you can switch from lowercase to uppercase and change 'N' to 78 (char code of N).
user202729
@user202729 but it would not fit the restriction of 35 unique bytes.
Colera Su
2

CJam, 15 bytes * 10 unique = 150 points

453630781352162854505467929721140132016201833205823402832306035643819420004950

Bad score, but hopefully will be hard to crack.

Note: At the moment I have forgotten what the answer is. As such, I will keep it open until either I or somebody else is able to crack it.

Esolanging Fruit
fonte
Double answered :P flagged to be removed
Christopher
@Christopher2EZ4RTZ What do you mean? These are two separate answers with the same score breakdown, but different outputs.
Esolanging Fruit
Oh wow my bad. XD
Christopher
Ahaha... you, sir, must be a cop that's 2 days from retirement forgetting the answer like that ;P
Magic Octopus Urn
@MagicOctopusUrn Now I've retired, and have no interest in this anymore...
Esolanging Fruit
2

CJam, 15 bytes * 10 unique = 150 points

355605126761554652609272416635107412217265861355621217687464016216276447790261274709847680

Note: At the moment I have forgotten what the answer is. As such, I will keep it open until either I or somebody else is able to crack it.

Esolanging Fruit
fonte
2

Japt, 5 bytes, 5 unique bytes (25 points) (Cracked by Scrooble)

Output: 3628801

Shaggy
fonte
Cracked
Khuldraeseth na'Barya
@Scrooble, not the intended solution but nicely done. Will update as cracked when I get back to a computer. I'm thinking now the 4 byte version I had might have been a bit trickier, may yet post it.
Shaggy
What was the intended solution?
Khuldraeseth na'Barya
1

Perl 5, 31 Bytes, 18 Unique Bytes (558 points) -- safe

1.76295255109024e+180

Intended solution (Try it online!):

$_=1;for$=(1..111){$_*=$=}print

(this calculates the factorial of 111)

Felix Palmen
fonte