Reversed Engineered from Uniqueness (Thread di Cop)


23

Dato l'output del programma del cop ( o), il conteggio dei byte ( n) e il numero di byte univoci ( c) utilizzati, viene fornito un pezzo di codice corrispondente che è nlungo byte con cbyte univoci che corrispondono all'output del poliziotto o.


Questo è il filo della polizia . Pubblica soluzioni che devono essere risolte qui.

Il thread dei ladri si trova qui .


I poliziotti dovrebbero pubblicare soluzioni come questa:

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

    [Output]

---

(Optional spoiler)

Regole

  • Non puoi accettare alcun input per il tuo programma.
  • Il programma deve utilizzare almeno 1 byte, ma non può superare 255 byte.
  • Anche l'output stesso è limitato a 255 byte.
  • Il programma deve avere risultati di output coerenti se eseguito più volte.
  • Se l'invio non viene infranto entro 7 giorni, è possibile contrassegnarlo come "sicuro".
    • Quando lo contrassegni come sicuro, pubblica la soluzione desiderata e assegnala come c*n.
    • Contrassegna una risposta come "sicura" solo se vuoi davvero il +15 per una risposta accettata; è più divertente vedere per quanto tempo puoi andare.

vincente

  • Il post senza crack con il c*npunteggio più basso vince il thread del poliziotto.
  • Questo sarà deciso dopo 10 risposte sicure o poche settimane.

Avvertenze

  • Se ti senti arrogante, potresti dire all'utente l'algoritmo usando un tag spoiler .

Contributi non crackati:

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>


1
Sono ammesse funzioni? (A condizione che restituiscano una stringa, suppongo.)
Arnauld

1
@cairdcoinheringaahing. OP ha dichiarato: "Il programma deve avere risultati di output coerenti quando eseguito più volte."

5
Solo un suggerimento per i futuri CnR: le sfide in cui l'utente può scegliere un output fisso arbitrario sono piuttosto problematiche per i CnR perché le persone possono fondamentalmente schiacciare la tastiera (escludendo le restrizioni della sintassi) e pubblicare il risultato, perché non è necessario che il poliziotto capisca quali sono i loro il programma sta effettivamente facendo. Altrimenti, questa è una bella sfida. :)
Martin Ender,

4
@EriktheOutgolfer Come ho detto "salvo restrizioni di sintassi". Il punto non era che in realtà pubblichi un flusso casuale di personaggi, ma un programma casuale valido che non devi capire. E soprattutto in molti esolang, è molto semplice scrivere un programma che genera una discreta quantità di immondizia casuale senza dover capire cosa fa quel programma.
Martin Ender,

1
Considerando che questa sfida ha già più di 30 risposte, suggerisco di aggiungere uno snippet di codice che elenca gli invii non crackati come in questo post.

Risposte:


11

Haskell , 173 byte, 8 unici, 1384 punti, sicuri

"[tag:reverse_engineering]"

Sembra che questa risposta voglia fornire un tag rilevante alla domanda, usando solo 8 byte diversi.

Come al solito, la tua soluzione dovrebbe funzionare incollando il blocco di codice su TIO: provalo online!


Soluzione

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

Sì, questo è un codice Haskell valido: provalo online!

Come funziona

Il carattere di sottolineatura _viene utilizzato come carattere jolly nella corrispondenza del modello di Haskell. 'è usato per i personaggi, ad es 'a'. Tuttavia, entrambi _e 'fanno anche parte dei caratteri consentiti per i nomi degli identificativi (all'interno di alcune restrizioni, ad es. 'Non possono verificarsi all'inizio del nome.). Pertanto __, _', _'_, _''e così via sono tutti nomi identificatore valido. Utilizzando alcuni nomi più descrittivi, il codice sopra diventa

'[':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:_=['_'..]

La prima riga produce la stringa "[tag:reverse_engineering]"se ogni variabile è assegnata al carattere corretto. Questa assegnazione è raggiunto nella seconda riga: ['_'..]produce la stringa "_`abcdefghijklmnopqrstuvwxyz{|}~ ... ", strega corrisponde sul modello _:_:a:_:_:_:e:_:g:_:i:_:_:_:_:n:_:_:_:r:s:t:_:v:_per ottenere l'assegnazione desiderata a='a', e='e'e così via.


10

Brain-Flak, 62 byte totali, 6 unici, 372 punti, Cracked

Ecco il tuo output:

10993592

C'è qualcosa di speciale in questo numero ma non è nell'OEIS ;)

Se stai pensando di utilizzare uno strumento informatico per risolvere questo problema, sei sfortunato, il giocatore di golf intero ottiene 110 byte per questo numero:

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

Provalo online!

Dovrai farlo a mano.


Suggerimenti

Ecco alcuni suggerimenti, rivelerò più suggerimenti più utili nel tempo. In bocca al lupo!

10993592 è il 97 ° termine di una sequenza su OEIS, ma non appare perché sono inclusi solo alcuni termini.


La mia soluzione utilizza 3 loop, ma sono non annidati 3 livelli di profondità.


La mia soluzione

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

Provalo online!

Questo utilizza uno dei miei trucchi preferiti, il codice

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

calcola l'ennesimo termine di A090809 . L'invio completo riempie solo il codice con un 97 per creare un numero elevato.


Non posso fare a meno di notare che 10, 993 e 592 sono presenti in PI nell'intervallo decimale 43-63 ... 592 è presente anche nei primi 10. Non ho idea se Brain-Flak potrebbe raggiungere questo obiettivo in 62 byte però ...
Yytsi

Modalità ASCII o modalità numerica?
user202729

@ user202729 Ho usato la modalità numerica, quindi credo che anche i ladri dovrebbero usarla. Sarei seriamente sorpreso se ciò fosse possibile in modalità ASCII sulla base di tentativi precedenti, quindi probabilmente non vale la pena perseguire.
Wheat Wizard

1
@ThePirateBay Non penso che "a quale sequenza OEIS appartenga" sia sempre un'informazione utile, considera quanto esoterica Brain-Flak sia. È anche un elemento di A000027, ma anche questa osservazione è inutile.
user202729


7

MATL , 6 byte × 3 univoci = 18 punti. Cracked

1+0i 0+1i -1+0i 0-1i

2
Accidenti a te, aritmetica in virgola mobile!
Stewie Griffin,

2
@StewieGriffin Vedo che ti stai divertendo MrGreen
Luis Mendo,

A proposito, i.^(0:3)non dà imprecisioni in virgola mobile in Octave, ma J4:q^in MATL ...
Stewie Griffin

@StewieGriffin La differenza sorge perché utilizza la funzione di visualizzazione di MATL num2str(..., '%.15g '). Vedi ad esempio qui . Ma ciò non accade per MATL in esecuzione su Matlab. La conclusione è che num2strfunziona in modo leggermente diverso in Matlab e in Octave
Luis Mendo il

Comunque, ciò non influisce su questa risposta. L'output indicato può essere ottenuto con MATL in esecuzione su Matlab e su Octave; e in particolare su TIO
Luis Mendo il

6

Gelatina , 7 byte × 6 unici = 42 punti, incrinati

843606888284160000

Provalo online!

8! × 16! ¤



Oh, ahah l'ho rotto con uno zero finale per errore!
Jonathan Allan,

@JonathanAllan Bene, è facilmente sostituibile , ad esempio. Ora è troppo tardi, immagino ...
Erik the Outgolfer,

Bene, ho risolto lo stesso problema, con un ostacolo inutile: p
Jonathan Allan,

@JonathanAllan Se vuoi, prova a decifrarne uno nuovo!
Erik the Outgolfer,

6

Malbolge , 15 byte, 13 unici, punteggio 195. Sicuro!

Uscite:

PPCG

Sicuro! Codice previsto:

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

Provalo online!


Sono certo della procedura per risolvere questo problema costruendo con la forza bruta il programma che emette P e costruendo sopra di essa un'altra P, ecc. Arrivare a 15 probabilmente sfrutta i due Ps insieme.
Joshua,

Malbolge è il male. È già troppo difficile scrivere un programma in Malbolge, per non parlare di crackare una proposta.
user202729

6

JavaScript (ES8), 103 byte, 42 unici (4.326 punti) [SICURO]

Uscita hexdump:

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

Il punteggio è anormalmente grande, lo so, ma comunque penso che questo possa essere interessante da decifrare. Il programma è una funzione che restituisce una stringa (solo per evitare confusione, questo non è REPL).

Non dovrebbe essere troppo difficile, suppongo, tutto riguarda la ricerca del modello.

Soluzione

Sembra che sia stato più duro di quanto pensassi, secondo il fatto che nessuno l'aveva rotto. Credevo che potessero esserci più soluzioni facili da realizzare. Comunque, ecco la soluzione prevista:

f = m => [... m = f + f + f] .map ((a, p) => p + 1 e 256 '': String.fromCharCode ((p & 4 m [p ^ 17]: a) .charCodeAt^83^p*.3)).join

Per qualche motivo non viene visualizzato correttamente come frammento di codice. Ecco il link TIO .


Contrassegnato come sicuro?
user202729

@ user202729. Sono d'accordo, forse il puzzle era più difficile di quanto pensassi, quindi ora è contrassegnato come sicuro.

5

Ottava, 13 byte, 5 personaggi unici, punteggio: 65. Sicuro!

20085918935040000

Questo non dovrebbe essere troppo difficile. Se non vuoi passare subito a quelli più difficili, potrebbe essere una bella prima sfida :)

Nota: quando ho letto la domanda, ho pensato: Emettere un numero, non emettere una stringa. L'output è simile al TIO:

ans =    2.0086e+16

E sembrerà così se lo hai fatto format long

ans =  20085918935040000

oppure puoi stamparlo in questo modo:

printf('%i',ans)
20085918935040000

Cosa avevo e spiegazione:

prod prodprod

Semplice come quella. =)

Ha spiegato:

Normalmente dovresti scrivere questo come prod('prodprod'):, ma Octave tratta tutto ciò che viene dopo il nome della funzione come una stringa (matrice di caratteri). Questi vengono implicitamente convertiti nei loro valori ASCII e moltiplicati insieme.


4

MATL, 4 byte, 4 unici, 16 punti. Cracked

Produzione:

1388289520800

Quello che avevo:

1X%p
Questo spinge il numero 1, controlla quale classe è, quindi moltiplica i valori ASCII della stringa risultante 'double'.



4

Java 8 (programma completo), 97 byte totali, 34 unici, 3298 punti ( Cracked by @RobertoGraham )

Produzione:

1.4241570377303032

NOTA: questo è un programma completo. Se ()->invece sono consentite funzioni sotto forma di :

Java 8 (funzione lambda), 40 byte totali, 18 unici, 720 punti ( Cracked by @ user202729 )

Probabilmente è abbastanza difficile, ma comunque .. Non è come se Java vincesse comunque qualcosa con questa quantità di punti ..


suggerimenti:

Il codice previsto non contiene virgolette singole o doppie. (La funzione restituisce un doppio.)
Il codice previsto non contiene cifre ( 0-9).


Soluzione prevista:

Abbastanza divertente (e impressionante) il modo in cui entrambe le fessure sono completamente diverse da quello che avevo in mente, ma chapeau per entrambi i cracker!

Funzione: programma 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)));}}


Perché sembra che tu abbia due programmi, ma solo un output?
Okx,

1
@Okx Perché il secondo è una funzione.
Erik the Outgolfer,

@Okx Come menzionato Erik , perché sono entrambi uguali. La parte superiore come programma, la parte inferiore come funzione. Sto ancora aspettando la risposta al commento di Arnauld in modo da poter rimuovere uno dei due ..
Kevin Cruijssen,

Così vicino, una stampa semplice della stringa è della lunghezza giusta ma due uniche uniche :-) - in realtà, 1 se non conti la nuova riga ...
Kevin,


4

MATL, 11 byte, 10 unici, 110 punti. SICURO!

Produzione:

10803850202590

Solo per "aiutarti" a modo tuo:

Questo è il prodotto di:

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

ed è uno in meno del 372884884433primo numero.


E qui ci sono alcuni veri consigli. Se non si rompe in poche ore, rivelerò la soluzione.

  1. - C'è un qdentro

  2. - C'è un Bdentro

  3. - C'è un ^dentro

  4. - C'è un hdentro

  5. - C'è un tdentro

Il vero codice:

9K ^ ZqsBthXB

Spiegazione:

Spingere due numeri 9e K, quindi, esponenziazione. Crea un elenco di tutti i numeri primi sotto quel numero e sommali. Converti in binario, duplica il vettore binario e concatenalo con se stesso. Converti nuovamente in decimale e genera implicitamente.


3

Haskell , 10 byte, 3 unici, 30 punti, incrinati

2416508937

Un bel numero che contiene ogni cifra, sebbene vengano utilizzati solo 3 byte univoci.

La soluzione prevista funziona sostituendo la parte di codice nel seguente collegamento TIO: Provalo online!



@ H.PWiz Non mi aspettavo che durasse a lungo, ma questo è stato comunque molto veloce. Mi aspettavo (o almeno speravo) che i ladri avrebbero provato prima le soluzioni aritmetiche.
Laikoni,

3

Haskell , 29 byte, 15 byte unici, 435 punti, incrinato

"33333333333333333333333333333333333333333333334333333333333333333333333333"

Questa è una stringa contenente 373 volte e una singola subdola 4.

La soluzione prevista funziona sostituendo la parte di codice nel seguente collegamento TIO: Provalo online!

Modifica: H.PWiz ha trovato un crack valido (che potrebbe anche essere golfato a 28 byte), ma non la soluzione prevista.

suggerimenti:

Non è necessaria l'aritmetica. Esiste una soluzione a espressione singola.




3

Esplodi , 9 byte totali, 4 unici, 36 punti

Produzione:

22k2Dk}D}

Nota che la documentazione non si allinea completamente con l'implementazione per questo linguaggio - l'ho scritto un giorno e non l'ho più toccato da allora, quindi eventuali bug nell'implementazione che possono esistere ora sono sicuramente delle funzionalità.

Inoltre, non credo che questo linguaggio sia completo di Turing, quindi potresti probabilmente forzarlo brutalmente, ma è noioso.

Ti darò una taglia considerevole se puoi automatizzare l'output di reverse engineering in codice Explode in modo ottimale breve.


Il punteggio del tuo codice è 36 giusto? L'output segnerebbe anche 36 punti, quindi sto solo assicurandomi che non sia un errore. :)
Stewie Griffin,

@StewieGriffin sì, perché quando ho letto la domanda per la prima volta l'ho letto male e ho pensato che il codice dovesse avere la stessa lunghezza dell'output.
Stephen,

Quanto dovrebbe essere breve il "codice esplode golfizzato"?
user202729

@ user202729 mi dispiace, avrei dovuto spiegare - esplodi in modo ottimale il codice, dal momento che è completamente deterministico
Stephen

Ma il problema è che le persone possono scrivere un codice di forza bruta per fondare l'output "in teoria", ma non è pratico in pratica.
user202729


2

Pyth, 7 byte, 6 unici, 7 * 6 = 42 punteggio totale

312069475503262125385169244603150327250717758754411025379995130624544231547913731661607993843298516888546865336571981925596

Dai un'occhiata al thread dei suggerimenti di Pyth per ispirazione;)


2

Gelatina , 3 byte × 3 unici = 9 punti, incrinati

263409560461970212832400

Provalo online!

Un altro tentativo di Jelly, questa volta più stimolante spero.

ȷc⁵



@JonathanAllan Con la mia soluzione prevista questa volta: p Immagino che sia stato troppo facile la forza bruta, giusto? Ovviamente c'erano solo 2763520 possibili soluzioni ... e, ironia della sorte, usi la stessa funzione per calcolare questo numero e il numero da decifrare.
Erik the Outgolfer,


2

Excel, 22 byte, 16 unici, 352 punti, Cracked

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

Questo potrebbe non essere molto difficile da decifrare, ma posso usare una funzione che altrimenti non riuscirò mai ad usare. Inoltre, il punteggio non vincerà nulla a meno che molti altri non vengano violati.


incrinato . Probabilmente non è il tuo codice originale, ma funziona.
wythagoras,


2

Gelatina , 8 byte * 6 unico = 48 ( Cracking )

241975308641975308641975308641975308641975308641926913580246913580246913580246913580246913580246916

Puoi provare a decifrarlo qui .

Soluzione prevista: 7ẋ²Ḍ²ẋ4S



@JonathanAllan Il tuo crack non è valido, scusa (non stampa il risultato corretto). Puoi vedere la differenza qui
Mr. Xcoder

@JonathanAllan Heh, ha provato a risolvere un'altra sfida allo stesso tempo (guarda gli argomenti!: P)
Mr. Xcoder

1
@JonathanAllan Nice, ho aggiunto anche la soluzione prevista nella mia risposta: D
Mr. Xcoder

2

Haskell , 30 byte, 17 unici, 510 punti, incrinati

"6666666444444455666666666566555533333334333333333"

La soluzione prevista funziona sostituendo la parte di codice nel seguente collegamento TIO: Provalo online!

Questo utilizza lo stesso approccio della mia risposta precedente , che è stata decifrata utilizzando un approccio diverso.

Alcuni suggerimenti:

Non è necessaria l'aritmetica. Ho una soluzione a espressione singola.



2

Javascript, 11byte , byte 7unici (77 punti) (crackato)

0.022522522522522525

dichiarazione di funzione lambda inclusa nel conteggio byte, la chiamata di funzione no.

Questo dovrebbe essere davvero facile.


Risolto il problema con il crack di @Milk
Arnauld del

2

Gelatina , 8 byte , 2 unici, 8 × 2 = 16 punti - Sicuro!

-4.408500694095235e-05

(Esistono solo 8.355.840 programmi possibili, quindi credo che dovrebbe essere rotto).

Inizia provalo online!

Come?

⁽⁽°°°°°°
⁽⁽°è una base di 250 letterali che -27221
°converte da radianti a gradi. Applicandolo cinque volte:
-475.09607568537643
-8.291990784013993
-0.1447225407260702
-0.0025258848375215096
-4.408500694095235e-05


Bello! Inizialmente penso che alcuni byte doppi possano essere correlati qui, ma poi l'ho respinto. Ho anche considerato °, ma non ci ho pensato e ho pensato che dovresti restare con a partire da 0.
user202729

@ user202729 è diverso da , non sono in alcun modo correlati (tranne che consumano i due caratteri che seguono).
Erik the Outgolfer,

@EriktheOutgolfer Spiacente, ho appena sbagliato a scrivere i personaggi. Intendevo .
user202729

2

Gelatina , 4 byte , 4 unici, 4 × 4 = 16 punti - Sicuro!

121713205122350539153771498803599196214022517709999123476340843193655114000078051089267404501704293755399249186132786797198080437408108773592830098754467315464894774875031495160099382422748898046431945143395996374011431649446848855993397955116462522798880

Si noti che l'output è lungo 255 byte, proprio al limite.

Sì, lo stesso punteggio della mia altra voce Jelly (non ancora crackata) .

Inizia provalo online!

Come?

7ÆĊ⁺
7è un letterale sette
ÆĊottiene il n ° numero di catalano
il 7 ° catalana numero è 429
ripetizioni dell'atomo precedente
il 429 ° numero di Catalan è 121713205122350539153771498803599196214022517709999123476340843193655114000078051089267404501704293755399249186132786797198080437408108773592830098754467315464894774875031495160099382422748898046431945143395996374011431649446848855993397955116462522798880.



72 byte è un po 'lungo, sì. È possibile rimuovere gli spazi (62). Inoltre potresti usare vettorializzare rtra due elenchi di indici di pagine di codice e concatenare con un altro elenco di indici di pagine di codice per ridurlo a 35 byte , ma ci sono anche ancora byte ripetuti e 35 >> 4 ... buona fortuna!
Jonathan Allan,

2

C (macchina a complemento a due, sizeof (int) = 4), 76 byte e 35 byte unici per un punteggio di 2660, Sicuro

Produzione:

10542949672924294967287429496729029742949672954294967287429496728808914294967289429496728742949672946944294967291429496728742949672914964294967294429496728742949672891980429496728842949672874294967295792 

che è lungo 203 byte.

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

Senza #include non funzionerà.


Possiamo usare alcune funzionalità specifiche del compilatore come in gcc?

1
@ThePirateBay: non l'ho fatto.
Giosuè il

1
Ho trovato un approccio interessante ma non ho potuto golfare l'ultimo byte, quindi l'ho pubblicato qui. main(i){for(;42>i;printf("%u","eirwtlegowvnfemuwphejsno"[abs(24-i++)]-'n'));}
Colera,

@ColeraSu Probabilmente puoi passare da lettere minuscole a maiuscole e passare 'N'a 78(codice char di N).
user202729

@ user202729 ma non si adatterebbe alla limitazione di 35 byte univoci.
Colera,

2

CJam, 15 byte * 10 unici = 150 punti

453630781352162854505467929721140132016201833205823402832306035643819420004950

Punteggio negativo, ma speriamo che sia difficile da decifrare.

Nota: al momento ho dimenticato quale sia la risposta. Come tale, lo terrò aperto fino a quando io o qualcun altro non saremo in grado di romperlo.


Doppia risposta: P contrassegnato per essere rimosso
Christopher

@ Christopher2EZ4RTZ Che vuoi dire? Queste sono due risposte separate con la stessa suddivisione del punteggio, ma risultati diversi.
Esolanging Fruit,

Oh wow mio male. XD
Christopher,

Ahaha ... tu, signore, devi essere un poliziotto a 2 giorni dalla pensione dimenticando la risposta in quel modo; P
Magic Octopus Urn

@MagicOctopusUrn Ora mi sono ritirato e non ho più interesse in questo ...
Esolanging Fruit

2

CJam, 15 byte * 10 unici = 150 punti

355605126761554652609272416635107412217265861355621217687464016216276447790261274709847680

Nota: al momento ho dimenticato quale sia la risposta. Come tale, lo terrò aperto fino a quando io o qualcun altro non saremo in grado di romperlo.



1

Perl 5 , 31 byte, 18 byte unici (558 punti) - sicuro

1.76295255109024e+180

Soluzione prevista ( provalo online! ):

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

(questo calcola il fattoriale di 111)

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.