Visualizzare i valori della tabella verticalmente mantenendo la struttura della tabella

Question

State verificando altri modi utilizzati per ordinare i valori dell'array verticalmente per l'utilizzo in una tabella ma la maggior parte di essi equivaleva a rovesciare la tabella di 90 gradi a destra. Ho cercato di pensare a un modo per implementarlo correttamente, ma penso di aver bisogno di aiuto.

Ad esempio, la tabella (ordine orizzontale):

a b c d e 
f g h i j 
k l m n o 
p q r 

Is riordinate a (ordine verticale):

a e i m p 
b f j n q 
c g k o r 
d h l 

Come si può vedere la struttura è trattenuto dal 2 ultime cellule sono vuoto.

non come questo:

a e i m q 
b f j n r 
c g k o 
d h l p 

In questo esempio, la tabella è simile a lanciare lateralmente. Qualcuno sa come farlo correttamente?

Answer 1

MODIFICATO: Questo è più difficile di quanto pensassi e l'ho incasinato la prima volta (o due). Dovrebbe funzionare ora.

Diciamo che avete la vostra struttura della tabella memorizzati in una matrice bidimensionale:

$data = array(
    array('a', 'b', 'c', 'd', 'e'), 
    array('f', 'g', 'h', 'i', 'j'), 
    array('k', 'l', 'm', 'n', 'o'), 
    array('p', 'q', 'r') 
); 

Dal momento che si desidera mantenere la stessa "forma" è necessario determinare le dimensioni del tavolo. Per fare ciò possiamo prendere lo count della prima riga, poiché sappiamo che la prima riga deve essere la larghezza massima della tabella. L'altezza è solo il numero di elementi nella matrice.

Abbiamo anche bisogno del numero totale di elementi, ma possiamo sopravvalutare prendendo $ larghezza * $ altezza.

$total = $width * $height; // 20 

Quindi è davvero solo un po 'di matematica calcolare dove vanno le cose. Dobbiamo utilizzare un contatore separato per gli indici vecchi e nuovi perché dovremo incrementarli in modo diverso una volta che iniziamo ad avere buchi.

$new_data = array(); 
$j = 0; 
for($i = 0; $i < $total; $i++) { 
    $old_x = floor($i/$width); // integer division 
    $old_y = $i % $width;  // modulo 

    do { 
    $new_x = $j % $height;  // modulo 
    $new_y = floor($j/$height); // integer division 
    $j++; 
    // move on to the next position if we have reached an index that isn't available in the old data structure 
    } while (!isset($data[$new_x][$new_y]) && $j < $total); 

    if (!isset($new_data[$new_x])) { 
    $new_data[$new_x] = array(); 
    } 
    if (isset($data[$old_x][$old_y])) { 
    $new_data[$new_x][$new_y] = $data[$old_x][$old_y]; 
    } 
} 

Answer 2

Il trucco è quello di sottrarre uno per i "appeso" colonne. Quelle sono le colonne che hanno un valore mancante nell'ultima riga.

// setup some initial test data... rip this out and replace with whatever 
$values = array(); 
for ($x = 0; $x < 18; ++$x) 
    $values[] = chr($x + ord("a")); 

Possiamo modificare arbitrariamente il numero di colonne. Il numero di righe è determinato dalla dimensione dei nostri dati divisa per il numero di colonne che utilizziamo.

// change # of columns to desired value 
$columns = 5; 
$rows = (int) ceil(count($values)/$columns); 

Alcune colonne sono bloccate. Questa è la colonna manca un valore nell'ultima riga.

// the number of columns that will "hang" or miss a value in the last row 
$hanging_columns = $columns * $rows - count($values); 

$counter = 0; 
for ($y = 0; $y < $rows; ++$y) { 
    for ($x = 0; $x < $columns; ++$x) { 
    // if we've displayed all values, stop 
    if ($counter++ >= count($values)) break; 

    // calculate the correct index to display 
    $index = ($y + $x * $rows); 
    // if we are in a hanging column, we need to back up by one 
    if ($x > $columns - $hanging_columns) $index -= 1; 

    // display the value 
    echo $values[$index] . " "; 
    } 
    echo "\n"; 
} 

Answer 3

Ecco un'altra soluzione

$unflipped = array('a', 'b', 'c', 'd', 'e', 
       'f', 'g', 'h', 'i', 'j', 
       'k', 'l', 'm', 'n'); 


function flip90($arr, $lineHeight) 
{ 
    $tbl = array(); 

    $index = 0; 
    $counter = 1; 


    for($i = 0; $i < count($arr); $i++) 
    { 
     if($counter > $lineHeight) 
     { 
      $index++; 
      $counter = 1; 
     } 

     if($counter <= $lineHeight) 
     { 
      $tbl[$index][$counter] = $arr[$i]; 

      $counter++; 
     } 

    } 

    return $tbl; 
} 

$flipped = flip90($unflipped, 5); 
echo "<pre>"; 
var_dump($flipped); 
echo "<pre>"; 

La funzione ha bisogno della matrice e l'altezza della linea per il dimensionamento vostra tavola