Problem with huge list

[ben robinson]

if i understand correctly, your list object should really only need four
rows:
one row for a trial that presents two digits, neither of which is the probe
one for a trial that presents two digits, one of which is the probe
and one each for valid and invalid 6 digit trials.
then you just need to nest a list or two into this main list...
maybe have one nested list with all the possible number combinations for a 6
digit trial, and one with the possibilities for a 2 digit trial.  obviously,
the nested list with the 6 digit possibilities only needs to be nested on
the two rows from which you're calling 6 digit trials, and the nested list
of 2 digit possibilities only needs to be nested on the rows which are
calling your 2 digit trials.  set those nested lists to random w/o
replacement, and set the weights on your 4 trial types within your main list
such that you are sure to sample all the trial types from the nested lists.
does that make sense?

ben

On Thu, Mar 6, 2008 at 8:14 AM, Nikos Konstantinou <nkonstantinou at gmail.com>
wrote:

> Dear E-prime group,
>
> I 'd appreciate any help on this issue:
>
> I created an experiment which has two tasks. Task 1: participants hear
> over the headphones either two or six digits which they have to remember
> until the end of the trial. At the end of the trial, they see a single probe
> digit (visual this time) on the screen, which matches one of digits they
> heard at the beggining of the trial 50% of the times.
>
> One way of doing it is something like this:
>
> Weight   Digit1    Digit2    Digit3    Digit4    Digit5    Digit6
> ProbeDigit
> 1
> [Digit:0] [Digit:1] [Digit:2] [Digit:3] [Digit:4] [Digit:5] [ProbeDigit:0]
> 1
> [Digit:0] [Digit:1] [Digit:2] [Digit:3] [Digit:4] [Digit:5] [ProbeDigit:1]
> 1
> [Digit:0] [Digit:1] [Digit:2] [Digit:3] [Digit:4] [Digit:5] [ProbeDigit:2]
> 1
> [Digit:0] [Digit:1] [Digit:2] [Digit:3] [Digit:4] [Digit:5] [ProbeDigit:3]
> 1
> [Digit:0] [Digit:1] [Digit:2] [Digit:3] [Digit:4] [Digit:5] [ProbeDigit:4]
> 1
> [Digit:0] [Digit:1] [Digit:2] [Digit:3] [Digit:4] [Digit:5] [ProbeDigit:5]
> 6
> [Digit:0] [Digit:1] [Digit:2] [Digit:3] [Digit:4] [Digit:5] [ProbeDigit:6]
>
> A problem with this solution is that it results in a huge list of rows,
> one for every possible compination.
> Although the experiment is working this way, I believe there is an easier
> and "smarter" way of doing this. Maybe using and InLine?
>
> Anybody can help?
> Thanks in advance,
>
> Nikos
>
> >
>

--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups "E-Prime" group.
To post to this group, send email to e-prime at googlegroups.com
To unsubscribe from this group, send email to e-prime-unsubscribe at googlegroups.com
For more options, visit this group at http://groups.google.com/group/e-prime?hl=en
-~----------~----~----~----~------~----~------~--~---

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://listserv.linguistlist.org/pipermail/eprime/attachments/20080306/737ecea6/attachment.htm>