Creazione di un quadrato incrociato

Devi prendere l'input di un numero intero di uno o più e produrre un quadrato fatto di qualsiasi carattere stampabile di tua scelta con una croce diagonale attraverso il centro.

L'idea generale è che l'output sia un quadrato vuoto che presenta una croce diagonale .:

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

Nell'esempio sopra, gli "*" rappresentano la casella esterna e gli "#" rappresentano la croce diagonale.

Nota che l'esempio sopra usa due caratteri diversi in modo che sia più facile vedere come appare l'output, il tuo programma dovrebbe usare solo un carattere.

Ingresso

Un numero intero di 1 o più, è garantito che sia dispari.

Produzione

Un quadrato composto da un personaggio a tua scelta con una croce nel mezzo.

• La croce deve essere diagonale
• Il quadrato può essere emesso tramite la funzione o scritto nell'output
• Le nuove righe finali vanno bene
• Se lo desideri, può anche essere visualizzato come grafico, diagramma o immagine

Esempi

Input: 1
Output:
*

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

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

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

Specifiche

• Sono consentite funzioni o programmi completi
• Puoi ottenere input con i tuoi mezzi preferiti
• Le scappatoie standard non sono ammesse
• I programmi devono funzionare senza alcuna istruzione aggiuntiva, ad es using. C#Devono essere inclusi nella voce
• È possibile eseguire l'output da una funzione o stampare il risultato

Questo è il golf del codice, quindi vince la soluzione più breve.

MATL , 20 19 17 byte

2-:XdtP!+~TTYa1YG

Puoi provarlo sperimentalmente in MATL online . Potrebbe non essere necessario aggiornare la pagina se non funziona.

Esecuzione di esempio:

Versione ASCII: 19 byte

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

Provalo online!

VBA Excel, 168 byte

Istruzione:

Trovo che Excel con l'aiuto di VBA sia uno strumento efficace e sufficiente per questa sfida. Imposta il foglio di lavoro di Excel come segue

Sì, usiamo i piccoli pixel classici di forma quadrata come i vecchi tempi usando le celle in un foglio di lavoro come pixel. Ha-ha ...

Qui utilizzo la cella A1 come input e cambio il colore del carattere in rosso. Perché rosso? Perché il rosso è di tre lettere, quindi si adatta al golf. Scrivi ed esegui il seguente codice nella finestra immediata:

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 il codice:

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

Spiegazione dettagliata:

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

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

Passando attraverso la diagonale delle celle dell'intervallo: Cells(i, i).Interior.Color = vbRed

Fase finale e output: Cells(i, N + 1 - i).Interior.Color = vbRed

JavaScript (ES6), 96 byte

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 byte

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

Utilizza l'idea di Jonathan Allan di produrre numeri binari come:

11111
11011
10101
11011
11111

Le righe vengono create con bit aritmetico e visualizzate in binario. Ogni parte è o nel resto. Le parti sono prodotte da potenze di 2 n(fisse) e i(cadenti) via

1. Lato sinistro 1
2. Lato destro n
3. Diagonali ien/i
4. In alto e in basso da n-1quando i==1o i==n.

In realtà, (1) e (4) sono combinati producendo 1quando 1<i<ne in caso n-1contrario.

Python, 114 110 96 90 byte

Totalmente cambiato:

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

Restituisce un elenco di stringhe, caratteri usando 1e 0.
-6 byte grazie a TheBikingViking

Provalo su ideone

Python 2 @ 110 precedente

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)

Provalo su ideone

Java 7, 131 130 128 125 124 122 byte

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 byte salvati grazie a @LeakyNun ;
1 byte salvato grazie a @ OliverGrégoire nella mia risposta per Disegna un quadrato vuoto di # con la sfida della larghezza data ;
2 byte salvati grazie a @cliffroot .

Codice non testato e test:

Provalo qui.

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

Produzione:

*

***
***
***

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

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

Matlab, 68 66 64 58 byte

Poiché è consentito anche l'output grafico:

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

Quali uscite es

Le uniche versioni ascii sarebbero:

Questo sta usando l'indicizzazione 0,1,2,3,...

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

In alternativa con l'indicizzazione 1,3,7,... :

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

C #, 112 101 byte

Grazie a TheLethalCoder per avermi ricordato che queste cose anonime non sono consentite in 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;};

Chi ha detto che C # non è un linguaggio divertente per giocare a golf?

Logo, 155 byte

Soluzione grafica, implementata come funzione

Ho ritoccato la mia risposta per Alphabet Triangle e ho cambiato un po 'gli angoli. Come prima, rdisegna una linea di caratteri. Questa volta, la bfunzione disegna una casella disegnando un bordo dritto e uno diagonale, ruotando e ripetendo quattro volte. Questo fa sì che le diagonali vengano disegnate due volte (una sopra l'altra), ma era meno codice che gestirlo separatamente. Questa risposta gestisce anche correttamente i numeri pari. Ho dovuto aggiungere una gestione speciale per un input di 1per impedirlo di andare avanti.

L'ho implementato come una funzione, bche accetta la dimensione come argomento:

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

Provalo sull'interprete Logo di Calormen.com . Per chiamarlo, aggiungi una linea e chiama bnel seguente formato:

b 7

... oppure prova il piatto del campionatore, che disegna quattro campioni nelle dimensioni 5, 7, 9 e 11, ruotando di 90 gradi tra:

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

R, 102 byte

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

Si noti che è più efficiente esprimere la condizione utilizzando% in% di i == 1 | j == 1 | ...

Haskell, 102 100 96 91 87 byte

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

• Salvato 2 byte, grazie a flawr .
• Hai salvato altri 4 byte usando la comprensione dell'elenco.
• 5 byte salvati combinando flawr il miglioramento di conany
• 4 byte salvati sostituendoli anyconelem

Versione non golfata:

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

Sono sicuro che questo può ancora essere migliorato, ma questo è quello che ho escogitato per ora.

Vecchia versione:

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 byte

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":"*":" ");};

Programma di test

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 byte

19 byte grazie a Quentin.

7 byte salvati passando da un loop nidificato doppio a un 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);}

Suggerimenti di golf benvenuti.

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, ma funziona abbastanza bene.

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

Suggerimenti di golf sicuramente benvenuti, è passato troppo tempo da quando ho PowerShell'd.

SILOS , 212 byte

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

Provalo online!

GNU sed, 117 114 + 1 (flag r) = 115 byte

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

Poiché sed non ha un supporto nativo per i numeri, l'input è dato in unario sulla base di questo consenso . La seconda metà del quadrato è la prima metà che è stata memorizzata in ordine inverso nello spazio di attesa.

Correre:

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

Produzione:

00000
00 00
0 0 0
00 00
00000

Python, 89 byte

Questo è stato un ritorno al passato! Ho usato il modulo tartaruga di 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)

Ecco il risultato quando n = 200:

Scala, 141 137 byte

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)

Correre:

$ scala cross.scala 10

Tecnicamente potrei rimuovere le cose di stampa e andare a qualcosa di simile

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}

Ciò renderebbe 135 o 121 byte a seconda che si contino le cose della sintassi della funzione.

Versione leggibile:

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 byte

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

Provalo online!

Probabilmente golfable.

Python 2, 83 byte

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 un elenco di caratteri della riga per inserire a *nel primo, nell'ultimo, nell'io e nell'ultimo posto. La prima e l'ultima riga iniziano come tutte *, e il resto come tutti gli spazi. Funziona anche per i pari. lambdaUn'espressione è probabilmente più breve di modifica, ma mi piace questo metodo.

Pyke, 28 24 23 byte

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

Provalo qui!

Mathematica, 81 byte

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

Crea un sistema di coordinate con l'origine al centro e calcola dove *dovrebbero andare le s. Emette un array di stringhe, una per riga.

Javascript ( 289 270 byte)

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: salvato 19 byte grazie a Philipp Flenker.

Perl, 83 +1 = 84 byte

Corri con la -nbandiera.

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

La nuova riga letterale salva 1 byte su \no $/.

Leggibile:

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

Il codice stampa la riga superiore e la salva $c, quindi stampa un mucchio di spazi con gli slot appropriati sostituiti con as, quindi stampa di nuovo la riga superiore.

L'assegnazione alla $\variabile dice all'interprete di stampare il contenuto (un asterisco, una nuova riga e un altro asterisco) dopo ogni print, ma questo NON si verifica dopo a say.

SmileBASIC, 46 byte

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

(No, SB NON utilizza grafica 1 indicizzata ...)

Carbone di legna, 8 byte (non competitivo; sfida postdatati in lingua)

ＧＨ+↘↑↙Ｎ*

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione: Se utilizzato come parametro per il PolygonHollowcomando, +disegna una casella e le frecce creano quindi le diagonali. Ci sono alcuni altri personaggi di scelta rapida, ma avrebbero bisogno di essere ridefinito per essere utile ad esempio Yè equivalente ↖↗↓ma se era eqivalent per ↗↓↖poi Y+sarebbe sufficiente.

SHELL ( 135 byte ):

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

test:

 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 byte

cambia se con \ n per 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()}}

Provalo online!