arrayKeys68.php

Напишите функцию PHP для фильтрации многомерного массива. Функция вернет те элементы, которые будут соответствовать указанному значению
<?php
    function array_filter_by_value($my_array, $index, $value)
    { 
        if(is_array($my_array) && count($my_array)>0)  
        { 
            foreach(array_keys($my_array) as $key){ 
                $temp[$key] = $my_array[$key][$index]; 
                 
                if ($temp[$key] == $value){ 
                    $new_array[$key] = $my_array[$key]; 
                } 
            } 
          } 
      return $new_array; 
    } 
$colors = array( 
   0 => array('key1' => 'Red', 'key2' => 'Green', 'key3' => 'Black'), 
   1 => array('key1' => 'Yellow', 'key2' => 'White', 'key3' => 'Pink') 
); 
$results = array_filter_by_value($colors, 'key2', 'White');     
print_r($results);      
?>

//Напишите PHP функцию для удаления указанной двойной записи из массива
<?php
function array_uniq($my_array, $value) 
{ 
    $count = 0; 
    
    foreach($my_array as $array_key => $array_value) 
    { 
        if ( ($count > 0) && ($array_value == $value) ) 
        { 
            unset($my_array[$array_key]); 
        } 
        
        if ($array_value == $value) $count++; 
    } 
    
    return array_filter($my_array); 
} 
$numbers = array(4, 5, 6, 7, 4, 7, 8);
print_r(array_uniq($numbers, 7));
?>

//Напишите функцию PHP, которая умножает два многомерных массива. 
<?php

// FUNCTIONS

function mul($x, $y){
    return ($x * $y);
}

// Example Arrays

$array_1 = array(array(1,4,7), array(2,5,8), array(3,6,9));
$array_2 = array(array(7,6,4), array(5,8,1), array(4,3,2));

// Check for row/column equivalence

$array_1_cols = count($array_1);
$array_1_rows = count($array_1[0]);
$array_2_cols = count($array_2);
$array_2_rows = count($array_2[0]);

// Check to see if matrix multiplication is possible

if($array_1_cols == $array_2_rows) {

$m_cols = $array_2_cols;
$m_rows = $array_1_rows;

$array_3 = array();
$col_index = 1;

// Start loop for each column of the new matrix

while($col_index <= $m_cols) {
$m_col_index = $col_index - 1;
$sub_array[$col_index] = array();

// Start loop for each row of the new matrix

$row_index = 1;
while($row_index <= $m_rows) {
$m_row_index = $row_index - 1;

// Auxiliary array for each row of A
$a_row[$row_index] = array();

$a_index = 1;
while($a_index <= $array_1_cols) {
$start_p = $a_index - 1;
$el_part_[$a_index] = $array_1[$start_p];
$el_part_[$a_index] = $el_part_[$a_index][$m_row_index];
array_push($a_row[$row_index], $el_part_[$a_index]);
++$a_index;
}

// Array for columns of B

$b_col[$col_index] = $array_2[$m_col_index];

// Build matrix C - defined over the rows of A and the columns of B

$c_part[$row_index][$col_index] = array_map('mul', $a_row[$row_index], $b_col[$col_index]);

$c_el[$row_index][$col_index] = array_sum($c_part[$row_index][$col_index]);

array_push($sub_array[$col_index], $c_el[$row_index][$col_index]);

// End row loop

++$row_index;
}

array_push($array_3,$sub_array[$col_index]);

++$col_index;
}

echo "<pre>"; print_r($array_3); echo "</pre>";

} else {

echo "This is not possible!";

}


?>

//Напишите программу PHP для определения адресов электронной почты, которые не являются уникальными
<?php
function array_not_unique($my_array) {
    $same = array();
    natcasesort($my_array);
    reset ($my_array);
    $old_key    = NULL;
    $old_value    = NULL;
    foreach ($my_array as $key => $value) {
        if ($value === NULL) { continue; }
        if ($old_value == $value) {
            $same[$old_key]    = $old_value;
            $same[$key]        = $value;
        }
        $old_value    = $value;
        $old_key    = $key;
    }
return $same;
}
$test_array = array();
$test_array[1]    ='xyz@example.com';
$test_array[2]    ='dse@example.com';
$test_array[3]    ='xyz@example.com';
$test_array[4]    ='mno@example.com';
print_r(array_not_unique($test_array));
?>

//Напишите функцию PHP, чтобы найти уникальные значения из многомерных массивов и сгладить их на нулевой глубине
<?php
function array_flat($my_array) 
    { 
         $fa = array();
		 $l = 0;
        foreach($my_array as $k => $v ) 
        { 
            if( !is_array( $v ) ) 
            { 
               $fa[ ]= $v; 
                
                continue;           
            } 
             $l++; 
            $fa= array_flat( $v, $fa, $l ); 
            $l--; 
      } 
       
        if( $l == 0 ) $fa = array_values( array_unique( $fa ) );         
        return $fa;       
    } 
$tmp = array( 'a' => array( -1,-2, 0, 2, 3 ), 'b' => array( 'c' => array( -1, 0, 2, 0, 3 ) ) ); 
print_r(array_flat($tmp));
?>

//Напишите PHP-скрипт для объединения двух разделенных запятыми списков только с уникальным значением
<?php
$list1 ="4, 5, 6, 7";
  $list2 ="4, 5, 7, 8";
  // combine both lists with unique values only
  $result = implode("," , array_unique(array_merge(explode(",",$list1),explode(",", $list2))));
  echo $result."\n";
?>

//Напишите PHP-скрипт для объединения (используя один массив для ключей и другой для его значений) следующих двух массивов. ('x', 'y', 'y'), (10, 20, 30)
<?php
function combine_Array($keys, $values)
{
    $result = array();
    foreach ($keys as $i => $k) {
        $result[$k][] = $values[$i];
    }
    array_walk($result, create_function('$v', '$v = (count($v) == 1)? array_pop($v): $v;'));
    return    $result;
}
$array1 = array('x', 'y', 'y');
$array2 = array(10, 20, 30);
print_r(combine_Array($array1, $array2));
?>

//Напишите программу PHP для удаления повторяющихся значений из массива, который содержит только строки или только целые числа
<?php
$colors = array( 
  0 => 'Red', 
  1 => 'Green', 
  2 => 'White', 
  3 => 'Black', 
  4 => 'Red', 
); 
$numbers = array( 
  0 => 100, 
  1 => 200, 
  2 => 100, 
  3 => -10, 
  4 => -10, 
  5 => 0, 
); 
$uniq_colors = array_keys(array_flip($colors)); 
$uniq_numbers = array_keys(array_flip($numbers)); 
print_r($uniq_colors);
print_r($uniq_numbers);
?>

//Напишите функцию PHP, чтобы получить массив с первым ключом и значением
<?php
function array_1st_element($my_array)
{
  list($k) = array_keys($my_array);
  $result  = array($k=>$my_array[$k]);
  unset($my_array[$k]);
  return $result;
}
$colors = array('c1'=>'Red','c2'=>'Green','c3'=>'Black');
print_r(array_1st_element($colors));
?>

//Напишите PHP-скрипт, чтобы сделать многомерную разницу, т.е. вернуть значения первого массива, которых нет во втором массиве
<?php
$color1 = array( array('Red', 80), array('Green', 70), array('white', 60) ); 
        
$color2 = array( array('Green', 70), array('Black', 95) ); 
        
$color = array_udiff($color1, $color2, create_function( 
    '$a,$b', 'return strcmp( implode("", $a), implode("", $b) ); ') 
    ); 
        
print_r($color);
?>

//Напишите PHP-скрипт для удаления всех пробелов в массиве
<?php
 $my_array = array(15, null, "  ", -2, NULL, "", " \n", "Red", 54, "\t");
print_r($my_array);
$result = array_filter($my_array, create_function('$x','return preg_match("#\S#", $x);'));                 
print_r($result);
?>

//Напишите PHP-скрипт для создания двумерного массива (4х4), инициализированного до 10
<?php
$a = array_fill(0, 4, array_fill(0, 4, 10));
  print_r($a);
?>

//Напишите функцию PHP, чтобы проверить, являются ли все значения массива строками или нет
<?php
function check_strings_in_array($arr) 
{
    return array_sum(array_map('is_string', $arr)) == count($arr);
}
$arr1 = array('PHP', 'JS', 'Python');
$arr2 = array('SQL', 200, 'MySQL');
var_dump(check_strings_in_array($arr1));
var_dump(check_strings_in_array($arr2));
?>

//Напишите функцию PHP, чтобы установить объединение двух массивов
<?php
function array_union($x, $y)
   { 
      $aunion=  array_merge(
            array_intersect($x, $y),
            array_diff($x, $y),     
            array_diff($y, $x)      
        );
        return $aunion;
   }
$a = array(1, 2, 3, 4);
$b = array(2, 3, 4, 5, 6);
print_r(array_union($a, $b));
?>

//Напишите скрипт PHP, чтобы получить последнее значение массива, не влияя на указатель
<?php
$colors = array('c1' => 'Red',  'c2' => 'Green',  'c3' => 'White',  'c4' => 'Black'); 
echo next($colors)."\n";  
$last = array_pop(array_keys(array_flip($colors)));
echo $last."\n";   
echo current($colors)."\n";  
?>

//Напишите функцию PHP, которая складывает два многомерных массива
<?php
function readArray( $arr, $k, $default = 0 ) {
    return isset( $arr[$k] ) ? $arr[$k] : $default ;
}

function merge( $arr1, $arr2 ) {
    $result = array() ;
    foreach( $arr1 as $k => $v ) {
        if( is_numeric( $v ) ) {
            $result[$k] = (int)$v + (int) readArray( $arr2, $k ) ;
        } else {
            $result[$k] = merge( $v, readArray($arr2, $k, array()) ) ;
        }
    }
    return $result ;
}
$basketA = array( "fruit" => array(), "drink" => array() ) ;
$basketA['fruit']['apple'] = 1;
$basketA['fruit']['orange'] = 2;
$basketA['fruit']['banana'] = 3;
$basketA['drink']['soda'] = 4;
$basketA['drink']['milk'] = 5;

$basketB = array( "fruit" => array(), "drink" => array() ) ;
$basketB['fruit']['apple'] = 2;
$basketB['fruit']['orange'] = 2;
$basketB['fruit']['banana'] = 2;
$basketB['drink']['soda'] = 2;
$basketB['drink']['milk'] = 2;

$basketC = merge( $basketA, $basketB ) ;
print_r( $basketC ) ;
?>

//Напишите функцию PHP, которая сравнивает два многомерных массива и возвращает разницу
<?php
function key_compare($a,$b)
{
    if($a===$b)        
    return 0;
    return($a>$b)?1:-1;
}
function multidimenssional_array_diff($arr1, $arr2)
{
return array_diff_uassoc($arr1['c'], $arr2['c'],"key_compare");
}
//multidimenssional arrays
$color1=array('a'=>'White','b'=>'Red','c'=>array('a'=>'Green','b'=>'Blue','c'=>'Yellow'));
$color2=array('a'=>'White','b'=>'Red','c'=>array('a'=>'White','b'=>'Red','c'=>'Yellow'));
print_r(multidimenssional_array_diff($color1, $color2));
?>

//Напишите функцию PHP для создания многомерного уникального массива для любого индекса ключа
<?php
function unique_array($my_array, $key) { 
    $result = array(); 
    $i = 0; 
    $key_array = array(); 
    
    foreach($my_array as $val) { 
        if (!in_array($val[$key], $key_array)) { 
            $key_array[$i] = $val[$key]; 
            $result[$i] = $val; 
        } 
        $i++; 
    } 
    return $result; 
}  
$students = array( 
    0 => array("city_id"=>"1", "name"=>"Sara",  "mobile_num"=>"1111111111"), 
    1 => array("city_id"=>"2", "name"=>"Robin", "mobile_num"=>"2222222222"), 
    2 => array("city_id"=>"1", "name"=>"Sonia", "mobile_num"=>"3333333333"), 
); 
print_r(unique_array($students, "city_id"));
?>

//Напишите PHP-скрипт для удаления определенного значения из массива с помощью функции array_filter ()
<?php
 $colors = array('key1' => 'Red', 'key2' => 'Green', 'key3' => 'Black');
$given_value ='Black';
print_r($colors);
$new_filtered_array = array_filter($colors, function ($element) use ($given_value) { return ($element != $given_value);}); 
print_r($filtered_array);
  
print_r($new_filtered_array);
?>

//Напишите функцию PHP для преобразования строки в массив (обрезка каждой строки и удаление пустых строк)
<?php
 $string ="  IANA is the global coordinator of the DNS root. 
The root is the upper-most part of the DNS hierarchy, 
and involves delegating administrative responsibility 
of “top-level domains”, which are the last segment of 
a domain name, such as .com, .uk and .nz. Part of this 
task includes evaluating requests to change the operators 
of country code domains, as well as day-to-day maintenance
of the details of the existing operators. ";
$result = array_filter(array_map('trim', explode("\n", $string)), 'strlen');
print_r($result);
?>