Espacio en blanco significativo: ladrones

18

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.

Martin Ender
fuente

Respuestas:

8

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
nimi
fuente
7

> <>, 40 bytes, por DanTheMan

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

Muy divertido de hacer ejercicio.

Pruébalo en> <> idioma

Pelícano verde azulado
fuente
¡Buen trabajo! Me alegra que hayas disfrutado descifrándolo.
DanTheMan
7

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.

SLuck49
fuente
¡Hola, bien hecho! ;-)
Arnauld
2
$/**/=/[ \n]/;s['sp'+'lit']($)... oh, eso está sucio.
Patrick Roberts
En caso de que alguien tuviera curiosidad sobre mi intento de fuerza bruta, era pastebin.com/aN9Z1jVM
Patrick Roberts
6

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);
}   
Riley
fuente
¡Guauu! Buen trabajo. Incluso tuve problemas para leerlo al final, y lo escribí.
rexroni
@rexroni #defineabome echó por un tiempo. Al principio pensé que tenía que ser #define ab olo que agregaría algunos ;s adicionales , pero eso no funcionó cerca del final.
Riley
sí, eso fue elegido específicamente para hacerlo más difícil :)
rexroni
5

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,'')
Dom Hastings
fuente
4

RprogN, por Ataco

Esto parece hacer el truco

' ' ` R
"
" ` R
MickyT
fuente
Accidentalmente lo jugué mientras descifraba jaja, hasta 14 bytes
Alfie Goodacre
Tengo mucha curiosidad por cómo lo jugaste.
ATaco
@ATaco el programa tiene solo 14 bytes. ¿Contaste un salto de línea final o algo así?
Martin Ender
@ATaco Me equivoqué, no pude probar nuevas líneas en el compilador en línea, lo que a su vez me hizo pensar que estaba funcionando, pero había eliminado el literal lf
Alfie Goodacre
4

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

nmjcman101
fuente
¡Buen trabajo! Esa es la solución exacta que tuve. :)
DJMcMayhem
3

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

Riley
fuente
Ninja'd por un minuto!
Kritixi Lithos
@KritixiLithos Same, estaba a punto de presentarse cuando apareció esta respuesta ^^
Denker
3

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.

MickyT
fuente
Agradable, +1 Agregué una explicación parcial en mi respuesta :)
Stewie Griffin
1
@StewieGriffin, gracias por la explicación. Estaba tratando de trabajar por qué funcionó, pero iba lentamente.
Documentos
1
@MickyT Te refieres a detallado como Java :-P ¡Buen trabajo de craqueo!
Luis Mendo
3

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
Stewie Griffin
fuente
Buen trabajo de craqueo!
Luis Mendo
2
Gracias :) No sabía nada sobre MATL antes de comenzar ... Supongo que mi explicación no es del todo correcta (¿pero debería estar bastante cerca?). Me llevó mucho tiempo, ya que el 1e5impreso 100000, o 1eera una llamada reshape, pero ¿qué era 5? (Ahora veo que %está al final de la línea, por lo que sería 5M, no un cinco y un M. Además, pensé que tenía que tener Y(en una línea. En general, un tutorial MATL muy agradable :)
Stewie Griffin
La explicación es totalmente correcta :-) Sí, es una buena (aunque solo un poco difícil) comenzar con un idioma
Luis Mendo
2

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.

PurkkaKoodari
fuente
Enumerar el número del policía en su encabezado está bien (ya que el desempate recompensa tamaños más grandes de todos modos).
Martin Ender
2

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.

Enlace Ng
fuente
Como se comentó en las leches, responda que esto necesita C # 6+, si lo cambian, ¿usted también puede?
TheLethalCoder
2

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.
James Holderness
fuente
Hay documentos en la wiki de github.
Conor O'Brien
¡buena idea! Es impresionante que hayas hecho esto sin la wiki: D
Conor O'Brien
1

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
Leche
fuente
1

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)
MickyT
fuente
¡Bien hecho en descifrarlo! Esperaba que los Cerrores fueran confusos, ¡pero buen trabajo, sin embargo!
Kritixi Lithos
@KritixiLithos para ser honesto, una vez que separé las capas y me di cuenta de que la mayor parte del trabajo se realizó en la capa superior, se hizo más fácil. Aprendí un poco sobre el idioma haciendo esto, así que gracias :)
MickyT