Esto es parte de un desafío de policías y ladrones. Ve aquí por la parte de la policía.

Para el propósito de este desafío, definiremos los espacios en blanco como solo saltos de línea (0x0A) y espacios (0x20). Tenga en cuenta que la mayoría de los idiomas y los sabores de expresiones regulares también consideran muchos otros caracteres como espacios en blanco, tanto dentro como fuera del rango ASCII, por lo que es posible que no pueda utilizar los elementos integrados correspondientes.

El desafío de los ladrones

La respuesta de un policía se puede descifrar transformándola en un programa o función válida (en el idioma elegido), que realiza la tarea de eliminar espacios en blanco de una cadena de entrada, insertando espacios en blanco en el código. Por ejemplo, si recibió la siguiente entrada:

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

El programa debería generar

Hello,World!

Después de insertar espacios en blanco, el recuento de bytes de la solución no debe exceder el recuento de bytes indicado en la respuesta del policía. No tiene que encontrar la misma solución exacta que el policía, siempre y cuando la suya sea válida según las restricciones anteriores.

Si logra esto, publique una respuesta con la solución, vinculando la respuesta del policía, y deje un comentario sobre la respuesta del policía vinculando la suya.

El ladrón que descifra la mayor cantidad de respuestas policiales gana. Los lazos se rompen por la suma de los tamaños de las respuestas de los policías descifrados (a favor del ladrón que descifra los envíos más largos)

Cada respuesta de policía solo se puede descifrar una vez y, por supuesto, no puedes descifrar tu propia respuesta. Si la respuesta del policía resulta ser inválida antes o después de ser descifrada, no se cuenta para el puntaje del ladrón.

Haskell, 100 bytes, por 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 bytes, por DanTheMan

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

Muy divertido de hacer ejercicio.

Pruébalo en> <> idioma

JavaScript ES6, 199 bytes por Arnauld

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``

Me di cuenta de que la división "SecretCode"significaba que estaba buscando 11 números que sumaban (supuse) 33. Este es un problema de barras y estrellas donde el número de espacios son las estrellas y las letras en "SecretCode"las barras. Hice los cálculos para ver cuántas combinaciones había que probar (1.917.334.783 combinaciones) y decidí simplemente aplicar la fuerza bruta, me llevó todo el día.

Probablemente haya una forma más inteligente de hacerlo, por ejemplo, notar que ktiene que ser así 33y 66para los índices 10 y 21 respectivamente, pero soy vago.

C, 475 bytes por 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}

Podría comenzar a usar algunas de estas definiciones :)

Después del preprocesador, el código se ve así:

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

Ruby, 86 bytes + 1 bandera = 87 por histocrat

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

Esto fue realmente divertido, cada carácter en la cadena que se pasa evalse reemplaza con el código de carácter ( ord) XOR ^(...)contra el número de espacios restantes en la cadena. El código resultante es:

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

RprogN, por Ataco

Esto parece hacer el truco

' ' ` R
"
" ` R

V, 37 bytes, por DJMcMayhem

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

No imprimibles

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

TryItOnline

La üverdad me tiró para un bucle, me quedé esperando que tanto ella como îpara ser comandos.

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

Í üîin V se traduce en :%s/ \|\n//gin vim, que elimina globalmente todos los espacios en blanco. El Ícomando está en la wiki, y los üy îare |y nrespectivamente con su conjunto de bits alto

C, 140 bytes por 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();}}

(También espero estar haciendo esto bien).

MATL, 22 bytes por Luis Mendo

Aunque no puedo estar seguro de por qué, esto parece funcionar

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

Tendré que ver si puedo resolver lo que está haciendo. Pensé que los comentarios tenían que tener saltos de línea después de ellos y luego era solo una cuestión de colocar los espacios en los lugares correctos.

MATL, 22 21 bytes por Luis Mendo.

Finalmente ... MickyT lo descifró mientras escribía una explicación, por lo que su respuesta es la "válida". Publiqué esto de todos modos, de acuerdo con esta meta publicación .

My Yson innecesarios y están comentados. Es suficiente agregar 4 caracteres de espacio en blanco, no 5.

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

Esto es equivalente al más compacto :

t' @ *'dm7dw(

Explicación parcial:

         % 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, 65 bytes por ninjalj

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

Pruébalo en línea!

Esto fue muy divertido. Deducí que dado que hay pocos comandos de cambio de dirección y ninguno ^<[]?xo similar, tiene que usar envoltura. Luego escribí un script de Python para ayudar a obtener el espacio correcto para elj 's.

El código funciona tomando input ( ~) y duplicándolo dos veces ( ::). Luego resta 10 ( ':'0o ord(':') - ord('0')) y 32 ( '[';oord('[') - ord(';') ). Luego, el segundo resultado se niega lógicamente (1 si era espacio, 0 de lo contrario) y se empuja un 8.

Ahora viene la parte que necesitaba descubrir qué omitir. Se 1+!omite al continuar a la siguiente línea. #se salta el@ . El resultado negado lógicamente (0 o 1) se multiplica por el 8 y se agrega 1.

El código luego salta esa cantidad (es decir, 1 o 9) espacios más uno adicional a medida que se mueve la IP. Si el personaje no era un espacio, termina en el !. El código de caracteres menos 10 se niega lógicamente (1 si era nueva línea, 0 en caso contrario). jluego no omite nada, ,se llama a print ( ) y se reanuda el bucle envolviendo verticalmente.

Si el personaje era un espacio, la línea inferior se repite nuevamente 32, 22como la parte inferior de la pila. Los primeros jsaltos 705 espacios. Luego la línea se repite por tercera vez. Si quedan más de dos 10 en la pila (el código solo los deja), el primero jsalta 100 espacios y el ciclo se repite. De lo contrario, el primer jsalto al !, se niega un cero, el segundo jsalta sobre la impresión y el programa continúa.

Me las arreglé para jugar golf hasta 59 bytes.

C # 6, 201 bytes, por leche

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);

demo de repl.it

trueJoinno está definido, por lo que solo string.Concat()queda.
pes "\n". p[0]^32^10es el espacio Hubiera sido (un poco) más difícil si es p[0]^42u otras constantes similares.

reticular, 43 bytes, por Conor O'Brien

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

Pruébalo en línea!

Esto fue más difícil para mí de lo que debería haber sido porque fui demasiado estúpido para encontrar la documentación y terminé adivinando cómo funcionaban algunos de los comandos. Por lo tanto, parte de esta explicación puede no ser del todo precisa, pero esta fue mi comprensión básica del código.

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 bytes por LethalCoder

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

repl.it

La cadena al final de la línea 1 es " \n"(espacio + nueva línea).

/*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, 88 bytes por Kritixi Lithos

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

Explicación

                               # 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)