Muestre el resultado aleatorio de un lanzamiento de dados si se hace con un dado en forma de cubo, en ASCII.

$ dice

debería resultar en uno de

-----
|   |
| o |
|   |
-----

-----
|o  |
|   |
|  o|
-----

-----
|o  |
| o |
|  o|
-----

-----
|o o|
|   |
|o o|
-----

-----
|o o|
| o |
|o o|
-----

-----
|o o|
|o o|
|o o|
-----

Golfscript, 56 caracteres

"-"5*n"|":|"o "1/:&6rand:§1<=" "&§3<=|n|&§5<=]&§2%=1$-1%

La solución se puede probar aquí .

Python, 112 110 caracteres

from random import*
r=randrange(6)
C='o '
s='-----\n|'+C[r<1]+' '+C[r<3]+'|\n|'+C[r<5]
print s+C[r&1]+s[::-1]

Ruby 1.9, 80 84 caracteres

z=" o";$><<(s=?-*5+"
|#{z[2/~a=rand(6)]} #{z[a/3]}|
|"+z[a/5])+z[~a%2]+s.reverse

Windows PowerShell, 89 93 96 97 101 119 caracteres

-join('-----
|{0} {1}|
|{2}{3}'-f'o '[$(!($x=random 6);$x-lt3;$x-ne5;$x%2)])[0..14+13..0]

Python, 109 caracteres unicode

#coding:u8
print u"鱸헓ȅ᪮ԅ᪅餠☏汁끝鐸즪聗K糉툜㣹뫡燳闣≆뤀⩚".encode("u16")[2:].decode("zlib").split("\n\n")[id(list())%7-1]

Nota: Esto no utiliza la función aleatoria, por lo que no será tan aleatorio como lo hacen otros.

Perl, 74 caracteres

Corre con perl -M5.010.

$-=rand 6;$_="-----
|0 2|
|4";s/\d/$->$&?o:$"/ge;say$_,$-&1?$":o,~~reverse

(Tenga en cuenta que las nuevas líneas en el listado son parte de la cadena y no solo se insertan para la legibilidad).

Si se pregunta qué diablos hace la $->$operación, las siguientes notas de lectura pueden ser útiles:

• La variable $-trunca automáticamente su valor asignado a un entero.

• La variable $"está preestablecida en un solo espacio.

• oes una palabra sin formato (que representa "o").

Golfista por primera vez

Python, 161 caracteres

from random import*
n=randint(1,7)    
o,x='o '
a='-'*5
b=(x,o)[n>3]
d=(x,o)[n>5]
c=(x,o)[n>1]    
print a+'\n|'+c+x+b+'|\n|'+d+(x,o)[n%2]+d+'|\n|'+b+x+c+'|\n'+a

Lisp común 170

(let*((r(random 6))(a "-----
|")(c "o")(d " ")(e "|
|")(f(concatenate 'string a(if(< r 1)d c)d(if(< r 3)d c)e(if(> r 4)c ))))(concatenate 'string f(if(evenp r)c d)(reverse f)))

Tenga en cuenta que las nuevas líneas son significativas. A diferencia de estos tontos lenguajes "modernos", Common Lisp favorece la legibilidad sobre la concisión, por lo que tenemos la engorrosa construcción "concatenate 'string ..." y no hay una forma sucinta de hacer referencia a un carácter en una cadena.

JavaScript ( 169 168 141 137)

r=Math.random()*6|0;s='-----\n|'+(r>0?'o ':'  ')+(r>2?'o':' ')+'|\n|'+(r-5?' ':'o');alert(s+(r%2?' ':'o')+s.split('').reverse().join(''))

No se ve muy bien alertporque no es una fuente de ancho fijo, pero puede estar seguro de que es correcta, o pruebe emitiendo una <pre>etiqueta y haciendo writeln:-)

Prueba: http://jsfiddle.net/d4YTn/3/ (solo funciona en navegadores compatibles con JS 1.7, como FF2 +)

Créditos: Mathtruco pirateado de @minitech y lógica de impresión de dados de @Keith.

Editar : eliminar el Mathtruco de @minitech porque en realidad lo hizo más largo :-)

Edición 2 : Guardar 17 caracteres. Pide prestado un truco a @Keith para aprovechar la simetría de los dados. Utilice el truco para simplificar la conversión de números aleatorios a int.

Edición 3 : Eliminar 1+para cambiar el número aleatorio de 1-6 a 0-5 y guardar 2 caracteres. Como resultado, también puede cambiar r%2-1a r%2y guardar otros 2 caracteres.

Edición 4 : jsfiddle está funcionando nuevamente. Actualizado :-)

JavaScript, 215 213 212 145 135

r=Math.random()*6|0;alert('-----\n|'+[r>2?'o o':r?'o  ':'   ',r%2?r>3?'o o':'   ':' o ',r>2?'o o':r?'  o':'   '].join('|\n|')+'|\n-----');

Batí mellamokb, pero cambié mi solución original por completo. Si desea que esto se vea bien, use Google Chrome o algo así, cambie alerta console.logy listo.

Editar: prestado el truco | 0 de mellamokb para guardar algunos personajes.

PHP 119 126 128 131 188 201 213 234 239

<?$c=($r=rand()%6)%2?$r>4?'o ':'  ':' o';$b=$r>0?$r<3?'o  ':'o o':'   ';echo$a="-----\n|$b|\n|$c",substr(strrev($a),1);

C - 215

#include <time.h>
#include <stdlib.h>
main(){char a[]=A,b[]=B,c=3,d=(srand(time(0)),rand()%6+1),e=d-2;if(d==1)a[5]=C;else{while(--e>-1)a[b[D[d-3]-48+e]-48]=C;a[0]=a[10]=C;}p(E);while(--c>-1)p("|%s|\n",a+c*4);p(E);}

Compila con:

cl /DA="\"   \0   \0   \"" /DB="\"5282582468\"" /DC='o' /DD="\"0136\"" /DE="\"+---+\n\"" /Dp=printf dice.c

Python 133

import random as R
i=R.randint(1,6)
a='   ';b='0 0'
A='-----\n|'+((a,'0  ')[i>1],b)[i>3]+'|\n|'
print A+((a,' 0 ')[i%2],b)[i>5]+A[::-1]

F # - 165 161 caracteres

(System.Random()).Next 6|>fun x->[for y in[x>0;x%2=0;x>2;x=5]->if y then"o"else" "]|>fun[a;b;c;d]->printf"-----\n|%s %s|\n|%s%s%s|\n|%s %s|\n-----"a c d b d c a

Python 108 114 119 121 122 129

wtf! parece la primera solución? pero yo no ... tramposo

108

import random as R
i=R.randint(1,6)
X=' 0'
A='-----\n|%s %s|\n|'%(X[i>1],X[i>3])+X[i>5]
print A+X[i%2]+A[::-1]

119

import random as R
i=R.randint(1,6)
X=' 0';a=X[i>5]
A='-----\n|%s %s|\n|%s|'%(X[i>1],X[i>3],a+X[i%2]+a)
print A+A[-6::-1]

Perl - 111 103 101

$n=int rand 6;
($t="-----\n|0 1|\n|232|\n|1 0|\n-----\n")=~s/(\d)/5639742>>6*$1>>$n&1?o:$"/eg;
die$t;

APL (69)

5 5⍴(5⍴'-'),{⊃⍵↓' o|'}¨2,(⌽M),2,2,(N∊¨6(1 3 5)6),2,2,2,⍨M←3 6 1>⍨N←?6

Haskell, 154 162 167 172 caracteres

import System.Random
main=randomRIO(1::Int,6)>>=putStrLn. \x->let{h="-----\n|"++c(>1):' ':c(>3):"|\n|"++[c(>5)];c f|f x='o'|True=' '}in h++c odd:reverse h

Utiliza aproximadamente la misma idea que la de Python.

Versión legible:

import System.Random

main = do
    x <- randomRIO (1 :: Int, 6)
    putStrLn (render x)

render x = str ++ check odd ++ reverse str
  where
    str = concat
        [ "-----\n|"
        , check (> 1)
        , " "
        , check (> 3)
        , "|\n|"
        , check (> 5)
        ]
    check f = if f x then "o" else " "

Golfscript 80 65

6rand):^;'-'5*n+:_[^6&0^4&^6=].^1&+-1%+3/{'|'\{'o'' 'if+}/'|'n}/_

El programa se puede probar aquí.

PHP 126 127 179

<?$x=($r=rand(1,6))>3?"o o":($r<2?"   ":"o  ");$z=$r>5?"o o":($r%2==0?"   ":" o ");$v="-----\n|$x|\n";echo"$v|$z|".strrev($v);

Otra solución PHP. Llegué a casi la misma solución por Oleg.

Pitón (153)

Esta no es la presentación más pequeña, solo pensé que se veía bien :)

import random as r
print"""-----
|%c %c|
|%c%c%c|
|%c %c|
-----"""%tuple(
r.choice([
"   o   ",
"o     o",
"o  o  o",
"oo   oo",
"oo o oo",
"ooo ooo"]))

Q (120 caracteres)

dice:{(`t`e`l`c`r`w!5 cut"-----|   ||o  || o ||  o||o o|")(,/)(`t;(`e`c`e;`l`e`r;`l`c`r;`w`e`w;`w`c`w;`w`w`w)(*)1?6;`t)}

Uso:

dice[]

DO, 168 164 163 caracteres

Lo siento si llego un poco tarde a la fiesta, pero como todavía no se ha aceptado ninguna respuesta y la única otra solución C fue algo más larga, aquí va ...

#include<stdio.h>
main(){srand(time(0));char*o="O ",r=rand()%6,i=o[r<1],j=o[r<3],k=o[r<5];printf("-----\n|%c %c|\n|%c%c%c|\n|%c %c|\n-----\n",i,j,k,o[r&1],k,j,i);}

Puede eliminar la inclusión y guardar otros 18 caracteres, pero luego no se compila sin advertencias.

Editar :
usando el truco de la línea de comandos de user23241 , el código C más corto que produce el resultado (sin advertencias del compilador) es solo 12 caracteres:

#include I
M

Al menos si haces trampa y usas la siguiente línea de comando para compilar:

gcc -DI="<stdio.h>" -DM="main(){srand(time(0));char*o=\"O \",r=rand()%6,i=o[r<1],j=o[r<3],k=o[r<5];printf(\"-----\n|%c %c|\n|%c%c%c|\n|%c %c|\n-----\n\",i,j,k,o[r&1],k,j,i);}" dice.c -o dice

c, 140 caracteres

r,i,s;main(){srand(time(i=0));r=rand()%6;for(s=-1;i-=s;)putchar("\n|   |-o"[i>5?i==8&&r||i==10&&2<r||i==14&&4<r||i==15&&(s=1)&~r?7:i%6:6]);}

PHP: 1284

Este es mi segundo CodeGolf, y realmente no estaba apuntando tanto a la brevedad como a la mutabilidad del código y a los criterios de juego.

Puedes generar dados de 4 lados y de 6 lados.

Tal vez más tarde lo acortaré y lo haré un poco más dinámico.

function draw_dice($numdice=1,$sides=4)
{
/* Verify acceptable parameters. */
if($sides<4){die("You must choose 4 sides or greater.");}
if($numdice<1){die("You must have at least one dice.");}
/* End verification */
$a=' ';
$b=' ';
$c=' ';
$d=' ';
$e=' ';
$f=' ';
$g=' ';
$h=' ';
$i=' ';
$j=' ';

switch($sides)
{
case $sides%2==0:
if($sides==4)
{
$ran=rand(1,$sides);
switch($ran)
{
case 1:
$e="o";
break;
case 2:
$a="o";
$j="o";
break;
case 3:
$b="o";
$g="o";
$j="o";
break;
case 4:
$a="o";
$c="o";
$g="o";
$j="o";
break;
}
echo "<div style='text-align:center;display:inline-block;'>";
echo " - <br/>";
echo "| |<br/>";
echo "|$a$b$c|<br/>";
echo "| $d$e$f |<br/>";
echo "|  $g$h$i$j  |<br/>";
echo "---------<br/>";
echo "</div>";

}

if($sides==6)
{
$ran=rand(1,$sides);
switch($ran)
{
case 1:
$e="o";
break;
case 2:
$a="o";
$i="o";
break;
case 3:
$a="o";
$i="o";
$e="o";
break;
case 4:
$a="o";
$c="o";
$g="o";
$i="o";
break;
case 5:
$a="o";
$c="o";
$g="o";
$i="o";
$e="o";
break;
case 6:
$a="o";
$c="o";
$d="o";
$f="o";
$g="o";
$i="o";
break;
}
echo "-----<br/>";
echo "|$a$b$c|<br/>";
echo "|$d$e$f|<br/>";
echo "|$g$h$i|<br/>";
echo "-----<br/>";
}

if($sides!==4&&$sides!==6)
{
die("Only 4 and 6 sided are supported at this time.");
}

break;

case $sides%2==1:
die("Must have even number of sides.");
break;
}

}

draw_dice(1,4);

Salida de 4 lados:

    - 
   | |
  |o o|
 |     |
|  o  o  |
---------

Salida de 6 lados:

-----
|o  |
| o |
|  o|
-----

JavaScript 220 bytes

r=(1+Math.random()*6|0).toString(2).split("").reverse();b=r[1];c=r[2];s=[[b|c,0,c],[b&c,1&r[0],b&c],[c,0,b|c]];"-----\n|"+s.map(function(v){return v.map(function(w){return w?"o":" "}).join("")}).join("|\n|")+"|\n-----";

Ruby, 134 132 119 118 117 112 111 caracteres,

Mi segundo golf en la vida. He usado números mágicos. ¿Algún consejo por favor?

r=?-*5+"
|"+((a=:ghklm[rand 6])?a.to_i(36).to_s(2).tr("10","o "):"    o").insert(3,"|
|")
$><<r+r[0,14].reverse

Salidas:

ice@distantstar ~/virt % ruby ./golf.rb
-----
|o o|
|   |
|o o|
-----
ice@distantstar ~/virt % ruby ./golf.rb
-----
|o o|
|o o|
|o o|
-----
ice@distantstar ~/virt % ruby ./golf.rb
-----
|   |
| o |
|   |
-----
ice@distantstar ~/virt % 

VimScript - 169 caracteres

Tenga en cuenta que esto no es puro Vim ya que Vim no tiene un generador de números aleatorios incorporado. Hay extensiones que se pueden descargar, por supuesto, pero como soy un hombre incondicional de Linux, pensé, ¿por qué no confiar en el entorno de shell?

Código

norm5a-^[YPo|   |^[YPP
let x=system('echo $RANDOM')%6+1
if x<2
norm jllro
el
norm lrolljj.k
if x>3
norm k.hjj
en
if x>2
norm h.k
en
if x>5
norm .l
en
if x>4
norm l.
en
en

Explicación

• La primera línea genera la "caja" que representa el dado.
• La segunda línea obtiene un número aleatorio del entorno y el uso de la aritmética modular obliga a que sea un número válido para un dado.
• Las líneas restantes se mueven alrededor de la cara del dado rellenando las o's. Tenga en cuenta que esto está destinado a ser optimizado para el menor número de caracteres, no el menor número de movimientos (es decir, habría formas más rápidas en los giros de teclas si lo estuviera haciendo manualmente, haciendo iftodo lo que tengo en la cabeza).
• Como siempre, ^no es un literal ^sino una indicación de una secuencia de escape.

Pruebas

Cambie RANDOMa DICEVALUE, guarde el código VimScript dice.vim, luego ejecute este script de shell en él, dando como argumentos los números que desea probar:

#!/bin/sh
for DICEVALUE in $@; do
    export DICEVALUE
    vim -S dice.vim
done

Mathematica 166 161 146 143 caracteres

a="O  ";b=" O ";c="  O";d="   ";e="O O";RandomInteger@{1, 6}/.Thread@Rule[Range@6,{{d,b,d},{a,d,c},{a,b,c},{e,d,e},{e,b,e}, {e,e,e}}]//MatrixForm

Salida de muestra:

Si las llaves de matriz ofenden, puede reemplazar MatrixFormcon TableFormen el código.

PHP 5.4, 107 bytes

<?$r=rand(1,6);$d=[' ','o'];$o='+---+
|'.$d[$r>1].' '.$d[$r>3].'|
|'.$d[$r>5];echo$o.$d[$r%2].strrev($o);

102 bytes *

<?$r=rand(1,6);$d=' o';$o='+---+
|'.$d[$r>1].' '.$d[$r>3].'|
|'.$d[$r>5];echo$o.$d[$r%2].strrev($o);

** Desafortunadamente, la versión de 102 bytes emite avisos debido a la conversión de boola intal indexar la cadena $d. Aparte de eso, funciona bien.*