Supponiamo che una sfida con codegolf non contenga spazi bianchi per la durata del programma. Imbroglia questo sistema codificando il tuo script in spazi bianchi e golf uno script che decodifica ed esegue gli spazi bianchi incorporati.

Esempio

La mia soluzione a JBernardo s' Meta Golf Challenge è stato quello di codificare il codice Sage (o Python) in spazi, e il golf il decoder.

s = ' '
for c in '<lots of whitespace>'.split(s):
    s+=chr(len(c))
exec s

La codifica è prendere uno script, anteporre una nuova riga e, per ogni personaggio cdello script, le ord(c)schede di output seguite da uno spazio. Preparare una nuova riga è necessario poiché sto usando Python e avvio lo script scon uno spazio.

punteggio

Una soluzione completa contiene una descrizione della codifica utilizzata (se è complicata, fornire uno script) e uno script "decodifica ed esegui". Il tuo punteggio è il numero di caratteri non bianchi nello script di decodifica ed esegui.

Gli spazi bianchi (la lingua) sono vietati

Inoltre, non è consentito alcun linguaggio che abbia un set completo di operatori che utilizzano solo caratteri di spazi bianchi: accetterò il punteggio più basso diverso da zero.

Golfscript, 12 caratteri

La stringa delimitata da 'precede questi 10 caratteri:

n/{,}%''+~

Ogni riga è decodificata in un carattere, il cui valore ASCII (probabilmente Unicode, in effetti) è la lunghezza della riga.

Sfortunatamente se provo a incollare il mio esempio Hello World, Markdown rimuove gli spazi extra, anche in un <pre>blocco.

CPAN, 16

use Acme::Bleach;

CPAN ha tutto. O almeno, il modulo giusto.

Perl, 29

$_="";s/     */chr length $&/ge;eval

All'interno che s///sono una scheda quindi uno spazio. La codifica è una codifica ultra-base con spazi, preceduta da schede.

Prova questo sulla riga di comando:

$ tr ST ' \t' <<< '$_="TSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS"; s/TS*/chr length $&/ge; eval' | perl

Modifica: beh, lol, non riesco a trovare un modo corretto per copiare e incollare il mix tab / space. Credetemi, funziona a casa :) Aggiornamento: lì, lì, codificatotr

JavaScript

Sostituisci \tcon una scheda per ottenere il conteggio dei caratteri pubblicati.

Standard (64 caratteri)

eval(eval("'<code here>'".replace(/\t */g,function(s){return"\\"+s.length})))

Funzione freccia (49 caratteri)

eval(eval("'<code here>'".replace(/\t */g,(s)=>"\\"+s.length)))

Programma encoder per entrambi

for(var i = 0, si = prompt("Enter the code."), so = ""; i < si.length; ++i) so += '\t' + Array(+si.charCodeAt(i).toString(8)).join(' '); prompt("Here is the result.", so);

Yabasic (88 caratteri)

a$ = "<code here>"
for a = 1 to len(a$)
    if mid$(a$, a) < " " then b = b + 1
    else b$ = b$ + chr$(b) : b = 0
    endif
next
compile(b$)
a()

Utilizzare lo stesso programma codificatore della mia soluzione C, ma non rimuovere il primo carattere. Il codice originale deve essere nella forma di una subroutine a(), ad esempio:

sub a():?"hello, world":end sub

C (99 caratteri)

main(c, p)
{
    char *s = "<code here>";
    for (p = popen("cc -xc -oa -", "w"); *s;)
        *s++ - 9 ? c -= putc(c, p) : ++c;
    execl("a", pclose(p));
}

Testato solo con (e forse funziona solo con) GCC.

Programma di codifica corrispondente (rimuovere manualmente il primo carattere dal suo output):

#include <stdio.h>

int main()
{
    int c;
    while ((c = getchar()) != EOF) {
        while (c--) putchar(9);
        putchar(32);
    }
    return 0;
}

D (101 caratteri)

import std.algorithm;mixin((){char[]r;foreach(c;splitter("<lots of whitspace>"," "))r~=cast(char)c.length;return r;}());

stessa codifica della domanda (non è necessario per la nuova riga)

Bash (solo builtin, 44 caratteri)

IFS=
eval `while read a
do printf '\'${#a}
done<<a
<code here>
a`

Script codificatore corrispondente:

od -b | cut -b9- | tr ' ' '\n' | while read a
do
    for (( b = 0; b < $((10#$a)); ++b ))
    do
        echo -n ' '
    done
    echo
done

K5, 12 byte

.`c$-':&9=" "

Eseguire ( .) la stringa formata dai valori ascii ( `c$) data dalla differenza tra ogni coppia ( -':) degli indici dove ( &) l'input è una tab ( 9=" ").

L'input è una stringa di caratteri tab e non tab e i valori dei caratteri sono codificati nel numero di non tab (spazi o newline) tra ogni tab. Un codificatore di esempio:

" ",/{(x#" "),"\t"}'-1+

Esegue un join in esecuzione che inizia con uno spazio su ( " ",/) x spazi ( x#" ") uniti con una scheda ( ,"\t") in cui X è ciascuno di ( {...}') uno meno i valori dei caratteri della stringa di input ( -1+).

In azione:

  enc: " ",/{(x#" "),"\t"}'-1+
  dec: .`c$-':&9=

  enc "2+3"
"                                                  \t                                          \t                                                  \t"
  dec enc "2+3"
5

Ruby, 43

Molto semplice, la codifica sta mettendo x spazi per riga, dove x è il valore ASCII del carattere, la decodifica è inversa.

Il seguente script è solo un convertitore unario in ASCII e funziona anche quando cose diverse dagli spazi sono libere:

eval("".split("\n").map{|x|x.length.chr}.join)

Sostituisci semplicemente la stringa vuota con il programma che ti piace.

La cosa in un formato più riutilizzabile:

from_space = lambda {|text| text.split("\n").map{|x| x.length.chr}.join}
to_space = lambda {|text| text.chars.map{|x| " " * x.ord}.join("\n")}

p from_space [ to_space [ "abc" ] ] #=> "abc"