这是警察和强盗挑战的一部分。去这里参加警察的活动。

为了解决这一挑战，我们将空白定义为仅换行（0x0A）和空格（0x20）。请注意，大多数语言和正则表达式都将许多其他字符也视为空格，无论是在ASCII范围内还是在ASCII范围之外，因此您可能无法使用相应的内置函数。

强盗的挑战

警察的答案可以通过将其转换为有效的程序或函数（使用所选语言）来破解，该程序或函数通过将空格插入代码中来执行从输入字符串中删除空格的任务。例如，如果您收到以下输入：

H e l l o,
 W o r l  d!

程序应该输出

Hello,World!

插入空格后，解决方案的字节数不得超过cop答案中指出的字节数。只要您的解决方案受上述约束的约束，您就不必找到与警察完全相同的解决方案。

如果您可以管理此问题，请在解决方案中发布答案，并链接到警察的答案，然后对警察的答案发表评论，并链接回您的答案。

破解最多警察答案的强盗获胜。领带被破解的警察答案的大小之和打断（赞成强盗破解更长的提交内容）。

每个警察的答案只能破解一次，当然，您也不能破解自己的答案。如果警察的答案在被破解之前或之后被证明是无效的，则不计入强盗的分数。

Haskell，100字节，作者Laikoni

main=interact$id doid lines id words 
doid oi d o id=do
 iddoid<-do oi id
 oid<-do o iddoid
 do d oid

> <>，​​40字节，作者DanTheMan

v <<
i/\
:=
:
:a?
0/>/
1?o
-=
="
?
;"
>^

锻炼真的很有趣。

在> <>语言上尝试

JavaScript ES6，Arnauld 199字节

s=>eval(atob`ISYgJiAtOkI8Qk97BRBeaxZFShoUZSsiOGkMenNy`.replace(/./g,(c,i)=>String.fromCharCode(c.charCodeAt()^(k+="     S    e c  r   e t     C    o   d  e   ".split(/\w/)[i%11].length)),k=0)).join``

我意识到拆分的"SecretCode"意思是我正在寻找11个数字的总和（我假设为33）。这是一个星条问题，其中空格数是星，而字母"SecretCode"是条。我进行了数学运算，看看有多少种组合可以尝试（1,917,334,783种组合），并决定只是蛮力地花了整整一天的时间。

有可能是去了一个关于它的更聪明的办法，该实例注意到k必须是33和66分别为10指数和21，但我很懒。

C，475字节，来自rexroni

#include<unistd.h>
#define a char
#define b *
#define c write
#define d stdin
#define e stdout
#define f read
#define g (
#define h )
#define i while
#define j if
#define k 0
#define l &
#define m ,
#define n =
#define o ;
#define p 1
#define gpml ml h
#define abo
#define ml d m p
#define jg d o abo
#define lb abo d
#define gf h abo c
#define jgm b e n
#define pml f g
#define gpm lb
int main(){a jg a jgm l jg i g pml k m l gpml h j g d!=' '&&gpm!='\n'gf g p m l gpml o}

我可能会开始使用其中一些定义：)

在预处理器之后，代码如下所示：

int main(){
    char stdin;
    char *stdout = &stdin;
    while(read(0, &stdin, 1))
        if(stdin !='' && stdin!='\n')
            write(1, &stdin, 1);
}   

Ruby，86个字节+ 1个标志= 87（按组织架构）

eval"( T $ }{(! // ; : 67 8 ? 32. && )".gsub(/ |(.)/){$1&&$&.ord.^($'.count(' ')).chr}

这真的很有趣，传递给字符串的每个字符都eval被替换为字符代码（ord）^(...)，并与字符串中剩余的空格数进行异或。结果代码为：

$_.tr!(''<<32<<10,'')

RprogN，作者： Ataco

这似乎可以解决问题

' ' ` R
"
" ` R

V，37字节，作者：DJMcMayhem

O     VrS200@"kIi|D@"A üî|D@"

无法打印的内容：

O     <esc>Vr<C-a>S200<esc>@"kIi<C-v><C-v><esc>|D@"<esc>A üî<esc>|D@"

在线试用

在ü真正扔我一个循环，我一直都期待着它，î是命令。

O                 # Insert 5 spaces above this line
Vr<C-a>           # Change them all to <C-a>
S200<esc>         # Replace the line with 200
@"                # Play back the 5 <C-a>'s, 200 -> 205
k                 # ????
Ii<C-v><C-v><esc> # insert "i<C-v>" so our line is now "i<C-v>205"
|D@"<esc>         # Delete the line and then run it, which inserts "Í" (ASCII 205)
A üî<esc>         # Append " üî" so our line is "Í üî"
|D@"              # Delete the line and run it

Í üî在V中转换为:%s/ \|\n//g在vim中，这将全局删除所有空格。该Í命令位于Wiki上，并且ü和和分别为和î，|并n设置了高位

C，140字节by betseg

#include<stdio.h>
int main(){int a=getchar();while(a!=EOF){//\a=getchar();
if(a!=10&&a!=32)//\\putchar(a^10^32);
putchar(a);a=getchar();}}

（我也希望我做对了。）

MATL，Luis Mendo的22个字节

虽然我不确定为什么，但这似乎有效

t' @ * 'dm1e5%M
dw%Y
(

我必须看看我是否能解决它的问题。我认为注释后面必须有换行符，然后只需要在正确的位置插入空格即可。

MATL，Luis Mendo提供的22 21字节。

最终... MickyT在我写解释时破解了它，所以他的回答是“有效”的。无论如何，我根据此meta post发布了此内容。

M并且Y是不必要的，并已被注释掉。只需添加4个空格字符，而不是5个即可。

t' @ *'dm1e5%M
dw%Y
(

这相当于更紧凑：

t' @ *'dm7dw(

部分说明：

         % Implicit input
t        % Duplicate input
' @ *'   % String with ASCII-values [32   64   32   42]
d        % diff, giving [32  -32   10], 32 is space, 10 is newline
m        % ismember, checking if the character is 32 or 10
1e5      % 10000, but could just as well be 7
d        % Taking the diff of the scalar 1e5, returning an empty matrix []
w        % Swap stack in order to use ( below
(        % Equivalent to x(y)=[], where x is the input string, and y is the logical
         % vector found using ismember (m)
         % Implicit output

Befunge-98，ninjalj编写的 65个字节

~v       >#@
 >::':'0--\'[';--!8v1+!
*1+j  !j,v         >#@

在线尝试！

这很有趣。我推断出，由于几乎没有方向改变命令，并且没有命令^<[]?x或类似命令，因此必须使用换行。然后，我编写了一个Python脚本来帮助正确设置的间距j。

该代码通过输入（~）并将其复制两次（::）来工作。然后，它减去10（':'0或ord(':') - ord('0')）和32（'[';或ord('[') - ord(';')）。然后，第二个结果在逻辑上取反（如果为空格则取1，否则为0），并按8。

现在需要确定要跳过的部分。将1+!被继续在下一行跳过。#跳过@。逻辑否定的结果（0或1）乘以8，然后加1。

然后，随着IP的移动，代码将跳过许多（即1或9）空格，再加上一个额外的空格。如果字符不是空格，则以结束!。字符代码减10逻辑取反（如果为换行符则为1，否则为0）。j然后跳过任何内容，并,调用print（），并通过垂直包装来恢复循环。

如果字符是一个空格，则底行再次以32, 22堆栈底部循环。第一个j跳跃705个空格。然后，该行第三次循环。如果堆栈上还剩下两个10（代码只留下了10），则第一个j跳100个空格，然后循环重复。否则，第一个j跳转到!，否定零，第二个j跳转到打印图上，程序继续。

我设法将其压缩到59个字节。

C＃6，201字节， 按牛奶

using System.Linq;
_=>string./**/
#if trueJoin
(/*"*//*/""/**//*/"*/",
#else
Concat(//*/,
#endif
from m in" "let p=$@"{@" 
"[1]}"from i in(_.Replace(p,@""))where!new[]{p[0]^32^10}.Contains(i)select@i);

复制演示

trueJoin未定义，因此仅string.Concat()保留。
p是"\n"。p[0]^32^10是空间。如果它是p[0]^42常数或其他类似的常数，将会（有点）困难。

网状，43字节，由Conor O'Brien

ISBqv<>>$$4j
E :d/v$v?
c+91d/ v?E
;!?l$/o $

在线尝试！

对我来说，这比应该做的要困难得多，因为我太愚蠢了，找不到文档，最终不得不猜测某些命令的工作方式。因此，其中的某些解释可能并不完全准确，但这是我对代码的基本理解。

I               Push all the input on to the stack as a string
 S              Convert it into a character array.
  B             Turns that array into individual characters on the stack.
   q            Reverse the stack so the first letter is on top.
    v           Move down... 
    /           ...and turn left.
E :d            Duplicate the value and test if equal to space.

       v?       If it is a space we move down until we wrap to the top.
       >$$      Drop the test result and the space.
          4j    Jump over the next 4 commands (having wrapped to the start).
    v           Bringing us back to the first down arrow, ready to test the next char.

     v$         If it wasn't a space, drop the test result and move down.
c+91d/          Turn left and push a newline (char 10) on to the stack.
       v?E      If equal, we go down, following the same path as with the space.

     /          If not equal, turn down.
   l$/          Then turn left, drop the test result, and push the stack size.
;!?             If zero (the stack is empty) we terminate.
        o$      Otherwise wrap around, drop the stack size, and output the char. 
     /          Then turn down wrapping around to the top of the program.
    v<          Then turn left and down to start the process from the beginning again.

C＃，159个字节 由LethalCoder提供

using System.Linq;s=>string.Join("",string.Join("",s.Split(@" 
".Replace(new string((char)0x0D,1),"").ToCharArray())).Select(c=>c+""!=""?c+"":"").ToArray());

代表

第1行末尾的字符串是" \n"（space + newline）。

/*Func<string, string> Lambda =*/ s =>
    string.Join("",                                                           // No-op
    string.Join("",                                                           // Join (without whitespace)
        s.Split(@" \n".Replace(new string((char)0x0D,1),"").ToCharArray())    // Split on whitespace
    ).Select(c=>c+""!=""?c+"":"").ToArray());                                 // No-op

Minkolang v0.15，Kritixi Lithos编写的88个字节

$oI[dd" "=$r'10'=1J,? 1R]r$O3.14
$$$
Cdollars             >
$$$
Ceverywhere           >x

说明

                               # Layer 1
$o                             # input chars onto stack
  I                            # stack length pushed to stack
   [                    ]      # loop popped TOS times (length of string)
    dd                         # duplicate, duplicate
      " "                      # push space to stack
         =                     # equality check
          $r                   # swap
            '10'               # number 10 to stack (LF char)
                =              # equality
                 1J            # or
                   ,           # not
                    ?          # if true jump next
                               # drop to layer 2
                      1R       # rotates the stack 1 time
                         r     # reverse the stack
                          $O   # output the stack
                             . # stop
$$$                            # Layer 2
                     >         # shift right and then drop to layer 3
$$$                            # Layer 3
                      >x       # shift right, pop char off stack and drop to Layer 1 (end loop)