Écrire un programme ou une fonction qui "réagit" à un entier donné n (entrée via le paramètre de fonction / args / stdin)

Le programme ne se soucie pas des nombres négatifs, aime même, n'aime pas les nombres impairs et craint le nombre 13.

Il doit afficher les éléments suivants:

si n <0:

 --------------------------
 |                        |
 |                        |
(|      _          _      |)
 |                        |
 |                        |
 |                        |
 |                        |
 |       oooooooooo       |
 |                        |
 |                        |
 |                        |
 --------------------------

si n% 2 == 0 et n> -1:

 --------------------------
 |                        |
 |                        |
(|      ^          ^      |)
 |                        |
 |                        |
 |                        |
 |     o            o     |
 |       oooooooooo       |
 |                        |
 |                        |
 |                        |
 --------------------------

si n% 2 == 1 et n> -1 et n! = 13:

 --------------------------
 |                        |
 |                        |
(|      >          <      |)
 |                        |
 |                        |
 |                        |
 |                        |
 |       oooooooooo       |
 |     o            o     |
 |                        |
 |                        |
 --------------------------

si n == 13:

 --------------------------
 |                        |
 |                        |
(|     (O)        (O)     |)
 |                        |
 |                        |
 |       oooooooooo       |
 |       o        o       |
 |       oooooooooo       |
 |                        |
 |                        |
 |                        |
 --------------------------

La solution la plus courte en octets l'emporte.

CJam - 169

S24*aB*2li_D=3{_0<2{_2%}?}?\;:X"^^<>__":s"(O)"a2*+2/=~6X3=-{S*_@+_,C\-S*2*+@@++}:F~t7'o5*_7F:MtX3={5Mt6'o_7Ft}*X2<{X2*6+'o_5Ft}*{" |"\+'|+}%S'-26*+aa2*\*_3=1>"()"\*3\tN*

Essayez-le sur http://cjam.aditsu.net/

Explication de haut niveau:

S24*aB*crée une matrice pleine d'espaces, car le visage sans les bords
li_D=3{_0<2{_2%}?}?\;:Xlit le nombre et le convertit en 0 (pair), 1 (impair), 2 (négatif) ou 3 (13), le stocker dans X
X"^^<>__":s"(O)"a2*+2/=~sélectionne les types d'oeil (2 chaînes)
{S*_@+_,C\-S*2*+@@++}:F- la fonction F prend 2 chaînes (disons S1, S2) et un nombre (disons N) et crée une chaîne de 24 caractères contenant N espaces, S2, d'autres espaces, S1, N espaces
2 (eyes) 6X3=- (F)~tmet la ligne des yeux dans la matrice
7'o5*_7F:Mtmet la ligne buccale commune dans la matrice, et l'enregistre également dans M
X3={5Mt6'o_7Ft}*si X est 3, il met à nouveau M dans la matrice, 2 lignes plus haut, et place les côtés de la bouche entre
X2<{X2*6+'o_5Ft}*si X est 0 ou 1, il place les coins de la bouche dedans la position appropriée
{" |"\+'|+}%ajoute des bords verticaux et un espace à gauche sur chaque ligne
S'-26*+aa2*\*ajoute les bords horizontaux
_3=1>"()"\*3\tajoute les oreilles
N* ajoute des séparateurs de nouvelle ligne

Ruby, 241 224

f=->n{s=" #{?-*26}
"
s+=" |#{' '*24}|
"*11+s
s[84]=?(
s[110]+=?)
s[233,12]=m=?O*12
s[91,3]=s[102,3]=n<0?' _ ':n==13?(s[177,12]=m;s[205]=s[216]=?O;'(O)'):(s[203+d=n%2*56]=s[218+d]=?O;" #{n%2<1??^:b=?>} ")
s[103]=?<if b
$><<s}

Ceci définit une fonction à appeler comme f[13]. Je suis sûr qu'il y a beaucoup de place pour l'amélioration, similaire à ce que Ventero m'a aidé à faire ici .

Fondamentalement, je construis d'abord le cadre rugueux et attache les oreilles ainsi que la bouche. Ensuite, je place les yeux en fonction du nombre. En travaillant sur les personnages à mettre dans les yeux, je m'occupe aussi des différentes bouches donc je n'ai plus à vérifier le type de numéro. Enfin, je dois fixer l'œil droit pour les nombres impairs, car le code ci-dessus met la même chaîne dans les deux yeux.

C # - 349 octets

Je ne gagnerai certainement pas de prix, mais une manière différente de faire les choses.

Golfé:

class P{static void Main(string[]A){int j=64,i,r=0,n=int.Parse(A[0]);for(var f=(n<0?"IDID-TDTD-":n==13?"HDHD(IDIDOJDJD)SDSD(TDTDOUDUD)KIRI JHSJo":n%2<1?"IDID^TDTD^HIHIoUIUIo":"IDID>TDTD<HKHKoUKUKo")+@"JJSJoCBZM BB[M|BA[N-ADAD(\D\D)AA\N AA]N"+"\n";j++<78;)for(i=64;i++<93;System.Console.Write(f[r]))for(r=0;f[r++]>i|f[r++]>j|i>f[r++]|j>f[r++];r++);}}

Moins golfé:

class P
{
    static void Main(string[]A)
    {
        int j=64,i,r=0,n=int.Parse(A[0]); // everything is offset by 65 in this program

        for(
            var f=(n<0?"IDID-TDTD-": // this string describes a set of rectangles (x1,y1,x2,y2,ch)
                n==13?"HDHD(IDIDOJDJD)SDSD(TDTDOUDUD)KIRI JHSJo":
                n%2<1?"IDID^TDTD^HIHIoUIUIo":
                "IDID>TDTD<HKHKoUKUKo"
                )+@"JJSJoCBZM BB[M|BA[N-ADAD(\D\D)AA\N AA]N"+"\n";

            j++<78;) // the loop then prints the rectangles to the screen
            for(i=64;i++<93;System.Console.Write(f[r]))
                for(r=0;f[r++]>i|f[r++]>j|i>f[r++]|j>f[r++];r++);
    }
}

Python 2 - 255

Pas vraiment court, mais je le posterai quand même:

n=input()
o='o'
S='  '
w=y=7*S
b=' '+'-'*26+'\n'
p=' |%19s     |\n'
E=p%y*2
v=S+o*10+S
u=z=o+6*S+o
A=a='^ '
if n%2:A='< ';a='> ';u=y;w=z
if n<0:A=a='_ ';u=w=y
if n==13:A=a='(O)';u=w=v;v=S+o+S*4+o+S
print b+E+'(|%8s%11s     |)\n'%(a,A)+E+p%u+p%v+p%w+E+b

L'attribution des éléments pour les chaînes en Python me manque! :( Ensuite, on pourrait commencer par la matrice des caractères et simplement modifier les yeux et la bouche.

Python 2, 257

Pas un vainqueur, mais une approche alternative, assez proche! J'ai l'espoir de pouvoir en extraire quelques caractères supplémentaires. Construit toutes les lignes morceau par morceau, en utilisant des sous-chaînes communes pour vraiment extraire les octets.

X,Z=R=" |"
Q=X*5
Y=X*7
A=X+"-"*26
B=R+X*24+Z
n=input()
a,b,c,d,e,f,g=((("^>^<o  o "+Q)[n%2::2],"OO  ()o")[n==13],"__"+Q)[n<0]
for F in(A,B,B,"(|"+Q+e+a+f+Y+X+e+b+f+Q+"|)",B,B,R+Y+g*10+Y+Z,R+Q+c+X+g+Y+X+g+X+c+Q+Z,R+Y+"o"*10+Y+Z,R+Q+d+Y+Q+d+Q+Z,B,B,A):print F

CJam, 202

[S'-26*N]:Z[S'|:PS24*PN]:RR'(PS5*qi:XD=X0<-X2%2*+:Y[" ^ "_" > ""(O)"" - "__]=S8*Y[" ^ ""   "" < ""(O)"" - "__]=S5*P')NRRXD=[SPS7*'oA*S7*PN]:QR?Y[[SPS5*'oSC*'oS5*PN]:T_R[SPS7*'oS8*'oS7*PN]RRR]=QY2=TR?RRZ