Problem with huge list

[James Keidel]

hi NIkos

yes, indeed there should be an easier way to do this with an inline.
to get you started, basically your list only needs one row I think,
with attributes in place of values as you have in your email.

you then have a script which creates an array of integers, 0-9.  you
then call RandomizeArray and take the first 5 entries from the
randomized version.  half the time you set the probe digit to one of
the digits from the first five, the other half you take the 6th entry
in the randomized array and make that the probe.  One drawback here is
that there is no guarantee you won't have a duplicate trial in there,
but if that is a concern you can generate all the trials before
starting then run through them in a script to ensure there are no
duplicates.  I think it is extremely unlikely this would happen
though.

hope this helps you get started; feel free to email me if you get stuck at all.

best

JK

On Thu, Mar 6, 2008 at 1:14 PM, 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
-~----------~----~----~----~------~----~------~--~---