Tom, you could also try q(q>0)=1 instead of the /5 step (avoids having q(1) go to zero).

Here’s a one-liner solution that works ok for small problems:

>> find(round(ifft(fft([full(sparse(1,Points+1,1,1,max(Points)+1)),zeros(1,max(Points)*(N-1))]).^N))==0)-1

ans =

1 2 4 7 49 52 54 55

Your solution will fail for N>=10 because of this:

dec2base(10,11,4)

ans =

000A

We would like 000(10) but of course that is not possible.

for example:

Points = [0 3 5 8];

tic, lucios(10000,Points),toc

tic,matts(10000,Points),toc

Even for N = 100, the augmented solution is 20 times faster on my machine.
Anyway, interesting problem!

 

function nonScores4 = matts(N,Points)
% Assumes Points is sorted and has only unique values.  This is an
% extention of Lucio's solution.

a = false(max(Points),1);
a(nonzeros(Points)) = true;
t1 = [1 NaN];% These two are used in the augmented code below.
cnt = 1;%

for i = 1:N-1
    a(bsxfun(@plus,find(a),Points)) = true;
    t2 = t1;  %  Start augmented code.
    t1 = find(~a)'; % t1,t2 Successive vectors for successive #'s of q's.
    if ~isempty(t1) && ~isempty(t2) && numel(t1)==numel(t2) && t2(end)==(t1(end)-Points(end))
        cnt = cnt + 1;
        if cnt == 3
            vct = t1~=t2;
            t2(vct) = t2(vct) + (N-i)* Points(end);
            nonScores4 = t2;
            return % We can skip the rest of the iterations.
        end
    end  % End augmented code.
end

nonScores4 = find(~a)';

 

allAnswrs = …
arrayfun(@(x) double(dec2base(x,base, numAnswrs)) - charShft, …
(minNum : maxNum).’, ‘UniformOutput’, false);

with

allAnswrs = …
arrayfun(@(x) double(dec2base(x,base, numAnswrs)) - charShft, …
(minNum : numQuests : maxNum).’, ‘UniformOutput’, false);

numQuests = 7;
numAnswrs = 4;
Points = [0 3 5 8];

base = numQuests + 1;
minNum = numQuests;
maxNum = numQuests * base^(numAnswrs-1);
charShft = 48;

allAnswrs = …
arrayfun(@(x) double(dec2base(x,base, numAnswrs)) - charShft, …
(minNum : maxNum).’, ‘UniformOutput’, false);

indx = cellfun(@(x) sum(x) == numQuests, allAnswrs);

Feasible = unique(cat(1, allAnswrs{indx}) * Points(:));
notFeasible = setdiff(min(Points)*numQuests : max(Points)*numQuests, Feasible);

The key point of my solution is to use matrix exponentiation as the propagation algorithm, for this we need to start with an adjacency matrix. A non-zero entry in the (i,j) row-column indicates that the total cumulative score can change from (i-1) to (j-1) after considering the n-th question. Note that we need to make the score=index+1 because we need to have a score of zero also.

If you had the Bioinformatics Toolbox you could have propagated using “Breadth First Search”:

maxscorep1 = N*max(Points)+1;

A = toeplitz(sparse(1,1,1,1,maxscorep1),sparse(1,Points+1,1,1,maxscorep1));

setdiff(1:maxscorep1,graphtraverse(A,1,’Method’,'BFS’,'Depth’,N))-1
I used the TOEPLITZ function to create the required adjacency matrix. On purpose I used sparse indices, so the Toeplitz matrix is also sparse, as the particular adjacency matrix has many zeros, this allows to scale up the problem. A full matrix would have looked:

A = toeplitz([1;zeros(maxscorep1-1,1)],[1 0 0 1 0 1 0 0 1 zeros(1,maxscorep1-9)])
I need to admit that the solution with CONV previously posted is very elegant, perhaps it is possible to express a convolution in terms of a toeplitz matrix.
Lucio

–DA

function Feasible = feasibleTestScores(scores,problemscores,nprobs)
% uses recursive methodology to identify which test scores are achievable
%
% scores - a list of scores to test for feasibility.
%          All elements of scores must be non-negative integers
%
% problemscores - the possible (all integers) scores for each
%          problem in the test.
%
% nprobs - the number of problems in the overall test
%
% Feasible = logical vector, true where a score was feasible

scoresize = size(scores);
scores = scores(:);

problemscores = sort(problemscores(:),1,'descend');

% maximum possible score to worry about
maxscore = max(scores);

if maxscore<min(problemscores)
  Feasible = false(scoresize);
  return
elseif (maxscore == 0) && ismember(problemscores,0)
  Feasible = true(scoresize);
  return
elseif ((nprobs*problemscores(1)) < min(scores))
  Feasible = false(scoresize);
  return
elseif (nprobs==0)
  Feasible = true(scores==0);
  return
end

% check each potential number of scores for
% the largest (first element of) problemscores.
% Note that we don't need to worry about
% problemscores(1) being zero here.
n = min(nprobs,floor(maxscore/problemscores(1)));
Feasible = false(size(scores));
for i = 0:n
  Feasible = Feasible | ((i*problemscores(1)) == scores);
  k = ((i*problemscores(1)) < scores);
  if any(k)
    Feasible(k) = Feasible(k) | feasibleTestScores( ...
      scores(k)-i*problemscores(1),problemscores(2:end), ...
      nprobs-i);
  end
end
Feasible = reshape(Feasible,scoresize);

Test it out:

s = 0:20;
b = feasibleTestScores(s,[0 3 5 10],2);s(b)
ans =
     0     3     5     6     8    10    13    15    20

Thus, for only two problems, we can achieve 9 of the potential scores 0:20.

What happens when we have a test with 50 problems? Do you want to generate a grid with 4^50 elements in it? NO!!! How long does the recursive solution take?

tic,b = feasibleTestScores(0:500,[0 3 5 10],50);toc
Elapsed time is 1.282112 seconds.

Of the potential scores tested, how many were possible?

sum(b)
ans =
   485

result = {};
for N = 100:100:1000
  tic;
  p = [];
  p([0 5 11 17 23 29] + 1) = 1;
  q = 1;
  for k=1:N
    q = conv(p,q)/5;
  end;
  result{end+1} = find(~q) - 1;
  toc;
end
Elapsed time is 0.042640 seconds.
Elapsed time is 0.157314 seconds.
Elapsed time is 0.292813 seconds.
Elapsed time is 0.500169 seconds.
Elapsed time is 0.852585 seconds.
Elapsed time is 1.383100 seconds.
Elapsed time is 2.101764 seconds.
Elapsed time is 2.867327 seconds.
Elapsed time is 3.846593 seconds.
Elapsed time is 4.823939 seconds.

Let k1 = score for choice 1, k2 = score for choice 2, etc, and a1 = # of times choice 1 was chosen, a2 = # of times choice 2 was chosen, etc.

 Essentially, we want to all possible values of
   k1*a1 + k2*a2 + k3*a3 + k4*a4
 that satisfy the constraint
    a1 + a2 + a3 + a4 = N

The constraint can be enumerated and evaluated using NDGRID, as in Walter’s solution. Note that the NDGRID output has dimension K (the # of choices per question) rather than N (the number of questions).

% setup
Points = [0 3 5 8];
K = numel(Points);
N = 7;
% solve
[A{1:K}] = ndgrid(0:N);
combinations = cell2mat(cellfun(@(x)x(:),A,'unif',false));
indices = find(sum(combinations,2) == N);
possibleSums = unique(combinations(indices,:) * Points');
maximumValue = max(Points)*N;
setdiff(0:maximumValue,possibleSums)

Answers for various N:

N=7
     1     2     4     7    49    52    54    55
N=15
     1     2     4     7   113   116   118   119
N=30
     1     2     4     7   233   236   238   239
N=40
     1     2     4     7   313   316   318   319

I got out-of-memory errors for N=60. It would be interesting to see where the various algorithms break down. With Lucio’s second solution, I went up to N=100 without much of a problem, and I could probably go much higher.