Bedeutendes Leerzeichen: Räuber

18

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.

Martin Ender
quelle

Antworten:

8

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

> <>, 40 Bytes, von DanTheMan

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

Wirklich Spaß zu trainieren.

Probieren Sie es auf> <> Sprache

Blaugrüner Pelikan
quelle
Gut gemacht! Ich bin froh, dass du es genossen hast, es zu knacken.
DanTheMan
7

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.

SLuck49
quelle
Hey, gut gemacht! ;-)
Arnauld
2
$/**/=/[ \n]/;s['sp'+'lit']($)... oh, das ist dreckig.
Patrick Roberts
Falls jemand neugierig auf meinen Brute-Force-Versuch war, war es pastebin.com/aN9Z1jVM
Patrick Roberts
6

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);
}   
Riley
quelle
Wow! Gute Arbeit. Am Ende hatte ich sogar Probleme, es zu lesen, und ich schrieb es.
Rexroni
@ Rexroni #defineabowarf mich für eine Weile ab. Zuerst dachte ich, es #define ab omüsste etwas mehr sein ;, aber das hat gegen Ende nicht geklappt.
Riley
Ja, das wurde speziell ausgewählt, um es schwieriger zu machen :)
Rexroni
5

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

RprogN von Ataco

Dies scheint den Trick zu tun

' ' ` R
"
" ` R
MickyT
quelle
Ich habe es versehentlich beim Knacken gespielt, haha, bis auf 14 Bytes
Alfie Goodacre
Ich bin wirklich neugierig, wie du es gespielt hast.
ATaco
@ATaco das Programm ist nur 14 Bytes. Haben Sie einen Zeilenvorschub oder etwas anderes gezählt?
Martin Ender
@ATaco Ich habe mich geirrt, ich konnte keine Zeilenumbrüche auf dem Compiler online testen, was mich zu der Annahme veranlasste, dass es funktionierte, aber ich hatte das lf-Literal
Alfie Goodacre
4

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

nmjcman101
quelle
Gut gemacht! Das ist genau die Lösung, die ich hatte. :)
DJMcMayhem
3

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

Riley
quelle
Ninja'd ich um eine Minute!
Kritixi Lithos
@KritixiLithos Same, wollte gerade einreichen, als diese Antwort auftauchte ^^
Denker
3

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.

MickyT
quelle
Nizza, +1 Ich habe eine teilweise Erklärung in meiner Antwort hinzugefügt :)
Stewie Griffin
1
@StewieGriffin, danke für die Erklärung. Ich versuchte zu arbeiten, warum es funktionierte, aber es ging langsam voran. Sehr umfangreiche Dokumente Luis :)
MickyT
1
@MickyT Du meinst wortreich wie Java :-P Schöne Crackarbeit!
Luis Mendo
3

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
Stewie Griffin
quelle
Gute Cracking-Arbeit!
Luis Mendo
2
Danke :) Ich wusste nichts über MATL, bevor ich anfing ... Ich denke, meine Erklärung ist nicht ganz richtig (sollte aber ziemlich nah sein?). Es hat lange gedauert, bis das 1e5entweder gedruckt 100000wurde oder 1eein Anruf war reshape, aber was war dann 5? (Ich sehe jetzt, dass das %Ende der Zeile ist, also wäre es 5Mnicht eine Fünf und eine M. Außerdem dachte ich, ich müsste Y(eine Zeile haben. Alles in allem ein sehr schönes MATL-Tutorial :)
Stewie Griffin
Die Erklärung ist völlig korrekt :-) Ja, es ist eine gute (wenn auch nur ein wenig schwierige) Art, mit einer Sprache zu beginnen
Luis Mendo
2

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.

PurkkaKoodari
quelle
Das Auflisten der Anzahl der Polizisten in Ihrem Header ist in Ordnung (da der Tiebreaker ohnehin größere Größen belohnt).
Martin Ender
2

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 .

Link Ng
quelle
Wie auf Milch kommentiert, muss dies mit C # 6+ beantwortet werden, wenn sie sich ändert, können Sie das auch?
TheLethalCoder
2

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.
James Holderness
quelle
Es gibt Dokumente im Github-Wiki.
Conor O'Brien
gute Idee! Und beeindruckend, dass Sie dies ohne das Wiki getan haben: D
Conor O'Brien
1

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
Milch
quelle
1

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)
MickyT
quelle
Gut gemacht, es zu knacken! Ich hatte gehofft, die CAuslassungen würden verwirrend sein, aber trotzdem gute Arbeit!
Kritixi Lithos
@KritixiLithos um ehrlich zu sein, als ich die Ebenen aufteilte und feststellte, dass die meiste Arbeit in der obersten Ebene erledigt wurde, wurde es einfacher. Ich habe ein bisschen über die Sprache gelernt, also danke :)
MickyT