Mostra il risultato casuale di un lancio di dadi se fatto con un dado a forma di cubo, in ASCII.

$ dice

dovrebbe risultare in uno dei

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

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

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

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

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

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

Golfscript, 56 caratteri

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

La soluzione può essere testata qui .

Python, 112 110 caratteri

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 caratteri

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 caratteri

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

Python, 109 caratteri unicode

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

Nota: questo non utilizza la funzione casuale, quindi non sarà così casuale come fanno gli altri.

Perl, 74 caratteri

Corri con perl -M5.010.

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

(Notare che le nuove righe nell'elenco sono parte della stringa e non solo inserite per leggibilità.)

Se ti stai chiedendo cosa diavolo fa l' $->$operazione, le seguenti note di lettura possono essere utili:

• La variabile $-tronca automaticamente il valore assegnato a un numero intero.

• La variabile $"è preimpostata su un singolo spazio.

• oè una parola nuda (che rappresenta "o").

Giocatore di golf per la prima volta

Python, 161 caratteri

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 comune 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)))

Si noti che le nuove righe sono significative. A differenza di questi sciocchi linguaggi "moderni", Common Lisp privilegia la leggibilità rispetto alla succintualità, quindi abbiamo il costrutto ingombrante "concatenare" la stringa ... "e nessun modo sintetico per fare riferimento a un personaggio in una stringa.

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(''))

Non sembra del tutto corretto alertperché non è un carattere a larghezza fissa, ma ti assicuro che è corretto o prova emettendo un <pre>tag e facendo writeln:-)

Prova: http://jsfiddle.net/d4YTn/3/ (funziona solo con browser compatibili con JS 1.7, come FF2 +)

Riconoscimenti: Mathtrucco hackerato da @minitech e morire logica di stampa da @Keith.

Modifica : rimuovi il Mathtrucco da @minitech perché in realtà lo ha allungato :-)

Modifica 2 : salva 17 caratteri. Prendi in prestito il trucco di @Keith per sfruttare la simmetria dei dadi. Usa un trucco per semplificare la conversione di numeri casuali in int.

Modifica 3 : Rimuovi 1+per spostare il numero casuale da 1-6 a 0-5 e salvare 2 caratteri. Di conseguenza, posso anche cambiare r%2-1per r%2e salvare un altro 2 caratteri.

Modifica 4 : jsfiddle funziona di nuovo. Aggiornato :-)

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-----');

Batti mellamokb, ma ho cambiato completamente la mia soluzione originale. Se vuoi che appaia bene, usa Google Chrome o qualcosa del genere, cambia alertin console.loge voilà.

Modifica: preso | 0 trucco di mellamokb per salvare alcuni personaggi.

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

Compilare 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 caratteri

(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! sembra 1a soluzione ?! ma noniam ... imbroglione

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 caratteri

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

Usa approssimativamente la stessa idea di quella di Python.

Versione leggibile:

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}/_

Il programma può essere testato qui

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);

Un'altra soluzione PHP. Sono arrivato alla stessa soluzione di Oleg.

Python (153)

Questa non è di gran lunga la più piccola presentazione, ho solo pensato che fosse bello :)

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 caratteri)

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

C, 168 164 163 caratteri

Scusa se sono un po 'in ritardo alla festa, ma dal momento che nessuna risposta è stata ancora accettata e l'unica altra soluzione C era un po' più lunga, ecco qui ...

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

È possibile rimuovere l'inclusione e salvare altri 18 caratteri, ma non viene compilato senza avvisi.

Modifica :
usando il trucco da riga di comando di user23241 , il codice C più corto che produce il risultato (senza avvisi del compilatore) è solo 12 caratteri:

#include I
M

Almeno se imbrogliate e utilizzate la seguente riga di comando per compilare:

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 caratteri

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

Questo è il mio secondo CodeGolf, e non miravo davvero alla brevità quanto alla mutabilità del codice e alla corrispondenza dei criteri di gioco.

Puoi generare dadi a 4 facce e 6 facce.

Forse dopo lo accorcerò e lo renderò un po 'più dinamico.

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);

Uscita a 4 lati:

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

Uscita a 6 facciate:

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

JavaScript 220 byte

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-----";

Rubino, 134 132 119 118 117 112 111 caratteri,

Il mio secondo golf nella vita. Ho usato numeri magici. Qualche consiglio per favore?

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

Uscite:

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 caratteri

Nota che questo non è Vim puro poiché Vim non ha un generatore di numeri casuali incorporato. Ci sono estensioni che possono essere scaricate per questo ovviamente, ma dato che sono un irriducibile uomo di Linux, ho pensato, perché non fare affidamento sull'ambiente shell.

Codice

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

Spiegazione

• La prima riga genera la "scatola" che rappresenta il dado.
• La seconda riga prende un numero casuale dall'ambiente e usando l'aritmetica modulare lo costringe ad essere un numero valido per un dado.
• Le linee rimanenti si muovono attorno alla faccia del dado riempiendo quelle o. Nota che questo è pensato per essere ottimizzato per il minor numero di caratteri, non per il minimo numero di movimenti (cioè ci sarebbero modi più veloci a turno di sequenze di tasti se lo facessi manualmente — facendo iftutto nella mia testa).
• Come sempre, ^non è un letterale ^ma un'indicazione di una sequenza di fuga.

analisi

Cambiare RANDOMper DICEVALUE, salvare il codice VimScript in dice.vim, quindi eseguire questo script di shell su di esso, dando come argomenti qualunque numeri che si desidera verificare:

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

Mathematica 166 161 146 143 caratteri

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

Uscita campione:

Se le parentesi graffe matrice sono offese, è possibile sostituire MatrixFormcon TableFormnel codice.

PHP 5.4, 107 byte

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

102 byte *

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

** Purtroppo, i problemi di versione 102 byte accorge causa della colata di boolper intl'indicizzazione della stringa $d. A parte questo, funziona benissimo. *