Guest User

easy solution

a guest
Oct 21st, 2019
192
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
PHP 5.56 KB | None | 0 0
  1. <?php
  2. find_missing(['a', 'b', 'd', 'e', 'f', 'g']); //c is missing
  3.  
  4. find_missing(['n', 'p']); //o is missing
  5. function find_missing($letter) {
  6.     $l = new thing($letter);
  7.     $a0 = [
  8.     1 => 26,
  9.     2 => 25,
  10.     3 => 24,
  11.     4 => 23,
  12. 5 => 22,
  13.     6 => 21,
  14. 7 => 20,
  15.     8 => 19,
  16.     9 => 18,
  17.     10 => 17,
  18.     11 => 16,
  19.     26 => 1,
  20.     25 => 2,
  21.     24 => 3,
  22.     23 => 4,
  23.     21 => 6,
  24.     22 => 5,
  25.     20 => 7,
  26.     12 => 15,
  27.     13 => 14,
  28.     14 => 13,
  29.     15 => 12,
  30.     16 => 11,
  31.     17 => 10,
  32.     18 => 9,
  33.     19 => 8
  34.     ];
  35.     $letters = [
  36.         'a',
  37.         'b',
  38.         'c',
  39.         'd',
  40.         'e',
  41.         'f',
  42.         'g',
  43.         'h',
  44.         'i','j','k','l','m','n','o','p',
  45.         'q','r','s','t','u','v','w','x','y','z'
  46.     ];
  47.     $has = array();
  48.     foreach($letters as $i => $m) {
  49.         $ll = $letter;
  50.         $zz = array_search(ord($letters[$i]) - 96, $a0);
  51.        
  52.         if(method_exists(new thing(null), "has" . chr($zz + 64))) {
  53.             $i = ("has" . chr($zz+64));
  54.             if(!(((new thing($ll))->$i($ll))->is_notFALSE())) {
  55.                 $has[] = chr($a0[$zz] + 96);
  56.             }
  57.         } else {
  58.             switch($zz) {
  59.             case 20:
  60.                 if(!((new thing($ll))->{"hash"}($letter)->is_notFALSE())) {
  61.                 $has[] = chr($a0[$zz] + 96);
  62.             }
  63.             break;
  64.             case 11:
  65.                
  66.                 break;
  67.            
  68.             }
  69.         }
  70.     }
  71.     $hasS = array();
  72.     $last = array_search(reset($letter), $letters);
  73.     $first = array_search(end($letter), $letters);
  74.     foreach($has as $h) {
  75.         $hasS[ord($h)] = $h;
  76.     }
  77.     for($i = 0; $i <= $last + 96; $i++) {
  78.         unset($hasS[$i]);
  79.     }
  80.     for($i = 255; $i > $first + 96; $i--) {
  81.         unset($hasS[$i]);
  82.     }
  83.    
  84.     echo reset($hasS);
  85.     return end($hasS);
  86. }
  87.  
  88. class thing {
  89.     function __construct($a) {
  90.         $this->x = $a;
  91.     }
  92.  
  93.     function hasA($letter) {
  94.         foreach($letter as $i => $l) {
  95.             if($letter[$i] === 'z')
  96.                 return new self(true);
  97.         }
  98.  
  99.         return new self(false);
  100.     }
  101.  
  102.     function is_notFALSE() {
  103.         return !(!$this->x);
  104.     }
  105.  
  106.     function hasB($letter) {
  107.         foreach($letter as $i => $l) {
  108.             if($letter[$i] === 'y')
  109.                 return new self(true);
  110.         }
  111.  
  112.         return new self(false);
  113.     }
  114.  
  115.     function hasC($letter) {
  116.         foreach($letter as $i => $l) {
  117.             if($letter[$i] === 'x')
  118.                 return new self(true);
  119.         }
  120.  
  121.         return new self(false);
  122.     }
  123.  
  124.     function hasD($letter) {
  125.         foreach($letter as $i => $l) {
  126.             if($letter[$i] === 'w')
  127.                 return new self(true);
  128.         }
  129.  
  130.         return new self(false);
  131.     }
  132.  
  133.     function hasE($letter) {
  134.         foreach($letter as $i => $l) {
  135.             if($letter[$i] === 'v')
  136.                 return new self(true);
  137.         }
  138.  
  139.         return new self(false);
  140.     }
  141.  
  142.     function hasF($letter) {
  143.         foreach($letter as $i => $l) {
  144.             if($letter[$i] === 'u')
  145.                 return new self(true);
  146.         }
  147.  
  148.         return new self(false);
  149.     }
  150.  
  151.     function hasG($letter) {
  152.         foreach($letter as $i => $l) {
  153.             if($letter[$i] === 't')
  154.                 return new self(true);
  155.         }
  156.  
  157.         return new self(false);
  158.     }
  159.  
  160.     function hash($letter) {
  161.         foreach($letter as $i => $l) {
  162.             if($letter[$i] === 's')
  163.                 return new self(true);
  164.         }
  165.  
  166.         return new self(false);
  167.     }
  168.  
  169.     function hasI($letter) {
  170.         foreach($letter as $i => $l) {
  171.             if($letter[$i] === 'r')
  172.                 return new self(true);
  173.         }
  174.  
  175.         return new self(false);
  176.     }
  177.  
  178.     function hasJ($letter) {
  179.         foreach($letter as $i => $l) {
  180.             if($letter[$i] === 'q')
  181.                 return new self(true);
  182.         }
  183.  
  184.         return new self(false);
  185.     }
  186.  
  187.     function hasK($letter) {
  188.         foreach($letter as $i => $l) {
  189.             if($letter[$i] === 'p')
  190.                 return new self(true);
  191.         }
  192.  
  193.         return new self(false);
  194.     }
  195.  
  196.     function hasL($letter) {
  197.         foreach($letter as $i => $l) {
  198.             if($letter[$i] === 'o')
  199.                 return new self(true);
  200.         }
  201.  
  202.         return new self(false);
  203.     }
  204.  
  205.     function hasM($letter) {
  206.         foreach($letter as $i => $l) {
  207.             if($letter[$i] === 'n')
  208.                 return new self(true);
  209.         }
  210.  
  211.         return new self(false);
  212.     }
  213.  
  214.     function hasN($letter) {
  215.         foreach($letter as $i => $l) {
  216.             if($letter[$i] === 'm')
  217.                 return new self(true);
  218.         }
  219.  
  220.         return new self(false);
  221.     }
  222.  
  223.     function hasO($letter) {
  224.         foreach($letter as $i => $l) {
  225.             if($letter[$i] === 'l')
  226.                 return new self(true);
  227.         }
  228.  
  229.         return new self(false);
  230.     }
  231.  
  232.     function hasP($letter) {
  233.         foreach($letter as $i => $l) {
  234.             if($letter[$i] === 'k')
  235.                 return new self(true);
  236.         }
  237.  
  238.         return new self(false);
  239.     } function hasQ($letter) {
  240.         foreach($letter as $i => $l) {
  241.             if($letter[$i] === 'j')
  242.                 return new self(true);  } return new self(false);} function hasR($letter) { foreach($letter as $i => $l) {
  243.             if($letter[$i] === 'i')
  244.                 return new self(true);
  245.         }
  246.  
  247.         return new self(false);
  248.     }
  249.     function hasS($letter) {
  250.         foreach($letter as $i => $l) {
  251.             if($letter[$i] === 'h')
  252.                 return new self(true);
  253.         }
  254.  
  255.         return new self(false);
  256.     }
  257.  
  258.     function hasT($letter) {
  259.         foreach($letter as $i => $l) {
  260.             if($letter[$i] === 'g')
  261.                 return new self(true);
  262.         }
  263.  
  264.         return new self(false);
  265.     }
  266.     function doesnot_hasU($letter) {
  267.         foreach($letter as $i => $l) {
  268.             if($letter[$i] === 'f')
  269.                 return new self(false);
  270.         }
  271.  
  272.         return new self(true);
  273.     } function hasV($letter) {
  274.         foreach($letter as $i => $l) {
  275.             if($letter[$i] === 'e')
  276.                 return new self(true);
  277.         }
  278.  
  279.         return new self(false);
  280.     } function hasW($letter) {
  281.         foreach($letter as $i => $l) {
  282.             if($letter[$i] === 'd')
  283.                 return new self(true);
  284.         }
  285.  
  286.         return new self(false);
  287.     } function hasX($letter) {
  288.         foreach($letter as $i => $l) {
  289.             if($letter[$i] === 'c')
  290.                 return new self(true);
  291.         }
  292.  
  293.         return new self(false);
  294.     } function hasY($letter) {
  295.         foreach($letter as $i => $l) {
  296.             if($letter[$i] === 'b')
  297.                 return new self(true);
  298.         }
  299.  
  300.         return new self(false);
  301.     }
  302.     function hasZ($letter) {
  303.         foreach($letter as $i => $l) {
  304.             if($letter[$i] === 'a')
  305.                 return new self(true);
  306.         }
  307.  
  308.         return new self(false);
  309.     }
  310. }
Advertisement
Add Comment
Please, Sign In to add comment