Introdução

Mais complexo que Um quadrado de texto, pois isso requer preenchimento e entrada tem tipo de dados desconhecido.

Todos os anos, a Dyalog Ltd. realiza uma competição estudantil. O desafio é escrever um bom código APL. Esta é uma edição de código-golfe independente de idioma do décimo problema deste ano.

Tenho permissão explícita para postar esse desafio aqui, do autor original da competição. Sinta-se livre para verificar, seguindo o link fornecido e entrando em contato com o autor.

Problema

Escreva um programa / função que remodelará uma determinada sequência de caracteres ou lista numérica no menor quadrado que conterá todos os elementos da entrada, preenchendo com elementos adicionais, se necessário. O elemento pad deve ser o elemento de preenchimento padrão para o tipo de dados fornecido ou qualquer elemento de sua escolha. Os elementos do quadrado devem estar na ordem em que o achatamento fornecerá a ordem original dos dados de entrada (com elementos de preenchimento à direita, se houver).

Casos de teste

[1,2,3,4] →

[[1,2],
 [3,4]]

[1,2,3,4,5] →

[[1,2,3],
 [4,5,0],
 [0,0,0]]

"Dyalog APL" →

[["Dyal"],       [["D","y","a","l"],
 ["og A"],   or   ["o","g"," ","A"],
 ["PL  "],        ["P","L"," "," "],
 ["    "]]        [" "," "," "," "]]

[100] →

[[100]]

[] →

o equivalente mais próximo do seu idioma a uma matriz vazia, por exemplo, []ou[[]]

MATL , 12 9 bytes

Economizou três bytes graças a Luis. heem vez de UGwewe, mas adicionando um tno começo.

tnX^Xkthe

Experimente online!

Isso retorna os resultados, mas transpostos em comparação com o resultado na postagem dos OPs (o que é bom).

Explicação:

Isso funciona da mesma maneira para as entradas numéricas e de sequência, pois o MATL as trata da mesma maneira.

Suponha que a entrada seja 'Dyalog APL'

                % Implicit: Take string or numeric array as input
                % Stack: 'Dyalog APL'
t               % Duplicate
                % Stack: 'Dyalog APL'
                %        'Dyalog APL'
 n              % Number of elements in last element. 
                % Stack: 'Dyalog APL'
                %        10
  X^            % Take the square root of the number of elements
                % Stack: 'Dyalog APL'
                % Stack: 3.16...
    Xk          % Ceil last number
                % Stack: 'Dyalog APL'
                %        4
      t         % Duplicate element
                % Stack: 'Dyalog APL'
                %        4
                %        4
       h        % Concatenate the last to elements horizontally
                % Stack: 'Dyalog APL'
                %        4  4
        e       % reshape into 4 rows, and 4 columns. Pads the input with zeros or spaces
                % if necessary.
                % Stack: (Note that there's a trailing column not shown below)
                %        DoP 
                %        ygL 
                %        a   
                %        lA  

Isso não gera nada para entrada vazia, o que acontece como o MATL gera matrizes / strings vazias.

JavaScript (ES7), 70 bytes

a=>[...Array((a.length-1)**.5+1|0)].map((_,$,b)=>b.map(_=>a[i++]),i=0)

Retorna []para uma matriz / string vazia. Usa undefinedcomo o valor de preenchimento. Para o ES6, substitua (...)**.5por Math.sqrt(...)(+5 bytes).

Braquilog , 10 bytes

;Ac~c.\l~l

Experimente online!

Leva seqüências de caracteres como listas de caracteres (o solicitante confirmou que está tudo bem).

Isso é muito ineficiente em entradas mais longas, porque força bruta todas as possíveis remanejamentos da entrada, tentando progressivamente mais preenchimento, até encontrar uma que seja quadrada.

Explicação

;Ac~c.\l~l
;Ac         Append {the shortest list possible}.
   ~c       Split into a list of lists
      \l    such that it's rectangular, and the number of columns
     .  ~l  equals the number of rows

Os elementos de preenchimento usados ​​são o valor "qualquer valor" do Prolog _, que normalmente é renderizado como _Gmais alguns dígitos aleatórios na saída (para possibilitar que o mecanismo do Prolog expresse relacionamentos entre esses valores de uso geral).

Aliás, houve uma correção de bug no SWI-Prolog apenas alguns dias atrás, que torna esse programa possível (embora ele ainda pareça funcionar em versões mais antigas e com erros); a restrição "é retangular" implícita \foi quebrada anteriormente, mas foi fixada a tempo para o desafio.

Python 2 , 105 bytes

def f(a):b=len(a)and int((len(a)-1)**.5)+1;return[(a+[[0],' ']["'"in`a`]*b*b)[b*i:][:b]for i in range(b)]

Experimente online!

PHP, 139 bytes

Cadeia de saída como matriz de caracteres 2D

trabalha com uma []matriz vazia

$r=[];for($z=ceil(sqrt($n=(($b=is_array($g=$_GET[0]))?count:strlen)($g)));$c<$z*$z;$c++)$r[$c/$z^0][]=$c<$n?$g[+$c]:($b?0:" ");print_r($r);

Experimente online!

PHP, 143 bytes

precisa [[]]como matriz vazia

Cadeia de saída como matriz de cadeia 1D

$z=ceil(sqrt((($b=is_array($g=$_GET[0]))?count:strlen)($g)));print_r($b?array_chunk(array_pad($g,$z**2,0),$z):str_split(str_pad($g,$z**2),$z));

Experimente online!

Gelatina , 13 bytes

L½Ċẋ€`
0ṁ;@ṁÇ

Um link monádico que pega uma lista simples e retorna uma lista de listas.

Conjunto de testes em Experimente online!

Quão?

Anexa quantos zeros (o elemento de preenchimento) houver elementos na entrada e, em seguida, redimensione para um quadrado, descartando qualquer excesso de zeros para os requisitos no processo.

L½Ċẋ€` - Link 1, create a square list of lists of the required size: list a
L      - length of a
 ½     - square root
  Ċ    - ceiling (the required side length, S)
     ` - repeat argument (S) for the dyadic operation:
   ẋ€  -   repeat list for €ach (implicit range [1,2,...,S] on both its left and right)
       -   note: if the input list has no length then an empty list is yielded here

0ṁ;@ṁÇ - Main link: list a (strings are lists of characters in Jelly)
0      - literal zero
 ṁ     - mould like a (makes a list of zeros of the same length as the flat list a)
  ;@   - concatenate a with that
     Ç - call the last link (1) as a monad with argument a
    ṁ  - mould the (possibly oversized) flat array with extra zeros like the square array

R, 91 bytes

function(x){if(!is.double(x))x=strsplit(x,'')[[1]];matrix(x,r<-ceiling(sqrt(length(x))),r)}

Por padrão, R apóia as matrizes reciclando elementos do vetor de entrada e codifica as matrizes na ordem principal da coluna. Retornará uma 0x0matriz para uma entrada de double(0)(uma matriz dupla vazia) ou ''.

A primeira linha (a ifdeclaração) divide uma string em um vetor de seus caracteres constituintes; se eu puder pegar esse vetor, essa linha poderá ser removida.

Experimente online!

Bash , 91 77 69 67 bytes

L=`dc -e${#1}\ 1-v1+p`
[ -z "$1"]||printf %-$[$L*$L]s "$1"|fold -$L

Experimente online!

Formata texto, almofadas com espaços. Não produz nada para stdout na entrada vazia.

Atualização : roubou alguns truques das respostas aqui .

Haskell, 87 bytes

import Data.Lists
f x|c:_<-[n|n<-[1..],n^2>=length x]=take c$chunksOf c$x++(error[]<$x)

Experimente online!

O elemento de preenchimento é error[]o menor valor de qualquer tipo ( undefinedé um pouco mais longo).

Notas no link do TIO:

• você não pode imprimir error, concatenar matrizes com elementos de preenchimento de volta a uma lista e imprimir seu comprimento

• O TIO não possui Data.Lists, apenas Data.List.Splitmostra mais 5 bytes.

Como funciona: calcule o comprimento cda matriz c-por-c. Pegue os primeiros celementos da lista de pedaços de comprimento cda lista de entrada e, em seguida, uma lista de elementos de preenchimento com o mesmo tamanho da lista de entrada. Por exemplo :

[1,2,3,4,5]                                        -- Input 
[1,2,3,4,5,error,error,error,error,error]          -- fill elements appended
[[1,2,3],[4,5,error],[error,error,error],[error]]  -- chunks of length 3
[[1,2,3],[4,5,error],[error,error,error]]          -- take 3

Dyalog APL, 20 19 bytes

{(,⍨⍴⍵↑⍨×⍨)⌈.5*⍨≢⍵}

-1 Byte graças a @ Adám!

Experimente online!