Dies ist Teil einer Cops and Robbers-Herausforderung. Gehen Sie hier für die Polizisten.

Für diese Herausforderung definieren wir Leerzeichen als nur Zeilenvorschübe (0x0A) und Leerzeichen (0x20). Beachten Sie, dass die meisten Sprachen und Regex-Varianten auch viele andere Zeichen als Leerzeichen betrachten, sowohl innerhalb als auch außerhalb des ASCII-Bereichs, sodass Sie möglicherweise nicht in der Lage sind, die entsprechenden integrierten Funktionen zu verwenden.

Die Herausforderung der Räuber

Die Antwort eines Polizisten kann geknackt werden, indem sie in ein gültiges Programm oder eine gültige Funktion (in der ausgewählten Sprache) umgewandelt wird, mit der Leerzeichen aus einer Eingabezeichenfolge entfernt werden, indem Leerzeichen in den Code eingefügt werden. Zum Beispiel, wenn Sie die folgende Eingabe erhalten haben:

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

Das Programm sollte ausgeben

Hello,World!

Nach dem Einfügen eines Leerzeichens darf die Bytezahl der Lösung die in der Antwort des Polizisten angegebene Bytezahl nicht überschreiten. Sie müssen nicht genau die gleiche Lösung finden, die der Polizist beabsichtigt hat, solange Ihre Lösung unter den oben genannten Bedingungen gültig ist.

Wenn du das schaffst, poste eine Antwort mit der Lösung, verlinke die Antwort des Polizisten und hinterlasse einen Kommentar zu der Antwort des Polizisten, die zurück zu deiner führt.

Der Räuber, der die meisten Cop-Antworten knackt, gewinnt. Die Krawatten werden durch die Summe der Größen der geknackten Antworten der Polizisten gebrochen (zugunsten des Räubers, der längere Einreichungen knackt).

Jede Antwort eines Polizisten kann nur einmal geknackt werden, und natürlich dürfen Sie Ihre eigene Antwort nicht knacken. Wenn sich herausstellt, dass die Antwort des Polizisten vor oder nach dem Knacken ungültig ist, wird sie nicht auf die Punktzahl des Räubers angerechnet.

Haskell, 100 Bytes, von 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, von DanTheMan

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

Wirklich Spaß zu trainieren.

Probieren Sie es auf> <> Sprache

JavaScript ES6, 199 Bytes von 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``

Ich erkannte, dass die Aufteilung "SecretCode"bedeutete, dass ich nach 11 Zahlen suchte, die sich zu (ich nahm an) 33 summierten. Dies ist ein Problem mit Sternen und Balken , bei dem die Anzahl der Leerzeichen die Sterne und die Buchstaben in "SecretCode"den Balken sind. Ich habe nachgerechnet, wie viele Kombinationen es zu probieren gab (1.917.334.783 Kombinationen), und entschied mich dafür, es nur mit brachialer Gewalt zu versuchen, was den ganzen Tag gedauert hat.

Es ist wahrscheinlich ein intelligenter Weg , um darüber zu haben , weg, zum Beispiel bemerkt , dass ksein muss 33und 66für den Index 10 bzw. 21, aber ich bin faul.

C, 475 Bytes von 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}

Ich könnte anfangen, einige dieser Definitionen zu verwenden :)

Nach dem Preprozessor sieht der Code ungefähr so ​​aus:

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

Ruby, 86 Bytes + 1 Flag = 87 von Histocrat

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

Das hat wirklich Spaß gemacht. Jedes Zeichen in der Zeichenfolge, an die übergeben wurde, evalwird durch den Zeichencode ( ord) XOR-verknüpft, wobei ^(...)die Anzahl der verbleibenden Leerzeichen in der Zeichenfolge berücksichtigt wird . Der resultierende Code lautet:

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

RprogN von Ataco

Dies scheint den Trick zu tun

' ' ` R
"
" ` R

V, 37 Bytes, von DJMcMayhem

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

Unbedruckbares:

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

TryItOnline

Das ühat mich wirklich auf eine Schleife geworfen, ich habe immer wieder erwartet, dass es îauch Befehle gibt.

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 bedeutet :%s/ \|\n//gin vim, wodurch alle Leerzeichen global entfernt werden. Der ÍBefehl ist im Wiki und die üund îsind |und njeweils mit ihren hohen Bit gesetzt

C, 140 Bytes durch 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();}}

(Ich hoffe auch, dass ich das richtig mache.)

MATL, 22 Bytes von Luis Mendo

Obwohl ich nicht sicher bin warum, scheint dies zu funktionieren

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

Ich werde sehen müssen, ob ich herausfinden kann, was es tut. Ich stellte mir vor, dass den Kommentaren Zeilenvorschübe folgen mussten, und dann ging es nur darum, die Leerzeichen an den richtigen Stellen zu platzieren.

MATL, 22 21 Bytes von Luis Mendo.

Endlich ... MickyT hat es geknackt, als ich eine Erklärung schrieb, also ist seine Antwort die "gültige". Ich habe das trotzdem gepostet, gemäß diesem Meta-Post .

Mund Ysind unnötig und werden auskommentiert. Es reicht aus, 4 Leerzeichen hinzuzufügen, nicht 5.

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

Dies entspricht dem kompakteren :

t' @ *'dm7dw(

Teilweise Erklärung:

         % 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 von Ninjalj

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

Probieren Sie es online!

Das hat sehr viel Spaß gemacht. Da es nur wenige Befehle zum Ändern der Richtung und keine ^<[]?xoder ähnliche Befehle gibt, musste ein Zeilenumbruch verwendet werden. Ich habe dann ein Python-Skript geschrieben, um den richtigen Abstand für die j's zu finden.

Der Code funktioniert durch Eingabe ( ~) und zweimaliges Duplizieren ( ::). Dann werden 10 ( ':'0oder ord(':') - ord('0')) und 32 ( '[';oder ord('[') - ord(';')) subtrahiert . Dann wird das zweite Ergebnis logisch negiert (1 wenn Leerzeichen war, 0 sonst) und eine 8 wird gedrückt.

Jetzt kommt der Teil, der herausfinden musste, was zu überspringen ist. Das 1+!wird übersprungen, indem in der nächsten Zeile fortgefahren wird. #überspringt das @. Das logisch negierte Ergebnis (0 oder 1) wird mit der 8 multipliziert und 1 addiert.

Der Code springt dann um so viele (dh 1 oder 9) Stellen plus eine zusätzliche Stelle, wenn sich die IP bewegt. Wenn der Charakter kein Leerzeichen war, landet er am !. Der Zeichencode minus 10 wird logisch negiert (1 wenn Newline war, 0 sonst). jÜberspringt dann nichts, und print ( ,) wird aufgerufen, und die Schleife wird durch vertikales Umbrechen fortgesetzt.

Wenn das Zeichen ein Leerzeichen war, wird die unterste Zeile erneut 32, 22als unterste Zeile des Stapels angezeigt. Die ersten jSprünge 705 Felder. Dann wird die Leitung ein drittes Mal durchgeschleift. Wenn mehr als zwei Zehner auf dem Stapel übrig sind (der Code verlässt nur diese), jspringt der erste um 100 Felder und die Schleife wird wiederholt. Ansonsten jspringt der erste auf !, eine Null wird negiert, der zweite jspringt über den Ausdruck und das Programm wird fortgesetzt.

Ich habe es geschafft, es auf 59 Bytes herunter zu spielen.

C # 6, 201 Bytes, nach Milch

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

Repl.it Demo

trueJoinist nicht definiert, string.Concat()bleibt also nur .
pist"\n" . p[0]^32^10ist Raum. Es wäre (ein bisschen) schwieriger gewesen, wenn es p[0]^42oder andere ähnliche Konstanten wären .

netzförmig, 43 Bytes, von Conor O'Brien

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

Probieren Sie es online!

Das war für mich schwieriger, als es hätte sein sollen, weil ich zu dumm war, um die Dokumentation zu finden, und schließlich raten musste, wie einige der Befehle funktionierten. Einige dieser Erklärungen sind möglicherweise nicht ganz richtig, aber dies war mein grundlegendes Verständnis des Codes.

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

Die Zeichenfolge am Ende von Zeile 1 lautet " \n"(Leerzeichen + Zeilenumbruch).

/*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 von Kritixi Lithos

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

Erläuterung

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