Bu zorluğun amacı doğrultusunda, boşluk alanını yalnızca satır beslemeleri (0x0A) ve boşluklar (0x20) olarak tanımlayacağız . Çoğu dilin ve regex lezzetinin, ASCII aralığının içinde ve dışında bulunan diğer birçok karakteri de boşluk olarak kabul ettiğini, bu nedenle karşılık gelen yerleşiklerden yararlanamayabileceğinizi unutmayın.

Polislerin Mücadelesi

Seçtiğiniz bir dilde, ASCII (NUL hariç) karakterlerden oluşan bir dize alan bir girdi veya program yazmalısınız, girdi olarak ve tüm boşluklar kaldırılmış olarak çıkar. Örneğin, aşağıdaki girişi aldıysanız:

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

Çıkmalısın

Hello,World!

Başvurunuz daha sonra tüm boşluklar kaldırılmış olarak kaynak kodunuz olacaktır (çözümünüz ASCII aralığının dışında karakterler de içerebilse de, çözümünüzü girişin kendisiyle geçirme işlemi aynıdır). Amacınız, seçtiğiniz dilde geçerli bir çözümü bulmak için boşluk bırakılması gereken yeri bulmayı olabildiğince zorlaştırmaktır. Soyguncuların, kaldırdığınızdan daha az boşluk ekleyebileceğini, ancak daha fazlasını ekleyemeyeceğini unutmayın. Ayrıca soyguncularınızın tam kodunuzla eşleşmesi gerekmediğini, sadece geçerli bir çözüm bulmaları gerektiğini unutmayın.

Cevabınız aşağıdakileri içermelidir:

• Çözümünüzü yazdığınız dil (ve gerekirse sürümü).
• Beyaz boşluğu kaldırmadan önce çözümünüzün bayt sayısı .
• Beyaz boşluk ile çözümünüz kaldırıldı.

Çözümünüz bir program veya işlev olabilir, ancak bir snippet olmayabilir ve bir REPL ortamı üstlenmemelisiniz. STDIN, komut satırı argümanı veya işlev argümanı üzerinden girdi alabilir ve STDOUT, işlev dönüş değeri veya işlev (çıkış) parametresi üzerinden çıktı alabilirsiniz.

Adalet için, seçtiğiniz dil için uygun bir tercüman veya derleyici bulunmalıdır.

Bileşenleri karma, şifreleme veya rasgele sayı üretimi için kullanmamalısınız (rasgele sayı üretecini sabit bir değere yerleştirseniz bile). Çözümünüz makul bir masaüstü bilgisayarında 10 saniyenin altında bir veya daha fazla 100 karakterden oluşan herhangi bir diziyi işleyebilmelidir.

Cevabınız 7 gün içinde (168 saat) kırılmadıysa, cevabınızın güvenli olduğu kabul edilen kendi çözümünüzü açığa çıkarabilirsiniz . Çözümünüzü ifşa etmediğiniz sürece, 7 gün geçse bile, yine de hırsızlar tarafından kırılabilir. En kısa güvenli cevap kazanır (boşlukları kaldırmadan önce ölçülen).

Cevabınız çatlarsa, lütfen cevabınızın başlığında ve ilgili hırsızın cevabına bir bağlantı ekleyin.

Soyguncular bölümü için buraya gidin .

Uncracked Gönderiler

<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, nimi tarafından çatlak

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

Bu tam bir program ve dadaistik bir şiir.

Boşluklu kod (Çevrimiçi deneyin!)

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

^{Bana sorarsan hala oldukça şiirsel görünüyor.}

De-obfuscated

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

açıklama

do-Notation sözdizimsel şeker sadece, bu yüzden feşdeğer şekilde yazılabilir

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

Listeler için >>=-Operatör olarak tanımlanır concatMap, yani folur

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

Yani bir giriş verilmiş "a b\nc", linessatırbaşıyla de girdi böler ["a b","c"], wordsverimli beyaz boşluk her satırı böler [["a","b"],["c"]](, bu yüzden sadece şimdi bu yeni satır içerir fark olarak linesaslında gerekli değildir). Bir kere Birleştirilmesi verir ["a","b","c"], idkimlik işlevi ve böyle bir etkisi yoktur ve nihai birleştirme dize verir "abc".

C, 475 bayt, Riley tarafından kırıldı

C'nin bazı kısımları, boşlukların nereye gitmesi gerektiğini görmeyi gerçekten kolaylaştırıyor. Bununla birlikte c ön işlemcisi değildir. Bu yüzden bu kod iki yarıya bölünmüş durumda: 17 satıra kadar (beyaz boşluklu 236 karakter) kod neredeyse tamamen dağınık ve bundan sonra (beyaz boşluklu 239 karakter), iyi şanslar!

Bu yarışmayı uzun bir şansla kazanamayacağım, ancak c ön işlemciyle neler yapılabileceğini görmek istedim.

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

Derler (etkinleştirirseniz uyarılarla birlikte) gcc -std=c89 -ansivecat file | ./a.out

Bu düşündüğümden çok daha hızlı kırıldı, tebrikler! Stratejim, #definesbelirgin belirteç sınırlarını kaldırmak için (';' gibi) kullanmak ve daha sonra #definesbunların nasıl karıştırıldıklarını gerçekten sezgisel hale getirmek için daha fazla kullanmaktı .

Bu arada, kod sadece bariz boşluk eklendikten sonra neye benziyor:

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

Octave, 69 bayt, GÜVENLİ!

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

Giriş formatı: Yeni satırlar doğrudan komut istemine girilemez. Dizeyi şu şekilde birleştirerek oluşturun:

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

Fonksiyonu şöyle çağır (boşluk ekle):

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

Orijinal kod:

Bunun çalışması için sadece 66 bayta ihtiyacınız vardı, fakat fazla bilgi vermemek için başlığa 69 yazdım.

Orijinal kod şöyle görünür:

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

Açıklama:

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

U85ASCII tablosundaki kod noktasıdır , bu nedenle ilk boşluğun sonra olması gerektiği gibi görünecektir 85. Yanlış!

Boşluktan sonra boşluk 853koyarsak, karakter numarasını almalıyız 853, değil mi? Kullanımı charo tanınabilir karakter olup olmadığını kontrol etmek için:

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

Ancak, charkodda kullanmıyoruz, sayıları boş bir dizeyle birleştirdiğimiz daha kısa sürümü kullanıyoruz [853 '']. Aralık dışı bir hata vermek yerine, kısa sürüm sadece 256 modülünü alır.

Sadece böyle oldu 85+3*256 = 853. char(853)Bir uyarı verirken , [853,'']geri döner U.

Bu görevi Octave'da yapmanın açık yolu şudur:

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

İlkinden sonra bir parantez (kod noktası 40) olması gerektiğini biliyoruz U. 29tabii ki uymuyor bu yüzden uzayı bir adım öteye kaydırıp alacağız 296. mod(296,256) = 40. Bingo!

Bu şekilde devam edin ve sıralama ile bitirin:

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

Son olarak evaldizgiyi koda dönüştürmek için kullanıyoruz .

JavaScript ES6, 199 bayt, SLuck49 tarafından çatlak

Eklemek için 33 bayt boşluk ile oldukça hantal bir giriş.

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

> <>, 40 bayt, Teal pelican tarafından Cracked

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

Bu arada fishlanguage.com'u tercümanlar arasında farklılıklar olması durumunda kullandım.

Befunge-93, 58 bayt, Güvenli!

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

Çevrimiçi deneyin!

Orijinal Program

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

Çevrimiçi deneyin!

Bunun püf noktası, uygulama yolunun yataydan daha dikey olmasıydı, daha sonra dikey yolları daha fazla karıştırmak için kodda rasgele çeşitli boşluklar yerleştirildi. Satır sonları ve boşluklar nihayet kaldırıldıktan sonra, operasyonların birbirleriyle nasıl ilişkili olduğunu gösteren çok az şey vardı.

Yeterince zor olmadığında, biraz da bir araya girmeye başladım, bu yüzden bir dizi işlem birbirine dik olarak akan farklı kod yolları tarafından gerçekleştirildi. Belirli bir komut için doğru konumu bulduğunuzu düşünüyorsanız, daha sonra kodda tekrar kullanmanız gerekebileceğinin farkında olmayacağınız fikri.

Bazı şeyleri karmaşık hale getirmeye çalışmanın tüm bu çabasına değip değmeyeceğinden emin değildiniz, veya insanlar onu çözmeye çalışmaktan bile zahmet etmediler. :)

Kod Açıklaması

_      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 bayt, Bağlantı Ng tarafından Kırık

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

184 bayt çöktü ve 17 bayt boşluk bıraktı.

ConcatAmaçlanan çözümüm kullanılırken çatlak çözüm Join, burada amaçlanan çözüm:

_=>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 bayt. Çatlak ve çatlak .

Bu, STDIN üzerinden girdi alan ve STDOUT üzerinden çıktı üreten bir programdır.

Boşluksuz veya yeni satırsız kod:

t'@*'dm1e5%Mdw%Y(

Giriş biçimi nedeniyle Matl dize girdi alır nasıl biraz garip. Her satırın tek bir satır olması gerektiğinden, yeni satırlı satırlar doğrudan STDIN üzerinden girilemez (satırsonu girişin sonunu işaretler). Yani biçim aşağıdaki gibidir:

1. Bir dize tek tırnak işareti içine alınır . Dize içeriği tek tırnak içeriyorsa, bunlar çoğaltılarak çıkarılır . Örnek:'I''m a string'

2. Yeni satırlı bir dize girmek için, dize yeni satırlarda bölmek ve ASCII kodları gibi sayılar da dahil olmak üzere her şeyi birleştirmek (köşeli ayraçlar aracılığıyla) gerekir . Örneğin, ilk ve soyadımın oluşturduğu dizgiyi, aralarında yeni bir satır olacak şekilde düşünün. Olarak girilirdi ['Luis' 10 'Mendo'].

   Bu, diğer (muhtemelen yazdırılamayan) ASCII kodlarını girmenize olanak sağlar. Böylece yukarıdaki 1. maddede bulunan dize alternatif olarak girilebilir ['I' 39 'm ' 97 32 'string']. Burayı kontrol et .

   Tek koşul, parantez içindeki parçalardan en az birinin bir ip olmasıdır. Bu sayılar birleştirilirken ASCII kodları olarak yorumlanmaya zorlanır.

Gariplik için üzgünüm Bu formatı kullanırken iyi şanslar!

Orijinal çözüm

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

Her %biri bir yorum sembolüdür ve bu nedenle satırın geri kalanı dikkate alınmaz.

Boşluklar hiçbir şey yapmaz fakat ayırıcı olarak görev yapar. Örneğin 1e5, boşluk olmadan sayı olarak yorumlanır 100000.

t girişi alır ve kopyalar.

' @ *'Bu dizgeyi iter ve dveren [32 -32 10]( ardışık olmayan) ardışık farklarını hesaplar -32.

mhangi karakterlerin 32veya 10(veya -32) olduğunu belirten bir mantıksal satır dizisi verir .

1ardından ebir satır olarak yeniden şekillendirilir. Bu iş burada değil.

5ardından tekrar Mbasılır 1(en son çoklu giriş fonksiyonuna olan son giriş e).

dardışık farklılıkları hesaplar 1ve böylece verir [](boş dizi).

wtakas eder ve sonunda boşluk karakterlerine (atar [], yani bunları kaldırır.

RProgN , 15 Bayt Kırıldı!

''`R""`R

Buradaki kodla oynayabilirsiniz . Nispeten basit bir çözüm, umarım RProgN'in ipleri nasıl kullandığının sinir bozucu doğası, bu iz bırakmaz.

Orijinal Program

' ' ` R
"
" ` R

explination

İlk olarak, girdi örtük olarak yığına itilir. Stack:<INPUT>

Sonra yığına boşluk bırakmak için '' kullanırız. Stack:<INPUT> " "

“aslında” (WORD) tarafından temsil edilen bir dizgiyi itmeye çalışır ancak ondan sonra boşluk olduğu için boş bir dizge basar. Stack:<INPUT> " " ""

Buradaki R, Değiştir komutu için şekerdir. Stack:<INPUTWITHOUTSPACES>

Ardından, "NEWLINE", yeni bir satır içeren bir dizgeyi iter, ki bu güzeldir çünkü RProgN kaçarları kullanmaz, sadece dikine böyle bir dize itmenize izin verir. yığın<INPUTWOSPACES> "\n"

Daha sonra, tekrar `numarayı ve çıktımızı veren Replace'i kullanırız.

Ruby, 86 bayt + 1 flag = 87 ( Dom Hastings tarafından kırıldı )

Komut satırı bayrağı gerektirir -p.

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

Kod bu formda aslında geçerli, sadece no-op.

Işın , 72 bayt, Güvenli!

Şimdi bir 2d dili için. TIO Nexus'ta çalınabilir .

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

İnsanları kandırmaya çalışmak için çok şey olmadan oldukça yalındır bir program.

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

Labirent , 127 bayt

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

Umarım bu hakkı yaptım :) bu benim ilk polis ve soyguncular girişim.

Orijinal Kod

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

Java, büyük bir Tamsayı içe aktarma için 3241 + 28 Bayt

Bu giriş yalnızca tamamen kriptografik olarak güvenli bir giriş olasılığını kanıtlamak içindir. Bunun kurallar dahilinde olduğuna inanıyorum, ancak ruha aykırıysa, lütfen bana bildirin, ben de dürüstlükten kurtulacağım. Bu “güvensiz” i, (ve eğer) bir çatlak bulununcaya kadar bu süreye kadar süresiz olarak bırakacağım. Bu bir canavarlıktır ve kesinlikle daha da optimize edilebilirdi, ama işte burada.

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",""));}}}

Soyguncular için adalet dışında, burada tüm "bariz" boşluk eklendi.

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", ""));
        }
    }
}

İyi şanslar, bu çatlak görmek isterim. Aslında bu konuda sınırsız bir ödül bile kuracağım. Eğer herhangi bir noktada bunu kırarsanız, borsada 500 rep sonsuz akreditasyon alırsınız (ve muhtemelen harika bir matematiksel kağıt).

C, 140 byte, Riley tarafından kırıldı

Kolay bir tane ile başlayalım.

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

(Umarım bunu doğru yapıyorumdur.)

Befunge 98, 65 byte, Pietu1998 tarafından kırık

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

Orijinal program

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

V , 37 bayt nmjcman101 tarafından Cracked

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

Bu yazdırılamaz olduğundan, okunabilir sürüm:

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

Veya tercih ederseniz, bir 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 bayt, Kırık!

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

Çevrimiçi deneyin!

JavaScript ES6, 380 bayt, güvenli

Bu, başlangıçta serbest bırakmayı planladığım türden bir giriş. Çok büyük ve kazanma şansı neredeyse yok, ancak 7 güne dayanacak kadar kriptografik olarak güçlü olması gerektiğini düşünüyorum . Şimdi, yanlış olduğumu kanıtlamış olabilirim!

Eklenecek boşluğa 67 bayt.

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

Çözüm

Bu, Genişletilmiş Küçük Şifreleme Algoritmasının bir uygulamasıdır . 64 bit beyaz boşluk kodlu anahtar aşağıdaki 128 bit anahtara genişler:

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

Kaynak: Wikipedia

Şifresi çözüldükten ve ASCII'ye dönüştürüldükten sonra, 64-bit blok , Base64 ile kodlanmış temsili [x, y]olarak okur .c3BsaXQ=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 bayt, güvenli

Bu düpedüz kötülük.

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

İyi şanslar! 13 adet boşluk eklenecek.

Orijinal kod:

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

Çevrimiçi deneyin!

Bu aşağı yukarı aşağı basitleştirir:

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

C #, 159 bayt, Süt ile çatlak

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

153 çöktü, bu yüzden sadece 6 bayt boşluk bulmak için çok zor olmamalı ...

retiküler, 43 bayt, kırık

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

TIO'daki sürüm eski, ancak kendinize github'dan bir kopyasını alabilirsiniz .

Wolfram, 132

Muhtemelen birden fazla çözüme sahiptir (ipucu: Mersenne)

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

Çözüm

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]]]]&

Boşluk , 81 74 bayt

İnsan tarafından okunabilir versiyonu:

ttttttttttttttttttttt (21 tab characters)

Bunun eski bir meydan okuma olduğunu biliyorum ama umarım birileri bunu çözmeye isteklidir. Bytecount için optimizasyon yapmaya çalıştım, ancak aynı sayıda sekme karakteriyle daha kısa bir şey yapmak mümkün olabilir.

tcc, 850 bayt

Çok uzun bir çizgiyi yapıştırmaktan kaçınmak için bunu tr -d '\ n' | katlayın -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 bayt Güvenli!

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

Oldukça önemsiz olmalı. Bu benim ilk polisler ve soyguncular giriş.

Muhtemelen kendi dilimin ezoterik doğası nedeniyle hiç kimse ona saldırmamıştır. Kaymak için sakin bir yol gibi gözükse de, kısa olanların güvende olması gerçekten önemli değil.

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

Online denemek için çekinmeyin