Imprimir N ao quadrado

57

Escreva um programa ou função que obtenha um número inteiro não negativo N de stdin ou como argumento de função. Ele deve imprimir ou retornar uma sequência de um quadrado oco de arte ASCII, cujos lados são feitos cada um com N cópias do número N.

Especificamente:

Se N for 0, nenhuma cópia de N será usada; portanto, não deverá haver saída (ou apenas uma única nova linha à direita).

Se N for 1, a saída é:

1

Se N é 2:

22
22

Se N é 3:

333
3 3
333

Se N é 4:

4444
4  4
4  4
4444

Se N é 5:

55555
5   5
5   5
5   5
55555

O padrão continua 6até o fim 9.

Se N for 10, a saída é:

10101010101010101010
10                10
10                10
10                10
10                10
10                10
10                10
10                10
10                10
10101010101010101010

Observe que isso não é realmente quadrado. Tem 10 linhas de altura, mas 20 colunas de largura porque 10tem dois caracteres. Isto é pretendido. O ponto é que cada lado do "quadrado" contém N cópias de N. Portanto, todas as entradas além 9serão tecnicamente retângulos ASCII.

Por exemplo, se N for 23, a saída é:

2323232323232323232323232323232323232323232323
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
2323232323232323232323232323232323232323232323

Aqui estão Pastebins das saídas necessárias para 99, 100, 111e 123(eles podem olhar errado em um navegador, mas em um editor de texto que vai olhar correto). A saída para 1000é grande para Pastebin, mas ela teria 1000 linhas e 4000 colunas. Números com 4 ou mais dígitos devem funcionar como números menores.

Detalhes:

  • N deve ser escrito na representação usual do número decimal, sem nenhum +sinal ou outro dígito.
  • A área oca deve ser preenchida apenas com espaços.
  • Nenhuma linha deve ter espaços à esquerda ou à direita.
  • Uma única nova linha após a última linha dos quadrados é opcionalmente permitida.
  • Os idiomas escritos depois que esse desafio foi feito são bem-vindos, eles simplesmente não são elegíveis para ganhar .
  • O código mais curto em bytes vence!
Passatempos de Calvin
fonte
18
O quadrado para n = 10 parece mais quadrado que para n = 5. Hooray, fontes não quadradas!
Nneonneo
Podemos pegar o número inteiro como uma string?
Adám 02/03/16
11
@ Nᴮᶻ Sim, você pode
Calvin's Hobbies #

Respostas:

6

Jolf, 31 27 25 23 bytes

?=1i1ρρ,aii+*3έέi*li

Isso é codificado na codificação ISO-8859-7 e contém não imprimíveis, então aqui está um hexdump:

0000000: 3f3d 3169 31f1 f12c 6169 692b 2a33 dd05  ?=1i1..,aii+*3..
0000010: dd69 052a 056c 69                        .i.*.li

Experimente este violino online ou verifique todos os casos de teste de uma só vez (use o botão de execução completa) .

Isso sai com um erro para n = 0, que é permitido por padrão.

Agradecimentos massivos a Conor por jogar golfe fora 4 6! bytes. inb4 riscado quatro ainda parece um comentário de quatro

Explicação

?=1i1ρρ,aii+*3έ\x05έi\x05*\x05li

?=1i1                             if input is 1 return 1, otherwise...
       ,aii+*3έ\x05               draw an input x input hollow box of tabs
      ρ            έi             replace all tabs with input
     ρ               \x05*\x05li  replace all spaces with spaces * length of input
um spaghetto
fonte
Como você gerou o hexdump?
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Eu usei o xxd. Você pode reverter com xxd -r.
a spaghetto
16

Shtriped , 317 bytes

Enquanto estou fazendo a pergunta, posso mostrar minha nova linguagem "purista".

@ f x
 d x
 f
 @ f x
+ x y
 +
  i x
 @ + y
 h x
} x y
 e 1
 i 1
 d y
 d 1
 d x
 } x y
e 0
e 2
i 2
i 2
e 6
+ 2 2 6
+ 2 6 6
e T
+ 2 2 T
+ 6 T T
e N
t N
e P
+ T 0 P
e L
i L
*
 e x
 *
  + P x x
 @ * T
 h x
~
 } N P 0
 d 0
 i L
 * P
 ~
~
#
 p N
-
 s 6
_
 @ - L
$
 #
 @ _ n
 #
 s 2
@ # N
e n
+ N 0 n
d n
d n
s 2
@ $ n
@ # N

(definitivamente funciona na v1.0.0 )

Não há operações matemáticas embutidas no Shtriped, exceto incremento e decremento. Também não há loop ou condicionais, portanto, tudo isso precisa ser construído do zero em todos os programas.

Isso é o que meu programa faz, por exemplo, @é essencialmente um loop for, +é uma função disso, }é >=. A saída real é produzida apenas nas últimas 8 linhas do programa.

Também não há strings no Shtriped. Você pode receber e imprimir seqüências de caracteres, mas todas elas são representadas internamente como números inteiros de precisão arbitrários que só podem ser incrementados e decrementados. Portanto, não há uma maneira fácil de obter o comprimento da corda 10para preencher o centro do quadrado com a quantidade certa de espaços. Eu tive que juntar a função ~que efetivamente calcula floor(log10(N)) + 1para encontrar o comprimento de N em decimal.

Isto poderia provavelmente ser golfed um pouco mais, reorganizando onde e como que as variáveis são usadas, mas não que muito mais. Não há como contornar as limitações inerentes ao Shtriped. (Nunca foi para ser uma linguagem de golfe de qualquer maneira.)

Código comentado (uma barra invertida é um comentário):

@ f x \ function that calls f() x times, returns 0
 d x
 f
 @ f x
+ x y \ returns x + y
 +
  i x
 @ + y
 h x
} x y \ returns 1 if x >= y, else 0
 e 1
 i 1
 d y
 d 1
 d x
 } x y

\ declare and set up variables for the numbers 0, 2, 6, 10
e 0 \ 0 is used to help copy values via +
e 2 \ 2 is used for printing newlines
i 2
i 2
e 6 \ 6 is used for printing spaces
+ 2 2 6
+ 2 6 6
e T \ 10 is used for finding the string length of N
+ 2 2 T
+ 6 T T

e N \ declare N
t N \ and set it to what the user inputs

\ all the code from here to the last ~ is for finding the length of N as a string

e P \ P is the current power of 10 (10, 100, 1000...), starting with 10
+ T 0 P
e L \ L will be the length of N in decimal digits
i L

* \ function that returns P times 10 by adding P to itself 10 times
 e x
 *
  + P x x
 @ * T
 h x

~ \ function that increments L and multiplies P by 10 until N < P, at which point L will be the string length of N
 } N P 0 \ the 0 variable can be used as a dummy now since we don't need it anymore
 d 0
 i L
 * P \ multiply P by 10 to 
 ~
~

\ helper functions for displaying the output
# \ simply prints N as a decimal integer
 p N
- \ prints a single space
 s 6
_ \ prints L spaces (L = digit length of N)
 @ - L
$ \ prints one of the central N-2 lines of the square
 #
 @ _ n
 #
 s 2

\ finally, call these functions to display the output
@ # N \ print N copies of N (top line of square)
e n \ declare n and set it to N - 2
+ N 0 n
d n
d n \ if N was 0 or 1 the program will end here, having printed nothing if 0 or just the top line if 1
s 2 \ print a newline
@ $ n \ print the central line of the square N-2 times
@ # N \ print N copies of N (bottom line of square)

\ the output always prints without a trailing newline
Passatempos de Calvin
fonte
8

Sério, 32 31 30 29 bytes

╩╜ó$╝╜Dbu╜╛*n╜¬;╛l*' *╛+╛@+n(

Experimente online!

Explicação:

╩╜ó$╝╜Dbu╜╛*n╜¬;╛l*' *╛+╛@+n(
╩                              push each input to its own register
                                 (we'll call register 0 "n")
 ╜                             push n to the stack
  ó                            terminate if 0
   $╝                          push str(n) to register 1
                                 (we'll call register 1 "s")
     ╜Dbu╜╛*n                  make min(2,n) copies of s*n (the top and bottom)
                                 (this avoids an extra copy if n is 1)
             ╜¬;               push n-2 twice
                ╛l*' *         push (n-2)*len(s) spaces
                      ╛+╛@+    put s on the front and end of the string (a middle piece)
                           n   push (n-2) total copies of the middle piece
                            (  bring the top piece to the top
Mego
fonte
5

JavaScript (ES6), 73 82 78 bytes

Salvo bytes a4 graças a @ user81655

n=>(a=n[r='repeat'](n),n<2?a:a+`
${n+' '[r](n.length*(n-2))+n}`[r](n-2)+`
`+a)

Pega uma string, não um número para entrada.

Experimente online (todos os navegadores funcionam)

Downgoat
fonte
Você pode substituir *(n-2)por *~-~-npara salvar um byte.
Neil
@ user81655 graças, que fixa-lo
Downgoat
5
@Neil obrigado, mas que não parece guardar quaisquer bytes infelizmente
Downgoat
Desculpe, eu devo ter errado.
Neil
5

MATL , 34 29 26 bytes

:G\2<t!+gQ"@!2GVYX1GVnZ"YX

Isso funciona com a versão atual (13.0.0) do idioma / compilador

Experimente online!

:            % array [1,2,...,N], where N is input, taken implicitly
G\           % modulo N. Gives [1,2,...,N-1,0]
2<           % smaller than 2? Gives [1,0,...,0,1]
t!           % duplicate, transpose
+            % addition with broadcast. Gives 2D array with nonzeros in the border 
             % and zeros in the interior
gQ           % convert to logical, add 1: twos in the border, ones in the interior
"            % for each column of that array (note the array is a symmetric matrix,
             % so columns and rows are the same)
  @!         %   push column. Transpose into a row        
  2GVYX      %   replace twos by the string representation of N, via regexp
  1GVnZ"YX   %   replace ones by as many spaces as length of that string, via regexp
             % end for each, implicitly
             % display stack contents, implicitly
Luis Mendo
fonte
5

T-SQL / SQL Server 2012 ou superior, 167 161 bytes

DECLARE @ INT = 6;

SELECT IIF(u IN(1,s),REPLICATE(s,s),CONCAT(s,REPLICATE(' ',s-2*LEN(s)),s))
FROM(SELECT @ s)z CROSS APPLY(SELECT TOP(s)ROW_NUMBER()OVER(ORDER BY 1/0)u FROM sys.messages)v

Resultado:

666666 
6    6 
6    6  
6    6  
6    6 
666666 

LiveDemo

Digite o tamanho desejado e clique Run querypara obter a representação do texto.

Observe que esta demonstração não exibe fonte de largura fixa . Então 7é mais grosso que 1.


EDITAR:

Se tratarmos a entrada como uma string:

DECLARE @ VARCHAR(10) = '7';

SELECT IIF(u IN(1,s),REPLICATE(s,s),s+REPLICATE(' ',s-2*LEN(s))+s)
FROM(SELECT @ s)z CROSS APPLY(SELECT TOP(s+0)ROW_NUMBER()OVER(ORDER BY 1/0)u FROM sys.messages)v

LiveDemo2

lad2025
fonte
Isso é muito bom, eu aprendi como diminuir um pouco meus outros scripts. Não sabia a ordem por 1/0 e sys.messages
t-clausen.dk
Observação: a declaração do parâmetro de entrada deve ser realmente incluída na contagem dos bytes?
t-clausen.dk
@ t-clausen.dk Não tenho certeza sobre regras de contagem, quando o SQL é aplicado, mas perguntarei sobre a meta e informaremos.
lad2025
11
Você pode salvar alguns bytes criando s varchar (como esse '6') e substituindo concat por +.
t-clausen.dk
11
Parece que estão faltando alguns espaços. Eu acredito que você pode corrigi-lo por escrito (s-2)
t-clausen.dk
4

Julia, 78 bytes

n->(s="$n";(p=println)(s^n);[p(s*" "^(n-2)endof(s)*s)for i=2:n-1];n>1&&p(s^n))

Essa é uma função anônima que aceita um número inteiro e imprime o retângulo ASCII em STDOUT. Para chamá-lo, atribua-o a uma variável.

Ungolfed:

function f(n)
    # Save a string version of n
    s = "$n"

    # Print the top line
    println(s^n)

    # Print each middle line
    [println(s * " "^(n-2)endof(s) * s) for i = 2:n-1]

    # Print the last line if there is one
    n > 1 && println(s^n)
end

Experimente online

Alex A.
fonte
4

Ruby, 100 bytes

->n{s="";n.times{|i|s+=(i<1||i>n-2?"#{n}"*n :"#{n}#{' '*[(n-2)*n.to_s.size,0].max}#{n}")+$/};puts s}

Pena que eu não conseguia nem vencer JS. Qualquer ajuda adicional a ser apreciada seria apreciada.

Aqui está uma versão mais ou menos ungolfed:

def f(n)
    n.times{|num|
        if num == 0 || num == n-1
            s += "#{n}" * n
        else
            s += "#{n}"+" "*[(n-2)*n.to_s.length,0].max+"#{n}"
        end
        s += "\n"
    }
    puts s
end
Aearnus
fonte
11
Você pode atribuir uma variável, n.to_sjá que a usa muito, fornecendo m*na primeira e m+" "*[(n-2)*m.length,0].max+ma segunda parte.
Valor Ink
Baseei uma versão de 75 bytes nesta resposta. (O Javascript está atualmente em 78 bytes) Experimente online!
precisa saber é
4

Retina, 76 bytes

.+
$0$*n$0
n(?=n*(\d+))|.
$1_
\d+_
$_¶
T`d` `(?<=¶.*_.*).(?=.*_\d.*¶\d)
\`_
[empty line]

A explicação talvez venha amanhã.

Experimente online aqui.

randomra
fonte
7
Faz um tempo desde amanhã.
CalculatorFeline
Faz mais de um ano desde amanhã.
Freira vazando
4

C ++ 14, 156 caracteres

Eu pensei que era uma solução muito legal, mas obviamente não pode bater a maioria das outras entradas aqui.

#define f for(i=0;i++<n;c<<t);
[](string t){auto&c=cout;int n=stoi(t),i;f c<<'\n';for(i=0;++i<n-1;c<<t,c.width(~-n*size(t)+1),c.fill(0),c<<t+'\n');if(n-1)f}

Ungolfed:

#define f for ( i = 0; i++ < n; c << t ); // print top/bot row
[](string t) {
  auto& c = cout;
  int n = stoi(t), i;
  f // print first row
  c << '\n'; // kind of annoying but no way to get rid of (yes I tried
             // c << '\n'+t instead of c << t+'\n')
  for ( i = 0; ++i < n - 1; ) {
    c << t; // output the number
    // then we we get the width of necessary spaces
    c.width(~-n*size(t)+1); // Equivalent to (n-1)*size(t) + 1, but we save
                            // two bytes since ~- takes precedence over
                            // multiplication
    c.fill(0); // fill with spaces, ' ' == 0
    c << t+'\n';
   }
   if ( n-1 ) f // This if statement is dissapointing 
}

E, como sempre, para chamar a função use [](string t) { ... }("10");

STDQ
fonte
4

TSQL, 112 104 bytes

DECLARE @ varchar(10)='12'

PRINT REPLICATE(@,@)+ISNULL('
'+REPLICATE(@+ISNULL(SPACE((@-2)*len(@))+@,'')+'
',@-2)+REPLICATE(@,@),'')
1. generating first line
2. adding hollow lines + line breaks
3. adding last line(when needed)
t-clausen.dk
fonte
Você poderia adicionar uma explicação para quem não conhece o T-SQL?
gato
@cat escreveu uma breve explicação, e incluiu um violino
t-clausen.dk
Interessante, obrigado! Parece que sua contagem de bytes pode estar desativada: verifique aqui
cat
@cat obrigado. Eu estava procurando um link para isso. No entanto, a última linha com o FROM está apenas declarando e atribuindo valor a X, ouvi dizer que atribuir valores e declarar variáveis ​​não conta. Por favor corrija-me se eu estiver errado. Tentei salvar alguns bytes com essa atribuição de variáveis. Variáveis normais são prefixados com @ , custando 1 byte extra para cada vez que usá-lo
t-clausen.dk
11
@mazzy sim ele faz - 3. acrescentando última linha (quando necessário)
t-clausen.dk
3

Minkolang 0.15 , 57 bytes

nd?.d1-2&N.$z01FlOz2-[lz6Z" "I2-z2-*Dz6Z$O]01F.
z[z6Z]$Of

Experimente aqui!

Explicação

n                Read number from input
 d?.             Stop if n=0, continue otherwise
    d1-2&N.      Print 1 and stop if n=1, continue otherwise
           $z    Store top of stack in register (z, which is n)

01F                                   Gosub to second line
   lO                                 Print newline
     z2-                              Push value from register and subtract 2
        [                             Pop k and run body of for loop k times
                                      (Does not run if k <= 0)
         l                            Push a newline
          z6Z                         Push z and convert to string
             " "                      Push a space
                I2-                   Push length of stack minus 2
                   z2-                Push z minus 2
                      *               Pop b,a and push a,b
                       D              Pop k and duplicate top of stack k times
                        z6Z           Push z and convert to string
                           $O         Output whole stack as characters
                             ]        Close for loop
                              01F.    Gosub to second line and stop after returning.


z[   ]       For loop that runs z times
  z6Z        Push z and convert to string
      $O     Output whole stack as characters
        f    Return to position called from
El'endia Starman
fonte
3

Perl, 79 76 74 bytes

$_=$.=pop;s/./ /g;print$.x$.,$/,($.,$_ x($.-2),$.,$/)x($.-2),$.>1?$.x$.:''

Bem direto. O primeiro argumento da linha de comando é considerado o número. Coloque o script em um arquivo e execute com perl file.pl 1.

Kenney
fonte
shiftpode ser substituído por pop.
Oleg V. Volkov
3

Perl, 62 60 58 + 2 = 60 bytes

for$.(1..$_){say$.>1&$.<$_?$_.$"x(y...c*($_-2)).$_:$_ x$_}

Requer -nlEsinalizadores:

$ perl -nlE'for$.(1..$_){say$.>1&$.<$_?$_.$"x(y...c*($_-2)).$_:$_ x$_}' <<< 5
55555
5   5
5   5
5   5
55555

Com espaços adicionados:

for$.(1..$_) {
  say(
    $. > 1 & $. < $_
      ? $_ . $"x(length$_*($_-2)) . $_
      : $_ x $_
  )
}
andlrc
fonte
3

R, 90 bytes

x=scan();m=matrix(x,x,x);k=2:(x-1)*(x>2);m[k,k]=format("",w=nchar(x));write(m,"",n=x,s="")

Isso cria uma matriz de x*xtamanho e, em seguida, preenche espaços de tamanho nchar(x). Se xmenor que 2, nada está sendo preenchido.

David Arenburg
fonte
Eu sei que isso é um ano depois, mas ... x=scan();m=matrix(x,x,x);m[k<--c(1,x),k]=format("",w=nchar(x));write(m,"",x,,"")é 10 bytes a menos usando a indexação negativa e substituindo n=x,s=''por x,,'' tio.run/nexus/r#DYpBCsAgDAT/…
Giuseppe
@ Giuseppe E agora, algo completamente ilegível ... salve mais um byte.
JayCe 23/05
write("[<-"(matrix(x<-scan(),x,x),k<--c(1,x),k,gsub("."," ",x)),1,x,,"")por 72 bytes.
J.Doe
3

Pitão - 26 bytes


K*QQjbm++Q**lQ;ttQQttQK

Experimente online aqui .

Maltysen
fonte
@FryAmTheEggman o botão permalink parece estar quebrado
Maltysen
3

Pip -l , 21 bytes

Usa recursos de idioma mais recentes que a pergunta, permitida pela política atual; se o texto da pergunta for interpretado para substituir a política, consulte a resposta de 25 bytes abaixo.

Yq{MN++g%y>1?sMyy}MCy

Experimente online!

Obrigado à resposta de Luis Mendo no MATL pelo (a+1)%n<2truque.

Explicação

Yqlê uma linha de stdin e a puxa y. Então:

{              }MCy  Map this function to each coordinate pair in a y-by-y grid
                     (Inside the function, the list of both coords is g)
   ++g                Increment both coordinates
      %y              Take them mod y
 MN     >1?           Test whether the min of the resulting list is 2 or greater
           sMy         If so, it's in the center; use len(y) spaces
              y        If not, it's an edge; use the number y
                     Print result with newlines between rows (implicit, -l flag)

Resposta original de 2016, 25 bytes ( -lsinalizador positivo ):

Yq{MN++*a%y<2?ysX#y}MMCGy

Changelog:

  • MCfoi adicionado mais recentemente; na época, eu usei MMCG(mapa-mapa + grade de coordenadas).
  • Havia um erro no intérprete atual que impedia o uso ++em listas, então eu tive que fazer ++*(aplicar ++a cada elemento).
  • Map foi estendido: agora <string1> M <string2>retorna uma lista de len(<string2>)cópias de <string1>; Na época, eu usei o sX#yespaço de repetição de caracteres por len(y).
DLosc
fonte
2

Pitão, 37 30 bytes

J*K`QQI>Q1JV-Q2++Q*d-lJ*2lKQ;J

Experimente aqui.

J*K`QQ                          set K to repr(input); that is, stringified
                                  set J to K repeated (input) times
      I>Q1                  ;   if input is greater than 1...
          J                     output J (stringified input times input)
           V-Q2                 do this (input - 2) times...
               ++               output the following on one line:
                 Q              the input number
                  *d-lJ*2lK     n spaces, where n = len(J) - 2*len(K)
                           Q    the input number again
                            ;   break out of everything
                             J  output J (str(input)*input) one last time,
                                  regardless of whether input > 1
Maçaneta da porta
fonte
2

Retina , 90

Mais uma vez, tenho certeza de que isso será bastante praticável pelos especialistas:

.+
$&$&$*:$&$*;
+`(\d+:):
$1$1
+`([\d+:]+;);
$1$1
T`d` `(?<=;\d+:)[^;]+(?=:\d+:;\d)
:

;
¶

Experimente online.

Trauma Digital
fonte
11
Também postei uma resposta Retina , mas não é muito menor. (Você pode usar em vez de ;se livrar da última etapa?)
randomra
@randomra Bem, 80 <90, então nenhum argumento de minha parte :) :)
Digital Trauma
E se você usar o pilcrow [^¶]+é prático .+.
randomra
2

Gelatina, 28 bytes

Grr, não posso dizer se Jelly é ruim em cordas, ou se eu sou ruim em Jelly.

ŒṘ©L⁶xWẋWẋ$®W¤1¦€U'Z$$4¡j⁷ȯ⁷

Experimente online.

Lynn
fonte
Eu tenho tentado adaptar isso para uma resposta, mas sem muita sorte: /
Sp3000 20/16 '13:
2

Pyke , 33 bytes (não competitivo)

QD`i*Djli2*lR-k*iRi]3J"bR+2Q-*jR+

Explicação:

                                  - autoassign Q = eval_or_not(input())
QD`i*                             - Get the input multiplied by itself
Q                                 - [Q]
 D                                - [Q, Q]
  `                               - [repr(Q), Q]
   i                              - i = stack[0]
    *                             - [stack[0]*stack[1]]

     Djli2*lR-                    - Get number of spaces
     D                            - [^,^]
      j                           - j = stack[0]
       l                          - len(stack[0])
        i2*                       - i*2
           l                      - len(stack[0])
            R                     - rotate_2()
             -                    - stack[0]-stack[1]

              k*iRi               - Get middle line
              k*                  - " "*^
                iRi               - [i,^,i]

                   ]3J"bR+        - Join middle line together
                   ]3             - list(stack[:3])
                     J"           - "".join(stack[0])
                       bR+        - ^+"\n"

                          2Q-     - Get middle lines
                          2Q-*    - Q-2

                              jR+ - Add end line
                              jR+ - ^+j
Azul
fonte
2

CJam, 27 bytes

ri:X,_ff{a+[0X(]&XXs,S*?}N*

Obrigado a @ MartinBüttner por sugerir ff. O a+[0X(]&é bastante suspeito, mas tudo bem.

Experimente online!

ri:X              Read input integer and save as variable X
,_                Range, i.e. [0 1 ... X-1] and make a copy
ff{...}           Map with extra parameter, twice. This is like doing a Cartesian product
                  between two 1D arrays, but we get a nice X by X array at the end

                  For each coordinate pair,
a+                Put the two coordinates into an array
[0X(]&            Set intersection with the array [0 X-1]
X                 Push X
Xs,S*             Push a number of spaces equal to the length of X
?                 Ternary: choose one of the previous two depending on the set intersection

N*                Join X by X array with newlines
Sp3000
fonte
2

Python 2, 70 caracteres

def p(i):
 k=`i`;j=i-2;h=k*i;print h+'\n'+(k+' '*j*len(k)+k+'\n')*j+h
SumnerHayes
fonte
3
Não funciona para i = 1.
precisa saber é o seguinte
2

Haskell, 78 bytes

i x=unlines$take x$1#s:3#[s++(3#s>>" ")++s]++[1#s]where s=show x;z#s=[z..x]>>s

Exemplo de uso:

*Main> putStr $ i 4
4444
4  4
4  4
4444

A função >>é útil: <list> >> <string>faz length <list>cópias de <string>, por exemplo, as linhas superior e inferior de x=10are [1..10] >> "10"-> "10101010101010101010".

nimi
fonte
71 bytes
Max Yekhlakov 05/10
11
@MaxYekhlakov: Obrigado, mas infelizmente sua versão não funciona, para a 1qual um grito produz um único 1. Além disso, você retorna uma lista de cadeias, enquanto o desafio solicita uma única cadeia. Tínhamos regras de E / S muito mais rígidas na época, regras de E / S flexíveis são uma coisa mais recente.
nimi
2

Perl, 72 bytes

$_=($.=pop)-2;say for($.x$.,($..($.x$_)=~s/./ /rg.$.)x$_,$.x$.)[0..$.-1]

Depende dos recursos modernos do Perl:

diga 'alguma coisa'

está disponível automaticamente desde o Perl 5.10 (basta usar a v5.10 ou posterior).

str_expr = ~ s /.../.../ r

aceita muito bem para trabalhar em um rvalue (um str_expr não necessariamente reduzida para uma variável escalar) para se obter um r esultado (o ' r opção' no final da regex) sem alterar o str_expr inicial.

Franck Porcher
fonte
2

PHP, 151 bytes

function s($n){for($r=0;$r<$n;$r++){for($c=0;$c<$n;$c++){if($r*$c&&$r!=$n-1&&$c!=$n-1){for($d=0;$d<=log10($n);$d++){echo' ';}}else{echo$n;}}echo"\n";}}

Bagunça absoluta, precisa de mais tempo para otimizar. s(Number)fornece a saída.

ricdesi
fonte
2

Java 8, 280 bytes

interface A{static<T>void p(T o){System.out.print(o);}static void main(String[]a){long n=new Long(a[0]),l=a[0].length();for(long i=0;i<n;i++,p(a[0]));p("\n"+(n>1?a[0]:""));for(long j=2;j<n;j++,p(a[0])){for(long i=l*2;i<n*l;i++,p(' '));p(a[0]+"\n");}for(long i=1;i<n;i++)p(a[0]);}}

É apenas cerca de 10 vezes contanto que as respostas mais curtas, o que é realmente bom para Java!

Exemplo de execução:

$ java A 10
10101010101010101010
10                10
10                10
10                10
10                10
10                10
10                10
10                10
10                10
10101010101010101010
Mego
fonte
2

Python 3, 108 96 148 bytes

a=input()
b=c=int(a)-2 if a!="1" else 0
print(a*int(a))
while b:print(a+" "*int(len(a))*c+a);b-=1
if a!="1":print(a*int(a))

Ungolfed / explicou:

number = input() # Gets a number as input
iterator = var = int(number) - 2 if number != "1" else 0 # Assigns two variables, one of them an iterator, to the number minus 2 (the amount of middle rows in the square) if the number isn't 1. If it is, it sets the vars to 0 so the while doesn't trigger.
print(number * int(number)) # Prints the top row of the square.
while iterator != 0: # Loops for the middle rows
    print(number + " " * int(len(number)) * var + number) # Prints the number, then as many spaces as needed, and the number.
    iterator -= 1 # De-increments the iterator.
if number != 1: # Makes sure the number isn't 1, because 1 should return 1.
    print(a * int(a)) # Same as the first row, it prints the bottom row.

Como esta é minha primeira resposta ao , algumas críticas e / ou sugestões construtivas seriam úteis!

OldBunny2800
fonte
11
Use espaços únicos para que o recorte reduza alguns bytes. Na verdade, todo o seu ciclo pode ser embutido: while b!=0:print(a+" "*int(len(a))*c+1);b-=1. Além disso, while b:é equivalente a while b!=0, então são mais 3 bytes.
Mego
Correção de bug: a entrada 1 agora imprime 1, não o infiniteloop (meu navegador realmente me deixou triste). Isso agora leva mais toneladas de bytes.
precisa saber é o seguinte
2

Ferrugem, 141 137 bytes

Abusou de algumas coisas de formatação, caso contrário, isso levaria muito mais tempo.

|i|{let f=||{for _ in 0..i{print!("{}",i)}println!("")};f();if i>1{for _ in 0..i-2{println!("{}{0:1$}",i,i.to_string().len()*(i-1))}f()}}

Desembalado:

|i| {
    let f = || {
        for _ in 0..i {
            print!("{}",i)
        }
        println!("")
    };

    f();

    if i>1 {
        for _ in 0..i-2 {
            println!("{}{0:1$}",i,i.to_string().len()*(i-1))
        }
        f()
    }
}

Link para parque infantil

Aceeri
fonte
Isso não funciona quando eu tento aqui . Como posso testar isso?
Rɪᴋᴇʀ
Aqui está um link de playground para que você possa testá-lo . Eu usei um fechamento para atribuir isso a uma variável primeiro e depois chamá-lo.
Aceeri
Oh legal. Realmente não sei ferrugem, mas ótima resposta!
Rɪᴋᴇʀ
2

Powershell, 98 96 95 83 82 75 bytes

param($n)($l="$n"*$n)
if(($m=$n-2)-ge0){,"$n$(' '*"$n".Length*$m)$n"*$m
$l}

Script de teste simples e explicado:

$f = {

    param($n)
    ($l="$n"*$n)                #   let $l is a string contains N only and return this value as a first line
    $m=$n-2
    if($m-ge0){                 # if(N>1)
        $s=' '*"$n".Length*$m   #   let $s is spaces inside repeated (length of string represented of n * m)
        ,"$n$s$n"*$m            #   return $m strings contains: N, spaces and N
        $l                      #   retrun the first line again
    }

}

&$f 1
&$f 2
&$f 3
&$f 4
&$f 10

Resultado:

1
22
22
333
3 3
333
4444
4  4
4  4
4444
10101010101010101010
10                10
10                10
10                10
10                10
10                10
10                10
10                10
10                10
10101010101010101010
confuso
fonte