Herausforderung

Teilen Sie die Zeichenfolge anhand einer Zeichenfolge und einer Zahl in so viele gleich große Teile. Wenn die Zahl beispielsweise 3 ist, sollten Sie die Zeichenfolge in 3 Teile teilen, unabhängig davon, wie lang die Zeichenfolge ist.

Wenn sich die Länge der Zeichenfolge nicht gleichmäßig in die angegebene Zahl aufteilt, sollten Sie die Größe der einzelnen Teile abrunden und einen "Rest" der Zeichenfolge zurückgeben. Wenn die Länge der Eingabezeichenfolge beispielsweise 13 und die Zahl 4 beträgt, sollten Sie jeweils vier Zeichenfolgen der Größe 3 plus eine Restzeichenfolge der Größe 1 zurückgeben.

Wenn es keinen Rest gibt, können Sie einfach keinen oder den leeren String zurückgeben.

Es wird garantiert, dass die angegebene Anzahl kleiner oder gleich der Länge der Zeichenfolge ist. Die Eingabe "PPCG", 7wird beispielsweise nicht ausgeführt, da "PPCG"sie nicht in 7 Zeichenfolgen unterteilt werden kann. (Ich nehme an, das richtige Ergebnis wäre (["", "", "", "", "", "", ""], "PPCG"). Es ist einfacher, dies als Eingabe zu verbieten.)

I / O ist wie gewohnt flexibel. Sie können ein Paar der Zeichenfolgen und die verbleibende Zeichenfolge oder eine Liste von Zeichenfolgen mit dem Rest am Ende zurückgeben.

Testfälle

"Hello, world!", 4 -> (["Hel", "lo,", " wo", "rld"], "!") ("!" is the remainder)
"Hello, world!", 5 -> (["He", "ll", "o,", " w", "or"], "ld!")
"ABCDEFGH", 2 -> (["ABCD", "EFGH"], "") (no remainder; optional "")
"123456789", 5 -> (["1", "2", "3", "4", "5"], "6789")
"ALABAMA", 3 -> (["AL", "AB", "AM"], "A")
"1234567", 4 -> (["1", "2", "3", "4"], "567")

Wertung

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

Bonuspunkte (nicht wirklich 😛) dafür, dass Ihre Lösung tatsächlich den Teilungsoperator Ihrer Sprache verwendet.

Python 2 , 63 Bytes

s,n=input()
b=len(s)/n
while n:print s[:b];s=s[b:];n-=1
print s

Probieren Sie es online!

PHP> = 7.1, 75 Bytes

[,$s,$d]=$argv;print_r(preg_split('/.{'.(strlen($s)/$d^0).'}\K/',$s,$d+1));

Testfälle

PHP> = 7.1, 52 Bytes

drucke nur den Rest aus

[,$s,$d]=$argv;echo substr($s,(strlen($s)/$d^0)*$d);

Testfälle

Pip , 21 Bytes

20 Byte Code, +1 für -nFlag.

a~C(#a//b*XX)XbP$$$'

Übernimmt Eingaben als Befehlszeilenargumente; gibt Strings und Rest Newline-Separated aus. Probieren Sie es online!

Erläuterung

Spaß mit Regex-Operationen!

Nehmen wir abcdefgals unsere Zeichenfolge und 3als unsere Nummer. Wir konstruieren den regulären Ausdruck (.{2})(.{2})(.{2}), der drei Reihen von zwei Zeichen entspricht und diese in drei Erfassungsgruppen speichert. Dann können wir unter Verwendung der regulären Übereinstimmungsvariablen von Pip 1) die Liste der Erfassungsgruppen ["ab";"cd";"ef"]und 2) den Rest der Zeichenfolge drucken , die nicht übereinstimmt "g".

                      a,b are cmdline args; XX is the regex `.` (match any one character)
    #a//b             Len(a) int-divided by b: the length of each chunk
         *XX          Apply regex repetition by that number to `.`, resulting in something
                        that looks like `.{n}`
  C(        )         Wrap that regex in a capturing group
             Xb       Repeat the whole thing b times
a~                    Match the regex against a
               P$$    Print $$, the list of all capture groups (newline separated via -n)
                  $'  Print $', the portion of the string after the match

Haskell , 62 Bytes

#ist ein Operator, der ein Stringund ein Intnimmt und eine Liste von Strings zurückgibt.

Verwenden Sie als "Hello, world!"#4.

s#n|d<-length s`div`n=[take(d+n*0^(n-i))$drop(i*d)s|i<-[0..n]]

Probieren Sie es online!

Wie es funktioniert

• sist die Eingabezeichenfolge und ndie Anzahl der nicht verbleibenden Teile.
• dist die Länge jedes "normalen" Stückes. divist eine Ganzzahldivision.
• Das Listenverständnis konstruiert n+1Stücke, wobei das letzte der Rest ist.
  • iiteriert von 0bis neinschließlich.
  • Für jedes Stück wird zuerst die richtige Anzahl ( i*d) von Anfangszeichen dropvom Anfang an eingegeben s, dann ist eine erste Teilzeichenfolge taken vom Ergebnis.
  • Die Länge der Teilzeichenfolge sollte mit dAusnahme des Reststücks betragen.
    • Der tatsächliche Rest muss kürzer als sein n, da sonst die normalen Teile verlängert würden.
    • takeGibt den gesamten String zurück, wenn die angegebene Länge zu groß ist, sodass wir >=n-1für das Reststück eine beliebige Zahl verwenden können .
    • Der Ausdruck d+n*0^(n-i)gibt dob i<nund d+nob i==n. Es nutzt das 0^xist 1wann x==0, aber 0wenn x>0.

Python 2 , 68 67 65 Bytes

• @ musicman123 2 Bytes gespeichert: Ausgabe ohne Einschließen mit []
• Danke an @Chas Brown für 1 Byte: x[p*i:p+p*i]asx[p*i][:p]

def f(x,n):p=len(x)/n;print[x[p*i:][:p]for i in range(n)],x[p*n:]

Probieren Sie es online!

C ++ 14, 209 180 Bytes

Das ist ein bisschen zu lang, benutzt aber den Divisionsoperator:

#include<bits/stdc++.h>
using q=std::string;using z=std::vector<q>;z operator/(q s,int d){int p=s.length()/d,i=0;z a;for(;i<d+1;){a.push_back(s.substr(i++*p,i^d?p:-1));}return a;}

Verwendung:

vector<string> result = string("abc")/3;

Online-Version: http://ideone.com/hbBW9u

Pyth, 9 Bytes

cz*L/lzQS

Probieren Sie es online aus

Wie es funktioniert

Erstens Qwird automatisch initialisiert eval(input())und zautomatisch initialisiert input().

cz*L/lzQSQ
     lz      length of z
    /  Q     integer division by Q
  *L         times every element of
        SQ       [1, 2, …, Q]
cz           chop z at those locations

Jelly , 11 Bytes

Ld⁹x,1$}R⁸ṁ

Probieren Sie es online!

Rust , 107 Bytes

fn f(s:&str,n:usize)->(Vec<&str>,&str){let c=s.len()/n;((0..n).map(|i|&s[i*c..i*c+c]).collect(),&s[c*n..])}

Probieren Sie es online!

Formatiert:

fn q129259(s: &str, n: usize) -> (Vec<&str>, &str) {
    let c = s.len() / n;
    ((0..n).map(|i| &s[i * c..i * c + c]).collect(), &s[c * n..])
}

Dies indiziert einfach mapdie richtigen Schichten der Quelle str( collectin a Vec) und schneidet den Rest heraus.

Leider kann ich dies nicht zu einem Abschluss machen (74 Bytes):

|s,n|{let c=s.len()/n;((0..n).map(|i|&s[i*c..i*c+c]).collect(),&s[c*n..])}

wie der Compiler mit ausfällt

error: the type of this value must be known in this context
 --> src\q129259.rs:5:18
  |
5 |          let c = s.len() / n;
  |                  ^^^^^^^

und wenn ich den typ s:&strangabe, sind die lebensdauern falsch:

error[E0495]: cannot infer an appropriate lifetime for lifetime parameter in function call due to conflicting requirements
 --> src\q129259.rs:6:27
  |
6 |          ((0..n).map(|i| &s[i * c..i * c + c]).collect(), &s[c * n..])
  |                           ^^^^^^^^^^^^^^^^^^^
  |
note: first, the lifetime cannot outlive the anonymous lifetime #1 defined on the body at 4:18...
 --> src\q129259.rs:4:19
  |
4 |       (|s: &str, n| {
  |  ___________________^
5 | |          let c = s.len() / n;
6 | |          ((0..n).map(|i| &s[i * c..i * c + c]).collect(), &s[c * n..])
7 | |      })(s, n)
  | |______^
note: ...so that reference does not outlive borrowed content
 --> src\q129259.rs:6:27
  |
6 |          ((0..n).map(|i| &s[i * c..i * c + c]).collect(), &s[c * n..])
  |                           ^
note: but, the lifetime must be valid for the lifetime 'a as defined on the body at 3:58...
 --> src\q129259.rs:3:59
  |
3 |   fn q129259<'a>(s: &'a str, n: usize) -> (Vec<&str>, &str) {
  |  ___________________________________________________________^
4 | |     (|s: &str, n| {
5 | |          let c = s.len() / n;
6 | |          ((0..n).map(|i| &s[i * c..i * c + c]).collect(), &s[c * n..])
7 | |      })(s, n)
8 | | }
  | |_^
note: ...so that expression is assignable (expected (std::vec::Vec<&'a str>, &'a str), found (std::vec::Vec<&str>, &str))
 --> src\q129259.rs:4:5
  |
4 | /     (|s: &str, n| {
5 | |          let c = s.len() / n;
6 | |          ((0..n).map(|i| &s[i * c..i * c + c]).collect(), &s[c * n..])
7 | |      })(s, n)
  | |_____________^

Netzhaut , 92 Bytes

(.+)¶(.+)
$2$*1¶$.1$*1¶$1
(1+)¶(\1)+
$1¶$#2$*1¶
\G1(?=1*¶(1+))
$1¶
¶¶1+

O^$`.

¶1+$

O^$`.

Probieren Sie es online! Erläuterung: Die erste Stufe konvertiert die Anzahl der Teile in unär und nimmt auch die Länge der Zeichenfolge an. Die zweite Stufe teilt dann die Länge durch die Anzahl der Teile, so dass der Rest übrig bleibt. Die dritte Stufe multipliziert das Ergebnis erneut mit der Anzahl der Teile. Dies gibt uns die richtige Anzahl von Zeichenfolgen mit der richtigen Länge, aber sie haben noch nicht den Inhalt. Die Anzahl der Teile kann jetzt in der vierten Stufe gelöscht werden. Die fünfte Stufe kehrt alle Zeichen um. Dies hat den Effekt, dass der ursprüngliche Inhalt mit den Platzhalterzeichenfolgen umgeschaltet wird, aber obwohl er sich jetzt an der richtigen Stelle befindet, ist die Reihenfolge umgekehrt. Die Platzhalter haben ihren Zweck erfüllt und werden in der sechsten Stufe gelöscht. Schließlich kehrt die siebte Stufe die Charaktere in ihre ursprüngliche Reihenfolge zurück.

Perl 6 , 36 Bytes

{$^a.comb.rotor($a.comb/$^b xx$b,*)}

Probieren Sie es online!

Gibt eine Liste mit Listen von Zeichenfolgen zurück, wobei das letzte Element der Rest ist (sofern vorhanden).

Erläuterung:

{                                  }  # Anonymous code block
 $^a.comb                             # Split the string into a list of chars
         .rotor(                  )   # And split into
                            xx$b      # N lists
                $a.comb/$^b           # With string length/n size
                                ,*    # And whatever is left over  

JavaScript (ES6), 77 Byte

(s,d,n=s.length)=>[s.match(eval(`/.{${n/d|0}}/g`)).slice(0,d),s.slice(n-n%d)]

Gibt ein Array mit zwei Elementen zurück: den geteilten Zeichenfolgeteilen und dem restlichen Teil.

Testschnipsel

f=
(s,d,n=s.length)=>[s.match(eval(`/.{${n/d|0}}/g`)).slice(0,d),s.slice(n-n%d)]

<div oninput="O.innerHTML=I.value&&J.value?JSON.stringify(f(I.value,+J.value)):''">String: <input id=I> Number: <input id=J size=3></div>
<pre id=O>

Japt , 18 Bytes

¯W=Ul fV)òW/V pUsW

Online testen! (benutzt -Qflag um die Ausgabe zu visualisieren)

Erläuterung

¯W=Ul fV)òW/V pUsW  : Implicit: U = input string, V = input integer
   Ul fV            : Floor U.length to a multiple of V.
 W=                 : Assign this value to variable W.
¯       )           : Take the first W characters of U (everything but the remainder).
         òW/V       : Partition this into runs of length W / V, giving V runs.
              pUsW  : Push the part of U past index W (the remainder) to the resulting array.
                    : Implicit: output result of last expression

Python, 82 76 74 Bytes

def G(h,n):l=len(h);r=l/n;print[h[i:i+r]for i in range(0,n*r,r)],h[l-l%n:]

Nun, so wie es aussieht, qualifiziert es sich für die Bonuspunkte. _{Darf ich stattdessen bitte ein Cookie erhalten?} ^{Oh warte, sie sind nicht echt? Verdammt...}

Probieren Sie es online!

Python, 95, 87, 76, 73 Bytes

def f(s,n):
 a=[];i=len(s)/n
 while n:a+=s[:i],;s=s[i:];n-=1
 print a+[s]

Probieren Sie es online!

05AB1E , 12 Bytes

²g¹‰`s¹.D)R£

Probieren Sie es online!

Erläuterung

²g¹‰`s¹.D)R£
²g           # Push length of string
  ¹          # Push amount of pieces
   ‰         # divmod of the two
    `s       # Flatten the resulting array and flip it around
      ¹.D    # Repeat the resulting length of the pieces amount of pieces times(wow that sounds weird)
         )   # Wrap stack to array
          R  # Reverse (so the remainder is at the end)
           £ # Split the input string into pieces defined by the array

Brachylog , 16 Bytes

kʰ↙Xḍ₎Ylᵛ&ht↙X;Y

Probieren Sie es online!

Nimmt Eingaben als Liste [string, number]und gibt sie als Liste aus [remainder, parts]. (In den Testfällen "Hallo Welt!" Wurden die Kommas aus Gründen der Übersichtlichkeit durch Semikolons ersetzt, da die Zeichenfolgenfragmente nicht in Anführungszeichen gedruckt werden.)

                    The input
 ʰ                  with its first element
k ↙X                having the last X elements removed
    ḍ               and being cut into a number of pieces
     ₎              where that number is the last element of the input
      Y             is Y
       lᵛ           the elements of which all have the same length,
         &          and the input
          h         's first element
           t↙X      's last X elements
              ;     paired with
               Y    Y
                    are the output.

(Ich habe auch ein Komma im Code durch ein Semikolon ersetzt, um ein konsistentes Ausgabeformat zu erhalten. Mit dem Komma Fälle ohne Rest nur die Teile ohne leeren Rest aus, und so schön das für manche Zwecke ist, tue ich es nicht weiß eigentlich warum es so funktioniert ...)

Nachdem das Ganze 16 Bytes lang war, habe ich versucht, etwas basierend auf der +₁ᵗ⟨ġl⟩Arbeit zu machen , aber als die Korrekturen immer länger wurden, habe ich beschlossen, dass ich erst einmal bei meiner ursprünglichen Lösung bleiben würde.

C (gcc), 72 Bytes

d;f(s,n)char*s;{for(d=strlen(s)/n;n--;puts(""))s+=write(1,s,d);puts(s);}

Probieren Sie es online

Excel Formula, 185 173 165 161 149 Byte

Folgendes sollte als Matrixformel ( Ctrl+ Shift+ Enter) eingegeben werden :

=MID(A1,(ROW(OFFSET(A1,,,B1+1))-1)*INT(LEN(A1)/B1)+1,INT(LEN(A1)/B1)*ROW(OFFSET(A1,,,B1+1))/IF(ROW(OFFSET(A1,,,B1+1))=B1+1,1,ROW(OFFSET(A1,,,B1+1))))

Wo A1enthält Ihre Eingabe (zB 12345678) undB1 enthält den Divisor. Hierfür wird auch der Divisionsoperator von Excel als Bonus verwendet.

Nachdem Sie die Formel als Matrixformel eingegeben haben, markieren Sie sie in der Formelleiste und werten Sie sie mit aus F9, um das Ergebnis zurückzugeben. Beispiel:

-12 Byte: jeweils ersetzenINDIRECT("1:"&B1+1) durchOFFSET(A1,,,B1+1) , um 2 Bytes pro Vorkommen zu sparen, plus etwas Aufräumen, indem Sie redundante Klammern entfernen.

-8 Bytes: Redundante entfernenINDEX Funktion .

-4 Bytes: Überarbeitung der "Rest" -Behandlung.

-12 Bytes: Entfernen Sie redundante INT(LEN(A1)/B1)Daten, indem Sie das ROW(OFFSET(A1,,,B1+1))durch -1 erzeugte Array versetzen.

Python 2 , 77 76 Bytes

-1 Byte dank musicman523.

def f(s,n):l=len(s);print[s[i:i+l/n]for i in range(0,l-n+1,l/n)]+[s[l-l%n:]]

Probieren Sie es online!

Ruby , 53 Bytes

->s,n{a=s.scan(/.{,#{s.size/n}}/);[a[0,n],a[n,n]*'']}

Probieren Sie es online!

Mathematica, 58 Bytes

{#~Partition~a,#2}&@@TakeDrop[#,(a=Floor[Length@#/#2])#2]&

Reine Funktion, die eine Liste von Zeichen und eine positive Ganzzahl als Eingabe verwendet. Beispielsweise wird der letzte Testfall von aufgerufen

{#~Partition~a,#2}&@@TakeDrop[#,(a=Floor[Length@#/#2])#2]&[{"1","2","3","4","5","6","7"},4]

und kehrt zurück:

{{{"1"}, {"2"}, {"3"}, {"4"}}, {"5", "6", "7"}}

Haskell, 120 88 Bytes (danke an Ørjan Johansen!)

Zählt divals der Teilungsoperator?

Ich bin gespannt, wie ich das reduzieren kann, ich habe noch nicht alle Tricks gelernt.

q=splitAt;x!s|n<-div(length s)x,let g""=[];g s|(f,r)<-q n s=f:g r,(a,b)<-q(n*x)s=(g a,b)

Ohm, 3 Bytes (nicht konkurrierend?)

lvσ

Nicht konkurrierend, weil das eingebaute noch nicht in TIO implementiert ist und ich keinen PC zur Hand habe, um zu testen, ob es in der neuesten Version des Repos funktioniert.

Eingebautes ¯ \\ _ (ツ) _ / ¯. Ich habe das falsche eingebaut ... Aber hey, da liegt noch ein anderes herum. Jetzt habe ich zwei Mal das falsche eingebaute verwendet (oder ein eingebautes funktioniert falsch mit Resten).

Erhalte ich Bonuspunkte, weil ves sich um eine Aufteilung handelt?

CJam , 16 Bytes

{_,2$//_2$<@@>s}

Anonymer Block erwartet die Argumente auf dem Stapel und hinterlässt das Ergebnis auf dem Stapel.

Probieren Sie es online!

Erläuterung

Erwartet Argumente als number "string".

_,              e# Copy the string and get its length.
  2$            e# Copy the number.
    /           e# Integer divide the length by the number.
     /          e# Split the string into slices of that size.
      _         e# Copy the resulting array.
       2$       e# Copy the number.
         <      e# Slice the array, keeping only the first <number> elements.
          @@    e# Bring the number and original array to the top.
            >   e# Slice away the first <number> elements,
             s  e# and join the remaining elements into a string.

J , 26 Bytes

(]$~[,(<.@%~#));]{.~0-(|#)

Abgesehen von der Beseitigung von Räumen und Zwischenschritten wurde hier nicht golfen. Ich gehe davon aus, dass ich irgendwie den langen Weg gegangen bin, was mit meinen Klammern und Argumentationshinweisen ([ und] ) zu .

Im Jupyter-Notizbuch finden Sie Testfälle wie die folgenden:

   5 chunk test2
┌──┬───┐
│He│ld!│
│ll│   │
│o,│   │
│ w│   │
│or│   │
└──┴───┘

R , 79 63 Bytes

-16 von Giuseppe beim Reparieren der Indexierung

function(s,n,k=nchar(s),l=k%/%n)substring(s,0:n*l+1,c(1:n*l,k))

Probieren Sie es online!

Gebaut um Vektoreingaben zu geben substring()

PHP , 152 Bytes

Danke @ JörgHülsermann (Klammertipp!)

$c=$s=explode('|',readline());
while($s[1]--)$s[0]=preg_replace('/^'.($l[]=substr($s[0],0,strlen($c[0])/$c[1])).'/','',$s[0]);
$l[r]=$s[0];
print_r($l);

Probieren Sie es online!

Python 3 , 94 Bytes

i=input().split('|')
s,n=i[0],int(i[1])
c=len(s)//n
while n:print(s[:c]);s=s[c:];n-=1
print(s)

Probieren Sie es online!

PowerShell v3 + , 72 , 80 Bytes

Angenommen, $senthält die Eingabezeichenfolge;$nenthält die Anzahl der Zeichen pro "Stück". Dies setzt auch voraus, dass "StrictMode" ausgeschaltet ist. Andernfalls würde ein Fehler zurückgegeben, weil weiter in ein Array indiziert wird, als tatsächlich vorhanden ist (dh wenn das Array 4 Elemente enthält und ich das nicht vorhandene fünfte Element nenne). Wenn StrictMode deaktiviert ist, kümmert sich PS nicht darum und ignoriert den Fehler.

for($i = 0;$i -le $s.Length;$i+=$n+1){-join($s|% ToCharA*)[$i..($i+$n)]}

Notation verwenden ($s|% ToCharA*) ich 1 Zeichen speichern im Vergleich zu $s.ToCharArray():)

Aktualisieren:

Der Code wurde aktualisiert, um die Anforderungen der Herausforderungen zu erfüllen. Wieder nimmt an, $senthält die Eingabezeichenfolge; Diese Zeit $nenthält jedoch die Anzahl der "Teile". Der Rest wird zuletzt ausgedruckt. Und ich habe den Divisionsoperator von PowerShell verwendet

0..($n-1)|%{$p=[math]::Floor($s.length/$n)}{$s|% Su*($_*$p) $p}{$s|% Su*($n*$p)}

Probieren Sie es online!