Untuk tujuan tantangan ini, kami akan mendefinisikan spasi putih sebagai hanya baris baris (0x0A) dan spasi (0x20). Perhatikan bahwa sebagian besar bahasa dan rasa regex mempertimbangkan banyak karakter lain sebagai spasi putih, baik di dalam maupun di luar rentang ASCII sehingga Anda mungkin tidak dapat menggunakan built-in yang sesuai.

Tantangan Polisi

Anda harus menulis sebuah program atau fungsi dalam bahasa pilihan Anda, yang mengambil string, yang terdiri dari karakter ASCII (kecuali NUL), sebagai input dan output dengan semua spasi putih dihapus. Misalnya jika Anda menerima input berikut:

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

Anda harus mengeluarkan

Hello,World!

Kiriman Anda kemudian akan menjadi kode sumber Anda dengan semua spasi kosong dihapus (proses yang sama seperti meneruskan solusi Anda sebagai input untuk dirinya sendiri, meskipun solusi Anda juga dapat berisi karakter di luar rentang ASCII). Tujuan Anda adalah membuatnya sesulit mungkin untuk mencari tahu di mana spasi putih perlu dimasukkan untuk memulihkan solusi yang valid dalam bahasa pilihan Anda. Perhatikan bahwa perampok dapat memasukkan lebih sedikit spasi daripada yang Anda hapus, tetapi tidak lebih. Ingat juga bahwa perampok tidak harus cocok dengan kode persis Anda, mereka hanya harus menemukan solusi yang valid.

Jawaban Anda harus berisi yang berikut:

• Bahasa (dan versi jika perlu) di mana Anda menulis solusi Anda.
• Jumlah byte solusi Anda sebelum menghapus spasi.
• Solusi Anda dengan spasi kosong dihapus.

Solusi Anda bisa berupa program atau fungsi, tetapi bukan cuplikan dan Anda tidak boleh menganggap lingkungan REPL. Anda dapat mengambil input melalui STDIN, argumen baris perintah atau argumen fungsi dan output melalui STDOUT, nilai pengembalian fungsi atau parameter fungsi (keluar).

Untuk kepentingan keadilan, harus ada juru bahasa atau kompiler yang tersedia secara bebas untuk bahasa pilihan Anda.

Anda tidak boleh menggunakan built-in untuk hashing, enkripsi atau pembuatan angka acak (bahkan jika Anda menyemai generator nomor acak ke nilai tetap). Solusi Anda harus dapat memproses string 100 karakter atau kurang dalam waktu kurang dari 10 detik pada mesin desktop yang masuk akal.

Jika jawaban Anda belum retak dalam 7 hari (168 jam), Anda dapat mengungkapkan solusi Anda sendiri di mana titik jawaban Anda dianggap aman . Selama Anda tidak mengungkapkan solusi Anda, itu mungkin masih dapat dipecahkan oleh perampok, bahkan jika 7 hari telah berlalu. Jawaban aman terpendek menang (diukur sebelum menghapus spasi putih).

Jika jawaban Anda retak, harap tunjukkan ini di tajuk jawaban Anda, bersama dengan tautan ke jawaban perampok yang sesuai.

Buka di sini untuk bagian perampok.

Pengajuan Tidak Rusak

<script>site = 'meta.codegolf'; postID = 5686; isAnswer = false; QUESTION_ID = 103182;</script><script src='https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script><script>jQuery(function(){var u='https://api.stackexchange.com/2.2/';if(isAnswer)u+='answers/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJeRCD';else u+='questions/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJO6t)';jQuery.get(u,function(b){function d(s){return jQuery('<textarea>').html(s).text()};function r(l){return new RegExp('<pre class="snippet-code-'+l+'\\b[^>]*><code>([\\s\\S]*?)</code></pre>')};b=b.items[0].body;var j=r('js').exec(b),c=r('css').exec(b),h=r('html').exec(b);if(c!==null)jQuery('head').append(jQuery('<style>').text(d(c[1])));if (h!==null)jQuery('body').append(d(h[1]));if(j!==null)jQuery('body').append(jQuery('<script>').text(d(j[1])))})})</script>

Haskell, 100 byte, dipecahkan oleh nimi

main=interact$iddoidlinesidwordsdoidoidoid=doiddoid<-dooiidoid<-dooiddoiddodoid

Ini adalah program penuh dan puisi dadaistic.

Kode dengan spasi (Coba online!)

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

^{Masih terlihat cukup puitis, jika Anda bertanya kepada saya.}

De-dikaburkan

main = interact f
f s = do
 l <- lines s
 w <- words l
 id w

Penjelasan

The do-notation hanya sintaksis gula, sehingga fdapat dipersamakan ditulis sebagai

f s = lines s >>= words >>= id

Untuk daftar >>=-operator didefinisikan sebagai concatMap, jadi fmenjadi

f = concat . map id . concat . map words . lines

Jadi diberi input "a b\nc", linesbagi input di baris baru ["a b","c"], bagi wordssetiap baris di ruang putih menghasilkan [["a","b"],["c"]](seperti yang saya sadari sekarang ini termasuk baris baru, jadi linessebenarnya tidak diperlukan). Menggabungkan sekali memberi ["a","b","c"], idadalah fungsi identitas dan dengan demikian tidak memiliki efek dan penggabungan akhir menghasilkan string "abc".

C, 475 byte, dipecahkan oleh Riley

Bagian-bagian tertentu dari C membuatnya sangat sangat mudah untuk melihat ke mana spasi harus pergi. Namun, pra-prosesor c tidak. Jadi kode ini terbagi dalam dua bagian: hingga baris 17 (236 karakter dengan spasi putih) kode ini hampir tidak dikontrol, dan setelah itu (239 karakter dengan spasi putih), semoga berhasil!

Tidak akan memenangkan kompetisi ini dengan tembakan panjang, tapi saya ingin melihat apa yang bisa dilakukan dengan c pre-processor.

#include<unistd.h>#defineachar#defineb*#definecwrite#definedstdin#defineestdout#definefread#defineg(#defineh)#defineiwhile#definejif#definek0#definel&#definem,#definen=#defineo;#definep1#definegpmlmlh#defineabo#definemldmp#definejgdoabo#definelbabod#definegfhaboc#definejgmben#definepmlfg#definegpmlbintmain(){ajgajgmljgigpmlkmlgpmlhjgd!=''&&gpm!='\n'gfgpmlgpmlo}

Kompilasi (dengan peringatan, jika Anda mengaktifkannya) dengan gcc -std=c89 -ansidan berfungsi seperticat file | ./a.out

Ini retak jauh lebih cepat dari yang saya kira, selamat! Strategi saya adalah menggunakan #definesuntuk menghapus batas-batas token yang jelas (seperti ';') dan kemudian menggunakan lebih banyak #definesuntuk membuatnya benar-benar tidak intuitif bagaimana mereka dibolak-balik.

Ngomong-ngomong, ini adalah kode yang terlihat setelah hanya spasi kosong yang telah ditambahkan:

#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
// thus begins the obfuscation
#define gpmlmlh
#define abo
#define mldmp
#define jgdoabo
#define lbabod
#define gfhaboc
#define jgmben
#define pmlfg
#define gpmlb
int main(){
    ajgajgmljgigpmlkmlgpmlhjgd!=''&&gpm!='\n'gfgpmlgpmlo
}

Oktaf, 69 byte, AMAN!

@(U)eval([85329685312682956148388531268295156241''])

Format input: Baris baru tidak dapat dimasukkan secara langsung di command prompt. Buat string dengan gabungan seperti ini:

str = ['This is ',10,'a',10,'string']
str = This is
a
string

Panggil fungsi seperti ini (tambahkan spasi):

f=@(U)eval([85329685312682956148388531268295156241''])  
f(['This is ',10,'a',10,'string'])

Kode asli:

Anda hanya perlu 66 byte agar ini berfungsi, tetapi saya menulis 69 di header agar tidak memberikan terlalu banyak informasi.

Kode aslinya terlihat seperti ini:

@(U)eval([853 296 853 126 829 561 48 38 853 126 829 51 562 41 ''])

Penjelasan:

@(U)eval(.....)    % Anonymous function taking U as the input variable

Uadalah titik kode 85pada tabel ASCII, sehingga akan tampak seperti spasi pertama setelahnya 85. Salah!

Jika kita memasukkan spasi setelahnya 853, kita harus mendapatkan nomor karakter 853, kan ..? Menggunakan charuntuk memeriksa apakah itu karakter yang dikenali:

char(853)
warning: range error for conversion to character value

Namun, kami tidak menggunakan chardalam kode, kami menggunakan versi yang lebih pendek di mana kami menggabungkan angka-angka dengan string kosong [853 '']. Alih-alih memberikan kesalahan di luar jangkauan, versi yang lebih pendek hanya mengambil angka modulus 256.

Kebetulan itu saja 85+3*256 = 853. Sementara char(853)memberi peringatan, [853,'']kembali U.

Cara yang jelas untuk melakukan tugas ini dalam Oktaf adalah:

@(U)U(U~=10&U~=32)

Kita tahu bahwa harus ada tanda kurung pembuka (titik kode 40) setelah yang pertama U. 29jelas tidak cocok jadi kami menggeser ruang lebih jauh ke kanan dan mendapatkan 296. mod(296,256) = 40. Bingo!

Lanjutkan seperti ini dan akhiri dengan urutan:

[853 296 853 126 829 561 48 38 853 126 829 51 562 41 '']
ans = U(U~=10&U~=32)

Akhirnya, kita gunakan evaluntuk mengubah string menjadi kode.

JavaScript ES6, 199 byte, dipecahkan oleh SLuck49

Entri yang agak tebal dengan 33 byte ruang kosong untuk ditambahkan.

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

> <>, 40 byte, Retak oleh Teal pelican

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

Ngomong -ngomong, saya menggunakan fishlanguage.com , kalau-kalau ada perbedaan antara penafsir.

Befunge-93, 58 byte, Aman!

_vv$v<~:!`:<#^0*@-:0*5|845\+`-v0,<#-^<

Cobalah online!

Program Asli

_vv
 $ v<
 ~:!`
 :<#^0
*  @
-:0
*5 |
8
45
\+`
-
v0,<
#-
^<

Cobalah online!

Trik untuk ini adalah bahwa jalur eksekusi lebih vertikal daripada horizontal, kemudian berbagai ruang dimasukkan secara acak dalam kode untuk lebih jauh mengocok jalur vertikal. Setelah garis putus dan spasi putih akhirnya dihapus, mudah-mudahan ada sangat sedikit untuk menunjukkan bagaimana operasi terkait satu sama lain.

Dalam hal itu tidak cukup sulit, saya juga melemparkan sedikit interleaving, sehingga sejumlah operasi akhirnya dieksekusi oleh jalur kode yang berbeda yang mengalir saling tegak lurus. Gagasannya adalah bahwa jika Anda pikir Anda telah menemukan posisi yang benar untuk perintah tertentu, Anda tidak akan menyadari bahwa Anda mungkin perlu menggunakannya lagi nanti dalam kode.

Tidak yakin apakah sepadan dengan semua usaha yang dilakukan untuk membuat hal-hal rumit, atau orang-orang bahkan tidak repot-repot mencoba menyelesaikannya. :)

Penjelasan Kode

_      Since an empty stack is treated as zero, this initially just branches right.
v      The program flow is then directed downwards.
$      And this drop command initially does nothing because the stack is still empty.
~      A character is read from stdin.
::     Two duplicates are created.
55+-   We subtract 10 from the first copy (the 0- is just a nop to confuse things).
\48*-  And subtract 32 from the second copy.
*      The product of those two will be zero if the character is a newline or space.
_      So if we got whitespace, our branch goes right again repeating the loop.

v      If not, we go left, wrapping around till we hit the down arrow in column 3.
:<:    Again we make two duplicates of the character.
0`!|   One copy is used to compare if it's not greater than zero.
@      If it's not (i.e. it's the EOF), the branch goes up and we terminate.
<      Otherwise we go down and to the left.
,      Output the second copy of the character, leaving one remaining on the stack.
0      Push a zero to force the next branch right.
v      Redirect the flow down, wrapping to the top again.
_      Back at our initial branch, the zero we pushed forces us right.
v      Again the program flow is directed downwards.
$      And the drop command gets rid of the last duplicate character.
~      So now we're back reading the next character and the loop repeats.

C # 6, 201 byte, Retak oleh Link Ng

usingSystem.Linq;_=>string./**/#iftrueJoin(/*"*//*/""/**//*/"*/",#elseConcat(//*/,#endiffrommin""letp=$@"{@""[1]}"fromiin(_.Replace(p,@""))where!new[]{p[0]^32^10}.Contains(i)select@i);

184 byte runtuh, meninggalkan Anda 17 byte spasi.

Solusi retak menggunakan Concatsedangkan solusi yang saya maksudkan menggunakan Join, inilah solusi yang dimaksud:

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

MATL , 22 byte. Retak dan retak .

Ini adalah program yang mengambil input melalui STDIN dan menghasilkan output melalui STDOUT.

Kode tanpa spasi atau baris baru:

t'@*'dm1e5%Mdw%Y(

The format masukan sedikit canggung karena bagaimana MATL mengambil string input. String dengan baris baru tidak dapat dimasukkan secara langsung melalui STDIN, karena setiap input harus berupa satu baris (baris baru menandai akhir input). Jadi formatnya adalah sebagai berikut:

1. Sebuah string diapit dengan tanda kutip tunggal . Jika konten string menyertakan tanda kutip tunggal, mereka lolos dengan menduplikasi . Contoh:'I''m a string'

2. Untuk memasukkan string dengan baris baru, kita perlu membagi string pada baris baru dan menggabungkan semuanya (dengan tanda kurung siku), termasuk angka sebagai kode ASCII . Misalnya, perhatikan string yang dibentuk oleh nama depan dan belakang saya dengan baris baru di antaranya. Itu akan dimasukkan sebagai ['Luis' 10 'Mendo'].

   Ini memungkinkan memasukkan kode ASCII lainnya (mungkin tidak dapat dicetak). Jadi string pada item 1 di atas dapat dimasukkan sebagai alternatif ['I' 39 'm ' 97 32 'string']. Lihat di sini .

   Satu-satunya syarat adalah bahwa setidaknya salah satu bagian dalam tanda kurung adalah string. Itu memaksa angka apa pun untuk ditafsirkan sebagai kode ASCII saat digabungkan.

Maaf tentang canggung Semoga sukses menggunakan format ini!

Solusi asli

t' @ *'dm1e 5%
Mdw%Y
(

Masing %- masing adalah simbol komentar, dan sisa baris diabaikan.

Spasi tidak melakukan apa pun, tetapi berfungsi sebagai pemisah. Misalnya, 1e5tanpa spasi, akan diartikan sebagai angka 100000.

t mengambil input dan menduplikatnya.

' @ *'mendorong string itu, dan dmenghitung perbedaan berturut-turut, yang memberi [32 -32 10]( -32tidak ada gunanya).

mmemberikan larik baris logis yang menunjukkan karakter 32atau 10(atau -32) mana.

1diikuti oleh emembentuk ulang sebagai baris. Ini bukan op di sini.

5diikuti oleh Mdorongan 1lagi (input terakhir ke fungsi multi-input terbaru, yaitue ).

dmenghitung perbedaan berturut-turut 1, dan memberi [](array kosong).

wswap, dan akhirnya (ditugaskan []ke karakter spasi putih, yaitu menghapusnya.

RProgN , 15 Bytes Retak!

''`R""`R

Anda dapat mempermainkan kode di sini . Sebuah solusi yang relatif sederhana, mudah-mudahan sifat menyebalkan dari bagaimana RProgN menangani string akan meninggalkan masalah ini.

Program Asli

' ' ` R
"
" ` R

Penjelasan

Pertama, input secara implisit didorong ke stack. Tumpukan:<INPUT>

Kemudian, kami menggunakan '' untuk mendorong spasi ke tumpukan. Tumpukan:<INPUT> " "

`sebenarnya mencoba untuk mendorong string yang diwakili oleh` (WORD) tetapi karena ada spasi setelahnya, itu hanya mendorong string kosong. Tumpukan:<INPUT> " " ""

R di sini adalah gula untuk perintah Ganti. Tumpukan:<INPUTWITHOUTSPACES>

Selanjutnya, "NEWLINE" mendorong string yang berisi baris baru, yang bagus karena RProgN tidak menggunakan escapes, itu hanya lurus ke atas memungkinkan Anda mendorong string seperti itu. Tumpukan<INPUTWOSPACES> "\n"

Kemudian, kami menggunakan `trik lagi, dan Ganti, yang memberikan hasil kami.

Ruby, 86 byte + 1 bendera = 87 ( retak oleh Dom Hastings )

Membutuhkan bendera baris perintah -p.

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

Kode ini sebenarnya valid dalam formulir ini, hanya no-op.

Beam , 72 byte, Aman!

Sekarang untuk bahasa 2d. Dapat dimainkan dengan di TIO Nexus .

s'''>`+++)+Ss`n\
 n`sS+(+++`<``/
 >rgn\
 ^ @<(\  
     H         <
 ^    /

Program yang cukup lurus ke depan tanpa banyak di sana untuk mencoba menipu orang.

s'''>`+++)+Ss`n\ # Sets the memory slot 0 to 0, 10 to 10 and 32 to 32. n will redirect down
 n`sS+(+++`<``/  # since memory != store. \ is a red herring and not hit.
 >rgn\           # read in from input and set store to memory value. For all characters
 ^ @<(\          # other than space, LF and end of input this will be different and n will 
     H         < # redirect down then through to the print and back to read. Space, LF and  
 ^    /          # end of input get directed to the ( which tests for 0. This will redirect 
                 # space and LF to path back to read, otherwise it will skip over and halt

Labirin , 127 byte

);""{"".@"-;,""""":"##"*"(:"+":}-;{";;"*#{:;"#""+("-;"";;"})"";""""""""

Semoga saya melakukan ini dengan benar :) ini adalah entri polisi dan perampok pertama saya.

Kode Asli

 ) ;""{"".@
"-;, "" ""
"  :
" ##
" *
" (:
"  +
"  :}-;{
"    ; ;
" *#{: ;
" #    "
" +("-;"
"    ; ;
"    })"
"      ;
""""""""

Java, 3241 + 28 Bytes untuk impor bilangan bulat besar

Entri ini semata-mata untuk membuktikan kemungkinan entri yang murni aman secara kriptografis. Saya percaya ini ada dalam aturan, tetapi jika itu bertentangan dengan semangat, beri tahu saya dan saya akan menghapusnya dari keadilan. Saya akan membiarkan "tidak aman" ini tanpa batas waktu sampai saat (dan jika) celah ditemukan. Ini adalah monstrositas dan pasti bisa lebih dioptimalkan, tetapi ini dia.

interfacer{staticvoidmain(String[]A){Strings=",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,",q=",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,",a="",b="";for(Stringt:s.split(",")){a+=t.length();}for(Stringt:q.split(",")){b+=t.length();}if((newBigInteger(a).multiply(newBigInteger(b)).toString()).equals("3649760552772806991406184564114682549877113954361462782925976763675666255653486225665808494957477900238166874367635068317805381406282572366371821972593595701388544127398102379288357379612333197280663769935384647844344358594407966485992727383589962048236726744715096711312156760311643104858212670342667229690568585229658813910569607411855770280546861422837629553847973043531578541545436967345783407835402474562087790816775240815912495599135241317")){System.out.println(A[0].replaceAll("","").replaceAll("\n",""));}}}

Karena keadilan bagi para perampok, ini dia dengan semua ruang putih "jelas" yang ditambahkan.

interface r {

    static void main(String[] A) {
        String s = ",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,", q = ",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,", a = "", b = "";
        for (String t : s.split(",")) {
            a += t.length();
        }
        for (String t : q.split(",")) {
            b += t.length();
        }
        if ((new BigInteger(a).multiply(new BigInteger(b)).toString()).equals("3649760552772806991406184564114682549877113954361462782925976763675666255653486225665808494957477900238166874367635068317805381406282572366371821972593595701388544127398102379288357379612333197280663769935384647844344358594407966485992727383589962048236726744715096711312156760311643104858212670342667229690568585229658813910569607411855770280546861422837629553847973043531578541545436967345783407835402474562087790816775240815912495599135241317")) {
            System.out.println(A[0].replaceAll("", "").replaceAll("\n", ""));
        }
    }
}

Semoga beruntung, saya akan senang melihat ini retak. Bahkan saya akan melembagakan hadiah tak terbatas untuk ini. Jika suatu saat Anda melakukan crack ini, Anda akan diberikan penghargaan tak terbatas rep 500 rep pada pertukaran stack (serta kemungkinan makalah matematika yang bagus).

C, 140 byte, dipecahkan oleh Riley

Mari kita mulai dengan yang mudah.

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

(Saya harap saya melakukan ini dengan benar.)

Befunge 98, 65 byte, dipecahkan oleh Pietu1998

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

Program asli

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

V , 37 byte Retak oleh nmjcman101

OVrS200@"kIi|D@"Aüî|D@"

Karena ini memiliki unsintables, inilah versi yang dapat dibaca:

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

Atau jika Anda lebih suka, hexdump:

00000000: 4f1b 5672 0153 3230 301b 4022 6b49 6916  O.Vr.S200.@"kIi.
00000010: 161b 7c44 4022 1b41 fcee 1b7c 4440 22    ..|D@".A...|D@"

Minkolang v0.15 , 88 byte, Retak!

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

Cobalah online!

JavaScript ES6, 380 byte, aman

Ini adalah jenis entri yang awalnya saya rencanakan untuk rilis. Ini sangat besar dan hampir tidak memiliki peluang untuk menang, tetapi saya pikir itu harus cukup kuat secara kriptografi untuk bertahan 7 hari. Sekarang, saya mungkin terbukti salah!

67 byte ruang kosong untuk ditambahkan.

s=>{for(k=`|||`.split`|`.map(s=>s.replace(/\s/g,c=>(k-=(c<'')+1,n=n<<2|k&3),k=n=0)&&n),x=10106050295,y=-4955405499,i=32,d=2654435769,t=d*i;i--;y-=(x<<4^x>>>5)+x^t+k[t>>>11&3],t-=d,x-=(y<<4^y>>>5)+y^t+k[t&3]);returns[atob(([x,y].map(n=>String.fromCharCode(n&255,n>>8&255,n>>16&255,n>>24)).join``))](/[\n]/).join``}

Larutan

Ini adalah implementasi dari Algoritma Enkripsi Tiny Diperpanjang . Kunci yang dikodekan spasi 64-bit memperluas ke kunci 128-bit berikut:

K = [0xd224de37, 0x89e34e79, 0xe34e7748, 0x939e2789]

Sumber: Wikipedia

Setelah didekripsi dan dikonversi ke ASCII, blok 64-bit [x, y]bertuliskan c3BsaXQ=, yang merupakan representasi yang dikodekan dari Base64 split.

let f =

s=>{for(k=` 
 


   

 
 

|


 
 
 
    
  |  
 
    



 

|
     
 

 
 

 `.split`|`.map(s=>s.replace(/\s/g,c=>(k-=(c<' ')+1,n=n<<2|k&3),k=n=0)&&n),x=10106050295,y=-4955405499,i=32,d=2654435769,t=d*i;i--;y-=(x<<4^x>>>5)+x^t+k[t>>>11&3],t-=d,x-=(y<<4^y>>>5)+y^t+k[t&3]);return s[atob(([x,y].map(n=>String.fromCharCode(n&255,n>>8&255,n>>16&255,n>>24)).join``))](/[ \n]/).join``}

console.log(f(`H e l l o
W o r l d`))

Vitsy , 73 byte, aman

Ini benar-benar jahat.

5mW3m7m7m2mD&EPamX}<m15mEnl9mZD\[4m]^P-cm(D_2-3*bmD1-dmrnu-'

Semoga berhasil! 13 item ruang kosong untuk ditambahkan.

Kode asli:

5m
W3m7m
7m
2m
D&EPamX}
<m1
5mEn
l9mZ
D
\[4m]
^P-cm(D
_2-3*
bmD1-dmrnu-
'

Cobalah online!

Ini secara kasar disederhanakan menjadi:

<m1
W2\[2m]Z
l\[D&EP^P-_2-3*D1-rnu-(DX}]

C #, 159 byte, Retak karena susu

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

153 runtuh sehingga hanya 6 byte ruang kosong untuk ditemukan, seharusnya tidak terlalu sulit ...

reticular, 43 byte, retak

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

Versi TIO sudah usang, tetapi Anda bisa mendapatkan salinannya sendiri dari github .

Wolfram, 132

Mungkin memiliki lebih dari satu solusi (petunjuk: Mersenne)

StringReplace[#,""->"",Limit[x/(x-1),x->Boole[PrimeQ[
212821282128228281282128228821282128212821282-1]]]]&

Larutan

StringReplace[#," "->"",Limit[x/(x-1),x->Boole[PrimeQ[
2 128 2 128 2 128 2 2 8 2 8 128 2 128 2 2 8 8 2 128 2 128 2 128 2 128 2-1]]]]&

Spasi , 81 74 byte

Versi yang dapat dibaca manusia:

ttttttttttttttttttttt (21 tab characters)

Saya tahu ini adalah tantangan lama tapi mudah-mudahan seseorang mau mencoba untuk memecahkan ini. Saya mencoba untuk mengoptimalkan bytecount tetapi dimungkinkan untuk membuat sesuatu yang lebih pendek dengan jumlah karakter tab yang sama.

tcc, 850 byte

Untuk menghindari menempelkan garis yang sangat panjang saya melewati ini melalui tr -d '\ n' | lipat -b -w 60.

#!/usr/bin/tcc-run#include<stdio.h>typedefunsignedcharu;um[]
={104,105,16,152,94,131,43,42,112,214,53,207,116,170,185,210
};intmain(){uS[256];uk[256];ui,j,t;intc,n=0;FILE*f;f=fopen(_
_FILE__,"r");/*cannotfail*/while(-1!=(c=fgetc(f)))if(c==''||
c==10)k[++n]=c;fclose(f);i=0;do{S[i]=i;}while(++i!=0);j=0;i=
0;do{j=j+S[i]+k[i%n];t=S[i];S[i]=S[j];S[j]=t;}while(++i!=0);
i=0;do{if(S[i]!=m[i])j=1;}while(++i<sizeof(m));if(j==1){i=0;
do{printf("%d,",(int)S[i]);}while(++i<sizeof(m));printf("\n"
);}else{while(-1!=(c=fgetc(stdin)))if(c!=''&&c!=10)fputc(c,s
tdout);}returnj;}

SILOS , 159 byte Aman!

loadLinedef:lblgetagetzzzz/za=256:aX=getax=Xy=Xz=xx-10x|ifxbGOTOx:by-32y|ifycGOTOx:cprintCharX:xa+1z+1x=getaifxa:b

Harus cukup sepele. Ini adalah entri polisi dan perampok pertamaku.

Tidak ada yang menyerangnya, mungkin karena bahasa saya sendiri yang esoteris. Sepertinya cara curang untuk lewat, tetapi itu tidak terlalu penting karena yang lebih pendek aman.

loadLine
def : lbl geta get z zz
z/z
a=256
:a
X=get a
x=X
y=X
z=x
x-10
x |
if x b
GOTO x
:b
y-32
y|
if y c
GOTO x
:c
printChar X
:x
a+1
z+ 1
x=get  a
if x a
:b

Jangan ragu untuk mencobanya secara online