Make a rand with digits and do not allow ‘echo’ with repeated results up to 7 di

Always happy to help 🙂
No worries about PHP5, I can never remember the configurations of the servers I access. What’s important is the problem is solved! I imagine having access to Apache can be useful. You might consider upgrading the PHP there 😉

What’s odd about WP Cron is it’s not a true Cron Job implementation. It is dependent on visitation to WP to work (people, bots, hackers, any WP requests) Thus, depending traffic levels, the job may not execute on time. On low traffic sites, or if you need better time accuracy, a true Cron Job may need to be added, meaning you would need WP-CLI. Some people have setup a monitoring service like uptimerobot.com to ensure regular visitation instead of adding a Cron Job.

I’ll be watching for your next topic 🙂

If I understand correctly, it is not as easy as you think. I believe you are looking for the largest sequence of numbers that repeat at least once in an array of sequence arrays. It’s certainly something suited for computer processing. Analysis by eye is fraught with potential errors.

First let’s be sure we are using the right terminology. It’s not possible to have repeating keys in the same array. Do you mean repeating values? Or repeating keys in other arrays? Example indexed array print_r() output:

Array
(
    [0] => value for key/index 0
    [1] => value for key/index 1
    [2] => value for key/index 2
)

And for associative arrays:

Array
(
   [key-0] => value for key-0
   [key-1] => value for key-1
   [key-2] => value for key-2
)

Values in the same array may repeat, keys or indexes cannot.

Finding repeating single elements can simply be done with in_array(). Repeating keys from different arrays is similarly easy with array_keys(). Neither really helps us since we are concerned with sequences, not single values.

The process of identifying repeating elements is remarkably similar to the .zip compression algorithm (and likely others, I’m only familiar with .zip, or more generically the Lempel–Ziv lossless compression) A stream of data is examined for repeating elements, beginning with repeating pairs. Each pair found is assigned a token to represent it. The process is repeated for 3 values, then 4, etc. In some cases a repeating sequence could be comprised of new data and previously determined tokens.

It may occur there are repeating elements that are very long, which is replaced by a single token. The resulting compressed token stream is typically much shorter than the original data. They way the data is organized makes decompression a virtual reversal of the process.

Of course we do not need to keep track of smaller tokens, nor what they represent, nor the need to work in reverse, so the process is significantly simpler.

I’m unsure if it’s better to use array_slice() to find sequences or to implode arrays in order to use preg_match() or strpos() to locate matches. Since arrays can be evaluated for equivalence just like strings can, I’m inclined to use array_slice(). This is a valid equivalence and evaluates to true: array(1,2,3) == array(1,2,3)

The basic approach would be to take array slices out of the main data where slice length is anywhere from 2 to the maximum sub-array length. For each array slice, search through the main data looking for a match. For each match, record the slice length. After going through every possible array slice of every possible length, go through the recorded lengths to find the largest count.

This does not tell us what the longest sequence is, only that at least two of that length exist somewhere in the main data. That need can be accommodated, but first lets look at possible shortcuts because going through every possible array is going to be very time consuming.

I think the best shortcut is to work backwards from the longest possible array slice. As soon as any match is found, we know that is the longest, because we were already unable to find any longer matches. We also know what that sequence is since we just matched it. It does not tell us if there are any other matches of the same length or if there is more than one match to the sequence. There could be 5 sequences matching, we only found the first one encountered.

Of course we could complete the search at the current length to find more matches of the same length if need be. At least we still do not need to search for shorter sequences. We must also ensure we do not try to slice an array farther along than $maximum – $length, or else the slice will be incomplete. I’m not seeing any other shortcuts right now.

Because finite sizes are easier to think about than variables, I’m going to start by defining our main data as an array of 9 sub-arrays (indexed 0-8), each sub-array has a sequence of 19 numbers, indexed 0-18. This is assigned to $haystack. You can convert the finite sizes to variable sizes easily enough. The metaphor is searching for needles in a haystack. I think the basic algorithm would be like this (in pseudocode):

$needles = $haystack // the needles and haystack are the same. Different names for less confusion
set $flag to true    //a match will change it to false
while $flag is true {
  for $size = 19 to 2 { // length of needle and haystack sub-part

    // get all possible needles
    for $sub = 0 to 8 {
      $source = $needles[$sub]  //slice within each sub-array
      for $start = 0 to 19-$size {
        $needle = array slice $source at $start where length is $size

        // get all possible haystack sub-parts to compare with needle
        for $sub2 = 0 to 8 {
          $haypart = $haystack[$sub2] //check within each sub-array
          for $start2 = 0 to 19-$size {
            // do not compare $needle and $subpart when they are from the same source
            if ($sub == $sub2 && $start == $start2) skip the rest of this iteration and continue with next
            $subpart = array slice $haypart at $start2 where length is $size

            if ($needle == $subpart) then {

              // a match was found!
              set $flag to false
              output: A sequence of $size numbers has at least one duplicate
              print_r: [{implode ', ', $needle}] 
              break 5 //stop processing and break out of all loops 
            }
          }
        }
      }
    }
  }
}

The loop counters may need adjustment. The first pass through when $size == 19 is just supposed to compare each sub-array against all the rest, so each loop would run only once. Using pseudo code numbers, the first pass has loops doing from 0 to 0, which I think means nothing is run, but 0 to 1 is two passes, also incorrect. But in PHP we would have for ($n=0; $n<=0; $n++) which should give us one pass, so maybe it’s OK.

When $size == 18, each sub-array offers two possible slices. When 17, 3 slices, etc. This is all completely untested. You should do some careful checking at various points in the code to be sure the algorithm is working as it should be. I presented the algorithm as pseudocode because you should be able to work out for yourself proper coding syntax based on conversational phrases.