Hacer X sin Y


52

Por lo general, se dice que "Hacer X sin Y" puede ser una trampa para los principiantes que escriben desafíos ( fuente ). Sin embargo, soy arrogante y creo que definitivamente puedo hacer una X sin ninguna Y. Al azar Oh sí, esto será bueno.

Desafío: dado un número entero impar nmayor o igual a 1, genera un ex de longitud lateral nhecha de caracteres ascii imprimibles al azar sin "y" e "Y", y el espacio. Todos los caracteres permitidos deben tener una probabilidad distinta de cero, pero no necesariamente uniformes. Este es un por lo que gana el código más corto en bytes. Sin embargo, debes aleatorizar cada carácter, es decir, los puntales del ex no deberían ser iguales, a menos que sea por casualidad.

Los caracteres que aparecerán

!#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXZ[\]^_`abcdefghijklmnopqrstuvwxz{|}~"

Construyendo el ex

Longitud lateral 1:

x

Longitud lateral 3:

x x
 x
x x

Longitud lateral 5:

x   x
 x x
  x
 x x
x   x

etc.

Salidas de ejemplo

input
output
empty line

3
h 2
 ^
9 5

1
:

5
D   1
 W z
  W
 q j
W   1

Implementación de ejemplo

No necesita manejar entradas inválidas.


¿Qué personajes deben ser elegibles para aparecer?
xnor

@xnor Personajes de !a ~sans yyY
Conor O'Brien

@ LegionMammal978 No, porque los caracteres que no son Y incluyen yy .
Leaky Nun

77
Hmm .. al azar ...
NonlinearFruit

14
¿¡Espere!? ¿Podemos usar "Y" e "y" en nuestro código?
Adám

Respuestas:


3

Pyth, 28 27 26 25 bytes

jmuXGHO-rF "! ~" "Yy" {, d-tQd *; Q 
VQuXGHO-rF "! ~" "Yy" {, N-tQN * d 
VQuXGHO-r \! \ ~ "Yy" {, N-tQN *re
VQuXGHO-r \! \ ~ "Yy", N-tQN * d

Banco de pruebas.


55
Estoy bastante seguro de que esto nunca producirá el ~personaje, porque el rango no lo incluye. Puede arreglar esto cambiando ~el código en el carácter DEL literal.
FryAmTheEggman

10

Ruby, 102 bytes

Array#sampleno hace repeticiones para el muestreo del conjunto de caracteres, pero está bien porque la distribución de caracteres no tiene que ser perfectamente uniforme. Función recursiva, devuelve una matriz de líneas.

Pruébalo en línea!

f=->l{w,x,y,z=([*?!..?~]-%w"y Y").sample 4
l<2?[w]:[w+(s=' '*(l-2))+x,*f[l-2].map{|e|" #{e} "},y+s+z]}

7

En realidad, 62 bytes

"!⌂"♂┘ix♂c"Yy"@-╗½≈u;r2@∙`i=`M╪k`;dXR@+`M;dXR@+`"╜J' aI"£MΣ`Mi

Este es uno de los programas más largos que he escrito.

Pruébalo en línea!

Explicación:

Parte 1 : configurar la lista de personajes

"!⌂"♂┘ix♂c"Yy"@-
"!⌂"              push the string "!⌂"
    ♂┘            CP437 ordinal of each character ([21, 127])
      ix          range(21, 127)
        ♂c        character at each ordinal (list of printable ASCII characters)
          "Yy"@-  set difference with ["Y", "y"] (printable ASCII except "Y" and "y")

Pruébalo en línea!

Parte 2 : construir la matriz booleana para una X

½≈u;r2@∙`i=`M╪k`;dXR@+`M;dXR@+
½≈u;                            two copies of int(input/2)+1
    r                           range
     2@∙                        Cartesian product with itself
        `i=`M                   for each sublist: push 1 if both elements are equal, else 0
             ╪k                 split into int(input/2)+1-length chunks
                                (at this point, we have one quarter of the X)
               `;dXR@+`M        mirror each sublist (one half of the X)
                        ;dXR@+  mirror the entire list (the whole X)

Pruébalo en línea!

Parte 3 : elegir personajes aleatorios

`"╜J' aI"£MΣ`Mi
`"╜J' aI"£MΣ`M   for each row:
 "╜J' aI"£M        for each column:
  ╜J                 push a random value from the character list
    '                push a space
      a              invert the stack
       I             take the character if the value is 1, else take the space
           Σ       concatenate the strings
              i  flatten the list and let implicit output take care of the rest

Pruébalo en línea!


1
"Visualizar tejido de bits" era de 69 bytes ;-)
AdmBorkBork

6

Mathematica, 146 bytes

a:=RandomChoice[33~CharacterRange~126~Complement~{"Y","y"}];StringRiffle[Normal@SparseArray[{{b_, b_}:>a,{b_,c_}/;c-1==#-b:>a},{#,#}," "],"
",""]&

Función anónima. Toma un número como entrada y devuelve una cadena como salida.


6

Python 2, 171 bytes

from random import*
def x(n):
 w=range(-n/2+1,n/2+1)
 for i in w:
  o=''
  for j in w:c=randint(33,124);c+=(c>88)+(c>119);c=[c,32][bool(i^j and i^-j)];o+=chr(c)
  print o

Garantizado para elegir personajes aleatorios con probabilidad uniforme.

Pruébelo aquí: enlace ideone

EDITAR: Gracias a Morgan Thrapp por las correcciones.


from random import*ahorra 2 bytes. También puede unir las dos primeras líneas del jbucle con un punto y coma para guardar algunos bytes. (También creo Zy {tengo una mayor probabilidad de ocurrir que algunas otras cartas, no es que sea importante para la pregunta)
FryAmTheEggman

Puede bajar a 165 con un par de pequeñas modificaciones mothereff.in/…
Morgan Thrapp

2
En realidad, su salida es incorrecta para todos los casos de prueba. Estás haciendo que cada pierna sea igual a n en lugar del tamaño total del lado.
Morgan Thrapp

@ MorganThrapp Ah, tienes razón. Lo arreglaré
ossifrage aprensivo

4 bytes: bool(i^j and i^-j)->i not in(j,-j)
Jonathan Allan

6

Python, 142 139 135 bytes

Esta es una implementación sencilla de crear el carácter cuadrado por carácter. Si el personaje está en diagonal : usa un carácter aleatorio, de lo contrario : usa un espacio. Esto también utiliza una sustitución de expresiones regulares y un int aleatorio para generar no Ycaracteres:

import re,random
lambda x:''.join('\n'*(i%x<1)+re.sub("y|Y","t",chr(random.randint(33,126))+' ')[i%x!=i/x!=x-i%x-1]for i in range(x*x))

Explicación [Antiguo]

"\n".join( ... for i in range(x)) # Create 'x' lines 
''.join( ... for j in range(x))   # Create 'x' chars on each line
(...)[j!=i!=x-j-1]                # Not on diagonals? 2nd char in "? "; Else, choose the 1st
j!=i                              # Not on downward diagonal
i!=x-j-1                          # Not on upward diagonal
re.sub("y|Y","t", ... )           # Replace y or Y for t
chr(random.randint(33,126))+' '   # Random char + a space

Actualizar

  • -4 [16-07-30] Nueva línea acortada condicional
  • -3 [16-07-30] Cambiado a solo for-loop
  • -6 [16-07-29] Se intercambió la declaración if para ternary op. Gracias a @RootTwo
  • -11 [16-07-27] Se eliminaron los corchetes / espacios adicionales y se volteó si la declaración
  • -49 [16-07-27] Absorbió el método de @ squeamishossifrage al crear el cuadrado paso a paso, ¡Gracias!
  • -10 [16-07-27] Acortar char lambda + material matemático aleatorio de @ ConorO'Brien
  • -22 [16-07-26] Squeaze en un lambda + golf misceláneo
  • -6 [16-07-26] import*- Gracias a @KevinLau

1
randintes probablemente más corto para tus propósitos, más from random import*. Además, elimine parte de ese espacio en blanco innecesario.
Value Ink

2
[i,33][i in(89,121)]¡Funciona en cambio necesitando un ternario de largo aliento en su ffunción! También vea si puede eliminar el espacio que está justo después de sus printdeclaraciones
Value Ink el

Sugeriría probar un formato diferente para su explicación de código. Esto no es muy legible. Intenta ver cómo otros usuarios hacen el suyo. Incluso esto sería mejor.
mbomb007

1
re.sub("y|Y","t",chr(random.randint(33,126))+' ')[j!=i!=x-j-1]ahorra 6 bytes sobre la ... if ... else ...construcción.
RootTwo

5

Dyalog APL , 35 bytes

⎕UCS 32+(⊢+∊∘57 89)⌊?95×(⊢∨⌽)∘.=⍨⍳⎕

solicite el número
1 a través de esa
∘.=⍨tabla de igualdad de números (es decir, la diagonal tiene 1s)
(⊢∨⌽)O su imagen especular (da ambas diagonales) se
95×multiplica por 95
?rand int entre 1 y 95 para las diagonales, y flota entre 0 y 1 para el
piso de descanso deshacerse de los flotadores
(⊢+∊∘57 89)agregue uno a los elementos que son miembros de {57,89} (Yy - 32)
32+agregue 32 para convertir los 0 en espacios, y otros números en el rango adecuado se
⎕UCSconvierten en texto

TryAPL !


Me gusta cómo este también reacciona con números pares, a pesar de que eso no era parte del problema (e incluso podría ser involuntario). ¡Buen trabajo! Aunque, curiosamente, a veces trata una entrada de 4 de manera diferente a cualquier otra entrada.
kirkpatt

@kirkpatt Sí, ni siquiera noté el "extraño" ..
Adám

3

Python 2.7, 205 bytes:

from random import*;C=input()/2;S=' ';R=range;Z=lambda:chr(choice(R(33,89)+R(90,121)+R(122,128)));T=lambda*G:''.join([S*i+Z()+S*(2*(~-C-i)+1)+Z()+S*i+'\n'for i in R(*G)]);print T(C)+S*C+Z()+'\n'+T(~-C,-1,-1)

¡Pruébelo en línea! (Ideona)


3

MATL , 28 bytes

6Y2'Yy 'X-iZr1MZrXdwXdP2$X>c

Pruébalo en línea!

Todos los personajes permitidos tienen la misma probabilidad de aparecer. Funciona incluso para entrada también.

6Y2     % Predefined literal of ASCII chars from 32 to 126
'Yy '   % Not allowed chars
X-      % Set difference. Produces the set of allowed chars
i       % Input number, n
Zr      % Random sample without replacement. Gives a string with n chars taken from 
        % the allowed set
1MZr    % Do the same
Xd      % Diagonal matrix. Zeros will be displayed as spaces
wXd     % Diagonal matrix with the other string
P       % Flip vertically
2$X>    % Maximum of the two matrices
c       % Convert to char. Implicitly display

3

C, 154 bytes (o 119 sin la placa de caldera)

o(w,c){c=rand()%94+33;printf("%*c",w,w?c+!(c&95^89):10);}main(h){scanf("%d",&h);srand(time(0));for(int n=h,p;n--;)p=abs(h/2-n),o(h/2-p+1),p&&o(p*2),o(0);}

O 119 bytes como una función X(h)con srand(time(0))cuidado en otro lugar:

o(w,c){c=rand()%94+33;printf("%*c",w,w?c+!(c&95^89):10);}X(h,n,p){for(n=h;n--;)p=abs(h/2-n),o(h/2-p+1),p&&o(p*2),o(0);}

Descompostura:

o(w,c){                         // "Output" function, for all printing
    c=rand()%94+33;             // Generate random char, whether we need it or not
    printf("%*c",               // Print a char with some number of leading spaces
           w,                   // Use "w" (width) - 1 leading spaces
           w?                   // Either print the random char...
             c+!(c&95^89)       // (exclude "y" and "Y" by incrementing to "z"/"Z")
                         :10    // ...or print a newline if called with w = 0
    );
}
main(h){                        // Main function; repurpose argc to store grid size
    scanf("%d",&h);             // Get grid size from stdin
    srand(time(0));             // Boiler-plate for random number seeding
    for(int n=h,p;n--;)         // Loop over all lines (count down to save chars)
        p=abs(h/2-n),           // Calculate half-distance between "X" bars
        o(h/2-p+1),             // Output the first half of the "X" (">")
        p&&                     // If we are not in the centre:
           o(p*2),              //   output the second half of the "X" ("<")
        o(0);                   // Output a newline
}

3

código de máquina x86, 70 bytes

60 89 d7 31 db 43 88 ce b2 fe 49 d1 e1 87 da 0f
c7 f0 24 7f 3c 22 72 f7 48 3c 79 74 f2 3c 59 74
ee aa 49 7c 1c 00 df 79 06 86 f7 42 43 eb f6 f6
c3 01 74 03 b0 0a aa 51 88 f9 b0 20 f3 aa 59 eb
cc c6 07 00 61 c3

Mi código ejecutable, desmontado:

0000003d <myheh>:                                       
  3d:   60                      pusha                   
  3e:   89 d7                   mov    %edx,%edi        
  40:   31 db                   xor    %ebx,%ebx        
  42:   43                      inc    %ebx             
  43:   88 ce                   mov    %cl,%dh          
  45:   b2 fe                   mov    $0xfe,%dl        
  47:   49                      dec    %ecx             
  48:   d1 e1                   shl    %ecx             

0000004a <myloop>:                                      
  4a:   87 da                   xchg   %ebx,%edx        

0000004c <myrand>:                                      
  4c:   0f c7 f0                rdrand %eax             
  4f:   24 7f                   and    $0x7f,%al        
  51:   3c 22                   cmp    $0x22,%al        
  53:   72 f7                   jb     4c <myrand>      
  55:   48                      dec    %eax             
  56:   3c 79                   cmp    $0x79,%al        
  58:   74 f2                   je     4c <myrand>      
  5a:   3c 59                   cmp    $0x59,%al        
  5c:   74 ee                   je     4c <myrand>      
  5e:   aa                      stos   %al,%es:(%edi)   
  5f:   49                      dec    %ecx             
  60:   7c 1c                   jl     7e <mydone>      

00000062 <mylab>:                                       
  62:   00 df                   add    %bl,%bh          
  64:   79 06                   jns    6c <myprint>     
  66:   86 f7                   xchg   %dh,%bh          
  68:   42                      inc    %edx             
  69:   43                      inc    %ebx             
  6a:   eb f6                   jmp    62 <mylab>       

0000006c <myprint>:                                     
  6c:   f6 c3 01                test   $0x1,%bl         
  6f:   74 03                   je     74 <myprint1>    
  71:   b0 0a                   mov    $0xa,%al         
  73:   aa                      stos   %al,%es:(%edi)   

00000074 <myprint1>:                                    
  74:   51                      push   %ecx             
  75:   88 f9                   mov    %bh,%cl          
  77:   b0 20                   mov    $0x20,%al        
  79:   f3 aa                   rep stos %al,%es:(%edi) 
  7b:   59                      pop    %ecx             
  7c:   eb cc                   jmp    4a <myloop>      

0000007e <mydone>:                                      
  7e:   c6 07 00                movb   $0x0,(%edi)      
  81:   61                      popa                    
  82:   c3                      ret                     

Es una función que recibe el tamaño de la X en ecx, y un puntero al búfer de salida en edx.

Llena el búfer de salida secuencialmente con bytes. Hay 2 * n - 1iteraciones (igual al número de caracteres que no son espaciales para generar). En cada iteración, hace lo siguiente:

  • Generar un número aleatorio
  • Juega con el número para ajustarlo al rango; si es malo, regrese y genere nuevamente
  • Imprime el caracter aleatorio
  • Imprima una nueva línea (cada dos iteraciones)
  • Imprima la cantidad adecuada de espacios

La conversión de un número aleatorio a un carácter aleatorio no es notable:

myrand:
    rdrand eax;
    and al, 7fh;
    cmp al, 22h;
    jb myrand;
    dec eax;
    cmp al, 'y';
    je myrand;
    cmp al, 'Y';
    je myrand;

La parte interesante es el cálculo del número de espacios. Debe generar los siguientes números (ejemplo para N = 9):

7    1
5    2
3    3
1    4

     3
1    2
3    1
5    0
7

Los números se toman alternativamente de dos progresiones aritméticas. El primero baja con el paso -2, y el segundo sube con el paso 1. Cuando la primera progresión llega a -1 (en el medio de la X), hay una falla (se elimina -1), y luego Las progresiones cambian de dirección.

Las progresiones se almacenan en registros ebxy edx- las partes altas bhy dhalmacenan el número actual, y las partes bajas bly dlalmacenan el paso. Para alternar entre las progresiones, el código intercambia los registros con xchg.

Cuando la progresión llega a -1 (alrededor de la mylabetiqueta), aumenta ambos registros, cambiando los pasos de -2, 1a -1, 2. Esto también cambia las funciones de los registros, por lo que intercambia las partes altas de los registros.

Al final de la función, almacena un byte cero para indicar el final de la cadena.


2

Lua, 277 bytes

Bueno ... Lua es muuuy buena manipulando cuerdas: D. Primera vez que tuve que usar localen una declaración! Podría guardar algunos bytes usando Lua 5.1 en lugar de 5.3 porque movieron la función global unpackal objeto tableen Lua 5.2. Pero prefiero seguir con la última versión que tengo :).

Define una función que debería llamarse con un único parámetro (el segundo se usa para fines de recursividad) y devuelve una cadena.

function f(n,N)N=N or n e=" "p="\n"r=math.random C=e.char
R={}for i=1,4 do x=r(33,126)R[i]=x~=89 and x~=121 and x or r(33,88)end
local s,S,a,b,c,d=e:rep((N-n)/2),e:rep(n-2),table.unpack(R)return
n<2 and s..C(a)..p or s..C(a)..S..C(b)..s..p..f(n-2,N)..s..C(c)..S..C(d)..s..p
end

Sin golf

function f(n,N)                       
  N=N or n                          -- N is equal to the n we had on the first call
  e=" "                             -- shorthand for the space
  p="\n"                            -- shorthand for the newline
  r=math.random                     -- shorthand for math.random
  C=e.char                          -- uses the string e to obtain the function string.char
  R={}                              -- define an array for our random values
  for i=1,4                         -- iterate 4 times (for the random characters)
  do
    x=r(33,126)                     -- random between ASCII "!" and "~"
    R[i]=x~=89 and x~=121           -- if we didn't pick y or Y
           and x                    -- keep this number
         or r(33,88)                -- or roll for a character between "!" and "X"
  end
  local s,S                         -- these variables have to be local
          ,a,b,c,d                  -- or the recursion would change them
         =e:rep((N-n)/2),e:rep(n-2) -- s and S are the number of spaces for the X
           ,table.unpack(R)         -- a,b,c and d are the 4 random characters
  return n<2                        -- if n==1 
           and s..C(a)..p           -- we're at the center of the X, time to end recursion
         or                         -- else
           s..C(a)..S..C(b)..s..p   -- concatenate the topmost line for n
           ..f(n-2,N)               -- with the inner X
           ..s..C(c)..S..C(d)..s..p -- and the bottom line
end

2

JavaScript (ES6), 137 131 125 bytes

n=>[...Array(n)].map((_,i,a)=>String.fromCharCode(...a.map((r=Math.random()*94,j)=>i-j&&i+j+1-n?32:(r+72&95&&r)+33))).join`\n`

Donde \nrepresenta el carácter literal de nueva línea. Editar: guardado 1 byte moviendo el ' 'interior de la String.fromCharCodeexpresión. Ahorré 5 bytes haciendo que mi generación aleatoria de caracteres no sea uniforme; la expresión r+72&95es cero para los valores que se asignan a Yy yy !se genera un en su lugar. Guarde 4 bytes cuando me di cuenta de que la propagación String.fromCharCodeevita tener que hacerlo join. Ahorró 2 bytes al robar un truco de @ edc65.


2

PowerShell v2 +, 112 bytes

Param($i)function f{Random(33..126-ne121-ne89|%{[char]$_})};1..$i|%{$a=,' '*$i;$a[$_-1]=f;$a[$i-$_]=f;$a-join''}

Lee la entrada de la línea de comando.

Para cada línea, se crea una matriz de espacios, los índices correctos se completan con caracteres extraídos de la función f, luego la matriz de caracteres se une a la salida como una línea.


Puede guardar 6 bytes moviendo el [char]elenco fuera de Random, y volteando -joinpara ser un operador unario ---Param($i)function f{[char](Random(33..126-ne121-ne89))};1..$i|%{$a=,' '*$i;$a[$_-1]=f;$a[$i-$_]=f;-join$a}
AdmBorkBork

En realidad, puede guardar otro par de bytes reemplazando el functioncon el equivalente de PowerShell de un lambda y usar el operador &de llamada para llamarlo. El siguiente es 103 bytes -Param($i)$z={[char](Random(33..126-ne121-ne89))};1..$i|%{$a=,' '*$i;$a[$_-1]=&$z;$a[$i-$_]=&$z;-join$a}
AdmBorkBork

En realidad, en realidad ;-), se puede ahorrar algo más por el colapso de su -ne, moviendo el [char]molde a ser un [char[]]yeso en $a(el canje ' 'de 32en el proceso), y moviendo $z's definición en un parens la primera vez que se llama. Hasta 99 (¡woo! Sub-100!) -Param($i)1..$i|%{$a=,32*$i;$a[$_-1]=&($z={Random(33..126-ne121,89)});$a[$i-$_]=&$z;-join[char[]]$a}
AdmBorkBork

Ah, guarde otro byte moviendo $ala definición a un parens la primera vez que se usa. Hasta 98 ​​ahora - Param($i)1..$i|%{($a=,32*$i)[$_-1]=&($z={Random(33..126-ne121,89)});$a[$i-$_]=&$z;-join[char[]]$a}Creo que me detendré aquí ;-) jeje
AdmBorkBork

2

MATLAB, 86 bytes

a=@(n)(char(changem(randi(92,n),33+[0:55 57:87 89:93],1:92).*(eye(n)|fliplr(eye(n)))))

Algunos ejemplos:

>> a(1)

ans =

i


>> a(3)

ans =

~ {
 Z 
* ^


>>a(5)

ans =

k   E
 | M 
  }  
 ] s 
b   t


>> a(10)

ans =

Q        k
 +      a 
  j    w  
   X  [   
    rO    
    %3    
   P  d   
  K    q  
 r      & 
?        v

Entonces, se llama una función que cambia los valores en una matriz de acuerdo con algunas reglas changem. ¡Gran nombre!
anatolyg

2

Pip , 33 bytes

32 bytes de código, +1 para -lbandera. Por extraño que parezca, el código comienza Yy termina con y...

Ya{$=a|$+a=y-1?RCPARM-`y`s}MMCGy

Toma entrada como un argumento de línea de comando. Pruébalo en línea!

Explicación

Construye una cuadrícula del tamaño apropiado; reemplaza elementos en las diagonales con un carácter aleatorio que no sea y, y todos los demás elementos con espacio.

                                  a is 1st cmdline arg; PA is printable ASCII characters;
                                  s is space (implicit)
Ya                                Yank a into y (global var, accessible within functions)
                             CGy  y by y coordinate grid
  {                       }MM     To each coordinate pair, map this function:
   $=a                             Fold on equality (true if both elements are equal)
      |                            Logical OR
       $+a                         Fold on +
          =y-1                     and test if equal to size - 1
              ?                    If the preceding expression is true, then:
                 PARM               From printable ASCII chars, remove         
                     -`y`           regex matching y, case-insensitive
               RC                   Take a random choice from the resulting string
                         s         Else, space
                                  The whole expression returns a nested list, which is
                                  autoprinted as lines of concatenated items (-l flag)

1

php, 135 bytes

<?php for(;$i<$n=$argv[1];){$s=str_pad('',$n);$s[$i?:0]=chr(rand(33,126));$s[$n-++$i]=chr(rand(33,126));echo str_ireplace(Y,X,"$s
");}

El enfoque bastante sencillo usa str_pad para hacer una cadena de espacios de la longitud requerida, reemplaza los caracteres necesarios con caracteres aleatorios y luego reemplaza cualquier Ys (insensible a mayúsculas y minúsculas) con Xs y repite la línea.
Genera avisos 2n + 3 pero, como de costumbre, está bien.


1

Emacs Lisp, 269 bytes

(defalias'n'number-sequence)(set'c(mapcar'string(delq 89(delq 121(n 33 126)))))(defun c()(nth(random(length c))c))(defun s(x)" ")(defun x(l)(let((s(mapcar's(n 1 l))))(dotimes(i l)(set'x(copy-seq s))(setf(nth i x)(c)(nth(-(length x)i 1)x)(c))(message(apply'concat x)))))

Sin golf y ligeramente modificado:

(defvar c (mapcar 'string (delq 89 (delq 121 (number-sequence 33 126)))))
(defun c() (nth (random (length c)) c))
(defun s(x)" ")
(defun x(l)
  (let ((s(mapcar's(n 1 l)))
        x)
    (dotimes (i l)
      (set 'x (copy-seq s))
      (setf (nth i x) (c)
            (nth (- (length x) i 1) x) (c))
      (message (apply 'concat x)))))

1

JavaScript (ES6), 128131

Editar 3 bytes guardados gracias a @Neil

Muy voluminoso, probablemente no sea el mejor enfoque. Bonificación: funciona con entradas pares o impares.

n=>[...Array(n)].map((_,i,z)=>String.fromCharCode(...z.map((r=1+Math.random()*94,j)=>32+(j==i|j==n+~i&&(r+7&31?r:25))))).join`
`

F=n=>[...Array(n)].map((_,i,z)=>String.fromCharCode(...z.map((r=1+Math.random()*94,j)=>32+(j==i|j==n+~i&&(r+7&31?r:25))))).join`\n`

Z=_=>{
    o=F(+S.value),O.textContent=o,/y/i.test(o)||setTimeout(Z,100)
}
setTimeout(Z,100)
<input id=S value=15 type=number>
<pre id=O></pre>


Creo que r+7&31da el mismo resultado que (r&31)-25.
Neil

@Neil suena bien, gracias
edc65

¡Me gusta cómo esto ilustra el hecho de que es aleatorio! +1
Conor O'Brien

1

C, 268 bytes

V(c){for(c=89;c==89||c==121;c=rand()%95+33);return c;}p(n,s){n^1?s-n?printf("%*.c",s-n,32):0,printf("%c%*.c%c\n",V(),n*2-3,32,V()),p(n-1,s),s-n?printf("%*.c",s-n,32):0,printf("%c%*.c%c\n",V(),2*n-3,32,V()):printf("%*.c%c\n",s-n,32,V());}f(n){srand(time(NULL));p(n,n);}

Llame f()con el tamaño del xpara dibujar.


Debe llamar sranddentro de sus funciones, no pueden confiar en el estado global. Sin embargo, puede lograr un programa mucho más corto con dos bucles anidados y utilizando el carácter de retroceso. Una solución general podría ser como este , pero creo que una variante específica utilizando ventanas clocksería válido.
FryAmTheEggman

¿Puedes arrendar agregar la versión de tu compilador? en gcc version 4.8.1para Windows y gcc version 5.3.0para Cygwin no funciona ... (en Ideone Works)
Giacomo Garabello

Sé que funciona con GCC 6.1.0, pero al menos debería funcionar con> 4.9. También funciona con clang 3.8.1. ¿Qué errores ves?
owacoder

1

Matrices , 79 bytes (no competidoras)

Matricks sobresale como el comienzo de hacer la xy todos los valores aleatorios, pero fracasa cuando se trata de condicionales ...

Marqué esto como no competitivo porque tuve que corregir algunos errores y hacer que todas las nuevas funciones funcionen después de que se publicó este desafío.

m:n;:1;mr=c:L:L;k({}|{X;})*{m_?33:126;;:L:l;miC<121,89>:gr:c;;:49:gr:c;;:L:l;};

Corre con python matricks.py x.txt [[]] <input> --asciiprint

Explicación:

m:n;:1;mr=c:L:L;                   #Initialize matrix to be a square with
                                   #a diagonal of 1s
k...;                              #Set the output to...
({}|{X;})*                         #The boolean x matrix multiplied by...
{m_?33:126;;:L:l;                  #A bunch of random characters
miC<121,89>:gr:c;;:49:gr:c;;:L:l;} #But make sure they are not y or Y

Esto también admite números pares.


1

Python 2, 204 191 183 bytes

De acuerdo, la competencia de Python aquí se está volviendo feroz. Aquí está mi intento de reducir tantos bytes como sea posible. Por ahora estoy atascado (Ok, atascado de nuevo).

Créditos a @NonlinearFruit por la forma en que se seleccionan los caracteres aleatorios.

Versión de 183 bytes:

import re,random
s=i=input();t=lambda:re.sub("y|Y","t",chr(random.randint(33,126)))
while i>-s:i-=2;u=abs(i);z=(s-u)/2-1;print('',' '*-~z+t()+'\n')[-1==i]+(' '*z+t()+' '*u+t())*(i>-s)

¡Pruébelo en línea! (Ideona)

El cambio principal es reescribir el condicional

(" "*(z+1)+t()+"\n"if -1==i else"") 

como

(""," "*-~z+t()+'\n')[-1==i]

que ahorra 7 bytes.

Versión de 191 bytes:

import re,random
s=i=input();t=lambda:re.sub("y|Y","t",chr(random.randint(33,126)))
while i>-s:
 i-=2;u=abs(i);z=(s-u)/2-1;print(' '*(z+1)+t()+'\n'if -1==i else'')+(' '*z+t()+' '*u+t())*(i>-s)

¡Pruébelo en línea! (Ideona)

Los cambios principales son la forma en que se seleccionan los caracteres aleatorios y algunos reordenamientos de código, como el s=input();i=s;devenir s=i=input();, eliminar la r=rangeasignación ya que ya no es necesaria y llamar absdirectamente, ya que da como resultado menos bytes de código.

¡Superando la respuesta más corta anterior en Python por 1 byte! @R. El enfoque de Kap se usa para generar los caracteres aleatorios. Cada iteración del ciclo while se imprime una fila del ex.

Versión de 204 bytes :

from random import*
s=input();i=s;a=abs;r=range;t=lambda:chr(choice(r(33,89)+r(90,121)+r(122,128)))
while i>-s:
 i-=2;z=(s-a(i))/2-1;print(' '*(z+1)+t()+'\n'if -1==i else'')+(' '*z+t()+' '*a(i)+t())*(i>-s)

¡Pruébelo en línea! (Ideona)

Versión sin golf para tener una idea de cómo funciona:

from random import *
random_character = lambda : chr(choice(range(33,89)+range(90,121)+range(122,128)))

size = input()
current_row = size

while current_row > -size:
    current_row-=2
    n_leading_spaces = (size-abs(current_row)/2)-1 
    row_to_print = ''
    if current_row == -1:
        row_to_print = ' ' * (n_leading_spaces+1) + random_chr() + '\n'
    if current_row > -size:
        row_to_print += ' ' * n_leading_spaces + random_chr()+' '*abs(current_row)+random_chr()
    print row_to_print

¡Fue difícil manejar el caso de 1 personaje!


1

SmileBASIC, 97 bytes

INPUT S
FOR X=1TO S
FOR Y=1TO S
Q=RND(93)+33?CHR$((Q+!(Q-121&&Q-89))*(X==Y||X+Y==S+1));
NEXT?NEXT

En lugar de tener que calcular el número de espacios entre cada personaje o algo, decidí imprimir en todas las ubicaciones donde X==Yo X+Y==Size+1.
El generador de caracteres aleatorios solo agrega 1 si genera yo Y, por lo tanto, zy Zson un poco más comunes de lo habitual.


1

PHP, 100 bytes

for(;($x%=$n=$argv[1])?:$y++<$n&print"\n";)echo strtr(chr($y+$x++-$n&&$x-$y?32:rand(33,126)),yY,zZ);

toma datos del argumento de la línea de comando; correr con -nr.

bucle combinado imprime caracteres dependiendo de la posición

Descompostura

for(;
    ($x%=$n=$argv[1])       // inner loop
        ?
        :$y++<$n&print"\n"  // outer loop; print newline
;)
    echo strtr(chr(             // 2. replace Y with Z; print
        $y+$x++-$n&&$x-$y       // 1: if position is not on diagonals
            ?32                 // then space
            :rand(33,126)       // else random printable
    ),yY,zZ);
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.