O desafio

Neste desafio, você deve executar duas tarefas diferentes (mas relacionadas), dependendo da ordem da entrada.
Seu programa receberá uma string se um número inteiro ncomo entrada e

• divida sem pedaços de comprimento nse svier primeiro. O último elemento será mais curto, se necessário.
• separe sem npedaços de igual comprimento se nvier primeiro. Se len(s)não for um múltiplo dos nprimeiros len(s) mod nelementos, será um mais longo.

Você pode pegar apenas essas 2 entradas. snunca conterá apenas dígitos.

Notas

• Você pode usar o mapeamento reverso. Observe isso na sua resposta se você fizer isso.
• sconterá apenas caracteres ASCII imprimíveis (sem novas linhas).
• Você não pode usar nenhum componente interno que resolva essas duas tarefas diretamente. Todos os outros builtins são permitidos.
• Você precisa usar os dois argumentos da mesma fonte.
• Você pode levar os argumentos em uma lista ordenada ou em qualquer outro formato que indique claramente a ordem deles, desde que não seja ambígua.
• Você pode pegar a entrada como uma sequência / fluxo e usar um caractere que não é válido (como um nulo) para separá-los.
• nsempre será igual ou menor que o comprimento se maior que zero.
• Você pode produzir a lista resultante em qualquer formato razoável, desde que indique claramente as partes específicas e sua ordem.

Exemplo

Entrada: programming, 3
O último elemento contém apenas 2 caracteres, porque 11 não é divisível por 3.
Saída: ["pro", "gra", "mmi", "ng"]

A entrada: 3, programming
11 não é um múltiplo de 3; portanto, os 2 primeiros elementos serão um mais longo:
Saída: ["prog", "ramm", "ing"]

Regras

• Função ou programa completo permitido.
• Regras padrão para entrada / saída.
• Aplicam-se brechas padrão .
• Isso é código-golfe , e a menor contagem de bytes vence. O desempatador é uma inscrição anterior.

Casos de teste

Os casos de teste foram gerados com este programa Pyth (usa builtins, portanto, nenhuma resposta válida). Obrigado a @FryAmTheEggman por fornecer a versão base disso!

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

Feliz codificação!

MATL, 46 26 21 27 29 42 bytes

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

Experimente Online! (Atualizado ligeiramente para funcionar com a versão mais recente do idioma)

Explicação

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)

Provavelmente isso é irremediavelmente superprojetado.

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

Chame-o como (...)("programming")(3)usar o 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]}

E eu tomo o primeiro lugar por 2 bytes ...

AWK, 121 130 128 122 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

O único problema é se a primeira entrada é uma sequência que começa com um valor numérico. Isso causaria AWKver a string como esse número e a segunda entrada como a string.

OK ... corrigiu o problema numérico, mas adicionou 9 bytes :(.

Retrabalhado um pouco para salvar alguns bytes.

Quase de volta ao comprimento 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

Exemplo de uso:

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

Como funciona: o trabalho principal é realizado pela função auxiliar, qque recebe um par de números (d,m)e uma string s. Primeiro, ele cria uma lista de mtempos, d+1seguida por muitos infinitos d(por exemplo, (1,3)-> [2,2,2,1,1,1,1,1,...]). Em seguida, ele é splitPlacesdividido sem pedaços de tamanhos fornecidos pela lista. splitPlacespara se sficar sem elementos, então uma lista infinita é boa.

A função principal #verifica qual parâmetro é o número n/ string stre chama qcom um (div (length str) n, mod (length str) n)ou (n, 0)mais 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();

A parte de leitura de entrada ocupou um pouco de espaço. Vencedor da resposta mais longa.

Uso # 1:

$ 3, helloworld

>> hell, owo, rld

Uso # 2:

$ helloworld, 3

>>hel, low, orl, d

Pitão, 181 bytes

Vamos fingir que o código mais longo em bytes ganha \ 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

Experimente aqui! (O intérprete online parece ter um erro, exibe a entrada enquanto não deveria)

Aqui está a saída do terminal:

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

Sério, estou aberto a uma nova abordagem. Eu sou novo em python, então provavelmente perdi alguns atalhos.

Quero dizer, acho que minha resposta é desesperadora, pois é mais longa que a resposta em 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),"
";

• A sequência não deve começar com dígitos.
  (Substitua +@$ppor is_numeric($p)para corrigir.)
• A saída não deve conter um pedaço "0".
  (Insira ~para ASCII imprimível, a&para qualquer ASCII antes $t;de corrigir.)
• Corra com -nrou experimente online .

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

Experimente online!

Menos golfe:

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