El reto

En este desafío, debe realizar dos tareas diferentes (pero relacionadas) dependiendo del orden de la entrada.
Su programa recibirá una cadena sy un número entero ncomo entrada y

• dividir sen pedazos de longitud nsi sviene primero. El último elemento será más corto si es necesario.
• dividir sen npedazos de igual longitud si nviene primero. Si len(s)no es un múltiplo de nlos primeros len(s) mod nelementos será uno más largo.

Solo puede tomar esas 2 entradas. snunca contendrá solo dígitos.

Notas

• Puede usar el mapeo inverso. Tenga esto en cuenta en su respuesta si lo hace.
• ssolo contendrá caracteres ASCII imprimibles (sin líneas nuevas).
• No puede utilizar ningún componente incorporado que resuelva esas dos tareas directamente. Todas las demás construcciones están permitidas.
• Tienes que tomar ambos argumentos de la misma fuente.
• Puede tomar los argumentos en una lista ordenada o en cualquier otro formato que indique claramente su orden siempre que no sea ambiguo.
• Puede tomar la entrada como una cadena / secuencia y usar un carácter que no sea una entrada válida (como un nulobyte) para separarlos.
• nsiempre será igual o menor que la longitud sy mayor que cero.
• Puede generar la lista resultante en cualquier formato razonable siempre que indique claramente las piezas particulares y su orden.

Ejemplo

Entrada: programming, 3
el último elemento contiene solo 2 caracteres, porque 11 no es divisible por 3.
Salida: ["pro", "gra", "mmi", "ng"]

Entrada: 3, programming
11 no es múltiplo de 3, por lo que los 2 primeros elementos serán uno más largo:
Salida: ["prog", "ramm", "ing"]

Reglas

• Función o programa completo permitido.
• Reglas predeterminadas para entrada / salida.
• Se aplican lagunas estándar .
• Este es el código de golf , por lo que gana el conteo de bytes más bajo. Tiebreaker es una presentación anterior.

Casos de prueba

Los casos de prueba se generaron con este programa Pyth (usa incorporados, por lo que no hay una respuesta válida). ¡Gracias a @FryAmTheEggman por proporcionar la versión base de eso!

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

¡Feliz codificación!

MATL, 46 26 21 27 29 42 bytes

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

Pruébalo en línea! (Actualizado ligeramente para trabajar con la última versión del idioma)

Explicación

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 bytes

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

Probablemente esto esté irremediablemente sobre-diseñado.

JavaScript (Firefox), 88 87 bytes

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

Llámalo como (...)("programming")(3)usando Firefox 30+.

Ruby, 119 bytes

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

Y tomo el primer lugar por 2 bytes ...

AWK, 121 130 128 122 Bytes

$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

El único problema es si la primera entrada es una cadena que comienza con un valor numérico. Esto provocaría AWKver la cadena como ese número y la segunda entrada como la cadena.

OK ... solucionó el problema numérico, pero agregó 9 bytes :(.

Se modificó un poco para guardar un par de bytes.

Casi de vuelta a la longitud original. :)

Haskell, 131 bytes

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

Ejemplo de uso:

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

Cómo funciona: el trabajo principal lo realiza la función auxiliar qque toma un par de números (d,m)y una cadena s. Primero construye una lista de mveces d+1seguida de infinitas d(ej. (1,3)-> [2,2,2,1,1,1,1,1,...]). Luego se usa splitPlacespara dividirse sen trozos de longitudes dados por la lista. splitPlacesse detiene si se squedan sin elementos, por lo que una lista infinita está bien.

La función principal #verifica qué parámetro es el número n/ cadena stry llama qcon uno (div (length str) n, mod (length str) n)o (n, 0)más str.

C # (LINQPAD) - 335 bytes

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 de lectura de entrada tomó un poco de espacio. Ganador de la respuesta más larga.

Uso # 1:

$ 3, helloworld

>> hell, owo, rld

Uso # 2:

$ helloworld, 3

>>hel, low, orl, d

Pyth, 181 bytes

Supongamos que el código más largo en bytes gana \ o /

DyGK@G0J:@G1"."1=YJV%lJKW<[email protected]=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

Pruébalo aquí! (El intérprete en línea parece tener un error, muestra la entrada mientras no debería)

Aquí está la salida del terminal:

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

En serio, estoy abierto a un nuevo enfoque. Soy nuevo en Python, así que probablemente me perdí algunas manos cortas.

Quiero decir, creo que mi respuesta es independiente desde el punto en que es más larga que la respuesta de JavaScript ...

PHP, 114 bytes

[$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 cadena no debe comenzar con dígitos.
  (Reemplace +@$pcon is_numeric($p)para arreglar).
• La salida no debe contener un fragmento "0".
  (Inserte ~para ASCII imprimible, a&para cualquier ASCII antes $t;de arreglarlo).
• Ejecutar -nro probarlo en línea .

PowerShell , 122 118 bytes

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''

Pruébalo en línea!

Menos golfizado:

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