Inspiré par ce commentaire ...

Merci aux utilisateurs Step Hen , Wheat-Wizard et Dennis de m'aider à préciser les spécifications de ce défi avant de le poster!

C'est le fil des flics. Pour le fil des voleurs, allez ici

Dans ce défi , vous êtes chargé d’exécuter du code qui fait en sorte que votre langage ne réponde plus à nos critères de programmation. Dans ce défi, cela signifie faire en sorte que la langue ne puisse plus ...

• Prendre des entrées et des sorties numériques

• Ajouter deux nombres ensemble

• Testez si un certain nombre est un nombre premier ou non.

C'est un flics et voleurs défi, où il y a deux défis différents avec deux objectifs différents: les Cops vont essayer d'écrire un code qui rend la langue la plupart du temps inutilisable, et les voleurs vont essayer de trouver la solution cachée qui permet aux flics pour récupérer leur langue.

En tant que flic, vous devez écrire deux extraits de code:

1. Celui qui rend votre langue pratiquement inutilisable, par exemple en supprimant les fonctions intégrées pour effectuer des opérations d’entrée / sortie et des opérations numériques. Plus vous supprimez de fonctionnalités, mieux ce sera. Ce code n'est pas autorisé à planter ou à sortir. Il devrait être possible d'ajouter du code à la fin de cet extrait, et ce code sera évalué . Et...

2. ... un extrait de code qui prend deux entiers non négatifs en entrée, les additionne et génère leur somme. Cet extrait doit toujours fonctionner correctement, même après l'exécution du premier extrait. Lorsque les deux extraits sont combinés, ils doivent former un programme complet qui ajoute deux nombres ou définir une fonction qui ajoute deux nombres. Idéalement, cet extrait devrait s’appuyer sur un comportement très obscur, afin d’être plus difficile à trouver.

Vous pouvez choisir n’importe quelle méthode standard d’entrée et de sortie . Cependant, vous devez indiquer exactement le format (entrée et sortie) que vous utilisez. Un voleur ne peut pas déchiffrer votre réponse à moins d’utiliser le même format que vous.

Après avoir écrit ces deux extraits, vous devez poster le premier comme réponse, sans révéler le second. Votre réponse devrait contenir toutes les informations suivantes:

• Le premier extrait (évidemment pas le second).

• Langue (y compris la version mineure, car la plupart des soumissions s'appuieront probablement sur des cas marginaux étranges)

• Format IO, qu'il s'agisse d'une fonction ou d'un programme complet. Les voleurs doivent utiliser le même format pour que leur crack soit valide.

• Tous les cas étranges requis pour que votre réponse fonctionne. Par exemple, ne fonctionne que sur Linux ou nécessite une connexion Internet . Évidemment, ceci est légèrement subjectif, mais si un policier a un cas extrême qui l’empêche de se fendre, et ne le révèle alors qu’après avoir été en sécurité, j’envisage cet esprit sportif médiocre. Un cambrioleur potentiel devrait avoir toutes les informations nécessaires pour déchiffrer votre réponse avant qu'elle ne soit fissurée.

Vous n'avez pas besoin de révéler le nombre d'octets jusqu'à ce que votre réponse soit sécurisée.

Voici un exemple. Pour le premier extrait, vous pouvez soumettre le programme Python 3 suivant:

Python 3

print=None

Prend une entrée de STDIN et une sortie vers STDOUT

Et comme deuxième extrait, vous pourriez écrire:

import sys
a,b=int(input()),int(input())
sys.stdout.write(a+b)

Ceci est valide car il faut entrer deux nombres et générer leur somme même si vous joignez les deux extraits, par exemple:

print=None
import sys
a,b=int(input()),int(input())
sys.stdout.write(a+b)

Cependant, il sera extrêmement facile pour un voleur de trouver une solution. Comme ce serait très facile à craquer, vous pourriez essayer de corriger cette approche particulière comme ceci:

import sys
sys.stdout=None
print=None

Cependant, même cela a une solution très simple:

del print
a,b=int(input()),int(input())
print(a+b)

En tant que policier, votre objectif est de rendre la solution de contournement cachée aussi obscure que possible, afin d’empêcher les voleurs de la trouver.

Les voleurs examineront l'une de vos réponses et tenteront de la résoudre. Ils peuvent le déchiffrer en écrivant un extrait valide qui pourrait fonctionner en tant qu'extrait 2 (en ajoutant deux nombres ensemble une fois que la langue est pratiquement inutilisable). Cela ne doit pas forcément être le même extrait que celui que vous aviez initialement prévu. Si un voleur déchiffre votre réponse, il laissera un commentaire, et vous devrez ensuite le modifier pour indiquer qu'il a été fissuré. Si votre message est fissuré, vous devez modifier votre réponse pour afficher la solution (extrait 2) initialement envisagée. Ce n'est pas une règle en soi , mais une suggestion amicale de garder le jeu amusant. Tu n'as pas à.

Si une réponse reste non masquée pendant une semaine entière, vous pouvez modifier votre deuxième extrait et indiquer que votre réponse est maintenant sûre . Si vous ne le modifiez pas à la fin de la semaine, les autres utilisateurs peuvent le résoudre jusqu'à ce que vous le fassiez. Si vous ne divulguez pas votre deuxième extrait, vous ne pouvez pas réclamer de points pour votre réponse, ni l'appeler en toute sécurité.

Le gagnant du fil des flics est la réponse la plus courte et la plus sûre, y compris les deux extraits , comptés en octets, et cette réponse sera acceptée après un délai suffisant. Vous n'avez pas besoin de révéler votre nombre d'octets jusqu'à ce que votre réponse soit sécurisée, car le nombre d'octets n'est pas pertinent pour votre score jusqu'à ce que votre réponse soit sûre. Si suffisamment de temps s’est écoulé et qu’aucune réponse n’est restée non fissurée, le gagnant sera la réponse restée non fissurée pendant la plus longue période.

S'amuser!

Clarifications de règles

• Le premier extrait doit fonctionner correctement sans aucune entrée . Il peut produire ce que vous voulez et cette sortie sera ignorée - tant que, une fois l'extrait de code créé, le deuxième est correctement exécuté.

• Le deuxième extrait doit en réalité être exécuté pour que votre réponse soit valide. Cela signifie une réponse comme

  import sys
  sys.exit()
  

  n'est pas valide car cela ne casse pas la langue. Il se ferme tout simplement. De même, entrer dans une boucle infinie n'est pas valide, car le deuxième extrait ne sera jamais exécuté.

• Après avoir été en sécurité, votre score correspond au nombre d'octets des deux extraits .

• Cela remonte à Veuillez révéler tout cas étrange requis pour votre réponse au travail ... Votre soumission doit contenir suffisamment d'informations avant d' être révélée pour être reproductible après avoir été révélée. Cela signifie que si votre réponse devient sûre, et que vous modifiez ensuite: voici ma réponse. Oh, BTW, cela ne fonctionne que si vous l'exécutez sur Solaris, la blague est sur vous! votre réponse est invalide et sera supprimée et non considérée comme éligible pour gagner.

• Le deuxième fragment de code est autorisé à se bloquer après la sortie de la somme - tant que la sortie est toujours correcte (par exemple, si vous choisissez une sortie sur STDERR et que vous obtenez alors une foule d'informations sur le blocage, elles ne sont pas valides).

• Vous ne pouvez pas modifier votre code après avoir soumis une réponse.

• Vous ne pouvez pas compter sur des fonctions cryptographiques telles que le cryptage, les fonctions de hachage, les CSPRNG, etc.

Extrait pour trouver des soumissions non fissurées:

<script>site='meta.codegolf';postID=5686;isAnswer=false;QUESTION_ID=133174;</script><script src='//ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script><script>jQuery(function(){var u='//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>

Gforth 0.7.3 (TIO) , 231 octets [SAFE]

Ce code redéfinit comme inutiles certaines méthodes de sortie nécessaires, ainsi que des ajouts et des éléments cruciaux pour la déclaration de fonctions. Bonne chance!

: . ;
: dec. ;
: u. ;
: .r ;
: u.r ;
: d. ;
: ud. ;
: d.r ;
: ud.r ;
: emit ;
: type ;
: + postpone 2drop ;
: ; + + + postpone exit reveal postpone [ ;

L'entrée consistera en deux entiers signés pris du haut de la pile en tant que paramètres de fonction. Sortie sur STDOUT.

Vous devez donc réparer les dégâts et définir une fonction qui extrait les deux premières valeurs de la pile et affiche le résultat sous forme d’entier (et non de float) sur STDOUT sans sortie supplémentaire (sans espace de fin).

Voici un modèle , si votre fonction d'objectif est nommée f.

Solution:

79 octets,

j'ai effectivement supprimé le immediatemot - clé de la fin de la redéfinition de ;. Il était donc nécessaire pour une réponse de l'inclure au début. La fonction que j'ai définie est essentiellement équivalente à la définition interne de ., mais elle n'imprime pas d'espace à la fin et l'ajout est effectué en premier, en déplaçant les nombres vers la pile à virgule flottante et vice-versa.

immediate : f s>f s>f f+ f>d swap over dabs <<# #s rot sign #> (type) #>> 0 0 ;

Essayez-le en ligne

Haskell, fissuré par Christian Sievers

import Prelude(getLine,print)
a=a

Programme complet, lisant deux nombres entiers (y compris des négatifs) de stdin et écrivant sur stdout.

Je viens de désactiver le prélude, donc presque rien n’est dans la portée, puis j’ai ajouté une définition; les importations supplémentaires sont syntaxiquement non valides. Je vous ai donné getLineet printbien.

Édité pour ajouter ma solution originale. La fissure de Christian était différente, mais exploitait les mêmes fonctionnalités de base (vous pouvez obtenir une quantité de calcul étonnante en accédant à des fonctions contenant du sucre syntaxique, même lorsque vous ne pouvez pas appeler directement un élément intégré ni même nommer les types impliqués).

import Prelude(getLine,print)
a=a
(x:l)!0=x
(x:l)!n=l!d[0..n]
d[x,y]=x
d(x:l)=d l
x^y=[x..]!y
x+y=f[0..y](x^y)(-((-x)^(-y)))
f[]x y=y
f _ x y=x
f.g= \x->f(g x)
f&0= \x->x
f&n=f.(f&d[0..n])
x*y=((+x)&y)0
x%[]=x
x%('-':s)= -(x%s)
x%(c:s)=x*10+i c%s
i c=l['1'..c]
l[]=0
l(x:s)=1+l s
main=do
 x<-getLine
 y<-getLine
 print((0%x)+(0%y))

Ce qui n'est probablement pas super-golfé de toute façon, mais ici, il est plus lisible:

import Prelude(getLine,print)
a=a

-- List indexing
(x : _) !! 0 = x
(_ : xs) !! n = xs !! (sndLast [0..n])

-- sndLast [0..n] lets us decrement a positive integer
sndLast [x, _] = x
sndLast (_ : xs) = sndLast xs

-- Pseudo-addition: right-operator must be non-negative
x +~ y = [x..] !! y

-- Generalised addition by sign-flipping if y is negative
x + y = switch [0..y] (x +~ y) (-((-x) +~ (-y)))
  where switch [] _ empty = empty   -- [0..y] is null if y is negative
        switch _ nonempty _ = nonempty

f . g = \x -> f (g x)

-- compose a function with itself N times
composeN f 0 = \x -> x
composeN f n = f . (composeN f (sndLast [0..n]))

-- multiplication is chained addition
x * y = composeN (+x) y 0

strToNat acc [] = acc
strToNat acc ('-' : cs) = -(strToNat acc cs)
strToNat acc (c : cs) = strToNat (acc * 10 + charToDigit c) cs

charToDigit c = length ['1'..c]

length [] = 0
length (_ : xs) = 1 + length xs

main = do
  x <- getLine
  y <- getLine
  print (strToNat 0 x + strToNat 0 y)

Python 2 , fissuré

Implémente l'addition en tant que fonction nommée

import sys
c="".join(open(__file__).read().split('\n')[4:])
if set(c)-set(' &)(,.:[]a`cdfijmonrt~')or"import"in c:sys.setrecursionlimit(1)
f=lambda\

Essayez-le en ligne!

Qu'est-ce que cela fait?

Afin de vous aider un peu, je vais expliquer ce que cela fait. Ce code ouvre le fichier source et vérifie si le reste du code correspond aux critères suivants:

• Ne contient pas la chaîne import
• Est composé uniquement des personnages &)(,.:[]a`cdfijmonrt~

En cas d'échec de l'un ou l'autre critère, la limite de récursivité est définie pour 1signifier que tout code que vous écrivez atteindra la limite de récursivité.

Il n’ya aucune astuce ici, j’ai écrit une solution qui utilise uniquement ces caractères et aucune importation. Je ne fais rien de subversif, mais je dirai que je pense que ce sera assez difficile à résoudre.

Pour vous faire gagner du temps, voici une courte liste de choses utiles que vous ne pouvez pas faire avec cette restriction.

• + bien duh,

• eval/ execJe n'allais pas te laisser sortir avec ça

• Les nombres, ils pourraient être plus utiles que vous ne le pensez

• Littéraux de chaîne

• len

• =, Aucune variable d'affectation

• >, <, ==. . . Je vous ai laissé sans comparaisons

• *, -, /, %, ^, |, >>, << Les seuls opérateurs disponibles sont ~et&

• __foo__Aucune de ces méthodes de double soulignement sophistiquées n'est autorisée.

Python 2 , fissuré

Ceci est la quatrième itération de cette réponse. Chacune des dernières réponses a été fissurée via la réinitialisation de la profondeur de récursivité.

Implémente l'addition en tant que fonction nommée

import sys
if set("".join(open(__file__).read().split('\n')[4:]))-set(' &)(,.:[]a`cdfijmonrt~'):sys.setrecursionlimit(1)
for m in sys.modules:sys.modules[m]=None
del sys;f=lambda\

Essayez-le en ligne!

Qu'est-ce que cela fait?

Afin de vous aider un peu, je vais expliquer ce que cela fait. Ce code ouvre le fichier source et vérifie si le reste du code est composé uniquement de caractères &)(,.:[]a`cdfijmonrt~

En cas d'échec, la limite de récursivité est définie pour 1signifier que tout code que vous écrivez atteindra la limite de récursivité.

J'ai également désactivé tous les modules, vous ne pouvez donc rien importer.

Il n’ya aucune astuce ici, j’ai écrit une solution qui utilise uniquement ces caractères et aucune importation. Je ne fais rien de subversif, mais je dirai que je pense que ce sera assez difficile à résoudre.

Pour vous faire gagner du temps, voici une courte liste de choses utiles que vous ne pouvez pas faire avec cette restriction.

• + bien duh,

• eval/ execJe n'allais pas te laisser sortir avec ça

• Les nombres, ils pourraient être plus utiles que vous ne le pensez

• Littéraux de chaîne

• len

• =, Aucune variable d'affectation

• >, <, ==. . . Je vous ai laissé sans comparaisons

• *, -, /, %, ^, |, >>, << Les seuls opérateurs disponibles sont ~et&

• __foo__Aucune de ces méthodes de double soulignement sophistiquées n'est autorisée.

Ma solution

Alors maintenant que xnor a résolu le problème de manière suffisamment satisfaite, je vais révéler ma solution

r,o:(o and f(~(~r&~o)&~(r&o),int(`r`[:r&~r].join([`dict()`[r&~r],`r&~r`,`dict([(r&~r,r&~r)])`[int(`~([]in[[]])`[[]in[[]]:])],`min`[[]in[[]]],`dict()`[~(r&~r)],`r&~r`]).format(r&o),int(`~([]in[[]])`[[]in[[]]:]))))or r

Surprise, surprise, c'est un tas de charabia. Plutôt que de décomposer cela, je vais passer en revue le processus de création de ce document.

J'ai commencé avec un algorithme d'addition assez standard

r,o:(o and f(r^o,r&o<<1))or r

Ensuite , j'ai utilisé une astuce pour représenter au niveau du bit ^avec |, &, ~.

r,o:(o and f((r|o)&~(r&o),r&o<<1))or r

J'ai utilisé un autre truc au bitwise pour me débarrasser de la |

r,o:(o and f(~(~r&~o)&~(r&o),r&o<<1))or r

Maintenant tout ce qui reste est la <<, ne devrait pas être trop dur, non? Eh bien préparez-vous pour un trajet cahoteux. Pour remplacer le bitshift, j'ai utilisé des chaînes pour ajouter un zéro à la fin de sa représentation binaire

r,o:(o and f(~(~r&~o)&~(r&o),int(bin(r&o)[2:]+"0",2)))or r

Cela pose quelques problèmes, mais le principal utilise l'addition . J'ai donc résolu ce problème en utilisant plutôt un format.

r,o:(o and f(~(~r&~o)&~(r&o),int("{}0".format(bin(r&o)[2:]),2)))or r

Nous ne sommes pas autorisés à utiliser bin. J'ai donc utilisé le formatage de chaîne pour convertir en binaire.

r,o:(o and f(~(~r&~o)&~(r&o),int("{0:b}0".format(r&o),2)))or r

Depuis que les littéraux de chaîne sont interdits, je dois construire la chaîne à {0:b}0partir de parties faites avec des ticks arrière et joinles assembler.

r,o:(o and f(~(~r&~o)&~(r&o),int("".join(["{","0",":","b","}","0"]).format(r&o),2)))or r

La chaîne vide est assez facile, vous pouvez juste faire

`r`[:0]

Les zéros étaient

`0`

et ils {:}ont tous été saisis dans des dictionnaires.

r,o:(o and f(~(~r&~o)&~(r&o),int("".join([`dict()`[0],`0`,`dict([(0,0)])`[2],"b",`dict()`[-1],`0`]).format(r&o),2)))or r

bsemble assez difficile à obtenir, ce n'est pas dans notre jeu de caractères, alors comment sommes-nous censés obtenir un objet qui a un bdans son repr? Eh bien voici comment: lorsque vous utilisez reprune fonction intégrée, vous obtenez quelque chose qui ressemble à

<built-in function name>

Et c’est d’où nous allons chercher notre b.

r,o:(o and f(~(~r&~o)&~(r&o),int("".join([`dict()`[0],`0`,`dict([(0,0)])`[2],`min`[1],`dict()`[-1],`0`]).format(r&o),2)))or r

Maintenant tout ce qui reste sont des nombres, je n'ai besoin que de -1, 0, 1 et 2 alors voici comment je les ai représentés:

-1 = ~(r&~r)
 0 = r&~r
 1 = []in[[]]
 2 = `~([]in[[]])`[[]in[[]]:]

2 pourrait en fait être un octet plus court

```r&~r```.find(`r&~r`)

sur la base des suggestions de @ Blender dans les commentaires, mais je n'y ai pensé qu'après coup.

Nous substituons donc ces chiffres dans

r,o:(o and f(~(~r&~o)&~(r&o),int(`r`[:r&~r].join([`dict()`[r&~r],`r&~r`,`dict([(r&~r,r&~r)])`[int(`~([]in[[]])`[[]in[[]]:])],`min`[[]in[[]]],`dict()`[~(r&~r)],`r&~r`]).format(r&o),int(`~([]in[[]])`[[]in[[]]:]))))or r

Et c'est la fissure.

C (gcc) fissuré!

#define D(f)void f(void);
D(printf)D(fprintf)D(putc)D(puts)D(getchar)D(putc)D(fputc)D(ferror)D(feof)D(read)D(fclose)D(fread)D(wr1te)D(fgets)D(fgetc)D(popem)D(gets)D(read)D(scanf)D(setbuf)D(execl)D(execlp)D(putchar)D(execle)D(execv)D(malloc)D(execvp)D(execvpe)D(exec)D(system)D(close)D(fwrite)D(open)D(free)
int stdin;
int main(){
//your code goes here...hehe
}

Essayez-le en ligne!

Entrée de STDIN et sortie sur STDOUT.

Cela fonctionne sans erreur. Hahaha c'est tout à fait mal. Je l'ai seulement testé sur le gcc de TIO. Comme d'habitude, vous devez ajouter votre code après cet extrait pour que cela fonctionne :) Le commentaire est méchant, ne l'écoutez pas.

Testé sur gcc (GCC) 6.3.1 20161221 (Red Hat 6.3.1-1). Devrait fonctionner sur n'importe quel système Linux.

Solution originale

#define D(f)void f(void);
D(printf)D(fprintf)D(putc)D(puts)D(getchar)D(putc)D(fputc)D(ferror)D(feof)D(read)D(fclose)D(fread)D(wr1te)D(fgets)D(fgetc)D(popem)D(gets)D(read)D(scanf)D(setbuf)D(execl)D(execlp)D(putchar)D(execle)D(execv)D(malloc)D(execvp)D(execvpe)D(exec)D(system)D(close)D(fwrite)D(open)D(free)
int stdin;
int main(){
//your code goes here...hehe
}
void __attribute__ ((destructor)) dtor() {
    int a,b,c,d;a=b=c=0;
    struct FILE* z = popen("cat", "r");
#define q(x)for(;(c=getc(z))^32&&c^-1;)x=10*x+c-48;
q(a);q(b);
    char*y=calloc(c=a+b,1);
    for(a=0;c;){y[a++]=(48+(c%10));c=c/10;}
    for(b=0;b<a/2;b++){d=y[b];y[b]=y[a-b-1];y[a-b-1]=d;}
    write(1,y,a);
}

C (GCC sous Linux) (fissuré)

Au lieu d'utiliser des techniques de bac à sable idiotes pour la lecture de fichiers, nous le faisons correctement - avec la liste blanche de SECCOMP!

Votre tâche: implémenter l’ajout avec entrée de STDIN et sortie vers STDOUT.

#include <stdlib.h>
#include <unistd.h>
#include <sys/prctl.h>
#include <linux/seccomp.h>
#include <syscall.h>
#include <stdio.h>
void sandbox();
__attribute__ ((constructor(0))) int s() {
    close(0);
    close(1);
    close(2);
    prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT);
}
int main() {
    sandbox();
    syscall(SYS_exit, EXIT_SUCCESS);
}
void sandbox() {
    // Your code here!
}

Essayez-le en ligne!

WTF est-ce !?

Pour vous aider dans votre tâche insurmontable, je vais vous expliquer ce que fait ce code.

__attribute__ ((constructor(0)))assure que la sfonction est exécutée en premier. La fonction ferme tous les descripteurs de fichiers ouverts pour STDIN, STDOUT et STDERR. Ensuite, le programme se limite à une liste blanche stricte SECCOMP, qui limite vos appels système aux éléments suivants:

read(2)
write(2)
_exit(2)
sigreturn(2)

Par conséquent, vous ne pouvez pas ouvrir de nouveaux fichiers (ou faire quoi que ce soit). Nous arrivons ensuite à main et appelons votre code, bien emballé dans la sandboxfonction.

En syscall(SYS_exit, EXIT_SUCCESS);fin de compte, il s’agit simplement de s’assurer que le programme se ferme proprement - par défaut, GCC se fermera avec exit_group(2)ce qui n’est pas autorisé par la liste blanche SECCOMP. Cette fonction existante est appelée après l' exécution de votre code.

Donc, vous n'avez aucun descripteur de fichier ouvert et vous ne pouvez rien ouvrir de nouveau. Impossible, non? ;)

Haskell , fissuré par Ben

main=main--

Essayez-le en ligne! Cela devrait être un programme complet lisant deux nombres de stdin et sortant la somme sur stdout.

Chaque programme complet commence par exécuter la mainfonction, mais ici mains’appelle et provoque une boucle infinie. Pour aggraver les choses, un commentaire de ligne est démarré avec --directement derrière l'appel récursif afin d'éviter de le modifier, par exemple main2, puis de le définir pour effectuer la somme.

Solution envisagée:

main=main--$()
_ --$ _ = do
     x <- readLn
     y <- readLn
     print $ x+y

Essayez-le en ligne!

--démarre un commentaire de ligne sauf s'il peut également être analysé dans le cadre d'un opérateur. (La syntaxe en surbrillance semble ignorer ce fait.) --$Est un opérateur infixe valide qui prend maincomme premier argument et un second argument factice (). Il est ensuite défini pour ignorer les deux arguments et pour effectuer la tâche requise à la place.

Assemblage en mode réel x86 16 bits ( fissuré )

_main:
    call l
    cli
    hlt
l:  pop si
    xor ax, ax
    mov bp, cs
    mov es, ax
    mov di, 12
    mov [di], si
    mov [di + 2], bp
    pushf
    mov bp, sp
    or word [bp], 256
    popf

Facile si vous connaissez le truc.

Javascript, fissuré

Ce défi est basé sur celui de Grant Davis , mais il résout la solution à laquelle il pensait (ce qui crée un iframe et utilise celui-ci window). La solution s'exécute dans la console javascript sous Chrome about:blank page, en prend deux input(), les additionne et donne console.logle résultat. Mettez votre code après:

d=prompt=console=document;new MutationObserver(s=>s.forEach(e=>{t=e.target;t.parentNode.removeChild(t)})).observe(d,{"childList":d, "subtree":d})

Tout d'abord, nous clobber promptet consoleet définir le raccourci d. Ensuite, nous créons un observateur de mutation avec un rappel qui supprime chaque cible mutée. Nous configurons l'observateur de la mutation pour qu'il observe le document et le notifie childListainsi que les subtreemodifications. Au lieu du littéral true, nous utilisons notre raccourci vers la valeur de vérité document(la spécification ne le permet pas, mais chrome le permet).

Après avoir posté ceci, j'ai réalisé un clobber beaucoup plus élégant. Ma solution prévue fonctionne toujours, mais la fissure affichée ne:

 h=document.querySelector("html");h.parentNode.removeChild(h);

Perl 5, fissuré par Ilmari Karonen

$_=<DATA>;
s/[+'{dPz|K.UD!_ iJ;o}e6tjWb7253k@%&Iq4l0AN:?\$8B`Yywn9^pfmZQTF"M#-]//g;
eval;
print@_,$!,pop,shift,<>,eval"@>",$\,@ARGV,eval"@$",$@,eval"@@",$,,eval"@,",$/
__DATA__

L'entrée est reçue sur des lignes séparées STDINet la sortie est imprimée STDOUT.

Tout le code va après le __DATA__marqueur. Ceci utilise une méthode similaire à la solution de @ WheatWizard en ce sens que le code est analysé et que les caractères inutilisables sont supprimés.

Cela a été testé sur les versions 5.8, 5.10 et 5.16 et ne nécessite aucun indicateur de ligne de commande.

Essayez-le en ligne!

Python 3, fissuré par zbw

import sys
for mod in sys.modules.values():mod.__dict__.clear()
1+1

Tous les modèles ont été supprimés, ce qui signifie qu’il n’ya pas de fonctions intégrées disponibles et qu’il est impossible de faire beaucoup plus. Sortie sur STDOUT, entrée de STDIN. Ceci est la deuxième itération de cette réponse après que la précédente a été cassée par une fissure triviale en ajoutant une instruction break.

APL (ngn-apl) , fissuré par ngn

Fabriqué en coopération avec mon collègue Marshall .

Entrer par les arguments gauche et droit à +. Par exemple, votre objectif est d’insérer le code après le texte suivant, de sorte que votre dernière ligne soit lue ⎕←3+2et sortie 5vers STDOUT.

+←-←−←⍴←≢←≡←⊥←⊤←⍟←○←⍳←⌹←~←∈←∊←⍷←<←≤←=←≥←>←≠←,←⍪←⌷←⌽←⍉←⊖←{}⋄⍣←∘

Essayez-le en ligne!

Fonctionne en définissant toutes les fonctions utiles {}qui prennent un ou deux arguments et renvoient une liste numérique vide. Définit également ⍣pour composer uniquement des fonctions.

Fissure

+←{⌈/⍋⍺⍵1/0}

⍺⍵1/0 répliquer 0 par l'argument gauche et l'argument droit et 1

⍋ obtenir les indices qui trieraient cela (puisque tous les éléments sont nuls, cela donne 0 1 2… (a + b)

⌈/ la valeur maximale (a + b)

Python 2 , fissuré

Ceci est la deuxième itération d'une réponse qui a été craquée une fois par @HyperNuetrino en utilisant une méthode à laquelle je ne m'attendais pas. Je l'ai maintenant corrigée alors j'espère que les seules solutions restantes devront respecter les restrictions que je voulais.

Implémente l'addition en tant que fonction nommée

import sys
c="".join(open(__file__).read().split('\n')[4:])
if set(c)-set(' &)(,.:[]a`cdfijmonrt~')or"import"in c:sys.setrecursionlimit(1)
sys.modules['sys'],sys.modules['os']=None,None;del sys;f=lambda\

Essayez-le en ligne!

Java 8, fissuré par @ OlivierGrégoire

Voici ma tentative. En gros, l’idée est de simplement surcharger tous les espaces de noms que vous pouvez utiliser pour afficher (et refléter, j’espère). La sortie est destinée à sdout (System.out).

class java {
    public static void main(String[]s){
       //there is no executable code in snippet one.
       //your code here.
    }
    class Class{}
    class Method{}
    class System{}
    class FileDescriptor{}
    class Logger{}
    class Runtime{}
    class Scanner{}
}

Les listes noires sont généralement une approche pire que les listes blanches, alors je suis sûr que ce n'est qu'une question de temps avant que quelqu'un propose une approche que je n'ai pas envisagée.

queues, fissuré par Mayube

#|1,1:A

Cela devrait être assez facile, mais on ne sait jamais.

Le "problème" était que sans Cvotre code, vous aviez une erreur.

La solution de Mayube:

#|1,1:A+BC

Chaque élément de la séquence est la première entrée plus la deuxième fois la troisième (ou 1)

Mes solutions:

#1,1:A+B,C

La séquence alterne entre la première entrée plus la deuxième entrée et la troisième entrée (1). Le premier élément dans le second est A+B.

#1,1:A+B+C-C

Semblable à la solution de Mayube - au lieu de multiplier B*C, ajoute Cet soustrait ensuite.

Essayez-le en ligne!

Explication

#|1,1      Append 1 and 1 to the end of the user's input
     :     Set mode to : (sequence 1: if given n, output nth term in sequence; if given no n, output whole sequence)
      A    Each item in the sequence equals the first input

Actuellement, ce programme génère des sorties 1, car sans entrée d'utilisateur, la première entrée est la première 1de l'entrée par défaut ( #).

Node.JS version 7.3.0 (fissuré par Dom Hastings)

var p=process,f;(_=>{var w=p.stdout.write,n='f'+(Math.random()*1e7|0),l=1
f=p.stdout.write=a=>eval(`(function ${n}(a){while(l&&((typeof a)[0]!='s'||'f'+a!=n));a=l?l="":a;w.apply(p.stdout,arguments);})`)(a)})();

Placez le deuxième bloc de code après le premier.

Avertissement: le deuxième bloc de code ne fonctionnera pas seul (sans être placé après le premier). Si cela n'est pas autorisé, je peux toutefois modifier le deuxième extrait.

Ceci est un programme complet. La sortie est process.stdout(STDOUT), l'entrée est process.argv(arguments de ligne de commande)

C'est mes premiers flics et voleurs, heureusement c'est un bon challenge :)

Essayez-le en ligne!

Le défi expliqué

Génère une variable aléatoire nde 0 à 1e7. Si vous appelez write avec le correct n, n’imprimez rien, mais définissez lsur 0, ce qui «déverrouille» la fonction d’écriture, vous permettant d’imprimer quoi que ce soit. Si vous essayez d'appeler write avec une chaîne autre qu'une chaîne, vous êtes envoyé dans une boucle infinie. Si vous essayez d’appeler en écriture avec une valeur autre que la valeur correcte nalors que l’écriture est "verrouillée", vous êtes renvoyé dans une boucle infinie afin d’éviter de deviner.

La solution envisagée

Se faufile au-delà du type qui vérifie apparemment les chaînes en utilisant un symbole, qui commence également par s. Cela renvoie une erreur dans la fonction résultant de l'appel eval car vous ne pouvez pas ajouter la chaîne "f" à un symbole. Nous attrapons l'erreur et utilisons regex pour récupérer nde la trace de pile, où elle se trouve dans le nom de la fonction. Ensuite, nous essayons d’écrire, nce qui n’imprime rien, mais définit la variable "lock" lsur 0 pour "déverrouiller" la fonction write. Maintenant que la fonction d'écriture est déverrouillée, nous imprimons simplement la somme.

try{f(Symbol())}catch(e){f(e.stack.match(/f(\d+)/)[1])
f(+p.argv[2]+ +p.argv[3]+"")}

RProgN2 , fissuré par Arnold Palmer

"+-/*÷^"{²[[\=};

Écrit sur tous les opérateurs mathématiques, sans aucun moyen de les restaurer. En particulier, il les remplace par une fonction qui supprime les deux premiers éléments de la pile.

Essayez-le en ligne!

Solution d'origine

{S]‘[L}`d={0RL}`i=«x=y=x{xd`x=yi`y=x}:y»`+=

{S]‘[L}`d={0RL}`i=«x=y=x{xd`x=yi`y=x}:y»`+=
{     }`d=                                  #Define a function, "d", which returns n-1
 S                                          #Convert the input to a stack, which, as a number, makes a stack of 1 - n.
  ]‘                                        #Duplicate the stack, and pop the top value off it.
    [                                       #Discard the popped'd value.
     L                                      #Get the length of the stack, which now is n-1.
          {   }`i=                          #Define a function, "i", which returns n+1
           0R                               #Get the range of numbers between 0 and n.
             L                              #Get the length of that stack, which is n+1
                  «                    »`+= #Define a function, "+", which takes two numbers, and outputs their sum. We use «» here, because it localises references, instead of globalising them.
                   x=                       #Set the first input to the value of "x", which by default, is x.
                     y=                     #Ditto for y.
                       x{          x}:      #While x is truthy, which in this case, is non-zero.
                         xd                 #Get x - 1
                           `x=              #Set x to it.
                              yi`y=         #And set y to y + 1
                                      y     #Push y to the output. And we're done.

Essayez-le en ligne!

Haskell, 161 144 octets, fissuré par BlackCap

{-#OPTIONS_GHC -fth -w#-}
module M where

Entrée sur STDIN, sortie sur STDERR. Ajouter à la fin du programme.

Edit: Destiné à être compilé sans aucun argument supplémentaire GHC, juste la normale ghc --make prog.hs.

Edité à nouveau pour réduire le nombre d'octets.

S'amuser!

Mascarpone , fissuré par Ilmari Karonen

[ Make 'i' and 'z' print 'q' ]$
v ['q.]v* 'i<^
v ['q.]v* 'z<^

[ Disable some standard commands ]$
v[]v*   '1<^
v[]v*   '$<^
v[]v*   '@<^
v[]v*   '{<^
v[]v*   '}<^
v[<:]v* '<<^
v[]v*   'v<^$

L'entrée est composée de chiffres d'église sur stdio, en utilisant ipour incrémenter et zpour zéro. Par exemple, 2 + 3 serait:

iiziiiz

Avec une fin de nouvelle ligne, la

sortie doit être un nombre sur stdout, au même format que sur stdio. Par exemple, si la réponse est cinq, vous devez générer:

iiiiiz

(le mascarpone n'a pas de concept de nombres)

Solution envisagée:

: '[/''/'i/'./' /':/',/'>/'!/']/* 'i<^
: '[/':/',/'>/'!/']/* 'z<^
: ,>!
'z.

Cela ne ressort pas immédiatement de la documentation, mais comme @IlmariKaronen l'a indiqué dans son crack, les littéraux de chaîne dans Mascarpone sont en réalité un sucre syntaxique pour pousser une séquence de caractères.

J'ai délibérément écrit des commentaires comme [this]$pour faire croire que je pousse une corde et que je la saute immédiatement après. Un cracker naïf aurait peut-être tenté [:,>!]/*de pousser une corde, de l'échanger avec l'interprète et de l'interpréter.

Je fais aussi semblant de faire apparaître l'interprète avec lequel je suis parti $, mais il $a déjà été redéfini en NOP. Il ne vous reste plus que cet interprète sur la pile et vous devez l’emporter tout au long du programme; à travers chaque caractère de chaque chaîne.

C # (.NET Core) fissuré par Ilmari Karonen

Aussi craqué par Josué .

namespace System
{
    class Console
    {
        static void Main()
        {
            //Your code goes here
        }
    }
}

Lit les deux valeurs de stdin et écrit le résultat dans stdout. Testé sur Windows avec Framework Version 3, 4.6 et sur TIO .

Voici le programme complet que j'avais prévu.

namespace System
{
    class Console
    {
        static void Main()
        {
            var t = Reflection.Assembly.Load("mscorlib").GetType("System.Console");
            var r = t.GetMethod("ReadLine");
            int a = int.Parse((string)r.Invoke(null, null));
            int b = int.Parse((string)r.Invoke(null, null));
            var w = t.GetMethod("WriteLine", new[] { typeof(int) });
            w.Invoke(null, new object[] { a + b });
        }
    }
}

Essayez-le en ligne!

GolfScript , craqué par Dennis

{}' !$%&()*+,-./<=>?@[\]^`|~'':'*~;

Essayez-le en ligne!

C'est un golf de code défi, après tout, alors pourquoi ne pas essayer GolfScript?

Une solution valide doit être un extrait de code qui lit deux entiers de la pile, les additionne et renvoie le résultat dans la pile. Le problème, c'est que cela devrait continuer à fonctionner même après que le code ci-dessus ait redéfini la quasi-totalité des opérateurs GolfScript intégrés sans rien faire. Au moins, je suis restée ;intacte, de sorte que vous pouvez toujours extraire des valeurs de la pile. ;-) Votre code devrait fonctionner sur l'interpréteur GolfScript standard, tel que mis en œuvre par exemple sur TIO (voir lien ci-dessus).

La solution de Dennis , comme moi - même , repose sur la rarement utilisé caractéristique de GolfScript qui permet le code Ruby interpolée dans des chaînes entre guillemets. Nous utilisons cette fonctionnalité pour définir un nouvel opérateur d'addition qui fonctionne exactement comme l' +opérateur intégré , puis nous l'appelons.

(Une des raisons pour laquelle la fonction d'interpolation Ruby dans GolfScript est si rarement utilisée est que, bizarrement, le code Ruby interpolé est exécuté lors de l'analyse et que sa sortie est mise en cache par l'interpréteur GolfScript. Ainsi, par exemple, vous avez une chaîne avec un code Ruby interpolé. dans une boucle, le code ne sera exécuté qu'une seule fois avant le démarrage du programme , puis restituera toujours la même valeur à chaque itération de la boucle. Vous pouvez contourner ce problème en utilisant chaîne eval pour différer l'analyse, mais cela rend la syntaxe déjà complexe encore plus complexe. moche et prolixe, et en tout cas pour ce défi, j’ai aussi désactivé l’opérateur eval ~, mais il s’avère que la définition de nouveaux opérateurs GolfScript intégrés est une chose que cette fonctionnalité fait réellement très bien et proprement.)

Node.js v8.2.0, fissuré par Dom Hastings

let mess = ctx => f => new Proxy (f, {
  has: (t, p) => p in t || p in ctx
, get: (t, p) => {
    let k = p in t? t[p]: ctx[p];

    if (k instanceof Function) return (
      function fetch (_k) {
        return mess (ctx) ( x => ( q => q instanceof Function
                                      ? fetch (q)
                                      : t (q)
                                  ) ( _k(x) )
                          )
      })(k);

    return k;
  }
});

with (mess (global) (x => x)) {
  dot   = f => a => b => f(a(b))
  ap    = f => g => x => f (x) (g (x))
  flip  = f => x => y => f (y) (x)
  Const = a => b => a
  id    = x => x
  num   = n => n (x => x + 1) (0)
  log   = console.log

  let x = flip (Const . id . id)
    , y = flip (Const . id . id . id)
  for (let i = 0; i < process.argv[2]; i++) x = ap (dot) (x)
  for (let i = 0; i < process.argv[3]; i++) y = ap (dot) (y)
  process.argv = [];

  logic = x => y => /* Your code here */;

  log . id . num ( logic (ap (dot) (x))
                         (f => z => (( y(flip (id) . id . flip (dot (id)) (f)) ) (Const (z))) (id) )
                 );
}

Vous devez implémenter la logicfonction. L'entrée correspond aux arguments fournis (à partir de stdin), la sortie correspond à tout ce que votre fonction renvoie (est imprimée sur stdout).

Mon église de code code les nombres de l'entrée. Le reste du code est juste là pour vous intimider.
La fonction mess permet de mettre en œuvre une notation sans points ( a . b == dot (a) (b)), que j'utilise principalement pour ajouter . id .des emplacements aléatoires, ce qui ne fait rien, mais qui confondra toute personne peu familière avec la programmation fonctionnelle.
La transformation appliquée aux nombres avant que je ne les passe à la logicfonction est x+1et y-1, ce qui donne 0, alors c'est un autre NOP à ajouter à l'obscurité.

La solution envisagée était:

logic = x => y => f => z => x (f) (y (f) (z))

Inform 7 , craquelé par poivre

For reading a command: rule fails.

[Your code here.]

Le lecteur doit saisir l’entrée sous forme de commande interactive, par exemple add 17 to 25ou sum 17 25. Vous êtes libre de choisir la forme exacte de la commande à saisir, à condition qu'elle comporte deux nombres. La somme des nombres (par exemple 42) doit être imprimée en réponse à la commande.

Le défi, bien sûr, consiste à faire cela alors que toute l'activité de "lecture d'une commande" est remplacée par une opération d'interdiction. Il y a probablement plusieurs façons de résoudre ce problème, mais au moins cela devrait nécessiter une certaine connaissance de la langue. Celui que j'ai créé est en fait assez simple, bien qu'un peu inattendu.

J'ai testé ma solution dans l'EDI GNOME Inform 7, version 6L38 , sur Ubuntu Linux. La solution envisagée fonctionne à la fois sur les back-ends Glulx et Z-machine, et devrait également fonctionner sur les autres versions récentes d'Inform 7. Notez que (sans solution de contournement appropriée) le code ci-dessus entraînera la boucle d’occupation de l’interprète lorsqu’il essaiera de lire une commande; l'interpréteur Z-machine semble ne plus répondre, et ne peut pas être arrêté à partir de l'EDI. Je recommande donc d'utiliser Glulx pour les tests.

CPython 3 (encore), fissuré par Sisyphe

import sys,os,functools
def p(f,e,a,_=os._exit):
 if e == "c_call":_(1)
sys.setprofile(p)

Vous pouvez faire tout ce que vous voulez - tant que cela n’est pas implémenté en C. Cela signifie non print, non input, tous vont _(1)s’arrêter et se terminer. Entrée de STDIN avec les numéros sur deux lignes séparées, sortie vers STDOUT. Je me demande combien de temps cela va durer ... Il m'a fallu un bon bout de temps pour trouver le deuxième extrait fonctionnel après avoir découvert cette astuce invalidante. Spécifier explicitement Cpython pour éviter d'être craqué n'est pas basé sur une implémentation alternative de sys.setprofile.

Java 8 ( fissuré )

Deuxième essai. Cette fois, j'ai investi deux minutes de test.

static {

    try {

        System.setIn(null);
        System.setOut(null);
        System.setErr(null);

        for (Method m : System.class.getMethods()) {

            m.setAccessible(false);

        }

        System.class.getMethod("getSecurityManager", new Class[0]).setAccessible(false);

        for (Method m : Class.class.getMethods()) {

            m.setAccessible(false);

        }

        SecurityManager mngr = new SecurityManager() {

            @Override
            public void checkPermission(Permission p) {

                if (p.getName().equals("createSecurityManager")) throw new SecurityException();
                if (p.getActions().startsWith("read")) throw new SecurityException();

            }

        };

        System.setSecurityManager(mngr);

        // Your code goes here.

    } catch (Throwable t) {

    }

}

La plupart des choses devraient être couvertes.

Python 2 fissuré

import sys,hashlib
c=open(__file__).read().split()[-1]
if c!='#'and hashlib.sha256(c).hexdigest()!='e6400dd63733d10ec042e3c28033cfa85e1d25fbef80020810c354d7c942e843':sys.exit() #

Essayez-le en ligne!

Je commencerai par dire que cette réponse est un geste sournois, conçu comme une réponse inférieure.

Inspiré des réponses de Wheat Wizard et HyperNeutrino .

L'extrait lit le fichier source et refuse de continuer si le dernier fragment de code séparé par des espaces n'est pas sha256 e6400dd63733d10ec042e3c28033cfa85e1d25fbef80020810c354d7c942e843.

EDIT : édité légèrement en réponse à ce commentaire . Le problème principal ne change pas, aucune tentative de crack n’est invalidée.

Java 8 fissuré par @ OlivierGrégoire

J'ai essayé de le rendre aussi difficile que possible! :) Et contrairement aux autres réponses Java à ce jour, vous devrez suivre les règles exactes du défi, en le plaçant après tout l'extrait de code (alors non, vous ne mettez pas votre code dans la public static void main(String[] args)méthode, vous le mettez après toute la classe. :) bonne chance!

J'ai ajouté des commentaires pour montrer ce qui est restreint.
( Inspiré par ce message, qui est moins restrictif et béatifiable avec la même approche que je pourrais utiliser pour ma réponse. )

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileDescriptor;
import java.io.FilePermission;
import java.io.PrintStream;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class Main {

  // Put everything in a static block so it is run before the static main method 
  // and any trailing (static) initializer-blocks:
  static {
    try {
      initializing();
    } catch (final Exception e) {
    }
  }

  static void initializing() throws Exception {
    // Overwrite System.out, System.err and System.in:
    System.setOut(new PrintStream(new ByteArrayOutputStream()));
    System.setErr(new PrintStream(new ByteArrayOutputStream()));
    System.setIn(new ByteArrayInputStream(new byte[0]));

    // Enable reflection for System.out, System.err and System.in:
    final Field modifiersField = Field.class.getDeclaredField("modifiers");
    modifiersField.setAccessible(true);
    final Class<?> fdClass = java.io.FileDescriptor.class;
    final Field outField = fdClass.getDeclaredField("out");
    outField.setAccessible(true);
    modifiersField.setInt(outField, outField.getModifiers() & ~Modifier.FINAL);
    final Field errField = fdClass.getDeclaredField("err");
    errField.setAccessible(true);
    modifiersField.setInt(errField, errField.getModifiers() & ~Modifier.FINAL);
    final Field inField = fdClass.getDeclaredField("in");
    inField.setAccessible(true);
    modifiersField.setInt(inField, inField.getModifiers() & ~Modifier.FINAL);

    // Replace existing System.out FileDescriptor with a new (useless) one:
    outField.set(null, new FileDescriptor());
    // Replace existing System.err FileDescriptor with a new (useless) one:
    errField.set(null, new FileDescriptor());
    // Replace existing System.in FileDescriptor with a new (useless) one:
    inField.set(null, new FileDescriptor());

    // Disable reflection for System.out, System.err, System.in again:
    modifiersField.setInt(outField, outField.getModifiers() & ~Modifier.FINAL);
    modifiersField.setInt(errField, errField.getModifiers() & ~Modifier.FINAL);
    modifiersField.setInt(inField, inField.getModifiers() & ~Modifier.FINAL);
    inField.setAccessible(false);
    errField.setAccessible(false);
    outField.setAccessible(false);
    modifiersField.setAccessible(false);

    // Overwrite the SecurityManager:
    System.setSecurityManager(new SecurityManager() {

      private boolean exitAllowed = false;

      @Override
      public void checkExec(final String cmd) {
        throw new SecurityException();
      }

      @Override
      public void checkPermission(final java.security.Permission perm) {
        final String name = perm.getName();
        // You're not allowed to read/write files:
        if (name.equals("setIO") || name.equals("writeFileDescriptor")
            || name.equals("readFileDescriptor")
            || ((perm instanceof FilePermission) && name.startsWith("/proc/self/fd/"))) {
          throw new SecurityException();
        }
        // You're not allowed to overwrite the Security settings:
        if (name.equals("setSecurityManager") || name.equals("suppressAccessChecks")) {
          throw new SecurityException();
        }
        // You're not allowed to use reflection anymore:
        if (name.equals("getModifiers") || name.equals("get") || name.equals("set")
            || name.equals("setBoolean") || name.equals("setByte")
            || name.equals("setChar") || name.equals("setShort") || name.equals("setInt")
            || name.equals("setLong") || name.equals("setFloat") || name.equals("setDouble")
            || name.equals("setFieldAccessor") || name.equals("setFieldAccessor")) {
          throw new SecurityException();
        }
        // When you try to leave the current VM it will stop the program:
        if (name.startsWith("exitVM") && !this.exitAllowed) {
          this.exitAllowed = true;
          System.exit(0);
        }

        // You know what, nothing is allowed!
        throw new SecurityException("Mhuahahahaha!");
      }
    });
  }

  public static void main(String[] args) {
    // Overwritting all given arguments:
    args = new String[0];

    // Exit the program before you can do anything!
    System.exit(0);
  }
}

// Your code goes below:

Essayez ici. (ideone.com au lieu de TIO, car cela ne semble pas fonctionner ici. Des tests ont été effectués dans l'EDI Eclipse, mais la solution que vous envisagez fonctionne si vous utilisez ideone.com.)

Gelée: craquelée

Ce sera incroyablement facile comparé à l’impressionnante réponse en Python de Wheat Wizard, mais on y va: P

“for c in code_page:
 if c in atoms:atoms[c].call=None”ŒVø<insert code snippet here>

Sha256 hexdigest de ma solution de contournement, y compris le premier extrait, est cfeb1e193ad77f66f039c0d6a792a3e4c311490f6412698e019ca1fae10c0e0a.

Remarque

Vous ne pouvez pas avoir de nouvelles lignes dans le code, sauf pour les chaînes, sinon ce code ne sera même pas exécuté, ce qui irait à l'encontre de l'objectif de ce défi.

Fissuré par DJMcMayhem

Pour être juste, cela utilise une nouvelle ligne, alors j'aimerais voir une solution qui n'utilise pas de nouvelle ligne.

Également une solution de Jonathan Allan

Cela n'utilise pas de saut de ligne, il a donc été craqué. : P

Ma solution est la suivante:

“for c in code_page:
 if c in atoms:atoms[c].call=None”ŒVø“print(int(input())+int(input()))”ŒV

Le premier extrait ne supprime que les atomes à caractère unique, ce qui signifie que Python eval fonctionne toujours :)))

JavaScript, fissuré

Entrée: prompt()deux fois

Sortie: console.log()

Ma solution ne fonctionne pas dans jsfiddle. Fonctionne sur le sujet: page blanche avec la console JS de Google Chrome.

prompt=console=0

Ma solution:

x=document.createElement("iframe")
x.src="data:text/html,<script>console.log(prompt()-0+(prompt()-0))</script>"
document.body.appendChild(x)

Explication:

J'ai enlevé prompt et console en les fixant égaux à 0.

Dans ma solution, je crée un iframe, qui crée un bac à sable, et une nouvelle instance de window dans laquelle prompt et console fonctionnent correctement.

Java, fissuré

import java.lang.reflect.*;
public class Main{
  public static void main(String... args){
    System.setOut(null);
    System.setErr(null);
    /*Your code here*/
  }
}

Cela devrait être très facile à craquer.

Solution envisagée

import java.lang.reflect.*;
public class Main{
public static void main(String... args){
  System.setOut(null);
  System.setErr(null);
  try{
    Class<?> cistream = Class.forName("java.io.InputStream");
    Class<?> cfostream = Class.forName("java.io.FileOutputStream");
    Class<?> costream = Class.forName("java.io.OutputStream");
    Class<?> cfdescriptor = Class.forName("java.io.FileDescriptor");
    Object sout = cfostream.getConstructor(cfdescriptor).newInstance(cfdescriptor.getField("out").get(null));
    Class<?> csys = Class.forName("java.lang.System");
    Field mod = Field.class.getDeclaredField("modifiers");
    mod.setAccessible(true);
    Field stdout = csys.getField("out");
    mod.set(stdout,Integer.class.cast(mod.get(stdout) )&~ Modifier.FINAL);
    stdout.set(null,Class.forName("java.io.PrintStream").getConstructor(costream).newInstance(sout));
    Class<?> cscanner = Class.forName("java.util.Scanner");
    Object scanner = cscanner.getConstructor(cistream).newInstance(System.in);
    Method nextInt = cscanner.getMethod("nextInt");
    int f = Integer.class.cast(nextInt.invoke(scanner));
    int s = Integer.class.cast(nextInt.invoke(scanner));
    int sum = s + f;
    System.out.println(sum);
  }catch(Throwable t){t.printStackTrace();}
  }
}

Essayez-le en ligne