Así que me gustaría que intentes generar imágenes de Rorschach como la imagen a continuación:

Aquí hay un enlace para más inspiración.

Este es un concurso de popularidad, pero diré que es probable que los colores sean más populares que el blanco y negro, así como las texturas.

Las imágenes de Rorschach se crean doblando papel con tinta para que un criterio sea la simetría.

El arte ASCII es válido, pero estará sujeto a los mismos criterios que el anterior.

Fortran 95

Este código es un poco grande, pero produce un buen resultado (ish) ASCii:

program Rorschach
implicit none

integer :: i, j, k, l, N, seed
integer, dimension (24) :: i_zero, j_zero
real :: aux
integer, dimension (17,12) :: matrix_I = 0
character, dimension (17,12) :: matrix_C

! random seed according to system clock
call SYSTEM_CLOCK(count=k)
call RANDOM_SEED(size=N)
allocate(seed(N))
seed=k+37*(/ (i - 1, i = 1, n) /)
call RANDOM_SEED(PUT=seed)

! generating 7 random points
do i=1,7
  call RANDOM_NUMBER(aux)
  i_zero(i) = 15 * aux + 2 ! range = 2-16
  call RANDOM_NUMBER(aux)
  j_zero(i) = 11 * aux + 2 ! range = 2-12
enddo

! generating 7 large spots of ink
do i=1,7
  matrix_I(i_zero(i),j_zero(i)) = 3 ! central points have ink value 3
  do k=-1,1
    do l=-1,1
      if (.NOT.((k==0) .AND. (l==0))) then ! immediate neighbours...
        if ( (((i_zero(i)+k)<=17).OR.((i_zero(i)+k)>0)) .AND. (((j_zero(i)+l)<=12).OR.((j_zero(i)+l)>0)) ) then ! ... that are inside the designed area ...
            if (matrix_I(i_zero(i)+k,j_zero(i)+l) < 2) matrix_I(i_zero(i)+k,j_zero(i)+l) = 2 ! ... and that do not have ink value larger than 2 will be attributed as 2
        endif
      endif
    enddo
  enddo
enddo

! generating N little sparkles of ink
call RANDOM_NUMBER(aux)
N = int(11 * aux) + 20 ! N = 20-30

i = 0
do while (i <= N)
  call RANDOM_NUMBER(aux)
  i_zero(i) = 16 * aux + 1 ! range = 1-17
  call RANDOM_NUMBER(aux)
  j_zero(i) = 11 * aux + 1 ! range = 1-12
  if (matrix_I(i_zero(i),j_zero(i)) < 1) then ! if the selected point already has more ink than 1, then cycle the loop
    matrix_I(i_zero(i),j_zero(i)) = 1
    else
      cycle
  endif
  i = i + 1
enddo

! converting matrix of integers into matrix of characters
do i=1,17
  do j=1,12
    select case(matrix_I(i,j))
      case(0)
      matrix_C(i,j) = " "
      case(1)
      matrix_C(i,j) = "."
      case(2)
      matrix_C(i,j) = "+"
      case(3)
      matrix_C(i,j) = "@"      
    end select
  enddo
enddo

! printing it on the screen + its reflection
do i=1,17
  do j=1,12
    write(*,"(A1)",advance="NO") matrix_C(i,j)
  enddo
  do j=12,2,-1
    write(*,"(A1)",advance="NO") matrix_C(i,j)
  enddo
  write(*,"(A1)") matrix_C(i,1)
enddo

end program Rorschach

El código está completamente comentado, pero la idea básica es que genera una matriz con valores entre 0 y 3, que representa la cantidad de tinta en ese punto. Hay 7 puntos grandes de tinta (un punto con un valor 3 rodeado de valores 2) y muchos pequeños "destellos" (valor 1). Esta matriz se convierte en una matriz de caracteres, utilizando la siguiente conversión:

0 =  
1 = .
2 = +
3 = @

Aquí hay un resultado:

 +++      .  .      +++ 
 +@++++   .  .   ++++@+ 
 ++++@+.        .+@++++ 
   .+++   ++++   +++.   
          +@@+          
. .   . +++@@+++ .   . .
.       +@++++@+       .
     ++++++  ++++++     
     +@+        +@+     
.    ++++      ++++    .
   .  +@+      +@+  .   
  .  .+++.    .+++.  .  
 . .   .        .   . . 
    .    .    .    .    
   .   ..      ..   .   
 .                    . 

Pitón

No es el mejor ni el más sencillo, pero aquí hay una solución de Python:

from PIL import Image
import random
import sys

imgsize = (int(sys.argv[1]), int(sys.argv[2]))
color = (0, 0, 0)
img = Image.new("RGB", imgsize, "white")

for j in range(0,int(sys.argv[3])):
    start = (random.randrange(0, imgsize[0]/2), random.randrange(0, imgsize[1]))
    point = start
    img.putpixel(point, color)

    blotsize = random.randrange(0, int(sys.argv[4]))
    for i in range(blotsize):
        directions = [(point[0], point[1]+1), (point[0], point[1]-1), (point[0]+1, point[1]), (point[0]-1, point[1])]
        toremove = []
        for direction in directions:
            if direction[0]>=(imgsize[0]/2) or direction[1]>=imgsize[1] or direction[0]<0 or direction[1]<0:
                toremove.append(direction)
        for d in toremove:
            directions.remove(d)
        point = random.choice(directions)
        img.putpixel(point, color)

cropped = img.crop((0, 0, imgsize[0]/2, imgsize[1]))
img = img.transpose(Image.FLIP_LEFT_RIGHT)
img.paste(cropped, (0, 0, imgsize[0]/2, imgsize[1]))

img.save("blot.png")

Simplemente hace un "camino errante" para una mancha, y hace varios de esos.

Un ejemplo de uso:

py inkblot.py width height blots blotsize
py inkblot.py 512 512 20 10000

Y algunas imágenes de ejemplo: