La sfida

In questa sfida devi svolgere due attività diverse (ma correlate) a seconda dell'ordine dell'input.
Il tuo programma riceverà una stringa se un numero intero ncome input e will

• dividere sin pezzi di lunghezza nse sviene prima. L'ultimo elemento sarà più corto se necessario.
• dividere sin npezzi di uguale lunghezza se nviene prima. Se len(s)non è un multiplo dei nprimi len(s) mod nelementi sarà uno più lungo.

Puoi prendere solo quei 2 ingressi. snon conterrà mai solo cifre.

Appunti

• È possibile utilizzare la mappatura inversa. Nota questo nella tua risposta se lo fai.
• sconterrà solo caratteri ASCII stampabili (nessuna nuova riga).
• Non è possibile utilizzare alcun builtin che risolva direttamente queste due attività. Sono ammessi tutti gli altri builtin.
• Devi prendere entrambi gli argomenti dalla stessa fonte.
• Puoi prendere gli argomenti in un elenco ordinato o in qualsiasi altro formato che indichi chiaramente il loro ordine purché non ambiguo.
• Puoi prendere l'input come una stringa / stream e usare un carattere che non è un input valido (come un nullbyte) per separarli.
• nsarà sempre uguale o inferiore alla lunghezza se maggiore di zero.
• È possibile produrre l'elenco risultante in qualsiasi formato resonable purché indichi chiaramente i pezzi particolari e il loro ordine.

Esempio

Input: programming, 3
l'ultimo elemento contiene solo 2 caratteri, perché 11 non è divisibile per 3.
Output: ["pro", "gra", "mmi", "ng"]

Input: 3, programming
11 non è un multiplo di 3, quindi i primi 2 elementi saranno uno più lungo:
Output: ["prog", "ramm", "ing"]

Regole

• Funzione o programma completo consentiti.
• Regole predefinite per input / output.
• Si applicano scappatoie standard .
• Questo è code-golf , quindi vince il conteggio dei byte più basso. Tiebreaker è una presentazione precedente.

Casi test

I casi di test sono stati generati con questo programma Pyth (usa i builtin, quindi nessuna risposta valida). Grazie a @FryAmTheEggman per averci fornito la versione base!

3, helloworld -> ['hell', 'owo', 'rld']
helloworld, 3 -> ['hel', 'low', 'orl', 'd']
1, programmazione -> ['programmazione']
programmazione, 1 -> ['p', 'r', 'o', 'g', 'r', 'a', 'm', 'm', 'i', 'n', 'g']
8, programmazione -> ['pr', 'og', 'ra', 'm', 'm', 'i', 'n', 'g']
programmazione, 8 -> ['programm', 'ing']
9, codice golf -> ['c', 'o', 'd', 'e', ​​'', 'g', 'o', 'l', 'f']
code golf, 9 -> ['code golf']
4, 133tspeak -> ['133', 'ts', 'pe', 'ak']
133tspeak, 4 -> ['133t', 'speak', 'k']

Buona programmazione!

MATL, 46 26 21 27 29 42 byte

jtU?jtbUe!tn2Gn>?0t(]tgbw(}ie]!2t$X{Oc''Zt

Provalo online! (Aggiornato leggermente per funzionare con l'ultima versione della lingua)

Spiegazione

j           % Explicitly grab the first input as a string
t           % Duplicate
U           % Attempt to convert it to a number
?           % If the conversion to a number was successful
    j       % Explicitly grab the second input as a string
    t       % Duplicate the value
    b       % Bubble-up the first element in the stack
    U       % Convert to a number from a string
    e       % Reshape the string into a nGroup x nPerGroup matrix
    !       % Take the transpose
    t       % Duplicate the result
    n       % Number of characters in the repmat result
    2Gn     % Number of characters in the string
    >?      % If chars in repmat > chars in string
        O   % Zero
        t   % Duplicate 
        (   % Assign the last element to a null character (bug in MATL)
    ]       % End if statement
    t       % Duplicate this matrix
    g       % Convert to a logical matrix
    b       % Bubble-up the original string
    w       % Flip the top two elements
    (       % Assign the non-empty characters to the chars from the input string
}           % Else the string comes first
    i       % Explicitly grab the second input (the number)
    e       % Reshape the characters into an nPerGroup x nGroup 2D array
]           % End of if statement
!           % Take the transpose so it reads left-to-right
2           % Number literal
t           % Duplicate
$X{         % Call num2cell to convert to a cell array
Oc          % Null character
''          % Empty string
Zt          % Replace null chars with empty strings
            % Implicit display of stack contents

JavaScript (ES6), 132 byte

(s,t)=>+t?[...Array(-~(~-s.length/+t))].map((_,i)=>s.substr(i*t,t)):[...Array(s=+s)].map(_=>t.slice(p,p-=~((t.length-p-1)/s--)),p=0)

Questo è probabilmente eccessivamente ingegnerizzato.

JavaScript (Firefox), 88 87 byte

a=>b=>(s=+b?a:b,i=x=0,l=s.length,[for(c of s)if(r=s.slice(x,x+=+b||l/a+(i++<l%a)|0))r])

Chiamalo come (...)("programming")(3)usando Firefox 30+.

Rubino, 119 byte

->x,y{r=[t=0];x.to_s==x ?(r.push x[t...t+=y]while x[t]):x.times{r.push y[t...t+=y.size/x+(r[y.size%x]? 0:1)]};r[1..-1]}

E prendo il primo posto di 2 byte ...

AWK, 121 130 128 122 byte

$1~/^[0-9]+$/{s=1}{a=$(s+1)
b=s?$1:$2
$0=""
for(j=-b;j<=c=length(a);)$0=$0 substr(a,j+=b+s,b+(s=s&&j<c%b*(b+1)?1:0))" "}1

L'unico problema è se la prima voce è una stringa che inizia con un valore numerico. Ciò farebbe AWKvedere la stringa come quel numero e la seconda voce come stringa.

OK ... risolto il problema numerico, ma ha aggiunto 9 byte :(.

Rielaborato un po 'per salvare un paio di byte.

Quasi tornato alla lunghezza originale. :)

Haskell, 131 byte

import Data.Lists
q(d,m)=splitPlaces$(d+1<$[1..m])++[d,d..]
a#b|all(`elem`['0'..'9'])a=q(divMod(length b)$read a)b|1<2=q(read b,0)a

Esempio di utilizzo:

*Main> "8" # "programming"
["pr","og","ra","m","m","i","n","g"]
*Main> "programming" # "8"
["programm","ing"]

Come funziona: il lavoro principale è svolto dalla funzione helper qche accetta una coppia di numeri (d,m)e una stringa s. Costruisce prima un elenco di mvolte d+1seguito da infiniti d(ad esempio (1,3)-> [2,2,2,1,1,1,1,1,...]). Quindi utilizza splitPlacesper dividere sin blocchi di lunghezze fornite dall'elenco. splitPlacessi interrompe se si sesauriscono gli elementi, quindi un elenco infinito va bene.

La funzione principale #controlla quale parametro è il numero n/ stringa stre chiama qcon uno (div (length str) n, mod (length str) n)o (n, 0)più str.

C # (LINQPAD) - 335 byte

var y=Util.ReadLine().Split(',');int x,j=0;var t=int.TryParse(y[0].Trim(),out x);x=x==0?int.Parse(y[1].Trim()):x;var i=t?y[1].Trim():y[0];var z="";if(!t){while(i.Substring(j).Length>x){z+=i.Substring(j).Length>x?i.Substring(j,x)+", ":"";j+=x;}z+=i.Substring(j);}else z=string.Join(", ",i.Split(x).Select(s=>string.Concat(s)));z.Dump();

La parte di lettura dell'input ha occupato un po 'di spazio. Vincitore della risposta più lunga.

Uso n. 1:

$ 3, helloworld

>> hell, owo, rld

Uso n. 2:

$ helloworld, 3

>>hel, low, orl, d

Pyth, 181 byte

Facciamo finta che il codice più lungo in byte vinca \ o /

DyGK@G0J:@G1"."1=YJV%lJKW<l@YN.EclJK=YXYN+@YN@YhN=Y.DYhN)FNr%lJK/-lJ%lJK/-lJ%lJKKW<l@YNsclJK=YXYN+@YN@YhN=Y.DYhN))RY)DPG=K@G1=J:@G0"."1=YJV/lJKW<l@YNK=YXYN+@YN@YhN=Y.DYhN))RY).xyQPQ

Provalo qui! (L'interprete online sembra avere un bug, mostra l'input mentre non dovrebbe)

Ecco l'output dal terminale:

» pyth split.pyth <<<'["helloworld", 3]' 
['hel', 'low', 'orl', 'd']
» pyth split.pyth <<<'[3, "Helloworld"]'
['Hell', 'owo', 'rld']

Seriamente, sono aperto a un nuovo approccio. Sono nuovo di Python, quindi probabilmente mi sono perso alcuni shorthands.

Voglio dire, penso che la mia risposta sia disperata dal punto in cui è più lunga della risposta javascript ...

PHP, 114 byte

[$t,$n,$p]=$argv;for(@+$p?$s=$n:$f=$n*($p=strlen($s=$p)/$n)%$n;$t;)echo$t=substr($s,$a+=$e,$e=$p+($i++<$f)|0),"
";

• La stringa non dovrebbe iniziare con le cifre.
  (Sostituisci +@$pcon is_numeric($p)per risolvere.)
• L'output non deve contenere un blocco "0".
  (Inserisci ~per ASCII stampabile, a&per qualsiasi ASCII prima $t;di risolvere.)
• Corri con -nro provalo online .

PowerShell , 122 118 byte

param($a,$b)if($a-is[int]){$a,$b=$b,((($l=$b|% Le*)-($c=$l%$a))/$a)}$a-split("(..{$b})"*$c+"(.{0,$b})"*$a.Length)-ne''

Provalo online!

Meno golf:

param($a,$b)
if($a-is[int]){
    $length=$b|% Length
    $c=$length%$a
    $a,$b=$b,(($length-$c)/$a)  # recalc length and swap
}
$pattern="(..{$b})"*$c+"(.{0,$b})"*$a.Length
$parts=$a -split $pattern       # pattern like '(..{3})(..{3})(.{0,3})(.{0,3})(.{0,3})'
$parts -ne ''                   # output not empty parts