Code Golf - Word Scrambler

Question

Rispondi con il codice sorgente più breve possibile per un programma che converte un testo in chiaro arbitrario nel corrispondente testo cifrato, seguendo l'input e l'output di esempio che ho fornito di seguito. Punti bonus * per il minimo tempo di CPU o la minima quantità di memoria utilizzata.

Esempio 1:

Testo semplice: la rapida volpe marrone salta sul cane pigro. Supercalifragilisticexpialidocious!

Testo cifrato: eTh kiquc nobrw xfo smjup rvoe eth yalz .odg! uioiapeislgriarpSueclfaiitcxildcos

Esempio 2:

Testo normale: 123 1234 12345 123456 1234567 12345678 123456789

Testo cifrato: 312 4213 53124 642135 7531246 86421357 975312468

Regole:

1. La punteggiatura è definita per essere inclusa con la parola più vicina.
2. Il centro di una parola è definito come soffitto ((strlen (parola) +1) / 2).
3. Lo spazio bianco viene ignorato (o compresso).
4. Le parole dispari si spostano prima a destra. Anche le parole si spostano prima a sinistra.

Puoi pensarlo come leggere ogni altro personaggio all'indietro (a partire dalla fine della parola), seguito dai caratteri rimanenti in avanti. Corporation = & Gt; XoXpXrXtXoX = & Gt; niaorCoprto.

Grazie a coloro che hanno sottolineato l'incoerenza nella mia descrizione. Questo ha portato molti di voi sulla strada sbagliata, di cui mi scuso. La regola n. 4 dovrebbe chiarire le cose.

* I punti bonus verranno assegnati solo se Jeff Atwood decide di farlo. Dal momento che non ho verificato con lui, le possibilità sono scarse. Siamo spiacenti.

Answer 1

Python, 50 caratteri

Per input in i:

' '.join(x[::-2]+x[len(x)%2::2]for x in i.split())

Versione alternativa che gestisce il proprio IO:

print ' '.join(x[::-2]+x[len(x)%2::2]for x in raw_input().split())

Un totale di 66 caratteri se inclusi gli spazi bianchi. (Tecnicamente, print potrebbe essere omesso se eseguito da una riga di comando, poiché il valore valutato del codice viene visualizzato come output per impostazione predefinita.)

---

Versione alternativa utilizzando reduce:

' '.join(reduce(lambda x,y:y+x[::-1],x) for x in i.split())

59 caratteri.

Versione originale (sia pari che dispari vanno prima a destra) per un input in <=>:

' '.join(x[::2][::-1]+x[1::2]for x in i.split())

48 caratteri incluso lo spazio bianco.

Un'altra versione alternativa che (sebbene leggermente più lunga) è leggermente più efficiente:

' '.join(x[len(x)%2-2::-2]+x[1::2]for x in i.split())

(53 caratteri)

Answer 2

J , 58 caratteri

>,&.>/({~(,~(>:@+:@i.@-@<.,+:@i.@>.)@-:)@<:@#)&.><;.2,&' '

Answer 3

Haskell , 64 caratteri

unwords.map(map snd.sort.zip(zipWith(*)[0..]$cycle[-1,1])).words

Bene, va bene, 76 se si aggiunge il " import List " ;.

Answer 4

Python - 69 caratteri

(compresi spazi bianchi e interruzioni di riga)

Gestisce tutti gli I / O.

for w in raw_input().split():
 o=""
 for c in w:o=c+o[::-1]
 print o,

Answer 5

Perl, 78 caratteri

Per input in $_. Se ciò non è accettabile, aggiungi all'inizio sei caratteri per $_=<>; o $_=$s;. La nuova riga è solo per la leggibilità.

for(split){$i=length;print substr$_,$i--,1,''while$i-->0;
print"$_ ";}print $/

Answer 6

C, 140 caratteri

Ben formattato:

main(c, v)
  char **v;
{
  for( ; *++v; )
  {
    char *e = *v + strlen(*v), *x;
    for(x = e-1; x >= *v; x -= 2)
      putchar(*x);
    for(x = *v + (x < *v-1); x < e; x += 2)
      putchar(*x);
    putchar(' ');
  }
}

compressa:

main(c,v)char**v;{for(;*++v;){char*e=*v+strlen(*v),*x;for(x=e-1;x>=*v;x-=2)putchar(*x);for(x=*v+(x<*v-1);x<e;x+=2)putchar(*x);putchar(32);}}

Answer 7

Lua

funzione 130 char, programma di funzionamento 147 char

Lua non ha abbastanza amore nel code golf - forse perché è difficile scrivere un breve programma quando hai parole chiave lunghe come function / end, if / then / <pre></pre>, ecc.

Prima scrivo la funzione in modo dettagliato con spiegazioni, quindi la riscrivo come una funzione compressa e autonoma, quindi la chiamo sull'argomento singolo specificato nella riga di comando.

Ho dovuto formattare il codice con <=> tag perché Markdown fa un lavoro orribile nel formattare Lua.

Tecnicamente potresti ottenere un programma in esecuzione più piccolo incorporando la funzione, ma è più modulare in questo modo :)

t = "The quick brown fox jumps over the lazy dog. Supercalifragilisticexpialidocious!"
T = t:gsub("%S+", -- for each word in t...
                  function(w) -- argument: current word in t
                    W = "" -- initialize new Word
                    for i = 1,#w do -- iterate over each character in word
                        c = w:sub(i,i) -- extract current character
                        -- determine whether letter goes on right or left end
                        W = (#w % 2 ~= i % 2) and W .. c or c .. W
                    end
                    return W -- swap word in t with inverted Word
                  end)


-- code-golf unit test
assert(T == "eTh kiquc nobrw xfo smjup rvoe eth yalz .odg !uioiapeislgriarpSueclfaiitcxildcos")

-- need to assign to a variable and return it,
-- because gsub returns a pair and we only want the first element
f=function(s)c=s:gsub("%S+",function(w)W=""for i=1,#w do c=w:sub(i,i)W=(#w%2~=i%2)and W ..c or c ..W end return W end)return c end
--       1         2         3         4         5         6         7         8         9        10        11        12        13
--34567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890
-- 130 chars, compressed and written as a proper function

print(f(arg[1]))
--34567890123456
-- 16 (+1 whitespace needed) chars to make it a functioning Lua program, 
-- operating on command line argument

Output:

$ lua insideout.lua 'The quick brown fox jumps over the lazy dog. Supercalifragilisticexpialidocious!'
eTh kiquc nobrw xfo smjup rvoe eth yalz .odg !uioiapeislgriarpSueclfaiitcxildcos

Sono ancora abbastanza nuovo a Lua, quindi mi piacerebbe vedere una soluzione più breve se ce n'è una.

---

Per una cifra minima su tutti gli arg a stdin, possiamo fare 111 caratteri:

for _,w in ipairs(arg)do W=""for i=1,#w do c=w:sub(i,i)W=(#w%2~=i%2)and W ..c or c ..W end io.write(W ..' ')end

Ma questo approccio genera uno spazio finale come alcune delle altre soluzioni.

Answer 8

Per un input in s:

f=lambda t,r="":t and f(t[1:],len(t)&1and t[0]+r or r+t[0])or r
" ".join(map(f,s.split()))

Python, 90 caratteri incluso lo spazio bianco.

Answer 9

TCL

125 caratteri

set s set f foreach l {}
$f w [gets stdin] {$s r {}
$f c [split $w {}] {$s r $c[string reverse $r]}
$s l "$l $r"}
puts $l

Answer 10

Bash - 133, supponendo che l'input sia nella variabile $ w

Piuttosto

for x in $w; do 
    z="";
    for l in `echo $x|sed 's/\(.\)/ \1/g'`; do
        if ((${#z}%2)); then
            z=$z$l;
        else
            z=$l$z;
        fi;
    done;
    echo -n "$z ";
done;
echo

compressa

for x in $w;do z="";for l in `echo $x|sed 's/\(.\)/ \1/g'`;do if ((${#z}%2));then z=$z$l;else z=$l$z;fi;done;echo -n "$z ";done;echo

Ok, quindi genera uno spazio finale.