Print N Squared

57

Escriba un programa o función que tome un entero N no negativo de stdin o como un argumento de función. Debe imprimir o devolver una cadena de un cuadrado hueco de arte ASCII cuyos lados están hechos con N copias del número N.

Específicamente:

Si N es 0, no se utilizan copias de N, por lo que no debería haber salida (o solo una nueva línea final).

Si N es 1, la salida es:

1

Si N es 2:

22
22

Si N es 3:

333
3 3
333

Si N es 4:

4444
4  4
4  4
4444

Si N es 5:

55555
5   5
5   5
5   5
55555

El patrón continúa hasta el 6final 9.

Si N es 10, la salida es:

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

Tenga en cuenta que esto no es realmente cuadrado. Tiene 10 filas de alto pero 20 columnas de ancho porque 10tiene dos caracteres de largo. Esto está destinado. El punto es que cada lado del "cuadrado" contiene N copias de N. Por lo tanto, todas las entradas más allá 9serán técnicamente rectángulos ASCII.

Por ejemplo, si N es 23, la salida es:

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

Aquí están Pastebins de los productos necesarios para 99, 100, 111, y 123(que puede parecer mal en un navegador, pero en un editor de texto que va a mirar correcta). El resultado para 1000es demasiado grande para Pastebin pero tendría 1000 filas y 4000 columnas. Los números con 4 o más dígitos deben funcionar igual que los números más pequeños.

Detalles:

  • N debe escribirse en la representación habitual de números decimales, sin +signo u otros no dígitos.
  • El área hueca solo debe llenarse con espacios.
  • Ninguna línea debe tener espacios iniciales o finales.
  • Opcionalmente, se permite una nueva línea después de la última línea de los cuadrados.
  • Los idiomas escritos después de que se realizó este desafío son bienvenidos, simplemente no son elegibles para ganar .
  • ¡El código más corto en bytes gana!
Pasatiempos de Calvin
fuente
18
El cuadrado para n = 10 parece más cuadrado que para n = 5. ¡Hurra, fuentes no cuadradas!
nneonneo
¿Podemos tomar el entero como una cadena?
Adám
1
@ Nᴮᶻ Sí, puedes
Calvin's Hobbies

Respuestas:

6

Jolf, 31 27 25 23 bytes

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

Esto está codificado en la codificación ISO-8859-7 y contiene elementos no imprimibles, así que aquí hay un hexdump:

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

Pruebe este violín en línea o verifique todos los casos de prueba a la vez (use el botón de ejecución completa) .

Esto sale con un error para n = 0, que está permitido por defecto.

¡Muchas gracias a Conor por jugar al golf 4 6! bytes inb4 tachado cuatro todavía parece un comentario cuatro

Explicación

?=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
un espagueti
fuente
¿Cómo generaste el hexdump?
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Usé xxd. Puedes revertirlo con xxd -r.
un spaghetto
16

Shtriped , 317 bytes

Mientras hago la pregunta, puedo mostrar mi nuevo lenguaje "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 en v1.0.0 )

No hay operaciones matemáticas integradas en Shtriped, excepto incrementos y decrementos. Tampoco hay bucles o condicionales, por lo que todas estas cosas deben construirse desde cero en cada programa.

Eso es lo que hace mi programa, por ejemplo, @es esencialmente un bucle for, +es una función de suma, }es >=. La salida real solo se produce en las últimas 8 líneas del programa.

Tampoco hay cadenas en Shtriped. Puede incorporar e imprimir cadenas, pero todas están representadas internamente como enteros de precisión arbitrarios que solo pueden incrementarse y decrementarse. Por lo tanto, no hay una manera fácil de obtener la longitud de la cadena 10para completar el centro cuadrado con la cantidad correcta de espacios. Tuve que improvisar la función ~que efectivamente calcula floor(log10(N)) + 1para encontrar la longitud de N en decimal.

Esto probablemente podría ser un poco más golfed reordenando dónde y cómo el que se utilizan las variables, pero no que mucho más. No hay forma de evitar las limitaciones inherentes de Shtriped. (De todos modos, nunca fue un lenguaje de golf).

Código comentado (una barra invertida es un comentario):

@ 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
Pasatiempos de Calvin
fuente
8

En serio, 32 31 30 29 bytes

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

Pruébalo en línea!

Explicación:

╩╜ó$╝╜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
fuente
5

JavaScript (ES6), 73 82 78 bytes

Guardado a4 bytes gracias a @ user81655

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

Toma una cadena, no un número para la entrada.

Pruébelo en línea (todos los navegadores funcionan)

Downgoat
fuente
Puede reemplazar *(n-2)con *~-~-npara guardar un byte.
Neil
@ user81655 gracias, eso lo solucionó
Downgoat
55
@Neil gracias, pero eso no parece guardar ningún byte desafortunadamente
Downgoat
Lo siento, debo haber contado mal.
Neil
5

MATL , 34 29 26 bytes

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

Esto funciona con la versión actual (13.0.0) del lenguaje / compilador

Pruébalo en línea!

:            % 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
fuente
5

T-SQL / SQL Server 2012+, 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

Salida:

666666 
6    6 
6    6  
6    6  
6    6 
666666 

LiveDemo

Ingrese el tamaño deseado y haga clic Run querypara obtener representación de texto.

Tenga en cuenta que esta demostración no muestra la fuente de ancho fijo . Entonces 7es más grueso que 1.


EDITAR:

Si tratamos la entrada como una cadena:

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
fuente
Esto es muy bueno, aprendí a acortar un poco algunos de mis otros scripts. No sabía el orden por 1/0 y sys.messages
t-clausen.dk
en una nota al margen. ¿Debería incluirse realmente la declaración del parámetro de entrada al contar los bytes?
t-clausen.dk
@ t-clausen.dk No estoy seguro acerca de contar las reglas, cuando se aplica SQL, pero preguntaré sobre meta y se lo haré saber.
lad2025
1
Puede guardar algunos bytes haciendo s varchar (como este '6'), luego puede reemplazar concat con +.
t-clausen.dk
1
Parece que te faltan algunos espacios. Creo que puede solucionarlo escribiendo (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))

Esta es una función anónima que acepta un número entero e imprime el rectángulo ASCII en STDOUT. Para llamarlo, asígnelo a una variable.

Sin golf:

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

Pruébalo en línea

Alex A.
fuente
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}

Lástima que ni siquiera pude vencer a JS. Se agradecería cualquier ayuda adicional al golf.

Aquí hay una versión más o menos no golfista:

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
fuente
1
Es posible que desee asignar una variable n.to_sya que la usa mucho, lo que le da m*npara la primera parte y m+" "*[(n-2)*m.length,0].max+mpara la segunda parte.
Value Ink el
Basé una versión de 75 bytes en esta respuesta. (Javascript está actualmente en 78 bytes) ¡ Pruébelo en línea!
benj2240
4

Retina, 76 bytes

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

La explicación tal vez llegue mañana.

Pruébelo en línea aquí.

randomra
fuente
77
Ha pasado un tiempo desde mañana.
CalculatorFeline
Ha pasado más de un año entero desde mañana.
Leaky Nun
4

C ++ 14, 156 caracteres

Pensé que era una solución bastante buena, aunque obviamente no puede superar la mayoría de las otras entradas aquí.

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

Sin golf:

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

Y como siempre, para llamar a la función use [](string t) { ... }("10");

STDQ
fuente
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
fuente
¿Podría agregar una explicación para aquellos de nosotros que no conocemos T-SQL?
gato
@cat escribió una breve explicación e incluyó un violín
t-clausen.dk
Interesante, gracias! Parece que su recuento de bytes podría estar apagado: marque aquí
gato
@cat gracias. Estaba buscando un enlace para eso. Sin embargo, la última línea con FROM es solo declarar y asignar valor a X, escuché que asignar valores y declarar variables no cuenta. Por favor, corríjame si estoy equivocado. Intenté guardar algunos bytes con esta asignación de variables. Las variables normales tienen el prefijo @ , lo que cuesta 1 byte adicional por cada vez que se usa
t-clausen.dk
1
@mazzy sí, lo hace - 3. agregando la última línea (cuando sea necesario)
t-clausen.dk
3

Minkolang 0.15 , 57 bytes

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

Pruébalo aquí!

Explicación

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
fuente
3

Perl, 79 76 74 bytes

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

Muy claro. El primer argumento de la línea de comandos se toma como el número. Coloque el script en un archivo y ejecútelo perl file.pl 1.

Kenney
fuente
shiftpuede ser reemplazado con pop.
Oleg V. Volkov
3

Perl, 62 60 58 + 2 = 60 bytes

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

Requiere -nlEbanderas:

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

Con espacios añadidos:

for$.(1..$_) {
  say(
    $. > 1 & $. < $_
      ? $_ . $"x(length$_*($_-2)) . $_
      : $_ x $_
  )
}
andlrc
fuente
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="")

Esto crea una matriz de x*xtamaño y luego se llena con espacios de tamaño nchar(x). Si es xmenor que 2, entonces no se está llenando nada.

David Arenburg
fuente
Sé que esto es un año después, pero ... x=scan();m=matrix(x,x,x);m[k<--c(1,x),k]=format("",w=nchar(x));write(m,"",x,,"")es 10 bytes menos usando indexación negativa y reemplazándolo n=x,s=''con x,,'' tio.run/nexus/r#DYpBCsAgDAT/…
Giuseppe
@Giuseppe Y ahora por algo completamente ilegible ... guarda un byte más.
JayCe
write("[<-"(matrix(x<-scan(),x,x),k<--c(1,x),k,gsub("."," ",x)),1,x,,"")por 72 bytes.
J.Doe
3

Pyth - 26 bytes


K*QQjbm++Q**lQ;ttQQttQK

Pruébelo en línea aquí .

Maltysen
fuente
@FryAmTheEggman el botón de enlace permanente parece estar roto
Maltysen
3

Pip -l , 21 bytes

Utiliza características de lenguaje más nuevas que la pregunta, lo cual está permitido según la política actual; Si se interpreta que la redacción de la pregunta anula dicha política, consulte la respuesta de 25 bytes a continuación.

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

Pruébalo en línea!

Gracias a la respuesta MATL de Luis Mendo por el (a+1)%n<2truco.

Explicación

Yqlee una línea de stdin y la introduce y. Entonces:

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

Respuesta original de 2016, 25 bytes (más -lindicador):

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

Registro de cambios:

  • MCfue agregado más recientemente; en ese momento, usé MMCG(mapa-mapa + cuadrícula de coordenadas).
  • Hubo un error en el intérprete actual que impedía usarlo ++en las listas, por lo que tuve que hacer ++*(aplicar ++a cada elemento) en su lugar.
  • Map se ha extendido: ahora <string1> M <string2>devuelve una lista de len(<string2>)copias de <string1>; en ese momento, solía sX#y, repitiendo cadenas por espacio len(y).
DLosc
fuente
2

Pyth, 37 30 bytes

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

Pruébalo aquí

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
Pomo de la puerta
fuente
2

Retina , 90

De nuevo, estoy bastante seguro de que esto será muy fácil de encontrar por los expertos:

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

;
¶

Pruébalo en línea.

Trauma digital
fuente
1
También publiqué una respuesta de Retina , pero no es mucho más pequeña. (¿Se puede usar en lugar de ;deshacerse de la última etapa?)
randomra
@randomra Bueno 80 <90, así que no hay discusión de mi parte :)
Digital Trauma
Y si usas el pilcrow [^¶]+es útil .+.
randomra
2

Jalea, 28 bytes

Grr, no puedo decir si Jelly es mala con las cuerdas, o si yo soy mala con Jelly.

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

Pruébalo en línea.

Lynn
fuente
He estado tratando de adaptar esto para una respuesta, pero sin mucha suerte: /
Sp3000
2

Pyke , 33 bytes (no competitivo)

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

Explicación:

                                  - 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
fuente
2

CJam, 27 bytes

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

Gracias a @ MartinBüttner por sugerir ff. El a+[0X(]&es bastante sospechoso, pero bueno.

Pruébalo en línea!

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
fuente
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
fuente
3
No funciona para i = 1.
BookOwl
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

Ejemplo de uso:

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

La función >>es útil: <list> >> <string>hace length <list>copias de <string>, por ejemplo, líneas superiores e inferiores para x=10are [1..10] >> "10"-> "10101010101010101010".

nimi
fuente
71 bytes
Max Yekhlakov
1
@MaxYekhlakov: Gracias, pero desafortunadamente su versión no funciona para lo 1que grita una sola salida 1. Además, devuelve una lista de cadenas, mientras que el desafío solicita una sola cadena. Tuvimos reglas de IO mucho más estrictas en los días, las reglas de IO flexibles son algo más reciente.
nimi
2

Perl, 72 bytes

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

Se basa en las características modernas de Perl:

di 'algo'

está disponible automáticamente desde Perl 5.10 (simplemente use v5.10 o posterior).

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

felizmente acepta para trabajar en un valor p (un str_expr no necesariamente reducida a una variable escalar) para producir un r esultado (la ' r opción' al final de la expresión regular) sin alterar la str_expr inicial.

Franck Porcher
fuente
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";}}

Desorden absoluto, necesita más tiempo para optimizar. s(Number)te da la salida.

ricdesi
fuente
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]);}}

¡Solo es aproximadamente 10 veces más largo que las respuestas más cortas, lo cual es realmente bueno para Java!

Ejemplo de ejecución:

$ java A 10
10101010101010101010
10                10
10                10
10                10
10                10
10                10
10                10
10                10
10                10
10101010101010101010
Mego
fuente
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 / explicado:

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 es mi primera respuesta de , algunas críticas constructivas y / o sugerencias serían útiles.

OldBunny2800
fuente
1
Use espacios individuales para la sangría para eliminar algunos bytes. De hecho, todo el bucle puede ser inline: while b!=0:print(a+" "*int(len(a))*c+1);b-=1. Además, while b:es equivalente a while b!=0, por lo que faltan 3 bytes más.
Mego
Corrección de errores: la entrada 1 ahora imprime 1, no infiniteloop (mi navegador realmente me dio un poco de pena). Esto ahora toma toneladas más de bytes.
OldBunny2800
2

Óxido, 141 137 bytes

Abusó de algunas cosas de formato, de lo contrario, esto hubiera sido mucho más tiempo.

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

Desempaquetado:

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

Enlace de juegos

Aceeri
fuente
Esto no funciona cuando lo intento aquí . ¿Cómo puedo probar esto?
Rɪᴋᴇʀ
Aquí hay un enlace de patio de recreo para que pueda probarlo , utilicé un cierre para que primero lo asigne a una variable y luego lo llame.
Aceeri
Oh genial Realmente no conozco el óxido, ¡pero una gran respuesta!
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}

Ungolfed y explicó el script de prueba:

$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

Salida:

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
mazzy
fuente