Bei einer gegebenen Liste von Ganzzahlen Lund einer Ganzzahl Nwird die Ausgabe Lin NUnterlisten gleicher Länge aufgeteilt.

Nicht teilbare Längen

Wenn Ndie Länge von nicht geteilt wird L, ist es nicht möglich, dass alle Unterlisten die gleiche Länge haben.

In jedem Fall ist die letzte Unterliste der Ausgabe diejenige, deren Länge so angepasst wird, dass sie den Rest der Liste enthält.

Dies bedeutet, dass alle Unterlisten mit LAusnahme der letzten eine Länge haben sollten length(L) // N, wobei //es sich um eine geschossige Unterteilung handelt (z 3//2 = 1. B. ).

Einige Regeln

• L kann leer sein.

• N >= 1.

• Sie können ein beliebiges eingebautes Gerät verwenden.

• Sie können die Eingabe STDINals Funktionsargument oder ähnliches durchgehen .

• Sie können die Ausgabe ausdrucken STDOUT, von einer Funktion zurückgeben oder Ähnliches.

• Sie können ein beliebiges Format für die Listen und die Ganzzahl auswählen, sofern dies die natürlichste Darstellung von Listen und Ganzzahlen in Ihrer Sprache ist.

Testfälle

Input:  [1,2,3,4], 2
Output: [[1,2],[3,4]]

Input:  [-1,-2,3,4,-5], 2
Output: [[-1,-2],[3,4,-5]]

Input:  [1,2,3,4], 1
Output: [[1,2,3,4]]

Input:  [4,8,15,16,23,42], 5
Output: [[4],[8],[15],[16],[23,42]]

Input:  [4,8,15,16,23,42], 7
Output: [[],[],[],[],[],[],[4,8,15,16,23,42]]

Input:  [2,3,5,7,11,13,17,19,23], 3
Output: [[2,3,5],[7,11,13],[17,19,23]]

Input:  [], 3
Output: [[],[],[]]

Input:  [1,2,3,4,5,6,7,8], 3
Output: [[1,2],[3,4],[5,6,7,8]]

Wertung

Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.

Pyth, 11 10 Bytes

1 Byte danke an @FryAmTheEggman .

cJEt*R/lJQ

Testsuite.

Nimmt Eingaben in umgekehrter Reihenfolge vor.

Beispieleingabe:

5
[1,2,3,4,5,6,7]

Beispielausgabe:

[[1], [2], [3], [4], [5, 6, 7]]

Erläuterung

cJEt*R/lJQ     Main function, first input:Q, second input:E.
cJEt*R/lJQQ    Implicit arguments.

c              The function c is special.
               It can chop arrays.
               If the second argument is a list of integers,
               then it chops the first array at the indices
               specified by the second array.

 JE            The first argument is the second input, stored
               to the variable J.

   t*R/lJQQ    This is the second argument.
      /lJQ     Yield length of J, integer-divided by Q.
    *R    Q    Multiply it to the following respectively:
                   [0,1,2,3,...,Q-1]
   t           Then throw away the first element.
               For example, if Q=3 and E=[1,2,3,4,5,6,7,8],
               we would now have [3,6].

JavaScript (ES6), 63 Byte

(a,n,l=a.length/n|0)=>[...Array(n)].map(_=>--n?a.splice(0,l):a)

Python, 76 73 Bytes

lambda L,N:list(map(lambda x,r=len(L)//N:L[x*r:][:r+(x>N-2)*N],range(N)))

Grundsätzlich eine unbenannte Funktion, die die Aufgabe ausführt. Danke an LeakyNun für die gesparten Bytes!

Common Lisp, 114 Bytes

(defun f(l n &optional(p(floor(length l)n))(i 1))(if(= i n)(list l)(cons(subseq l 0 p)(f(subseq l p)n p(+ i 1)))))

Ungolfed:

(defun f (l n &optional (p (floor (length l) n)) (i 1))
  (if (= i n) (list l)
              (cons (subseq l 0 p)
                    (f (subseq l p) n p (+ i 1))))
  )

Beispielaufruf:

(format t "~A~C~C" (f (read) (read)) #\return #\newline)

Probieren Sie es hier aus!

Grundsätzlich:

• Wenn wir die letzte Gruppe ausschneiden, geben Sie alles zurück, was noch von der ursprünglichen Liste übrig ist.
• Nehmen Sie andernfalls p = |L| / NElemente aus der Liste und fügen Sie diese zum Ergebnis eines rekursiven Aufrufs für den Rest hinzu. iist ein Iterationszähler, der für die Stoppbedingung verwendet wird.

Ich hatte die Herausforderung zunächst missverstanden und dachte, das Programm sollte Neher Gruppen von Elementen als NGruppen bilden. Auf jeden Fall erledigt diese Version die Aufgabe für zusätzliche 10 Bytes. LisP wird diesmal nicht gewinnen, aber ich konnte die Gelegenheit nicht wirklich verpassen: ')

Haskell, 69 67 Bytes

a%b=a#b where l#1=[l];l#n|(h,t)<-splitAt(div(length a)b)l=h:t#(n-1)

Anwendungsbeispiel: [1,2,3,4] % 3-> [[1],[2],[3,4]].

Ein einfacher rekursiver Ansatz, ähnlich der Antwort von @ xnor .

Edit: @ Will Ness sparte 2 Bytes. Vielen Dank!

PowerShell v2 +, 125 Byte

param($l,$n)if($p=[math]::Floor(($c=$l.count)/$n)){1..$n|%{$l[(($_-1)*$p)..((($_*$p-1),$c)[!($_-$n)])]}}else{(,''*($n-1))+$l}

Fühlt sich zu lang an, aber ich kann anscheinend keine Möglichkeit finden, das Slicing zum Laufen zu bringen, wenn die Ausgabe leere Arrays enthält. Ich benötige daher das Encapsulating if/ else, um diese Fälle zu behandeln. Da die PowerShell-Standardeinstellung .ToString()für Arrays über die Konsolenausgabe ein wenig seltsam aussehen kann, können Sie auch ein -join','ankreuzen, um die Arrays auf der Konsole als durch Kommas und nicht als durch Zeilenumbrüche getrennt anzuzeigen. Ich habe das in den folgenden Beispielen gemacht, um die Ausgabe klarer zu machen, aber Sie werden das nicht wollen, wenn Sie die Ausgabe in der Pipeline belassen, damit ein anderer Befehl sie aufnimmt.

Erläuterung

Übernimmt die Eingabe param($l,$n)für die Liste bzw. die Anzahl der Partitionen. Wir geben dann eine if/ else-Anweisung ein. Wenn die Größe der einzelnen Partitionen, $pnicht Null ist (Einstellung Helfer $cder zu sein .countauf dem Weg), sind wir in der if.

In der ifSchleife wechseln wir von 1zu $nmit |%{...}, und bei jeder Iteration erstellen wir einen ziemlich komplex aussehenden Array-Slice $l[(($_-1)*$p)..((($_*$p-1),$c)[!($_-$n)])]. Die erste Parenzahl ist unser Startindex, basierend darauf, auf welcher Partition wir sind und wie groß unsere Partitionsgröße ist. Wir berechnen das ..mit unserem Endindex, der aus einem Pseudoternären gebildet wird . Hier wählen wir entweder $c(das wörtliche Ende des Arrays) oder die Länge unserer Partition, je nachdem, ob wir uns im letzten Block befinden $_-$noder nicht.

Ansonsten sind wir in der else. Wir konstruieren ein leeres Array mit dem Komma-Operator ,''*, der einer Partition weniger entspricht als angefordert, und heften dann das Eingabearray als letztes Element an.

Beispiele

Hier zeige ich die mit Zeilenumbrüchen getrennten Partitionen und jedes einzelne Element mit ,, wie oben beschrieben.

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 (1,2,3,4) 2
1,2
3,4

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 (-1,-2,3,4,-5) 2
-1,-2
3,4,-5

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 (1,2,3,4) 1
1,2,3,4

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 (4,8,15,16,23,42) 5
4
8
15
16
23,42

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 (4,8,15,16,23,42) 7






4,8,15,16,23,42

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 (2,3,5,7,11,13,17,19,23) 3
2,3,5
7,11,13
17,19,23

PS C:\Tools\Scripts\golfing> .\n-chotomize-a-list.ps1 $null 3



PS C:\Tools\Scripts\golfing> 

F #, 100 98 Bytes

fun n l->
let a=List.length l/n
List.init n (fun i->if i<n-1 then l.[a*i..a*i+a-1] else l.[a*i..])

Verwenden der F # -Listenaufteilung mit einer if-Klausel, die entscheidet, ob ein Element oder alle verbleibenden Elemente ausgewählt werden sollen.

Prolog, 100 bis 99 Bytes.

n(A,B):-length(B,A).
p(L,K,G):-n(K,G),append(A,[_],G),n(N,L),M is N//K,maplist(n(M),A),append(G,L).

Rufen Sie zB an

p ([1,2,3,4,5,6,7], 3, X).
X = [[1, 2], [3, 4], [5, 6, 7]] .

PHP, 109 Bytes

<?for($n=(count($a=$_GET[0]))/($d=$_GET[1])^0;$i<$d;)$r[]=array_slice($a,$i*$n,++$i==$d?NULL:$n);print_r($r);

Alle Testfälle