Criando um quadrado cruzado

Você deve inserir um número inteiro de um ou mais e gerar um quadrado com qualquer caractere imprimível de sua escolha com uma cruz diagonal no centro.

A idéia geral é que a saída seja um quadrado oco que tenha uma cruz diagonal:

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

No exemplo acima, os '*' representam a caixa externa e os '#' representam a cruz diagonal.

Observe que o exemplo acima usa dois caracteres diferentes, para que seja mais fácil ver a aparência da saída, seu programa deve usar apenas um caractere.

Entrada

Um número inteiro de 1 ou mais, é garantido que seja ímpar.

Saída

Um quadrado que é composto de um personagem de sua escolha com uma cruz no meio.

• A cruz deve ser diagonal
• O quadrado pode ser emitido através da função ou gravado na saída
• Novas linhas à direita estão bem
• Pode imprimir como gráfico, diagrama ou imagem, se você desejar

Exemplos

Input: 1
Output:
*

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

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

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

Especificações

• Funções ou programas completos são permitidos
• Você pode obter informações através do seu meio preferido
• As brechas padrão não são permitidas
• Os programas devem funcionar sem nenhuma declaração adicional, isto usingé C#, devem estar incluídos na entrada
• Você pode imprimir a partir de uma função ou imprimir o resultado

Este é o código de golfe, portanto a solução mais curta vence.

MATL , 20 19 17 bytes

2-:XdtP!+~TTYa1YG

Você pode experimentá-lo experimentalmente no MATL online . Pode ser necessário atualizar a página se ela não funcionar.

Exemplo de execução:

Versão ASCII: 19 bytes

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

Experimente online!

Excel VBA, 168 bytes

Instrução:

Acho que o Excel, com a ajuda do VBA, é uma ferramenta eficaz e suficiente para esse desafio. Defina a planilha do Excel como a seguir

Sim, usamos os pequenos pixels clássicos em forma de quadrado, como nos velhos tempos, usando as células em uma planilha como os pixels. Ha-ha ...

Aqui eu uso a célula A1 como entrada e altero a cor da fonte para vermelho. Por que vermelho? Como o vermelho é de três letras, é adequado para jogar golfe. Escreva e execute o seguinte código na janela imediata:

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 o 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

Explicação passo a passo:

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

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

Loop na diagonal das células do intervalo: Cells(i, i).Interior.Color = vbRed

Etapa final e saída: 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

Usa a idéia de Jonathan Allan de gerar números binários como:

11111
11011
10101
11011
11111

As linhas são criadas com aritmética de bits e exibidas em binário. Cada parte foi inserida no resto. As peças são produzidas por potências de 2 n(fixas) e i(caindo) via

1. Lado esquerdo 1
2. Lado direito n
3. Diagonais ien/i
4. Superior e inferior n-1quando i==1ou i==n.

Na verdade, (1) e (4) são combinados produzindo 1quando 1<i<ne de n-1outra forma.

Python, 114 110 96 90 bytes

Totalmente alterado:

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

Retorna uma lista de strings, caracteres usando 1e 0.
-6 bytes graças ao TheBikingViking

Teste em ideone

Anterior Python 2 @ 110

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)

Teste em 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 salvos graças ao @LeakyNun ;
1 byte economizado graças a @ OliverGrégoire na minha resposta para o Draw um quadrado vazio de # com um desafio de largura determinado ;
2 bytes salvos graças a @cliffroot .

Ungolfed & código de teste:

Experimente aqui.

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

Saída:

*

***
***
***

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

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

Matlab, 68 66 64 58 bytes

Como a saída gráfica também é permitida:

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

Quais saídas, por exemplo

As versões somente ascii seriam:

Isso está usando a indexação 0,1,2,3,...

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

Como alternativa com a indexação 1,3,7,...:

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

C #, 112 101 bytes

Agradeço ao TheLethalCoder por me lembrar que essas coisas anônimas de instrução ou expressão lambda são permitidas em 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;};

Quem disse que o C # não é uma linguagem divertida para o golfe?

Logotipo, 155 bytes

Solução gráfica, implementada em função

Eu refiz minha resposta para o Triangulo do Alfabeto e mudei um pouco os ângulos. Como antes, rdesenha uma linha de caracteres. Desta vez, a bfunção desenha uma caixa desenhando uma borda reta e uma diagonal, girando e repetindo quatro vezes. Isso faz com que as diagonais sejam desenhadas duas vezes (umas sobre as outras), mas era menos código do que manipulá-las separadamente. Essa resposta também lida corretamente com números pares. Eu tive que adicionar um tratamento especial a uma entrada 1para impedir que ela prosseguisse.

Eu o implementei como uma função, bque assume o tamanho 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

Experimente no intérprete de logotipo da Calormen.com . Para chamá-lo, anexe uma linha e ligue bno seguinte formato:

b 7

... ou experimente o prato de amostrador, que extrai quatro amostras nos tamanhos 5, 7, 9 e 11, girando 90 graus 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")}

Observe que é mais eficiente expressar a condição usando% em% do 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=' '

• Economizou 2 bytes, graças ao flawr .
• Economizou mais 4 bytes usando a compreensão da lista.
• 5 bytes economizados combinando o aprimoramento do flawr comany
• 4 bytes salvos substituindo anyporelem

Versão não destruída:

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 = ' '

Eu tenho certeza que isso ainda pode ser melhorado, mas é isso que eu criei por enquanto.

Versão antiga:

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 teste

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 graças a Quentin.

7 bytes salvos alternando de um loop aninhado duplo para um loop.

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

Sugestões de golfe são bem-vindas.

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

Desajeitado, mas funciona bem o suficiente.

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

Definitivamente, as sugestões de golfe são bem-vindas, já faz muito tempo que eu não uso o 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

Experimente online!

GNU sed, 117 114 + 1 (sinalizador r) = 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

Como o sed não tem suporte nativo para números, a entrada é dada em unário com base nesse consenso . A segunda metade do quadrado é a primeira metade que foi armazenada em ordem inversa no espaço de espera.

Corre:

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

Saída:

00000
00 00
0 0 0
00 00
00000

Python, 89 bytes

Isso foi um retrocesso! Eu usei o módulo tartaruga do 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)

Aqui está o resultado quando 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)

Corre:

$ scala cross.scala 10

Tecnicamente, eu poderia remover o material de impressão e ir para 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}

Isso tornaria 135 ou 121 bytes, dependendo se você conta as coisas da sintaxe da função.

Versão legível:

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
 }

Pitão, 27 25 bytes

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

Experimente online!

Provavelmente jogável.

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 uma lista dos caracteres da linha para colocar *o primeiro, o último, o décimo e o penúltimo lugar. A primeira e a última linha iniciam como todas *e as demais como todos os espaços. Também funciona para os pares. Uma lambdaexpressão é provavelmente mais curta que a modificação, mas eu gosto desse método.

Pyke, 28 24 23 bytes

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

Experimente aqui!

Mathematica, 81 bytes

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

Cria um sistema de coordenadas com a origem no centro e calcula onde os *s devem ir. Produz uma matriz de seqüências de caracteres, uma por linha.

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}

Ungolfed:

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

EDIT: economizou 19 bytes graças a Philipp Flenker.

Perl, 83 +1 = 84 bytes

Corra com a -nbandeira.

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

A nova linha literal economiza 1 byte acima \nou$/ .

Legível:

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

O código imprime a linha superior e a salva $c, depois imprime vários espaços com os slots apropriados substituídos pora s, depois imprime a linha superior novamente.

A atribuição à $\variável diz ao intérprete para imprimir o conteúdo (um asterisco, uma nova linha e outro asterisco) depois de cada vez print, mas isso NÃO ocorre depois de a say.

SmileBASIC, 46 bytes

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

(Não, o SB NÃO usa gráficos indexados em 1 ...)

Carvão, 8 bytes (não competitivo; desafio pós-data do idioma)

ＧＨ+↘↑↙Ｎ*

Experimente online! Link é a versão detalhada do código. Explicação: Quando usado como parâmetro para o PolygonHollowcomando, +desenha uma caixa e as setas criam as diagonais. Existem outros caracteres de atalho, mas eles precisariam ser redefinidos para serem úteis, por exemplo, Yé equivalente a, ↖↗↓mas se fosse equivalente a ↗↓↖isso, Y+seria 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';}

testes:

 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 , 123 116 bytes

mude se com \ n para println

{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()}}

Experimente online!