Si fermerà? (Cops)

94

Questo è il filo della polizia. Il thread dei ladri è qui .

La tua sfida è creare un programma che funzioni per sempre senza arrestare 1 , a meno che non ottenga un input o input 2 . Se riceve quell'input, deve terminare in un tempo finito 3 . Questo è code-golf , quindi la risposta più breve che non è stata decifrata da un ladro entro una settimana dalla pubblicazione delle vittorie. Dopo che è trascorsa la settimana, contrassegnare la risposta come sicura e mostrare l'input di arresto (in a > ! spoiler quote). Se un ladro rompe l'invio, contrassegnalo come incrinato e mostra l'input di arresto (in a > ! spoiler quote).

Le presentazioni sono preferibili essere eseguibili e crackabili su TIO . Sono consentiti invii non eseguibili o crackabili su TIO, ma includere le istruzioni per scaricarli / eseguirli.

Rendi deterministico il tuo input e uniforme su tutte le corse. Vedi questo meta post per i dettagli.

Per favore, non "implementare RSA" o qualsiasi cosa cattiva per i ladri. Usa lingue e funzionalità oscure, non noiose crittografia e hash. Non posso far valere questo con le regole, ma puoi aspettarti downgrade votivi se tutto ciò che fai è sha(input) === "abcd1234".

1 Supponendo che il computer non si spenga, non si rompa, non venga inghiottito dal sole, si surriscaldi nella morte termica dell'universo o colpisca il timeout TIO degli anni '60.

2 Il programma deve arrestarsi su almeno un ingresso. Fintanto che scorre per sempre su un ingresso e si ferma su un altro, funziona.

3 Deve essere <60 secondi, quindi il codice può essere testato su TIO.

Cerchi invii non crackati?

fetch("https://api.stackexchange.com/2.2/questions/135363/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=>!i.body_markdown.toLowerCase().includes("cracked")).map(x=>{const matched = /^ ?##? ?(?:(?:(?:\[|<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).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>
Espandi frammento

code-golf  decision-problem  cops-and-robbers 
— programmer5000
fonte
1
@LuisMendo supponendo che la memoria infinita vada bene
— programmatore
1
@ programmer5000 Grazie per il chiarimento. Dovresti incorporare tutto questo nel testo della sfida. Non ci si aspetta che i rispondenti leggano tutti i commenti
— Luis Mendo,
6
Possiamo limitare l'input, per esempio, a un numero intero? Un ladro potrebbe passare un input non corretto o errato per terminare immediatamente il programma. O dovrei fare molta attenta convalida dell'input o usare un linguaggio in grado di rilevare errori arbitrari.
— xnor
3
@xnor Penso che dovresti fare il controllo degli input.
— Stephen,
1
@StepHen Funziona se l'input non valido è ancora in grado di essere analizzato dall'interprete. Se inserisco una stringa illegale, Rerrori immediatamente, senza nemmeno entrare nella funzione di crack. Direi che non conta come terminare effettivamente la funzione.
— JAD,

Risposte:

55

Malbolge, 128 byte, crackato da KBRON111

(=&r:#o=~l4jz7g5vttbrpp^nllZjhhVfddRb`O;:('JYX#VV~jS{Ql>jMKK9IGcFaD_X]\[ZYXWVsN6L4J\[kYEhVBeScba%_M]]~IYG3Eyx5432+rpp-n+l)j'h%B0

Divertiti!

(Sì, ho imparato Malbolge proprio per questo. Sì, ci è voluto un tempo assurdamente lungo per iniziare finalmente a lavorare. E sì, ne è valsa la pena.)

Avvolto, così puoi vederlo nella sua pienezza, ehm, "gloria":

(=&r:#o=~l4jz7g5vttbrpp^nllZjhhV
fddRb`O;:('JYX#VV~jS{Ql>jMKK9IGc
FaD_X]\[ZYXWVsN6L4J\[kYEhVBeScba
%_M]]~IYG3Eyx5432+rpp-n+l)j'h%B0

Ho usato questo interprete per testarlo; Non sono sicuro che sia importante, ma ho pensato di specificare per ogni evenienza.

— Maniglia
fonte
2
Questo è l'interprete che TIO usa btw.
— Dennis,
2
oh, "Buon divertimento" è una buona aggiunta
— Евгений Новиков
26
Sei un idiota. Malbolge è medio.
— Draco18s
1
Sono timbrato ... Il più lontano che ho ottenuto: su 13 input prima dell'arresto, solo il primo e il terzo hanno alcun impatto. Dopo approfondita reverse-engineering, ho scoperto che prima di ingresso deve essere 6e il terzo è uno dei quattro: !, #, /e -. Ma la combinazione non sembra risolvere il problema. L'ho messo qui, forse qualcuno più intelligente trova una soluzione. Se qualcuno lo desidera, posterò domani come sono arrivato a questi input. EDIT: Ora che ci penso, il mio programma ho scritto a scopo di reverse-engineering questo potrebbe avere un bug, e il primo ingresso può essere qualcosa di diverso 6. Il terzo personaggio è ancora valido.
— Grzegorz Puławski,
7
— Veedrac,
23

JavaScript (ES6), 17 byte, Cracked

x=>{for(;x==x;);}

Su TIO, poiché non so come fare readline Node.js su TIO, basta inserire l'input nella chiamata di funzione. Questo è ovvio per chiunque lo sappia e non per chiunque non lo sappia.

Provalo online!

Risposta:

La risposta è NaN, dal momento che in JavaScript, NaN != NaN.

— Stefano
fonte
2
Cracked . Bello l'uso di una stranezza della lingua!
— programmatore
3
Puoi scommettere :) Mi piace come tu fossi così fiducioso che è quello che ho scelto che l'hai modificato per me: P
— Stephen
12
NaN == NaNè falso in molte lingue diverse da JavaScript. Non lo definirei una "stranezza del linguaggio".
— Nayuki,
9
credo NaN != NaNsia una caratteristica dei numeri in virgola mobile
— undergroundmonorail
1
@undergroundmonorail: è corretto. La relazione tra due numeri IEEE in virgola mobile può essere sopra, uguale, sotto o non ordinata . Il risultato del confronto non è ordinato se uno o entrambi gli operandi sono di qualsiasi tipo di NaN. (Il punto in virgola mobile binario IEEE 754 ha molti pattern di bit NaN : qualsiasi cosa con l'esponente all-one e una mantissa diversa da zero è un NaN, indipendentemente dal bit del segno. Ci sono alcune regole per le quali ciò che va nel "payload" di un NaN, e per averlo propagato attraverso operazioni come +o max(), ma alla maggior parte delle persone non importa: P)
— Peter Cordes,
14

JS (ES6), 67 byte ( crackato )

(x,y)=>{while(x!==y||Object.is(x, y)||!isFinite(x)||!isFinite(y));}

Io penso che non ha fatto sbagli, potrebbe avere una soluzione facile che non ho visto.

Apprezzo qualsiasi feedback, questo è uno dei miei primi post

(+0, -0) Sì, js ha uno 0 negativo

— Juan Tonina
fonte
3
— Stephen,
Ora mi rendo conto che non ho bisogno di controllare se xe ysono limitati, ma non modificherò poiché era già rotto. Avrebbero potuto essere 38 byte
— Juan Tonina,
9

Javascript (NON node.js)

x=>{while(x+"h");}

L'invio desiderato non utilizza il tiro.

Suggerimento per la crepa desiderata:

L'invio desiderato non viene sovrascritto .toString()o utilizzato Set().

Crepa desiderata:

Object.create(null)

— programmer5000
fonte
Link crack corretto (non mio, solo un link alla risposta di Dom Hasting)
— Stephen
Cracked # 2 Cracked senza usare throw(dà comunque un errore)
— Grant Davis
Di nuovo incrinato senza usare throw, questa volta credo davvero perché Grant Davis non ha funzionato per me. Ancora TypeErrors.
— Haumed Rahmani il
2
Si potrebbe fare in x=>{try{for(;x+"h";)}catch(e){for(;;)}}modo che eventuali errori si traducano in un ciclo infinito, quindi errori di funzione prototipo mancanti (o eventuali errori) si tradurranno in un ciclo infinito.
— Grant Davis,
1
Questo funziona solo nel browser, non so perché, però: D
— jadkik94
8

C (gcc) , 75 byte Incrinato

#include<stdio.h>
int main(){char c[9];while(1){scanf("%8s",c);printf(c);}}

Provalo online!

Non ho mai pubblicato prima in un cops-n-ladri. Spero che questo non sia troppo ovvio.

Soluzione:

Un input di "% s" rende questo segfault. Ce ne sono molti altri che possono essere utilizzati; tutti sono printfidentificatori come "% n"
Questa è la classica printfvulnerabilità. In poche parole, la stringa di formato proviene direttamente dall'input dell'utente, quindi tutti gli printfspecificatori vengono superati, in modo non sicuro.

— Justin
fonte
1
— Conor O'Brien,
8

JavaScript (nel browser), 79 byte Cracked

x=>{try{for(;x||x!=null||x!=void 0||x===null||x===void 0;);}catch(e){for(;;);}}

Dovresti eseguirlo in un browser recente (come l'ultimo ESR di Firefox, l'ultimo Firefox, l'ultimo Chromium). L'esecuzione su vecchi browser (come Netscape 2, IE 4) non conta.

Nota: arrestato dal browser a causa del timeout qui non si ferma.

Fai sempre attenzione a non bloccare il browser durante il test di questi codici e buon furto ^ _ ^

document.all

— tsh
fonte
Posso usare setTimeout?
— Евгений Новиков
@ ЕвгенийНовиков Puoi chiamare questa funzione con qualsiasi parametro. Sembra però setTimeoutche il parametro non funzioni.
— TSH
l'idea è di fare var key=(()=>{setTimeout(args);return null})()e poicrackme(key)
— Евгений Новиков
sembra barare
— Евгений Новиков
1
— Juan Tonina,
6

PHP (crackato da Vicente Gallur Valero), 65 byte

<?php
parse_str($argv[1],$_);
while(!$_['(-0_0)> deal with it']);

Provalo online!

Più difficile di quanto possa sembrare. Modificato per essere possibile su TIO, al costo di un mucchio di byte. Riceve input tramite $argv[1].

— Sisifo
fonte
1
— Vicente Gallur Valero,
6

Buccia , 5 byte Incrinato

↑ε∞←ø

Provalo online!

Un po 'di spiegazione, poiché questa lingua è ancora piuttosto nuova:

←øottiene il primo elemento di un elenco vuoto: restituisce un valore che può assumere qualsiasi tipo, sia esso un tipo concreto o una funzione, che verrà quindi applicato all'input. ∞crea un elenco infinito composto da copie del risultato precedente (che nella maggior parte dei casi significherà un elenco di zero infiniti). ↑εaccetta elementi da questo elenco purché siano "piccoli", ovvero il loro valore assoluto sia ≤1; su un infinito elenco di zeri questo non si fermerà mai.

— Leo
fonte
@Veedrac che era in realtà la mia soluzione prevista
— Leo,
Bene, allora, incrinato!
— Veedrac,
5

Ruby , 31 byte ( crackato da Eric Duminil )

0until(3.send(gets)==5rescue p)

Provalo online!

Si noti che questo deve essere eseguito in un ambiente in cui non vi è alcuna nuova riga finale nel risultato gets, altrimenti è impossibile fermarlo (penso) poiché qualsiasi cosa che termina in una nuova riga si guasterà e colpirà il salvataggio.

— histocrat
fonte
— Eric Duminil,
Bello a proposito! Nessun metodo 3.methodsrestituisce 5o esce dal ciclo.
— Eric Duminil,
Darn! Ho scoperto la soluzione anche in modo indipendente, ma ero troppo concentrato sul renderlo uguale 5per pensare che la risposta corretta avrebbe comportato la funzione che ha svolto ...
— Value Ink
5

Bash 4.2, 14 byte ( crackato )

Proviamo di nuovo.

let ${1,,}
yes

Questo non funziona su TIO, che utilizza Bash 4.3. L'input avviene tramite argomenti della riga di comando.

Su Linux e con gcc installato, Bash 4.2.53 può essere scaricato e compilato come segue.

curl -sSL https://ftp.gnu.org/gnu/bash/bash-4.2.53.tar.gz | tar xz
cd bash-4.2.53
./configure
make -j
— Dennis
fonte
Cracked. Fondamentalmente ho finito per leggere la fonte.
— Veedrac,
4

Retina , 78 byte ( Cracked ) ( Cracked con soluzione prevista )

^
1
+`^1(1+)
$1¶$&
s`(?<=^|¶)(1+)(?=¶)(?!.*¶\1+$)

¶(?!1+$)

^(1+)¶\1$

+`1
11

È stato abbastanza divertente da scrivere, spero sia divertente da decifrare

Provalo online!

Incrinato con una soluzione non intenzionale e la soluzione prevista entro un minuto l'uno dall'altro. Uno pubblicato per primo, uno per primo commentato.

Soluzione prevista:

11111 o la rappresentazione unaria di n-1 dove n è un numero perfetto

— PunPun1000
fonte
— mbomb007
— Kritixi Lithos
Quindi di chi conta il crack? (Ho pubblicato prima il crack, ma mbomb007 ha commentato per primo)
— Kritixi Lithos
@Cowsquack entrambi
— programmatore
4

Java 8, 99 byte, Cracked

s->{try{Integer i=Integer.parseInt(s),c=i+32767;i+=32767;for(;i!=c;);}catch(Throwable t){for(;;);}}

Questo è un lambda del tipo Consumer<String> .

Ungolfed:

s -> {
    try {
        Integer i = Integer.parseInt(s), c = i + Short.MAX_VALUE;
        i += Short.MAX_VALUE;
        while (i != c) ;
    } catch (Throwable t) {
        while (true) ;
    }
}

Provalo online!(si noti che il programma di test si arresterà in modo anomalo su input vuoto, ma lo stesso lambda non lo farebbe!) (inoltre, utilizzare 'argomenti' non 'input' su TIO, poiché il programma di test utilizza argomenti, non STDIN)

Risposta prevista:

-32767; Questo funziona perché Java keep ha due tipi interi inte Integer. Integerè un oggetto che avvolge int. Inoltre, Java mantiene una cache di Integers che la casella -127attraverso 127. L' !=operatore controlla l'identità, quindi tramite un-boxing e auto-boxing qualsiasi numero in xcui si x + 32767trova [-127, 127]finirà per essere lo stesso Integeroggetto dalla cache, e quindi i != csarà falso.

— Socratic Phoenix
fonte
2
— Veedrac,
4

Bash 4.2, 10 byte ( crackato )

let $1
yes

Questo non funziona su TIO, che utilizza Bash 4.3. L'input avviene tramite argomenti della riga di comando.

Su Linux e con gcc installato, Bash 4.2.53 può essere scaricato e compilato come segue.

curl -sSL https://ftp.gnu.org/gnu/bash/bash-4.2.53.tar.gz | tar xz
cd bash-4.2.53
./configure
make -j
— Dennis
fonte
1
Cracked. Mi hai condotto in tondo pensando che questo fosse correlato a shellshock e che mi collegava a una versione rattoppata: P. Conta il crack involontario come piccola vendetta;).
— Veedrac,
Heh, non proprio quello che stavo cercando. Ho pubblicato una versione avanzata se vuoi provarlo.
— Dennis,
3

Java: 1760 ( Cracked )

Sento che è troppo cattivo giocare a questo, quindi ho solo offuscato i nomi delle variabili e l'ho reso "disordinato". È un dato di fatto così cattivo, che nel corso del tempo pubblicherò suggerimenti, solo per vederlo rotto.

Suggerimento 1: questo ha input validi teoricamente infiniti, ma ce n'è uno che è il più 'corretto'


public class Main {

	public static void main(String[] a) {
		try {
			while (a.length < 2) {
				int i = 0;
			}
			boolean invalid = 1 < 0;
			char l = '_';
			char h = '-';
			char[] DATATWO = a[0].toCharArray();
			char[] DATATOW = a[1].toCharArray();
			int length = DATATOW.length;
			if (DATATWO.length != length) {
				invalid = 1 > 0;
			}
			int transmissionStartIndex = 0;
			for (int i = 0; i < length; i++) {
				if (DATATWO[i] == l && DATATOW[i] == l) {
					transmissionStartIndex = i;
					break;
				}
			}
			int DATAONE = 0, reg = 0;
			boolean read = 1 < 0, full = 0 < 1;
			int bytes_read = 0;
			for (int i = transmissionStartIndex; i < length; i++) {
				if (DATATOW[i] == l && DATATOW[i + 1] == h) {
					bytes_read++;

					if (bytes_read == 8) {
						read = DATATWO[i] == h;
					} else if (bytes_read == 9) {
						invalid = (DATATWO[i] == h || invalid);
						System.out.println(invalid);
					} else if (bytes_read == 18) {
						System.out.println(invalid);
						invalid = (DATATWO[i] == h || invalid);
						if (invalid) {
							System.out.println("i36 " + DATATWO[i] + " " + h);
						}
						full = 1 > 0;
					} else if (bytes_read < 8) {
						DATAONE += (DATATWO[i] == h ? 1 : 0) << (7 - bytes_read);
					} else if (bytes_read < 18) {
						reg += (DATATWO[i] == h ? 1 : 0) << (8 - (bytes_read - 9));
					} else if (bytes_read > 18) {
						invalid = 1 > 0;
					}
					System.out.println(a[0]);
					System.out.println(new String(new char[i]).replace("\0", " ") + "|");
					System.out.println(a[1]);
				}
			}

			while (!(Integer.toHexString(DATAONE).equals("0x2b") && (read)
					&& Integer.toHexString(reg).equals("0xa6"))) {

				System.out.println(System.currentTimeMillis());
				try {
					Thread.sleep(1);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}

		} catch (Exception e) {
			while (true) {
			}
		}

	}
}

Provalo online!

— tuskiomi
fonte
Due argomenti vuoti sembrano funzionare
— Okx,
Inoltre, ti va di aggiungere un link tio? Penso che tutto ciò che dovresti fare è cambiare main in Main
— Okx
1
Incrinato , a parte un insetto.
— user3033745
Cracked - nessun bug specifico della versione.
— Okx,
3

Braingolf , 18 byte Incrinato

1+[#£-0!e>:$_1>|]

Provalo online!

Po Liiiitle più difficile di quanto l'ultimo, io iniziare a scrivere un vero e proprio uno dopo questo

La risposta è 163

— Skidsdev
fonte
Amico, questo è probabilmente l'unico atm di sottomissione sopravvissuto. Nota: inon funziona.
— Erik the Outgolfer,
Attenzione: in realtà si tratta di 19 byte ( £). E perché non -1funziona? Questo è difficile.
— Erik the Outgolfer,
@EriktheOutgolfer Ha 17 caratteri e 18 byte.
— totalmente umano il
@totallyhuman Giuro che avevo letto "19 UTF-8 byte, 18 caratteri" (lo script utente è abilitato) ...
— Erik the Outgolfer
— Adnan,
3

JavaScript (ES7), 41 byte ( compromesso e crackato )

Modifica: risolto per evitare che si blocchi in modo anomalo quando non viene dato alcun input (grazie @totallyhuman per averlo notato)

Probabilmente esistono diverse soluzioni, ma quella prevista è relativamente semplice.

(x=0)=>{for(;~x/x.length**3!=-2962963;);}

Soluzione prevista:

"8e7" (un numero nella notazione scientifica passato come una stringa)
Perché: ~ "8e7" / "8e7" .length ** 3 = -80000001 / 3 ** 3 = -80000001/27 = -2962963

— Arnauld
fonte
2
Nessun input funziona anche su questo, ma non voglio preoccuparmi di romperlo in quel modo ... A meno che non sia questa la soluzione prevista. : P
— totalmente umano il
@totallyhuman Beh, non è la soluzione prevista. :-)
— Arnauld
— Евгений Новиков
2
Aggiornamento: è stata progettata una soluzione lunga 3 byte
— вгений Новиков
3

Bash + Utils (Cracked by Dennis), 74 byte

Spero che ti piaccia tar, perché è l'unica utility che puoi usare.

cp /bin/tar .
env -i PATH=$PWD I=$? /bin/bash -r -c "$1"
while :;do :;done

Provalo online!

Crepa prevista

tar -cf --checkpoint=1 --checkpoint-action=exec="/bin/kill $I" .

— Sisifo
fonte
1
— Dennis il
@Dennis Nice! Ho pubblicato la mia crack prevista, che era un po 'più complessa.
— Sisifo,
3

Mathematica, 36 26 byte ( crackato )

#0[#;$IterationLimit=∞]&

Un ciclo molto breve #0[#;∞]che continuerà a funzionare da solo finché non si arresta in modo anomalo nel kernel ... ( $IterationLimitÈ solo per essere sicuro di rimanere bloccato per sempre per la maggior parte degli input).

Provalo su Wolfram Sandbox! - se sei bloccato in un ciclo infinito, puoi aspettare fino al timeout oppure puoi premere l'icona quadrata "interrompi valutazione" a sinistra del titolo del blocco note (unnamed).

NOTA : questa funzione modifica le $IterationLimitimpostazioni.

— JungHwan Min
fonte
— Martin Ender,
3

C #, 118 byte ( crackato )

using System;_=>{while(1>0){try{if(Nullable.GetUnderlyingType(Type.GetType(Console.ReadLine()))!=null)break;}catch{}}}

Non mi aspetto che duri troppo a lungo, ma è più imbarazzante di quanto sembri.

Fondamentalmente qualsiasi nome completo delle classi Nullable funziona, ma è strano scoprirlo come sembra il seguente:
System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]
Un modo più semplice per scoprire questa stringa è fare typeof(int?).FullName.

— TheLethalCoder
fonte
— Luc
3

C, 140 byte ( crackato )

n,i;f(){float x,y,z;for(scanf("%d %d",&n,&z,x=y=0);~((int)x-(int)(1/sqrt(y*2)));x*=(1.5-y*x*x))y=(x=z)/2,i=n-((*(int*)&x)/2),x=*(float*)&i;}

Si spera che non ci siano troppi input nemmeno vicini agli obiettivi che lo fermano, ma vediamo.

Provalo online!

— Steadybox
fonte
— Veedrac,
3

JavaScript (ES7), 73 byte ( Cracked !)

q=>{r=(n,i=0)=>i>1e3?n:r(n*16807%(2**31-1),i+1);while(r(q)!=627804986){}}

Soluzioni non desiderate: forza bruta. Il crack desiderato coinvolge la matematica.

Si noti che ci sono molte soluzioni (4194304) a causa del modulo.

— iovoid
fonte
1
— Veedrac,
3

Brainfuck , 170 byte incrinati!

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

Provalo online!

— Jerry
fonte
Benvenuti nel sito! È possibile salvare 11 byte rimuovendo le nuove righe dal codice.
— Wheat Wizard
Ho dimenticato che era il golf del codice, grazie!
— Jerry,
— user202729
Soluzione valida! Stimo che ce ne sono parecchi. Per chiunque risolva / bruti forzatamente, quello previsto è [az].
— Jerry,
Per ogni 4 caratteri, esiste esattamente 1 valore dell'ultimo carattere che interrompe il programma. Pertanto ci sono 256 ^ 4 = 4294967296 soluzioni supponendo che tu possa entrare nulin brainfuck. A proposito, puoi rimuovere due primi >2 byte di salvataggio.
— user202729
3

JavaScript ES6 (Node.js> = 6.0) , 326 byte (Sicuro)

((v,e=require('events').EventEmitter.prototype,l=_=>{while(1);},P=Proxy,p=process)=>(p.kill=p.exit,e.listeners=new P(e.listeners,{apply:(t,c,a)=>a[0]=='exit'?[]:t.apply(c,a)}),e.removeAllListeners=new P(e.removeAllListeners,{apply:(t,c,a)=>a[0]=='exit'?c:t.apply(c,a)}),p.on('exit',l),i=>{try{v(i)}catch(o){}l()}))(s=>eval(s))

Molto più semplificato dell'altra mia sfida , non sto più cercando di offuscare l'approccio per la soluzione, che mi ha fatto risparmiare un sacco di byte. Questa volta, process.kill()non funzionerà.

"delete process._events.exit;process.exit()"

Provalo online!

— Patrick Roberts
fonte
Woah! Bel lavoro!
— programmatore
Sembra che tu sia il vincitore, anche se mi aspettavo un codice molto più breve hehe
— Piyin
3

Swift 3, 14 byte ( crackato )

while !false{}

Per risolvere questo problema, inserisci il tuo codice prima o dopo questa affermazione.

  • La tua soluzione deve:
    • mantenere intatta questa affermazione, senza modificarne il codice
    • lascia effettivamente correre questa affermazione
      • Semplicemente commentandolo, chiamando fatalError(), ecc. Prima che non conti.
    • modificare il comportamento di questa istruzione per impedirne il looping per sempre
  • La soluzione non comporta l'arresto anomalo del programma.
— Alessandro
fonte
Non conosco Swift, ma penso che l'aggiunta di un timer prima di uscire da questo codice dopo alcuni secondi soddisfi i criteri.
@Yimin heh, intelligente, ma non modifica la semantica di questa affermazione, che è quello che stavo davvero cercando quando ho detto "modifica il comportamento di questa affermazione"
— Alexander
Sei sicuro che la soluzione funzioni? L'interprete ambiguous semanticsmi sta urlando .
— Daniel,
@Dopapp è quello che pensavo sarebbe successo nel mio precedente tentativo. Per qualche motivo, è legale ridefinire i nuovi operatori infix con firme dello stesso tipo di quelli già esistenti, ma il tentativo di fare lo stesso con un operatore unario genera un errore di ambiguità durante la compilazione. Questo è intenzionale e sono sicuro di avere una soluzione funzionante
— Alexander,
— Veedrac,
2

cQuents , 2 byte ( Cracked 1 ) ( Cracked 2 )

:A

Si noti che questo colpirà rapidamente il limite di uscita di 128 KiB su TIO, causandone l'arresto, ma quando eseguito localmente verrà ripetuto per sempre, tranne sull'input che lo rompe. Trovare quell'input dovrebbe essere abbastanza facile. Fino a quando non lo fai,:A continuerai a sporgerti la lingua triangolare.

Nota anche che questo dovrebbe essere giusto, Ama ieri sera ho rotto le modalità implicite. Nelle versioni precedenti dell'interpreteA funzionerebbe bene.

crepe:

L'input vuoto / newline sull'input è un crack valido. Tuttavia, escludendo che, passando più ingressi (separati dallo spazio) al programma, lo terminerai (se dai 2) o sbaglierai (se dai 3 o più).

Provalo online!

— Stefano
fonte
Cracked? (Errori con input vuoto)
— Luis Mendo,
— Kritixi Lithos,
@crackers sì, è una crepa valida. Darò il mio voto a qualcuno che trova il crack di input non vuoto.
— Stephen,
— PurkkaKoodari,
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.