Motivação : Às vezes, certos itens de uma lista não contam para o seu total. Por exemplo, contando passageiros de avião em filas, onde os bebês sentam no colo dos pais.

Desafio : escreva um programa para dividir uma lista de itens em pedaços. Cada pedaço (exceto possivelmente o último) tem o mesmo tamanho , em que tamanho é definido como o número de itens que passam por uma função predicada.

Regras :

1. Seu programa deve levar
   • uma lista de itens
   • um tamanho de pedaço inteiro positivo
   • uma função predicada (pega um item e retorna verdadeiro ou falso)
2. Você deve retornar a lista de entrada dividida em partes
3. Cada pedaço é uma lista de itens
4. No geral, os itens devem permanecer na mesma ordem, sem nenhum descartado
5. O número de itens que passam o predicado em cada bloco (exceto possivelmente o último) deve corresponder ao tamanho do bloco de entrada.
6. itens com falha no predicado não devem contar para esse tamanho
7. Itens com falha no predicado são
   1. ainda incluído nos pedaços de saída
   2. alocado para o primeiro pedaço, no caso de um pedaço estar "cheio", mas os próximos itens falharem no predicado
      • portanto, o pedaço final pode não consistir apenas em itens que falham no predicado
8. O pedaço final pode ter tamanho menor que o tamanho do pedaço, porque todos os itens foram contabilizados.

Exemplos não exaustivos:

O exemplo mais simples é considerar 1s e 0s, onde está a função predicada x ==> x > 0. Nesse caso, o sumde cada pedaço deve corresponder ao tamanho do pedaço.

• itens :, []tamanho 2:, predicado: x > 0-> []ou[[]]
• itens :, [0, 0, 0, 0, 0, 0]tamanho 2:, predicado: x > 0->[[0, 0, 0, 0, 0, 0]]
• itens :, [0, 1, 1, 0]tamanho 2:, predicado: x > 0->[[0, 1, 1, 0]]
• itens :, [0, 1, 1, 0, 1, 0, 0]tamanho 2:, predicado: x > 0->[[0, 1, 1, 0], [1, 0, 0]]
• itens :, [0, 1, 0, 0, 1, 0, 1, 1, 0]tamanho 2:, predicado: x > 0->[[0, 1, 0, 0, 1, 0], [1, 1, 0]]

E vamos terminar com os passageiros do avião, onde os bebês se sentam no exemplo do colo dos pais . Apara adulto, bpara bebê, a fila do avião tem 3assentos largos, o adulto sempre é listado antes do bebê:

• itens :, [A, b, A, b, A, A, A, b, A, b, A, A, b]tamanho 3:, predicado: x => x == A->[[A, b, A, b, A], [A, A, b, A, b], [A, A, b]]

Gelatina , 10 bytes

vⱮTm⁵ḊœṖŒṘ

Um programa completo que toma a função de caixa preta monádica como o primeiro argumento opcional, a lista como o segundo argumento opcional e o tamanho do bloco como o terceiro argumento opcional que imprime uma representação em Python da lista de listas resultante (para evitar o esmagamento implícito de Jelly na lista). listas contendo caracteres).

Experimente online! (observe que uma lista de caracteres é passada para um programa Jelly formatando-o como uma string citada em Python)

Quão?

vⱮTm⁵ḊœṖŒṘ - Main Link: B, L, S
 Ɱ         - map across second argument with (i.e. for X in L):
v          -   evaluate as a monad with input (i.e. B(X))
  T        - truthy indices (e.g. [0,0,1,0,1,1,1,0,0,0,1,0,0]T -> [3,5,6,7,10])
    ⁵      - 3rd optional argument = S
   m       - modulo slice   (e.g. [3,4,7,9,12,15,16,18,19,20]m3 -> [[3,4,7],[9,12,15],[16,18,19],[20]]
     Ḋ     - dequeue        (e.g. [[3,4,7],[9,12,15],[16,18,19],[20]]Ḋ -> [[9,12,15],[16,18,19],[20]]
      œṖ   - partition right (L) at the indices in that
        ŒṘ - print Python representaion

Braquilog , 37 bytes

hW&t~c.k{↰₂ˢl}ᵐ;WxĖ∧.bhᵐ↰₂ᵐ∧.t↰₂ˢl≤W∧

Experimente online!

Fiquei agradavelmente surpreso ao descobrir que isso - praticamente uma reafirmação da pergunta - termina com êxito e produz saída correta.

Supõe que o predicado está presente como predicado 2 abaixo deste código. Produz uma lista de listas ("chunks") ou falsepara uma entrada vazia.

Explicação:

hW&               % First input is W, the expected "weight" of each chunk
                  %  (i.e. the number of items passing predicate in each chunk)

t                 % Take the second input, the list of items
 ~c.              % Output is a partition of this list
    k{    }ᵐ      % For each partition (chunk) except the last, 
      ↰₂ˢ         %   Select the items in the chunk that pass the predicate
         l        %   Get the length of that
                  % (So now we have the list of the "weights" of each chunk)
            ;Wx   % Remove the input expected weight from this list, and 
               Ė  %  the result of this should be empty.
                  %  This verifies that the list of weights is either 
                  %  composed of all W-values, or is empty (when input is [0 0 0] for eg.)

    ∧.bhᵐ↰₂ᵐ      % And, the first element of each chunk (except the first) should
                  %  pass the predicate. This is another way of saying:
                  %  "Items failing the predicate are allocated to the earliest chunk"

    ∧.t↰₂ˢl≤W     % And, the final chunk (which we haven't constrained so far)
                  %  should have weight ≤ the input expected weight
                  %  This disallows putting everything in the final chunk and calling it a day!

    ∧             % (no further constraints on output)

Apl (Dyalog Unicode) 17 16 bytes (SBCS)

Obrigado a Adám por me salvar 1 byte.

w⊆⍨⌈⎕÷⍨1⌈+\⎕¨w←⎕

Experimente online! para fins de explicação, deixarei a solução de 17 bytes.

{⍵⊆⍨⌈⍺÷⍨1⌈+\⍺⍺¨⍵}

⍺⍺¨⍵aplicar o predicado à lista que retorna um vetor booleano
+\gera um total em execução que
1⌈substitui 0s com 1s
⌈⍺÷⍨divide cada elemento pelo tamanho do pedaço e arredonda as
⍵⊆⍨partições do vetor original por este

Limpo , 96 92 bytes

Usa uma função nomeada f :: a -> Boolpermitida de acordo com o meta consenso.

import StdEnv,StdLib
$l n|l>[]=last[[i: $t n]\\i<-inits l&t<-tails l|n>=sum[1\\e<-i|f e]]=[]

Experimente online!

Expandido (com destaque padrão para que os comentários apareçam):

$ l n // define function $ on `l` and `n`
 | l > [] // if `l` is not the empty list
  = last [ // the last element of ...
                   \\ i <- inits l // prefixes of `l`
                    & t <- tails l // matching suffixes of `l`
                    | n >= // where n is greater than or equal to
                           sum [1 \\ e <- i | f e] // the number of matching elements in the prefix
          [i: $t n] // prepend that prefix to the application of $ to the rest of the list
         ]
 = [] // if `l` is empty, return empty

Java 10, 207 186 159 148 bytes

a->n->{var r=new java.util.Stack();int l=a.size(),i=0,c=0,j=0;for(;i<=l;i++)if(i==l||f(a.get(i))&&++c>n&i>0){r.add(a.subList(j,j=i));c=1;}return r;}

Definitivamente, Java não é a linguagem certa para esse desafio (ou qualquer desafio do codegolf, é claro ..)

-21 bytes graças a @OOBalance

Experimente online.

Explicação:

a->n->{                    // Method with List & int parameters & List of Lists return-type
  var r=new java.util.Stack();
                           //  Result-list, starting empty
  int l=a.size(),          //  Size of the input-List
      c=0,                 //  Count-integer, starting at 0
      j=0,                 //  Range-integer, starting at 0
  i=0;for(;i<=l;i++){      //  Loop `i` in the range [0, `l`]
    if(i==l||              //   If this is the last iteration
       f(a.get(i))         //   Or if the black-box function is true for the current item
       &&++c               //    Increase the counter by 1
        >n&                //    If the counter is now larger than the size
        &i>0){             //    and it's not the first item of the List
      a.subList(j,j=i);    //     Add a sub-List to the result from range [`j`, `i`)
                           //     And set `j` to `i` at the same time
      c=1;}                //     And reset `c` to 1
  return r;}               //  Return the List of Lists as result

Formato de entrada da caixa preta:

Supõe que uma função nomeada boolean f(Object i)esteja presente, o que é permitido de acordo com esta meta resposta .

Eu tenho uma classe abstrata Testcontendo a função padrão f(i), bem como a lambda acima:

abstract class Test{
  boolean f(Object i){
    return true;
  }

  public java.util.function.Function<java.util.List, java.util.function.Function<Integer, java.util.List<java.util.List>>> c =
    a->n->{var r=new java.util.Stack();int l=a.size(),i=0,c=0,j=0;for(;i<=l;i++)if(i==l||f(a.get(i))&&++c>n&i>0){r.add(a.subList(j,j=i));c=1;}return r;}
  ;
}

Para os casos de teste, substituo essa função f. Por exemplo, o último caso de teste é chamado assim:

System.out.println(new Test(){
  @Override
  boolean f(Object i){
    return (char)i == 'A';
  }
}.c.apply(new java.util.ArrayList(java.util.Arrays.asList('A', 'b', 'A', 'b', 'A', 'A', 'A', 'b', 'A', 'b', 'A', 'A', 'b'))).apply(3));

R , 58 bytes

function(v,g,n,a=(cumsum(Map(g,v))-1)%/%n)split(v,a*(a>0))

Experimente online!

• -5 bytes graças a @Giuseppe

C (gcc) , 70 66 bytes

Eu uso uma estrutura para observar o início de uma sub-lista, pois C não sabe sobre essas coisas.

Obrigado ao ceilingcat pelas sugestões.

t;f(a,s,c)l*a;int(*c)();{for(;a->v;a++)(t+=c(a->v))>s?t=++a->s:0;}

Experimente online!

Haskell, 72 bytes

p#s|let l@(h:t)!a|sum[1|e<-h:a,p e]>s=a:l![]|n<-a++[h]=t!n;_!a=[a]=(![])

Experimente online!

p#s     = (![])         -- main function that takes a predicate function 'p',
                        -- a size 's' and a input list without a name that is
                        -- directly passed as the first argument to function '!'
  let  l@(h:t)!a        -- function '!' is a local function (so that 'p' and 's'
                        -- are in scope). Takes a list 'l' of at least one element
                        -- 'h' (and 't' being the rest of the list) and an
                        -- accumulator 'a'
   |sum[1|e<-h:a,p e]>s -- if 'p' holds for more than 's' elements in 'h' and 'a'
     =a:l![]            --   put 'a' in front of a recursive call with the same list
                        --   'l' and an empty accumulator
   |n<-a++[h]           -- else bind 'n' to 'h' appended to 'a' and
     =t!n               --   call '!' again with 't' and 'n'
  _!a=[a]               -- base case for '!'. If the input list is empty, return
                        --   a singleton list with 'a' 

MATL, 19 bytes

HyX$Ysi/Xk1y>+!w7XQ

Baseado na excelente resposta APL do jslip .

O MATL realmente não possui funções definidas pelo usuário, mas possui uma maneira de chamar o ambiente em que está sendo executado (MATLAB / Octave), portanto, isso é usado para a função predicada. O uso seria algo parecido com isto , mas essa funcionalidade é desativada online por razões de segurança, então aqui está uma versão que usa uma isoddfunção de predicado codificada em vez disso: Experimente no MATL Online .

H    % Push the function name to be called, assumed to be 
     %  stored in the H clipboard
y    % Take the first input, push copies of it both below and above the 
     %  function name
X$   % Call the function (say 'isupper') with the input as argument
     %  returns a boolean vector
Ys   % Cumulative sum
i/   % Take the chunk size and divide each element by it
Xk   % ceil
1y>+ % Turn the (initial) 0s to 1s
!    % Transpose. Now we have a column vector specifying which chunk 
     %  each input element should go into
w    % Bring the other copy of the input on top 
7    % Code for this function: '@(x){x.'}'
     %  i.e. place each chunk in a row vector and enclose it in a cell
XQ   % 'accumarray' - split the input into chunks based on
     %   the given column vector, apply the given function to each chunk
     %   (which here just wraps it up as a cell), and accumulate the results
     %   in an array.
     % implicit output

JavaScript (ES6), 69 bytes

Guardado 3 bytes graças a @tsh

Recebe entrada na sintaxe de currying (size)(predicate)(array).

s=>p=>g=a=>a.every(x=>p(x)?k--:++j,j=k=s)?[a]:[a.splice(0,j),...g(a)]

Experimente online!

Ruby , 57 bytes

->a,n,g{c=-1;a.group_by{|x|[0,c+=g[x]?1:0].max/n}.values}

Experimente online!

Lambda anônima que aceita matriz de entrada a, tamanho de bloco ne predicado g. Mantém um contador cde itens que correspondem ao predicado e agrupa itens pelo número de pedaços já usados. Infelizmente, o valor inicial -1 / n não chega a 0, portanto, temos que gastar alguns bytes para corrigi-lo.

R , 100 bytes

function(L,K,P,s=sapply(L,P),y=cut(cumsum(s),seq(0,sum(s),K),,T))for(l in levels(y))cat(L[y==l],"
")

Experimente online!

superado por digEmAll

Python 2 , 92 bytes

lambda a,c,p:reduce(lambda r,v:[r[:-1]+[r[-1]+[v]],r+[[v]]][sum(map(p,r[-1]+[v]))>c],a,[[]])

Experimente online!

JavaScript (Node.js) , 90 bytes

(s,p,r=[l=[]],n=s+1)=>g=a=>0 in a?g(a,(n=(n||s)-p(v=a.shift()))||r.push(l=[]),l.push(v)):r

Experimente online!

Invocar como F(2, x => x > 0)([0, 1, 1, 0])

Mathematica, 82 bytes

f[l_,s_,p_]:=Last@Reap[i=t=-1;Do[If[p@e,If[++i~Mod~s==0&&i>0,t++]];e~Sow~t,{e,l}]]

Ungolfed:

f[l_,s_,p_] :=                (* define a function that takes three    *)
                              (* arguments                             *)

  Last@Reap[                  (* collect and return results which were *)
                              (* gathered by the procedural loop below *)

    i=t=-1;                   (* initialize two counters               *)

    Do[                       (* start iterating over the list         *)

      If[p@e,                 (* if element passes predicate           *)
        If[                   (* then if preincremented i is 0 modulo  *)
          ++i~Mod~s==0&&i>0,  (* chunk size and i > 0                  *)
          t++                 (* increment t                           *)
        ]
      ];e~Sow~t,              (* finally sow the element tagged with   *)
                              (* the current value of t                *)

    {e,l}]                    (* e references current element of list  *)
                              (* l is the list itself                  *)
  ]

lé a lista de entrada; sé o tamanho do pedaço; pé uma função sem nome / anônima / pura / lambda que retorna verdadeiro / falso operando nos elementos da lista.

Last@Reap[...]retorna uma lista de listas de todos os elementos que estavam Sow-n dentro de .... Eles são agrupados em sublistas cujo segundo argumento e~Sow~té uma abreviação Sow[e, t].

Eu tive que inicializar contadores para -1 para lidar com um tamanho de bloco de 1, caso contrário, eu precisaria verificar Mod[i, s]( i~Mod~s) igual a 1, o que nunca poderia acontecer.

O restante do código é explicado no bloco não destruído.