Crear un cuadrado cruzado

Debe ingresar un número entero de uno o más y generar un cuadrado hecho de cualquier carácter imprimible de su elección con una cruz diagonal a través del centro.

La idea general es que la salida sea un cuadrado hueco que tenga una cruz diagonal a través de él .:

Input: 7
Output:
*******
*#   #*
* # # *
*  #  *
* # # *
*#   #*
*******

En el ejemplo anterior, los '*' representan la caja exterior y los '#' representan la cruz diagonal.

Tenga en cuenta que el ejemplo anterior usa dos caracteres diferentes para que sea más fácil ver cómo se ve la salida, su programa debe usar solo un carácter.

Entrada

Un entero de 1 o más, se garantiza que sea impar.

Salida

Un cuadrado que se compone de un personaje de su elección con una cruz en el medio.

• La cruz debe ser diagonal.
• El cuadrado puede salir a través de la función o escribirse en la salida
• Las nuevas líneas finales están bien
• Puede salir como un gráfico, diagrama o imagen si lo desea también

Ejemplos

Input: 1
Output:
*

Input: 3
Output:
***
***
***

Input: 5
Output:
*****
** **
* * *
** **
*****

Input: 7
Output:
*******
**   **
* * * *
*  *  *
* * * *
**   **
*******

Especificaciones

• Se permiten funciones o programas completos
• Puede obtener información por sus medios preferidos
• Las lagunas estándar no están permitidas
• Los programas deben trabajar sin ningún tipo de declaraciones adicionales es decir, usingS en C#, deben ser incluidos en la entrada
• Puede imprimir desde una función o imprimir el resultado

Este es el código de golf, por lo que gana la solución más corta.

MATL , 20 19 17 bytes

2-:XdtP!+~TTYa1YG

Puede probarlo experimentalmente en MATL en línea . Es posible que deba actualizar la página si no funciona.

Ejecución de muestra:

Versión ASCII: 19 bytes

2-:XdtP!+~TTYa~42*c

Pruébalo en línea!

VBA Excel, 168 bytes

Instrucción:

Creo que Excel con la ayuda de VBA es una herramienta efectiva y suficiente para este desafío. Establezca la hoja de trabajo de Excel como sigue

Sí, utilizamos los pequeños píxeles clásicos de forma cuadrada como en los viejos tiempos al usar las celdas en una hoja de trabajo como píxeles. Jaja...

Aquí uso la celda A1 como entrada y cambio su color de fuente a rojo. ¿Por qué rojo? Debido a que el rojo es de tres letras, es ideal para jugar al golf. Escriba y ejecute el siguiente código en la ventana Inmediato:

N=[A1]:Range("A1",Cells(N,N)).Interior.Color=vbRed:Range("B2",Cells(N-1,N-1)).Clear:For i=1To N:Cells(i,i).Interior.Color=vbRed:Cells(i,N+1-i).Interior.Color=vbRed:Next

Ungolfed el código:

Sub A()
    N = [A1]
    Range("A1", Cells(N, N)).Interior.Color = vbRed
    Range("B2", Cells(N - 1, N - 1)).Clear

    For i = 1 To N
        Cells(i, i).Interior.Color = vbRed
        Cells(i, N + 1 - i).Interior.Color = vbRed
    Next
End Sub

Explicación paso a paso:

N = [A1]: Range("A1", Cells(N, N)).Interior.Color = vbRed

Range("B2", Cells(N - 1, N - 1)).Clear

Recorriendo la diagonal de las celdas de rango: Cells(i, i).Interior.Color = vbRed

Paso final y salida: Cells(i, N + 1 - i).Interior.Color = vbRed

JavaScript (ES6), 96 bytes

f=
n=>[...Array(n--)].map((_,i,a)=>a.map((_,j)=>i&&j&&n-i&&n-j&&i-j&&n-i-j?' ':'*').join``).join`
`
;

<input type=number min=1 step=2 oninput=  o.textContent=f(this.value)><pre id=o>

Python 2, 65 bytes

i=n=2**input()/2
while i:print bin((n>i>1or~-n)|n|i|n/i)[2:];i/=2

Utiliza la idea de Jonathan Allan de generar números binarios como:

11111
11011
10101
11011
11111

Las filas se crean con aritmética de bits y se muestran en binario. Cada parte se oró al resto. Las partes son producidas por potencias de 2 n(fijo) y i(caída) a través de

1. Lado izquierdo 1
2. Lado derecho n
3. Diagonales iyn/i
4. Arriba y abajo n-1cuando i==1o i==n.

En realidad, (1) y (4) se combinan produciendo 1cuándo 1<i<ny de lo n-1contrario.

Pitón, 114 110 96 90 bytes

Totalmente cambiado:

lambda n:[bin(sum(2**p for p in[range(n),{0,n-1,r,n-1-r}][0<r<n-1]))[2:]for r in range(n)]

Devuelve una lista de cadenas, caracteres usando 1y 0.
-6 bytes gracias a TheBikingViking

Pruébalo en ideone

Python 2 @ 110 anterior

def f(n):g=range(n);n-=1;print'\n'.join(''.join((c in(r,n-r,0,n)or r in(0,n))and'#'or' 'for c in g)for r in g)

Pruébalo en ideone

Java 7, 131 130 128 125 124 122 bytes

String c(int n){String r="";for(int i=n,j;n-->0;r+="\n")for(j=0;j<n;r+=i*j<1|n-i<2|n-j<2|i==j|i==n-++j?"*":" ");return r;}

3 bytes guardados gracias a @LeakyNun ;
1 byte guardado gracias a @ OliverGrégoire en mi respuesta para Dibujar un cuadrado hueco de # con el desafío de ancho dado ;
2 bytes guardados gracias a @cliffroot .

Ungolfed y código de prueba:

Pruébalo aquí

class M{
  static String c(int n){
    String r = "";
    for(int i = n, j; n-- > 0; r += "\n"){
      for(j = 0; j < n;
            r += i < 1      // Responsible for the first horizontal line
               | j < 1      // Responsible for the first vertical line
               | n-i < 2    // Responsible for the last horizontal line
               | n-j < 2    // Responsible for the last vertical line
               | i == j     // Responsible for the top-left to bottom-right diagonal line
               | i == n-++j // Responsible for the top-right to bottom-left diagonal line (and increasing j)
             ? "*"
             : " ");
    }
    return r;
  }

  public static void main(String[] a){
    System.out.println(c(1));
    System.out.println(c(3));
    System.out.println(c(5));
    System.out.println(c(7));
  }
}

Salida:

*

***
***
***

*****
** **
* * *
** **
*****

*******
**   **
* * * *
*  *  *
* * * *
**   **
*******

Matlab, 68 66 64 58 bytes

Como la salida gráfica también está permitida:

k=input('');[x,y]=ndgrid(abs(-k:k));spy(~(max(x,y)<k&x-y))

Qué salidas, por ejemplo

Las versiones únicas de ASCII serían:

Esto está usando la indexación 0,1,2,3,...

k=input('');[x,y]=ndgrid(abs(-k:k));[(max(x,y)==k|~(x-y))*42,'']

Alternativamente con la indexación 1,3,7,...:

n=input('');k=1:n;m=eye(n);m([k,end-k+1])=1;[(m|flip(m'))*42,'']

C #, 112101 bytes

Gracias a TheLethalCoder por recordarme que estas cosas anónimas de declaración / expresión lambda están permitidas en C #.

n=>{var r="";for(int y=n--,x;y-->0;r+="*\n")for(x=0;x<n;r+=y%n*x<1|y==x|y==n-x++?"*":" ");return r;};

¿Quién dijo que C # no es un lenguaje de golf divertido?

Logo, 155 bytes

Solución gráfica, implementada como una función.

Reorganicé mi respuesta para Alphabet Triangle y cambié los ángulos un poco. Como antes, rdibuja una línea de caracteres. Esta vez, elb función dibuja un cuadro dibujando un borde recto y uno diagonal, girando y repitiendo cuatro veces. Esto hace que las diagonales se dibujen dos veces (una encima de la otra), pero era menos código que manejarlo por separado. Esta respuesta también maneja adecuadamente los números pares. Tuve que agregar un manejo especial para una entrada de1 para evitar que avance.

Lo implementé como una función, b que toma el tamaño como argumento:

pu
to r:n:b:l repeat:n[rt:b label "A lt:b if repcount>1[fd:l]] end
to b:s
repeat 4[rt 90
r:s 90-heading 20 rt 135
r:s 90-heading 20*sqrt 2 rt 45]
end

Pruébelo en el intérprete de logotipos de Calormen.com . Para llamarlo, agregue una línea y llame ben el siguiente formato:

b 7

... o pruebe el plato de muestra, que extrae cuatro muestras en tamaños 5, 7, 9 y 11, rotando 90 grados entre:

repeat 4[
  b repcount*2+3
  rt 90
]

R, 102 bytes

    n=scan();for(i in 1:n){for(j in 1:n){z=" ";if(i%in%c(1,n,n-j+1)|j%in%c(1,i,n))z="*";cat(z)};cat("\n")}

Tenga en cuenta que es más eficiente expresar la condición usando% en% que i == 1 | j == 1 | ...

Haskell, 102 100 96 91 87 bytes

c s=unlines.f$f.(#)where f=(<$>[1..s]);x#y|elem y[1,s,x]||elem x[1,s,s-y+1]='*'|1>0=' '

• Guardado 2 bytes, gracias a flawr .
• Ahorró 4 bytes más al usar las comprensiones de listas.
• 5 bytes guardados combinando la mejora de flawr conany
• 4 bytes guardados al reemplazar anyconelem

Versión sin golf:

cross :: Int -> String
cross s = unlines $ map line [1..s]
    where line y = map (pos y) [1..s]
          pos y x | x == y = '*'
                  | x == s - y + 1 = '*'
                  | y `elem` [1, s] = '*'
                  | x `elem` [1, s] = '*'
                  | otherwise = ' '

Estoy seguro de que esto todavía se puede mejorar, pero esto es lo que se me ocurrió por ahora.

Versión antigua:

c s=unlines.f$f.(#)where f=(<$>[1..s]);x#y|any(==y)[1,s,x]||any(==x)[1,s,s-y+1]='*'|1>0=' '

Java, 130 bytes

s->{for(int i=0;i<s;i++)for(int j=0;j<s;j++)System.out.print((s-1-i==j||i==j||i==0||j==0||i==s-1||j==s-1)?j==s-1?"*\n":"*":" ");};

Programa de prueba

Consumer<Integer> consumer = s -> {
        for (int i = 0; i < s; i++) {
            for (int j = 0; j < s; j++) {
                System.out.print((s - 1 - i == j || i == j || i == 0 || j == 0 || i == s - 1 || j == s - 1) ? j == s - 1 ? "*\n" : "*" : " ");
            }
        }
    };

    consumer.accept(20);

C, 140 121 114 bytes

19 bytes gracias a Quentin.

7 bytes guardados al cambiar de un bucle anidado doble a un bucle.

main(a){scanf("%d",&a);for(int i=0;i<a*a;i++,i%a||puts(""))putchar(i/a&&i/a^a-1&&i%a&&-~i%a&&i%-~a&&i%~-a?32:42);}

Sugerencias de golf bienvenidas.

PowerShell (133)

filter s($x){1..$x|%{$o="";$r=$_;1..$x|%{if($_-eq1-or$r-eq1-or$_-eq$x-or$r-eq$x-or$r-eq$_-or$r-1-eq$x-$_){$o+="*"}else{$o+="_"}};$o}}

Clunky, pero funciona lo suficientemente bien.

s(11)
***********
**_______**
*_*_____*_*
*__*___*__*
*___*_*___*
*____*____*
*___*_*___*
*__*___*__*
*_*_____*_*
**_______**
***********

Las sugerencias de golf definitivamente son bienvenidas, ha pasado mucho tiempo desde que utilicé PowerShell.

SILOS , 212 bytes

readIO 
a = i
lbla
a - 1
t = a
t + 1
t % i
t * a
b = i
lblb
b - 1
u = b
u + 1
u % i
u * b
u * t
v = a
v - b
u * v
v = a
v + b
v + 1
v % i
u * v
u |
if u c
print #
GOTO d
lblc
print .
lbld
if b b
printLine 
if a a

Pruébalo en línea!

GNU sed, 117114 + 1 (r flag) = 115 bytes

p;/^0$/Q;/^000$/{p;q}
h;s/./ /3g;s/  $/00/
:f;/ 00 /!{G;h;s/\n.*//p;t;:}
s/^(0 *)0  ?( *)0/\1 0\20 /
tf;s/00/0/p;g

Dado que sed no tiene soporte nativo para números, la entrada se da en unario basado en este consenso . La segunda mitad del cuadrado es la primera mitad que se almacenó en orden inverso en el espacio de espera.

Correr:

sed -rf crossed_square.sed <<< "00000"

Salida:

00000
00 00
0 0 0
00 00
00000

Python, 89 bytes

Esto fue un retroceso! Usé el módulo de tortuga de Python.

from turtle import*
n=input()
for i in[(n,n),(n,0),(0,n),(0,0),(n,0),(0,n),(n,n)]:goto(i)

Aquí está el resultado cuando n = 200:

Scala, 141 137 bytes

val s=args(0).toInt-1;val t=0 to s;print(t.map{x=>t.map{y=>if(x==0||x==s||y==0||y==s||x==y||x==s-y)"*" else " "}.mkString+"\n"}.mkString)

Correr:

$ scala cross.scala 10

Técnicamente, podría eliminar el material impreso e ir a algo como

def c(n:Int)={val (s,t)=(n-1,0 to n-1);t.map{x=>t.map{y=>if(x==0||x==s||y==0||y==s||x==y||x==s-y)"*" else " "}.mkString+"\n"}.mkString}

Esto lo convertiría en 135 o 121 bytes dependiendo de si cuenta el material de sintaxis de la función.

Versión legible:

def cross(n: Int) = {
   // Declares both s and t as variables with tuple expansion
   // s is the zero-based size and t is a range from 0 to s
   val (s,t) = (n-1, 0 to n-1)

   // Maps all rows by mapping the columns to a star or a space
   t.map { x =>
      t.map { y =>
        if (x == 0 || x == s || y == 0 || y == s || x == y || x == s-y) "*" 
        else " "
      }.mkString+"\n" // Concatenate the stars and spaces and add a newline
   }.mkString         // Concatenate the created strings
 }

Pyth, 27 25 bytes

jmsm?|qFKaLJ/Q2,dk}JKN\ Q

Pruébalo en línea!

Probablemente golfable.

Python 2, 83 bytes

i=n=input()
while i:l=['* '[1<i<n]]*n;i-=1;l[0]=l[~0]=l[i]=l[~i]='*';print`l`[2::5]

Modifica una lista de los caracteres de la fila para poner un lugar *en el primer, último, i y el último lugar. La primera y la última fila comienzan como todas *, y el resto como todos los espacios. Funciona para igualar también. Una lambdaexpresión es probablemente más corta que la modificación, pero me gusta este método.

Pyke, 28 24 23 bytes

]Ua]jshqjXq|0[j{|)Qt[)P

Pruébalo aquí!

Mathematica, 81 bytes

""<>#&/@Table[If[i^2==j^2||i^2==#^2||j^2==#^2,"*"," "],{i,-#,#},{j,-#,#}]&[(#-1)/2]&

Crea un sistema de coordenadas con el origen en el centro y calcula dónde *debe ir la s. Emite una matriz de cadenas, una por fila.

Javascript ( 289 270 bytes)

function s(a){b=[];for(i=0;i<a;i++)if(b.push([]),0==i||i==a-1)for(j=0;j<a;j++)b[i].push("*");else for(j=0;j<a;j++)0==j||j==a-1?b[i].push("*"):j==i||a-1-j==i?b[i].push("*"):b[i].push(" ");c="";for(i=0;i<b.length;i++){for(j=0;j<b[i].length;j++)c+=b[i][j];c+="\n"}return c}

Sin golf:

function square(size){
str=[];

for(i=0;i<size;i++){
    str.push([]);
    if(i==0||i==size-1){
        for(j=0;j<size;j++){
            str[i].push("*");
        }
    }else{
        for(j=0;j<size;j++){
            if(j==0||j==size-1){
                str[i].push("*");
            }else if(j==i||size-1-j==i){
                str[i].push("*");
            }else{
                str[i].push(" ");
            }
        }
    }
}

out="";
for(i=0;i<str.length;i++){
    for(j=0;j<str[i].length;j++){
        out+=str[i][j];
    }
    out+="\n";
}
return out;
}

EDITAR: Guardado 19 bytes gracias a Philipp Flenker.

Perl, 83 +1 = 84 bytes

Corre con la -nbandera.

$\="*
*";print$c="*"x($_+1);for$b(1..$_){@a=($")x$_;@a[$b-1,-$b]=(a,a);print@a}say$c

La nueva línea literal ahorra 1 byte sobre \no $/.

Legible:

$\="*\n*";
print$c="*"x($_+1);
for$b(1..$_){
    @a=($")x$_;
    @a[$b-1,-$b]=(a,a);
    print@a
}
say$c

El código imprime la línea superior y la guarda $c, luego imprime un montón de espacios con las ranuras apropiadas reemplazadas por as, luego imprime la línea superior nuevamente.

La asignación a la $\variable le dice al intérprete que imprima el contenido (un asterisco, una nueva línea y otro asterisco) después de cada print, pero esto NO ocurre después de a say.

SmileBASIC, 46 bytes

INPUT I
GBOX I,I,1,1GLINE 1,I,I,1GLINE 1,1,I,I

(No, SB NO utiliza gráficos indexados 1 ...)

Carbón de leña, 8 bytes (sin competencia; desafío de fechas posteriores al idioma)

ＧＨ+↘↑↙Ｎ*

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación: cuando se usa como parámetro del PolygonHollowcomando, +dibuja un cuadro y las flechas crean las diagonales. Hay algunos otros caracteres de acceso directo, pero tendrían que redefinirse para que sean útiles, por ejemplo, Yes equivalente a, ↖↗↓pero si fuera equivalente, ↗↓↖entonces Y+sería suficiente.

SHELL ( 135 Bytes ):

 C(){ j=$(($1-1));for i in $(seq 0 $j);do dc<<<2o10i`echo $((1|2**$i|2**($j-$i)|2**$j|(($i==0||$i==$j))*(2**$j-1)))`p;done|tr 01 ' X';}

pruebas:

 C 1
 X

 C 3
 XXX
 XXX
 XXX

 C 5
 XXXXX
 XX XX
 X X X
 XX XX
 XXXXX

 C 7
 XXXXXXX
 XX   XX
 X X X X
 X  X  X
 X X X X
 XX   XX
 XXXXXXX

 C 9
 XXXXXXXXX
 XX     XX
 X X   X X
 X  X X  X
 X   X   X
 X  X X  X
 X X   X X
 XX     XX
 XXXXXXXXX

Kotlin , 123116 bytes

cambiar si con \ n para imprimir

{s:Int->val n=s-1
for(r in 0..n){for(c in 0..n)print(if(n-r==c||r==c||r<1||c<1||r==n||c==n)"#"
else " ")
println()}}

Pruébalo en línea!