Intro

Komplexer als ein Textquadrat, da dies Auffüllen erfordert und die Eingabe einen unbekannten Datentyp hat.

Jedes Jahr veranstaltet Dyalog Ltd. einen Studentenwettbewerb. Die Herausforderung besteht darin, guten APL-Code zu schreiben . Dies ist eine sprachunabhängige Code-Golf- Ausgabe des diesjährigen zehnten Problems.

Ich habe die ausdrückliche Erlaubnis, diese Herausforderung hier vom ursprünglichen Autor des Wettbewerbs zu posten. Sie können dies überprüfen, indem Sie dem angegebenen Link folgen und den Autor kontaktieren.

Problem

Schreiben Sie ein Programm / eine Funktion, die eine bestimmte Zeichenfolge oder numerische Liste in das kleinste Quadrat umformt, das alle Elemente der Eingabe enthält, und füllen Sie sie gegebenenfalls mit zusätzlichen Elementen auf. Das Pad-Element sollte das Standardfüllelement für den angegebenen Datentyp oder ein beliebiges Element Ihrer Wahl sein. Die Elemente des Quadrats sollten in einer solchen Reihenfolge sein, dass durch Abflachen die ursprüngliche Reihenfolge der Eingabedaten erhalten wird (ggf. mit nachfolgenden Auffüllelementen).

Testfälle

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

[] →

Ihre Sprache entspricht am ehesten einer leeren Matrix, z. B. []oder[[]]

MATL , 12 9 Bytes

Dank Luis drei Bytes gespeichert. hestatt UGwewe, aber tam Anfang ein hinzufügen .

tnX^Xkthe

Probieren Sie es online aus!

Dies gibt die Ergebnisse zurück, ist jedoch im Vergleich zum Ergebnis in OPs post (was in Ordnung ist) transponiert.

Erläuterung:

Dies funktioniert sowohl für numerische als auch für Zeichenfolgeneingaben auf dieselbe Weise, da MATL sie auf dieselbe Weise behandelt.

Angenommen, die Eingabe ist '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  

Dies gibt nichts für leere Eingaben aus, was zufällig so ist, wie MATL leere Matrizen / Strings ausgibt.

JavaScript (ES7), 70 Byte

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

Gibt []für ein leeres Array / eine leere Zeichenfolge zurück. Wird undefinedals Füllwert verwendet. Für ES6 ersetzen (...)**.5mit Math.sqrt(...)(5 Byte).

Brachylog , 10 Bytes

;Ac~c.\l~l

Probieren Sie es online aus!

Nimmt Zeichenfolgen als Zeichenlisten (der Fragesteller hat bestätigt, dass dies in Ordnung ist).

Dies ist bei längeren Eingaben sehr ineffizient, da alle möglichen Umformungen der Eingabe brutal erzwungen werden und zunehmend mehr Polsterung versucht wird, bis eine gefunden wird, die zufällig quadratisch ist.

Erläuterung

;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

Die verwendeten Auffüllelemente sind Prologs "Beliebiger Wert" -Wert _, der normalerweise als _Gplus einige zufällige Ziffern bei der Ausgabe gerendert wird (damit die Prolog-Engine Beziehungen zwischen diesen Allzweckwerten ausdrücken kann).

Übrigens gab es vor wenigen Tagen einen Bugfix für SWI-Prolog, der dieses Programm ermöglicht (obwohl es anscheinend immer noch auf älteren, fehlerhaften Versionen funktioniert). Die von implizierte Einschränkung "Es ist rechteckig" \wurde zuvor aufgehoben, aber rechtzeitig für die Herausforderung behoben.

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

Probieren Sie es online aus!

PHP, 139 Bytes

Ausgabezeichenfolge als 2D-Zeichenarray

arbeitet mit []als leeres Array

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

Probieren Sie es online aus!

PHP, 143 Bytes

braucht [[]]als leeres Array

Ausgabezeichenfolge als 1D-Zeichenfolgenarray

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

Probieren Sie es online aus!

Gelee , 13 Bytes

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

Ein monadischer Link, der eine flache Liste erstellt und eine Liste von Listen zurückgibt.

Testsuite bei Try it online!

Wie?

Hängt so viele Nullen (das Auffüllelement) an, wie Elemente in der Eingabe vorhanden sind, und formt sie dann in ein Quadrat um, wobei alle Nullen, die den Anforderungen im Prozess entsprechen, entfernt werden.

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

Standardmäßig füllt R Matrizen auf, indem es Elemente des Eingabevektors recycelt und Matrizen in Spaltenreihenfolge codiert. Gibt eine 0x0Matrix für eine Eingabe von double(0)(ein leeres Doppelarray) oder zurück ''.

Die erste Zeile (die ifAnweisung) teilt eine Zeichenfolge in einen Vektor ihrer konstituierenden Zeichen auf. Wenn ich stattdessen diesen Vektor aufnehmen kann, kann diese Zeile entfernt werden.

Probieren Sie es online aus!

Bash , 91 77 69 67 Bytes

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

Probieren Sie es online aus!

Formatiert Text, Pads mit Leerzeichen. Gibt bei leerer Eingabe nichts zu stdout aus.

Update : Ok , ein paar Tricks aus den Antworten hier .

Haskell, 87 Bytes

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

Probieren Sie es online aus!

Das Füllelement ist error[]der kürzeste Wert eines beliebigen Typs ( undefinedetwas länger).

Hinweise zum TIO-Link:

• Sie können nicht drucken error, daher verkette ich Matrizen mit Füllelementen zurück zu einer Liste und drucke deren Länge

• TIO hat keine Data.Lists, nur Data.List.Splitso zeigt es 5 weitere Bytes.

So funktioniert es: Berechnen Sie die Länge cder c-mal-c-Matrix. Nehmen Sie die ersten cElemente der Liste der Längenabschnitte cder Eingabeliste, gefolgt von einer Liste der Füllelemente, die dieselbe Länge wie die Eingabeliste hat. Z.B :

[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 bis 19 Byte

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

-1 Byte danke an @ Adám!

Probieren Sie es online aus!