Criar caixas dinamicamente

22

O desafio:

Desenhe um retângulo de caixas ASCII: []

As regras:

Toma uma entrada de largura e altura

Você pode assumir que ambos são números

É necessário produzir uma sequência com caracteres de nova linha, \ n

Exemplos:

2, 2:

[][]
[][]

2, 3:

[][]
[][]
[][]

Menos bytes ganha.

code-golf  string  ascii-art 
— Robinlemon
fonte
2
Bom primeiro post! Bem-vindo ao PPCG!
— MD XF
1
Posso assumir que os números são positivos? Pode haver novas linhas à direita?
— Dzaima 2/06
inteiros @dzaima positivos, nenhuma fuga ou levando coisas
— Robinlemon
podemos imprimir no console ou precisamos retornar a string?
— Giuseppe
5
e se literalmente não pudermos imprimir novas linhas à direita? ele tende a ser uma boa prática para permitir que uma nova linha de arrasto
— destrutível limão

Respostas:

6

SOGL , 5 bytes

Ƨ[]*∙

Simples:

Ƨ[]    push "[]"
   *   multiply horizontally (repeating width times)
    ∙  get an array with input (height) items of that
       implicitly output the array joined with newlines
— dzaima
fonte
4

Mathematica, 26 bytes

Grid@Table["[]",{#2},{#}]&
— J42161217
fonte
Um Gridobjeto do Mathematica conta como "uma sequência com caracteres de nova linha"?
— David Zhang
4

MATL , 7 bytes

v&DiiX"

Experimente online!

Explicação

v    % Concatenate the (non-existing) stack contents: gives []
&D   % String representation: gives '[]'
ii   % Take two inputs
X"   % Repeat those numbers of times vertically and horizontally. Implicit display
— Luis Mendo
fonte
4

Pitão - 7 5 bytes

-2 bytes por um truque inteligente, graças a insert_name_here

VE*`Y

Experimente aqui

Explicação:

VE*`Y
V      # Loop
 E     # <input> number of times
   `Y  # String representation of empty list (used to be "[]", but insert_name_here pointed out this shorter alternative)
  *    # repeat string implicit input number of times
       # implicit print
— Maria
fonte
3
Você pode salvar 2 bytes usando `Y(representação de seqüência de caracteres da lista vazia) em vez de "[]".
— insert_name_here
@insert_name_here Ingenious !! Eu atualizei a resposta. Obrigado por apontar isso!
— Maria
1
Veio com esse código exato de forma independente. Bem feito.
— Isaacg
4

C, 47 46 bytes

f(w,h){for(h*=w;h--;)printf(h%w?"[]":"[]\n");}

ou

f(w,h){for(h*=w;h--;)printf("[]%c",h%w?0:10);}

Minha primeira tentativa de golfe com código, perdi algo óbvio?

— dbandstra
fonte
Existe isso para 45, mas tem uma nova linha no início:f(w,h){h*=w;while(h--)printf("\n[]"+!(h%w));}
— Conor O'Brien
Isso só funciona quando a largura é 2.
— dbandstra
Assim é, meu erro #
— Conor O'Brien
Ótimo primeiro golfe! Bem vindo ao site!
— MD XF
1
Usar um forloop não reduziria ainda mais o código?
— Spikatrix 4/17/17
3

05AB1E , 6 bytes

F„[]×,

Experimente online!

Explicação

A entrada assume como height, width

F         # height times do
 „[]      # push "[]"
    ×     # repeat width times
     ,    # print with newline
— Emigna
fonte
3

; # + , 197 bytes

>;;;;;;~++++++++:>~;;;;:>~*(-:~<~+-::>-:::<~<-+++++++++~:::<~+-:::>-::*)-::<-::::>-::(;)::>-::*(-:~<~+-::>-:::<~<-+++++++++~:::<~+-:::>-::*)-:<~<;;;;;-+>-:<-:-(-:::~<-:::(~<#<-;;-#~;)-:<#-::<;>-:-)

Experimente online!Requer um byte zero após cada número de entrada.

Eu meio que não sei como isso funciona. O que posso dizer é que esta parte do código:

 *(-:~<~+-::>-:::<~<-+++++++++~:::<~+-:::>-::*)-::<-::::>-::(;)::>-::*(-:~<~+-::>-:::<~<-+++++++++~:::<~+-:::>-::*)

está analisando os números de entrada.

— Conor O'Brien
fonte
3

brainfuck, 145 bytes

+++++++++[>++++++++++<-]>+[>+>+<<-]>>++>,>+++++++++[<----->-]<--->>>,>+++++++++[<----->-]<--->++++++++++<[<<<[>+>+<<-]>[<<<.>.>>-]>[<<+>>-]>>.<-]

Experimente online!

Meu primeiro código de golfe! Yay!

A entrada está em ascii + 48, portanto, para fazer 50, 50, você deve inserir b, b (as letras ascii para 98)

Explicação

+++++++++[>++++++++++<-]>+ Get the opening square bracket into first position
[>+>+<<-] Get it into the second and third position
>>++ Get the third position to be the closing bracket
>
,>+++++++++[<----->-]<--- Get first number into fourth cell
>>>
,>+++++++++[<----->-]<--- Get second number into seventh cell
>++++++++++ get newline into 8th position
<

[ Start our height loop
<<<[>+>+<<-] Get the width into the fifth and sixth positions
>[ Start our width loop at the fifth position
<<<.>. Print the second and third positions
>>-] Decrement the fifth position
>
[<<+>>-] copy the sixth position into the fourth position
>>. print newline
<-]
— vityavv
fonte
Impressionante. Bem vindo ao site! :)
— DJMcMayhem
Por que a entrada é ASCII + 48? Você pode salvar um monte de bytes apenas usando ASCII + 0 entrada (possivelmente ligando para o ASCII + versão 48 para a usabilidade)
— CalculatorFeline
Eu só queria conhecer os critérios para a entrada, @calculatorFeline
— vityavv
...Oh, certo. : |
— CalculatorFeline
2

J , 12 bytes

'[]'$~],+:@[

Experimente online!

Explicação

'[]'$~],+:@[   input: y, x
        +:@[   double y
      ],       pair with x
               this gives (x, 2y)
    $~         shape the left argument into the right argument's shape
'[]'           2-length character string

Isso nos dá uma xpor 2ysérie de repetir []personagens.

— Conor O'Brien
fonte
— Freira gêmea
2

Geléia , 7 bytes

ẋ⁾[]ẋ$Y

Um link diádico retornando uma lista de caracteres (ou um programa completo imprimindo o resultado).

Experimente online!

Quão?

ẋ⁾[]ẋ$Y - Main link: number w, number h          e.g. 2, 3
ẋ       - repeat w h times                            [2,2,2]
     $  - last two links as a monad:
 ⁾[]    -   literal ['[',']'],                        "[]"
    ẋ   -   repeat list (vectorises)                  ["[][]","[][]","[][]"]
      Y - join with newlines                          "[][]\n[][]\n[][]"
        - if a full program, implicit print
— Jonathan Allan
fonte
2

Ohm , 9 bytes

M"[]"َJ,

Experimente online!

Explicação

M"[]"َJ,
M         //Executes code input1 times
 "[]"     //Pushes []
     َ   //Duplicates [] input2 times
       J  //Joins the stack
        , //Prints with a trailing newline
— Datboi
fonte
2

PowerShell, 25 bytes

param($w,$h),("[]"*$w)*$h

-3 graças a Mathias!

— colsw
fonte
Você pode reduzi-lo para 25 assim:param($w,$h),("[]"*$w)*$h
— Mathias R. Jessen
2

Japt , 13 12 + 1 = 14 13 bytes

+1 para a -Rbandeira.

"[]"pN× òU*2

Experimente online

  • 1 byte economizado graças ao obarakon.
— Shaggy
fonte
Estar um pouco bêbado às vezes pode ajudar suas habilidades de programação : P
— ETHproductions
@ETHproductions: o desenho que eu estava procurando, mas estava bêbado demais para encontrar!
— Shaggy
Haha, espero que vocês estejam tendo uma noite divertida. fyi, U*Vpode ser encurtado paraN×
— Oliver
1
@obarakon: São duas oportunidades para trabalhar Nontem à noite. Nunca beba e golf, crianças!
— Shaggy
2

APL (Dyalog) , 11 bytes

'[]'⍴⍨⊢,2×⊣

Experimente online!

'[]' a corda

⍴⍨ repetido ciclicamente para preencher a forma

⊢ argumento correto (linhas)

, e

2× duas vezes

⊣ o argumento esquerdo (colunas)

— Adão
fonte
2

Carvão , 8 7 bytes

ＥＮ×[]Ｉη

Experimente online! Link é a versão detalhada do código. Recebe entrada na altura e largura da ordem. As primitivas de desenho do carvão vegetal não são adequadas para isso, portanto, isso apenas leva o caminho mais fácil e repete a []sequência adequadamente. Explicação:

 Ｎ      First input as a number
Ｅ       Map over implcit range
      η Second input
     Ｉ  Cast to number
   []   Literal string
  ×     Repeat
        Implicitly print on separate lines
— Neil
fonte
Bem, tem desenho primitivos para isso, mas ainda 8 bytes : P
— ASCII-only
@ Somente ASCII Desculpe, eu não sabia que Oblong trabalhava em seqüências arbitrárias. Arrumado!
— Neil
@ Somente ASCII Oh, e qual é o nome detalhado da variável de cadeia vazia predefinida?
— Neil
— somente ASCII
@ Somente ASCII Então, o que estou fazendo de errado aqui: Experimente online!
— Neil
1

R , 70 bytes

p=paste
function(w,h)p(rep(p(rep('[]',w),collapse=''),h),collapse='
')

Experimente online!

Retorna uma função anônima que constrói e retorna a string.

45 bytes, não conforme

function(w,h)write(matrix('[]',w,h),'',w,,'')

Uma função anônima que imprime a string no formato desejado.

Experimente online

— Giuseppe
fonte
1

Japonês , 7 bytes

6 bytes de código, +1 para o -Rsinalizador.

VÆç"[]

Não funciona na versão mais recente devido a um erro ç, mas funciona no commitf619c52 .Teste online!

Explicação

VÆ   ç"[]
VoX{Uç"[]"}  // Ungolfed
             // Implicit: U, V = input integers
VoX{      }  // Create the range [0...V) and replace each item X with
    Uç"[]"   //   U copies of the string "[]".
-R           // Join the result with newlines.
             // Implicit: output result of last expression
— ETHproductions
fonte
1

QBIC , 14 bytes

[:|?[:|?@[]`';

Explicação:

[:|     FOR a = 1 to (read input from cmd line)
?       PRINT a newlne
[:|     FOR c = 1 to (read input from cmd line)
?@[]`   PRINT A$ (containing the box)
';         and inject a semicolon in the compiled QBasic code to suppress newlines

Isso leva seus argumentos na ordem de #rows, #cols. A saída começa com uma nova linha.

— steenbergh
fonte
1

C #, 78 bytes

(w,h)=>"".PadLeft(h).Replace(" ","".PadLeft(w).Replace(" ","[]")+'\n').Trim();

Executar no C # Pad

Isso é mais curto do que com for-loops e não conheço nenhuma função em C # que possa se repetir com menos código.

— Arthur Rump
fonte
1

JavaScript (ES6), 43 36 bytes

A partir dos comentários, uma nova linha à direita agora é permitida.

w=>h=>("[]".repeat(w)+`
`).repeat(h)

Tente

f=
w=>h=>("[]".repeat(w)+`
`).repeat(h)
oninput=_=>o.innerText=f(+i.value)(+j.value);o.innerText=f(i.value=2)(j.value=2)
*{font-family:sans-serif;}
input{margin:0 5px 0 0;width:50px;}
<label for=i>w: </label><input id=i type=number><label for=j>h: </label><input id=j type=number><pre id=o>
Expandir snippet

— Shaggy
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.