Comment connaissez-vous le site? Découvrons-le.

C'est un défi des flics et des voleurs . Le fil du voleur.

En tant que policier, vous devez:

1. Trouvez un défi non supprimé et non fermé sur ce site pour répondre. Le défi ne peut pas comporter les balises suivantes: flics-and-robbers , popularité-contest , surveillance du code , sournois , castor occupé , roi de la colline , astuces , chaîne de réponse . Le défi doit avoir des restrictions sur la sortie valide.
2. Ecrire une soumission valide pour le défi, dans une langue trouvées sur Wikipédia ou esolangs.org ou tryitonline . La soumission ne doit pas nécessairement être compétitive, seulement valide. EDIT: Hashing dans votre soumission n'est pas autorisé
3. Postez la soumission ici, en gardant le défi secret. Vous devez publier l'intégralité de la soumission, ainsi que la langue (et la version, le cas échéant).

Au bout d'une semaine, si personne n'a trouvé le défi auquel vous répondez, vous pouvez poster le défi auquel répond votre soumission. À ce stade, votre soumission est sécurisée . Il vaut N points, où N est le nombre de votes positifs sur le défi (à partir de 2016-11-17 ) (Plus c'est élevé, mieux c'est)

Pour casser votre défi, un voleur doit trouver un défi pour lequel la soumission est une soumission valide.

Remarques:

• Si un défi nécessite une sortie X, et vous sortie XYou YXoù Yest autre chose que des espaces, la soumission est pas valable pour ce défi.
• Un défi plus récent que 2016-11-17 n'est pas autorisé.
• Les langues plus récentes que le défi caché sont autorisées.
• Je me réserve le droit d'interdire certaines contestations si elles sont largement applicables (pourraient s'appliquer à la majorité des soumissions).
• Merci à Daniel pour l'idée initiale!

Soumissions non fissurées:

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

Pip , 9 octets ( sûr , 15 points)

(q`\w+`1)

Ce qu'il faut faire devrait être facile à comprendre, mais la question est de savoir pourquoi ... ( TIO )

Le défi était Quelle est la langue? L'objectif: analyser le nom du langage de programmation à partir d'un en-tête de réponse PPCG. Par exemple:

Input: <h1>JavaScript, 13 chars / 32 bytes</h1>
Desired Output: JavaScript

Je ne sais pas si cela relève du "défi doit comporter des restrictions sur la sortie valide", car il s'agit d'un défi de batterie de tests marqué par "le pourcentage de tests que vous obtenez corrects" et ne nécessite donc pas que la sortie soit correcte pour toutes les entrées. Cependant, je dirai que le code ci-dessus obtient un taux correct d'environ 60%, ce qui n'est pas mauvais pour quelque chose d'aussi simple.

Perl - fissuré par DLosc

Donnons un facile pour les non-esolang

Courir avec -nl

say $_ ~~ reverse y-"({[]})"-")}][{("-r;;r-")}][{("-"({[]})"-y esrever ~~ _$ yas

Défi: vérificateur de palindrome pratique

Le code se bloque après avoir imprimé la vérité, mais selon cette méta-publication, tant qu'il produit la sortie correcte avant de planter et que les erreurs éventuelles sont sorties vers STDERR, c'est une solution valable.

Hexagonie , 548 octets, fissuré

69;{108;\_1$;;;/0;108\56;19|1^\6/15\;72_$23371<};;!;6;33|;;015><;;7;@3?;43+1586;2_3219><11;;'_8;;;2_|3;81|2<|8517;327}1_23;1;4$%;_4{5.1;1332_3;029&;'_};;1..527;2'..35;5212_>97;$;2/0;-;3_2;/233;08.._\901;0/13'}92...>/>/57\53;633;4'22;/|~>;441;45;;$161;371;3/;3.7026;`208;1<}>27;140;217;11.0;/2;692;<01/2;301;18;31/;10;/3;44<1914/111;{98;38;;;13/4;<;3;1;;/;112;<.$13032;..27;1;222/1;0<6..1;0;'..933721389/9<6;.;3;37..;;875;*;;0[1;287]59..902;;2;12;1;59;;3#..4;;1=249$345249;...;012}021#>/;44>114/4201;;;3>0;>;24;3/;;116._4>337;237/$5_>1{32;102;255;'_

Essayez-le en ligne!

Perl, coffre - fort , 18 points

Éditer : j'ai modifié la fin du code (voir l'historique d'édition) pour gérer un cas de bord (le défi ne dit rien à ce sujet, et l'auteur n'a pas répondu à la question, mais au moins ce code le gère) . Mais l'algorithme et la logique du code restent les mêmes.

perl -n0E '/.*/;s/(^0|A)(.{@{+}})?0/A$2A/s||s/0(.{@{+}})?A/A$1A/s?redo:say/A$/+0'

Ce code n'est pas obscurci (juste joué au golf). (Cela implique que ce -n0Ene sont pas optionnels).

Je ne me rends pas compte si c'est difficile ou non, mais je suppose que je serai réparé quand quelqu'un le craquera.

Le défi était: Peut-on résoudre le labyrinthe? .

Ce code trouvera toutes les cellules accessibles du labyrinthe (et les marquera d'un a A): si une cellule touche une cellule marquée d'un A, elle est accessible et nous le marquons Aaussi; et on recommence ( redo). Cela se fait grâce à deux regex: s/(^0|A)(.{@{+}})?0/A$2A/svérifie si un espace est à droite ou en bas d'un A, alors que s/0(.{@{+}})?A/A$1A/svérifie si un espace est à gauche ou au-dessus d'un A. A la fin, si la dernière cellule contient une Alui est accessible, sinon ce n'est pas (c'est ce que les say/A$/+0chèques, l' +0est ici pour vous assurer que le résultat sera 0ou au 1lieu de chaîne vide et 1).
Notez que /.*/correspond à une ligne entière, définissant ainsi@+à l'index de la fin de la première ligne, ce qui est la taille d'une ligne, ce qui permet d'utiliser pour .{@{+}}faire correspondre exactement autant de caractères qu'il y a sur une ligne. ( @{+}est équivalent à @+, mais seul l'ancien peut être utilisé dans regex)

Pour l'exécuter:

$ perl -n0E '/.*/;s/(^0|A)(.{@{+}})?0/A$2A/s||s/0(.{@{+}})?A/A$1A/s?redo:say 1-/0$/' <<< "0000001
0000010
1111011
0000000"
1

(et si vous remplacez la 1111011ligne par 1111111, le problème ne sera plus résolu, et le résultat sera 0au lieu de 1)

Perl, 56 octets, Coffre-fort (14 points)

undef$/;print+(<>^<>)=~y/\x81-\xff\x00-\x80/\x01-\xff/dr

Le défi était celui-ci , vous obligeant à créer un algorithme de diffing; vous devez pouvoir entrer deux fichiers et générer un diff, ou saisir un fichier et un diff et exporter l'autre fichier. La notation de ce défi est code-défi , en faisant le plus petit diff vainqueur; Cependant, ce défi n’exige pas de réponse compétitive, il est simplement conforme à la spécification. J’ai donc écrit un programme diffing de manière ludique, qui utilise simplement XOR pour combiner les entrées (ce qui signifie que le même programme fonctionne pour un-diffing).

La partie la plus difficile est de reproduire la longueur des fichiers originaux. L'entrée est spécifiée en ASCII, qui est un jeu de caractères de sept bits, me permettant ainsi d'utiliser le huitième bit pour suivre la longueur du fichier. Lors de la différenciation, nous définissons le bit haut de chaque octet en utilisant une y///instruction (qui est légèrement plus obscurcie que ne le serait l'arithmétique au niveau du bit). Lorsqu'on diffère (en notant que l'entrée a déjà le bit haut défini), on supprime les NUL de la sortie. (Je viens de me rendre compte que cela échouerait si l'entrée contenait des octets NUL; cependant, le défi est défini en termes de batterie de test et, heureusement, je ne pense pas qu'il y ait des octets NUL dans la batterie. S'il y en a, alors ce programme serait incorrect et devrait être disqualifié; un problème avec un policier et des voleurs est-ce que personne d’autre n’a suffisamment d’informations pour vous indiquer des failles facilement corrigées dans votre réponse!)

Octave, 15 points! SÛR

@(x,y)find((v=((z=cumsum(x.^2))(y:end)-[0,z(1:end-y)]))==max(v),1)-1

Essayez-le en ligne ici .

Explication:

Le code prend une chaîne d'entrée xcontenant des uns et des zéros 10010110110101et un entier y.

Pour trouver la moyenne mobile d'une séquence dans MATLAB / Octave, vous pouvez faire:

z = cumsum(x);
movmean = z(y:end) - [0 z(1:end-y)];

Puisque nous ne nous intéressons qu'à l'emplacement du maximum, pas aux valeurs réelles, nous n'avons pas besoin de nous soucier de convertir la chaîne en nombres. (x.^2)place toutes les valeurs ASCII 48,49pour 0,1. Cela est nécessaire car Octave ne peut pas utiliser cumsumdirectement sur des personnages. cumsum(+x)serait deux octets plus court mais indiquerait que xc'est une chaîne.

C’est en fait assez bien joué au golf (sauf au .^2lieu de +). Bien sûr, la convolution serait plus simple.

MATL . Fissuré

&:"@FYAYm7>vs

Essayez-le en ligne!

J'ai indiqué entrée et sortie même si ce n'est pas nécessaire. Comme c'est quand même dans l'historique d'édition: le programme entre deux nombres et en sort un.

C #, 590 octets, fissuré

(I,N)=>{string R="",p="`1234567890-=",P="~!@#$%^&*()_+",q="qwertyuiop[]\\",Q="QWERTYUIOP{}|",a="asdfghjkl;\'",A="ASDFGHJKL:\"",z="zxcvbnm,./",Z="ZXCVBNM<>?";foreach(var c in I){var f=c+"";if(p.Contains(f))R+=p[(p.IndexOf(c)+N)%13];else if(P.Contains(f))R+=P[(P.IndexOf(c)+N)%13];else if(q.Contains(f))R+=q[(q.IndexOf(c)+N)%13];else if(Q.Contains(f))R+=Q[(Q.IndexOf(c)+N)%13];else if(a.Contains(f))R+=a[(a.IndexOf(c)+N)%11];else if(A.Contains(f))R+=A[(A.IndexOf(c)+N)%11];else if(z.Contains(f))R+=z[(z.IndexOf(c)+N)%10];else if(Z.Contains(f))R+=Z[(Z.IndexOf(c)+N)%10];else R+=c;}return R;};

Probablement assez facile, aussi un programme assez long, _,

05AB1E , 27 octets, fissuré!

Pour cette soumission, une entrée est également requise pour que cela fonctionne. Ne devrait pas être trop difficile à craquer.

ávyl•B;£¡´•54B•2ît•‡y.li(}O

Explication (pour le challenge):

á                             # Keep all the letters of the input string
 vy                           # For each letter...
   l                          #   Convert to lowercase
    •B;£¡´•54B                #   String that turns into 'pnbrqk'
              •2ît•           #   Compressed int: 133591
                   ‡          #   Transliterates the following:
                                    p -> 1
                                    n -> 3
                                    b -> 3
                                    r -> 5
                                    q -> 9
                                    k -> 1
                    y.li }    #   If the current letter is lowercase...
                        (     #     Negate that number
                          O   # Sum up the result

Utilise le codage CP-1252 . Essayez-le en ligne!

아희 (Aheui) , 0 octet, fissuré

Essayez-le ici! (Le programme est déjà saisi pour vous: p)

Python, 935 octets

def oo000 ( num ) :
 return - ~ num
def ii ( num ) :
 return - ( oo000 ( oo000 ( ~ num ) ) )
def oOOo ( num1 , num2 ) :
 while num2 > 0 :
  num1 = oo000 ( num1 )
  num2 = ii ( num2 )
 return num1
 if 59 - 59: Oo0Ooo . OO0OO0O0O0 * iiiIIii1IIi . iII111iiiii11 % I1IiiI
def IIi1IiiiI1Ii ( num1 , num2 ) :
 I11i11Ii = num2
 oO00oOo = 0
 while I11i11Ii > 0 :
  oO00oOo = oOOo ( oO00oOo , num1 )
  I11i11Ii = ii ( I11i11Ii )
  if 92 - 92: O0O / oo000i1iIi11iIIi1 % Iii1IIIiiI + iI - Oo / o0O
 return oO00oOo
def hgj ( num1 , num2 ) :
 I11i11Ii = num2
 oO00oOo = 1
 while I11i11Ii > 0 :
  oO00oOo = IIi1IiiiI1Ii ( oO00oOo , num1 )
  I11i11Ii = ii ( I11i11Ii )
  if 48 - 48: iII111i % IiII + I1Ii111 / ooOoO0o * o00O0oo
 return oO00oOo
def O0oOO0o0 ( num1 , num2 ) :
 return oOOo ( num1 , - num2 )
 if 9 - 9: o0o - OOO0o0o
 if 40 - 40: II / oo00 * Iii1IIIiiI * o0o . ooOoO0o
print(hgj ( 9 , 9999 ))
# dd678faae9ac167bc83abf78e5cb2f3f0688d3a3

Désolé, j'ai utilisé un obfuscateur, mais ce n'est pas interdit et bien plus facile. (Et je n'ai pas eu tout ce temps pour le faire moi-même ...)

Ruby ( fissuré par DLosc )

p n = gets.to_i
p n = n*(3*n-1)/2 until n % 7 == 0

MATL . Coffre-fort , 93 points

dP7EGn:q^1J2/h)ts_hX=Gs[BE]Wd=~>~GBz*

Essayez-le en ligne!

Explication

Le défi était l' empreinte écologique du code source .

Le code calcule le poids de Hamming (nombre d'unités) dans la représentation binaire des codes ASCII de la chaîne d'entrée; sauf que la chaîne testsort 0(au lieu de son poids de Hamming, qui est 17).

Le boîtier spécial de cette chaîne est un peu obscurci. Le programme calcule d’abord le tableau de différences consécutives des codes ASCII de l’entrée et l’inverse. Pour testcela donne [1 14 -15].

Ensuite, le tableau formé par les premières npuissances de 14est calculé ( [1 14 196 ...]), où nest la longueur en entrée; et les premières floor(n/2)valeurs sont conservées. Donc, pour l'entrée testcela donne [1 14]. La somme annulée est ajoutée à ce tableau, ce qui donne [1 14 -15]pour l’entrée test. Ceci est testé pour l'égalité avec le tableau inversé de différences consécutives qui a été précédemment obtenu.

D'autre part, la somme des codes ASCII des caractères d'entrée est calculée et comparée à 448, générée comme la différence (consécutive) des éléments dans le tableau [2^6 2^9](où ^dénote la puissance).

L'entrée testest la seule chaîne avec des différences consécutives inversées de la forme [1 14 -15]et de la somme 448. Les différences []ou [1](pour les chaînes inoyt plus courtes) ne sont pas compatibles avec une somme totale de 448. Des différences [1 14 196]ou plus grandes ne peuvent pas être obtenues avec des caractères ASCII.

Le code vérifie si le résultat du test pour la première condition (différences consécutives) n'est pas inférieur au résultat annulé de la deuxième condition (somme totale). Cela donne 0si et seulement si les deux conditions sont remplies. Enfin, ceci est multiplié par le nombre de uns dans la représentation binaire des codes ASCII de l’entrée.

CJam ( coffre - fort , 21 points)

{W+W%~1{1$)}{)a1${\(+W%{1$1$-2=>}{+}w}{\;}?)_@*\+~}w+}

Ceci est un bloc anonyme (fonction).

Python 3, ~ 2000 octets, (sans danger: 23 points)

Programme original

exec("\n))o0000o000o<)]))]00000o000o[0o0o0o0o0o0o0o0o0o(00000000000000o0o(000000000000000o0o ni oooo0oooo rof)))0o0o0o0o0o0o0o0o0o(00000000000000o0o(000000000000000o0o ni 00oo00oo00oo00oo00oo rof]oooo0oooo[]00oo00oo00oo00oo00oo[0o0o0o0o0o0o0o0o0o(000ooo000ooo000o[ +]0o0o0o0o0o0o0o0o0o ni 00oo00oo00oo00oo00oo rof)00oo00oo00oo00oo00oo(000ooo000ooo000o[ni ooo000ooo000o rof)ooo000ooo000o(o0o0o0o0o-o0000o000o(000ooo000ooo000o(00o00o00o(tnirp\n)00000o000o,00000o000o(tresni.o0o0o0o0o0o0o0o0o0o:))00000000000000o0o=yek,0o0o0o0o0o0o0o0o0o(xam(00000000000000o0o<)o0o0o0o0o0o0o0o0o0o(00000000000000o0o elihw \n:)]00000o000o[]o0oooo,0o0o0o0o0o0o0o0o0o[( ni o0o0o0o0o0o0o0o0o0o rof\n;'=01NgwiNgwSNbBibpBybw8GMwAzbw8GM'b,]0o0o0o0o00oo ni ooooo0o00oo rof]]::0oooooo0oooo[))ooooo0o00oo(0oooooo(o0oooo ni ooo000ooo000o rof)ooo000ooo000o(00o00o00o[[=ooooo00oo,0o0o0o0o0o0o0o0o0o\n)'=kSZsBXd0BCLn5WayR3cgwCdulGK'b(0o0o.)(0o0ooo0o00ooo.o000oo esle o0000o000o fi o0000o000o+o0000o000o=0oooooo0oooo;)000000000000000o0o(o00oo00o=000000000000000o0o;)))(edoced.)o0o(0oo000o(000000o(o000oo,))(]o0000o000o[]edoced.)'==QbhRHa'b(0oo000o,'oo0o0o00o'[(oo0o0oo=o0o0o0o0o,oo0o0o0oo\n;)00000000000000o0o(o00oo00o,))(edoced.)'vJHZ'b(0oo000o(o00oo00o,)'bin'(o00oo00o=00000000000000o0o,0oooooo,o0oooo;))0000o0o0o(000000o(o000oo:0000o0o0o adbmal = o00oo00o ;)))(0o0oo00o(0oooooo(0o0oo0oo=0o0o0o0o00oo\n00000000000001**o0000o000o=o0000o000o;))(edoced.)'=cSbhRHanwCd1BnbpxyXfRncvBXbp91Xs4WavpmLnAyJ'b(0oo000o(o000oo=o0oo0oo00o,0o0oo00o,o0oo0oo,0o0oo0oo;edoced46b.)000oo0o(oo0o0oo=0oo000o\n;'==QYsxGKb92bwADMvVCN8EDIm9mcg8GMvBSauBybw82bwADMvBzbdliKq4SN'b ,))0o0oo00oo(000000o(__tropmi__ :0o0oo00oo adbmal,'base64',]0o0oo00oo[:0o0oo00oo adbmal = oo00oo00oo00oo00oo00oo,oo0o0oo,000oo0o,0oooooo\n;tni,'range','len','==Abh1mYkFGIv9GMwAzb682bwADMvBSYuRGIv9GMvBzbw82buYWYjR3bylWYshybvBDMw8WLxkiKqITJv9GMwAzb'b,lave,0**0000000000000009,0 ,]1-::[0o0ooo0o00o0oo:0o0ooo0o00o0oo adbmal,mus = 00o00o00o,000000000000000o0o,00000000000000o0o,o0o,o000oo,o0000o000o,00000o000o,000000o,000ooo000ooo000o\n"[::-1])

Défi

C’est en fait une réponse à mon propre défi, Primenary Strings . J'ai choisi cette option car presque tout sera en sortie 0, à l'exception de quelques entrées dans lesquelles un voleur aurait peu de chances d'entrer. Le code est un algorithme simple, mais fortement obscurci (à la main).

Pip , 13 octets

V$.C(A*a-A9)a

Essayez-le en ligne (donnez l'entrée comme arguments, pas comme entrée).

JavaScript, 533 octets, fissuré! par Dave

_=this;[490837,358155,390922].map(y=function(M,i){return _[[
U=[y+[]][+[]]][+[]][i]]=_[M.toString(2<<2<<2)]});function g(
s){return Function("a","b","c","return "+s)};e=g(u(["","GQ9\
ZygiYTwyPzE6YSpk","C0tYSki","SkoYSkvZChhLWIpL2QoYikg"].join(
"K")));h=g("A=a,B=b,g('A(a,B(a))')");j=g("a/b");L=g("Z=a,Y=\
b,g('Z(a,Y)')");k=L(j,T=2);F=g(u("KScpKWIsYShFLCliLGEoQyhEJ\
yhnLGM9RSxiPUQsYT1D").split("").reverse().join(""));RESULT=F
(h(e,k),j,g("_[U[10]+[![]+[]][+[]][++[+[]][+[]]]+[!+[]+[]][\
+[]][+[]]+17..toString(2<<2<<2)].pow(T,a)"));

Ce n’est pas mon obscurcissement préféré, mais c’est plutôt chouette. Appeler comme RESULT(inputs).

Je pourrais attribuer une prime de +50 points si vous expliquez en détail ce que mon code fait avec votre crack. (Ils ne doivent pas nécessairement être ensemble, alors n'hésitez pas à FGITW si cela vous convient.)

Pyke, 3458 octets, SAFE , score 99

wB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddsQI30>Q%)

Essayez-le ici!

Il y a quelques (30) 0x1boctets qui semblent avoir été mangés par SE.

Octave, 40 points. SÛR

Réponse légèrement obscurcie à un défi assez populaire.

y=find((x=mod(input('')*2,32))>12);sign(sum(x.*[1-y:nnz(x+8)-y]))

Je recommande de tester ceci sur octave-online . Ideone n’est pas très bon quand il s’agit de STDIN.

C'était le défi 2015 du simulateur de levier. Entrée sur le formulaire '123^32. La sortie sera -1 0 1pour Gauche-lourd, Équilibré et Droite-lourd dans cet ordre.

Cela ressemble à ceci quand il est complètement joué au golf :

s=mod(input(''),16);i=find(s>9);s*[1-i:numel(s)-i]'*inf

Cette sortie -Inf, NaN, Infpour L, B, R respectivement.

Haskell, SAFE

m f=map(f<$>)
g=reverse.("":)
f s|(f:c:s)<-m fromEnum.g.words$s,
    (f:c:s)<-init.unwords.g.m(\s->toEnum$if c!!0==s||s==sum(-32:c)then(last$f)else s)$s=init$s

Essayez-le sur Ideone . "Usage":

Prelude> f "Programming Puzzles & Code Golf"
"rogramming Puzzles "

Dans le défi String Shenanigans, on attribue à une chaîne une chaîne et deux caractères, qui doivent ensuite remplacer chaque occurrence du premier caractère par le second. Cependant, l'entrée est une chaîne contenant uniquement la chaîne réelle entre guillemets et les deux caractères séparés par des espaces:

Prelude> f "\"Hello, World!\" l r"
"Herro, Worrd!"

TeX, 240 bytes, SAFE , score 129

\let\N\newcount\let\I\ifnum\let\A\advance\let\E\else\N\a\N\b\N\c\def\D#1:#2:#3:{\I#1>#2\A#1by-#2\D#1:#2:#3:\E\I#1=#2 #3=1\E#3=0\fi\fi}\def\P#1:#2:{\I#1>#2\a=#1\D\a:#2:\c:\I\c=0\b=#2\A\b by1\P#1:\the\b:\E N\fi\E\I#1=1 N\E Y\fi\fi}\P1:2:\end

Enregistrez sous jeopardy.tex, puis exécutez pdftex jeopardy.texet ouvrez jeopardy.pdf.

Résultat: un PDF avec le texte N(et le numéro de page 1).

Python 3, fissuré!

Ecrire cela était hilarant, même si c'était facile à craquer à la fin :)

Z,O=__import__('time').strftime,401*5;from base64 import*;Q,I=(Z('%Y')),(O/401)*2;_=int(Q);D,P=(O,-~_),int(Q[~1:]);Q,I=(6+(P-eval(b64decode(b'KHN1bShbeCU0PDEgZm9yIHggaW4gcmFuZ2UobWluKEQpLG1heChEKSldKSk=').decode()+'*-1'*(O>_)))/10,'3'+repr(((P-10)*3)+10));print(Q,I)

Pyth - fissuré par le maltysen

Si cela aide, Pyth n'est pas l'une des réponses au défi caché.

u=.+G.*A

Essaye le!

C #, 91 octets

_=>{int b=0,w=0;for(;1>w||0<*(_-1);b+=++w**_++<<(9*w));return b%(3<w?903302656:41458688);};

Mathematica, 161 octets

Which[LetterQ@#,If[UpperCaseQ@#,ToUpperCase,#&][FromLetterNumber~Array~LetterNumber@#],DigitQ@#,Array[IntegerString,FromDigits@#+1,0],True,#]&/@Characters@#<>""&

BrainFuck - 140 Bytes, fissuré par daHugLenny

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

Essayez-le ici!

C ++ 14, fissuré

#include<vector>

auto h(auto i){return 0;}
auto h(auto i, auto x, auto...p){
 return x+(i-1?h(i-1,p...):0);
}

auto g(auto v){return v;}
auto g(auto v,auto x, auto...p){
 v.push_back(h(x,x,p...));
 return g(v,p...);
}

auto f(auto...p){
 return g(std::vector<int>{},p...);
}

Prend un nombre varié de paramètres et retourne a vector<int>.

Usage:

int main() {
 auto v = f(4,7,3,4,5);
 for (auto i:v) std::cout << i << ", ";
 std::cout << std::endl;
}

Mathematica, 34 octets, fissuré

±1={±0={}};±n_:=Array[±#&,n,0]

Fonction nommée ( ±).

Ruby, 50 octets

count = 0; 400.times do count +=1; end; puts count

sortie: 400

Python 2.7, 45 octets

import numpy;lambda a,n,t:numpy.arange(a,t,n)

Indice (ou peut-être pas): "le poisson utilise numpy."

2016.11.23 - deuxième indice: "Ne laissez rien flotter!"