Discover MakerZone

MATLAB and Simulink resources for Arduino, LEGO, and Raspberry Pi

Learn more

Discover what MATLAB® can do for your career.

Opportunities for recent engineering grads.

Apply Today

Correct

41Size
Leading solution size is 14.
This solution is locked. To view this solution, you need to provide a solution of the same size or smaller.

Test Suite

Test
Code Input and Output
1
Pass
 
%%
tic
vin=[4 33 36 47 63 79 146 159 176 191 178 215 226 228 261 262 291 295 322 368 456 461 465 473 479 500 512 527 570 572 613 639 641 654 667 684 699 701 746 751 763 767 786 819 872 925 932 959 965 972 ];
vexp=[1 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
2
Pass
 
%%
vin=[28 33 63 78 82 85 92 101 113 125 138 175 183 196 211 224 250 287 345 368 388 426 447 477 491 504 524 575 579 581 621 694 712 720 737 745 747 784 793 802 813 827 829 853 858 919 924 929 939 960 ];
vexp=[0 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
3
Pass
 
%%
vin=[19 19 ];
vexp=[1 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
4
Pass
 
%%
vin=[13 35 63 72 76 122 103 171 185 221 238 294 318 325 341 355 350 359 365 407 409 438 467 514 548 592 585 599 606 636 646 652 697 708 737 770 773 798 819 832 835 849 881 879 893 904 907 932 967 983 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
5
Pass
 
%%
vin=[28 72 94 114 136 147 177 185 199 216 214 230 243 252 264 417 285 426 428 445 450 463 465 467 482 485 495 531 537 547 575 558 598 654 677 678 692 685 785 853 891 894 897 905 906 910 918 933 963 979 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
6
Pass
 
%%
vin=[21 18 33 53 158 179 200 225 230 259 261 262 280 319 338 368 369 376 423 449 481 505 517 531 545 588 598 614 607 615 647 655 657 684 702 706 734 756 768 791 806 792 834 889 895 896 957 960 971 995 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
7
Pass
 
%%
vin=[52 53 66 83 119 129 132 145 202 237 274 281 284 296 298 326 442 386 451 456 475 476 486 493 499 520 523 525 589 605 612 626 630 638 694 718 740 763 791 798 800 801 811 839 868 874 895 891 971 984 ];
vexp=[2 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
8
Pass
 
%%
vin=[4 9 21 43 89 106 117 141 150 211 158 220 233 282 296 311 324 353 372 376 407 452 414 455 482 494 503 522 527 531 545 548 552 563 568 586 593 629 673 691 682 703 724 738 787 822 861 882 907 937 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
9
Pass
 
%%
vin=[29 51 80 105 109 114 129 154 175 167 188 198 227 266 270 437 345 446 459 469 470 478 479 520 582 587 591 611 618 619 658 677 670 683 686 689 710 758 728 815 821 852 870 912 937 946 960 969 985 998 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
10
Pass
 
%%
vin=[22 34 65 81 83 91 105 114 125 127 132 162 154 176 198 201 222 269 272 296 297 321 345 355 377 402 403 407 444 454 450 493 517 533 546 589 592 593 639 698 700 729 764 798 785 850 909 917 950 988 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
11
Pass
 
%%
vin=[30 94 106 118 125 136 151 161 162 176 233 240 272 290 320 337 347 352 370 433 412 499 504 510 513 572 593 621 629 640 646 710 712 721 735 741 750 786 804 812 814 817 822 844 893 932 944 945 954 972 ];
vexp=[1 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
12
Pass
 
%%
vin=[4 5 6 1 7 ];
vexp=[1 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
13
Pass
 
%%
vin=[1000 ];
vexp=[0 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
14
Pass
 
%%
vin=[25 37 40 56 62 81 86 136 95 140 225 228 274 236 297 332 417 516 545 549 573 582 583 595 600 601 603 624 673 699 714 716 719 720 746 737 762 790 802 814 821 835 852 868 860 871 899 910 923 984 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
15
Pass
 
%%
vin=[1000 1000 1000 1000 1000 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
16
Pass
 
%%
vin=[13 15 42 44 68 69 108 109 126 120 145 148 154 176 199 221 245 266 271 299 325 309 326 411 514 518 552 568 589 607 663 692 723 711 746 754 771 776 780 818 840 843 858 868 878 882 883 904 906 975 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
17
Pass
 
%%
vin=[17 13 ];
vexp=[1 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
18
Pass
 
%%
vin=[13 21 82 107 99 135 136 144 174 183 211 222 259 283 304 333 348 353 366 399 412 491 512 507 526 557 590 593 613 619 634 663 683 689 710 714 719 720 738 754 807 832 885 880 932 934 941 984 990 996 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
19
Pass
 
%%
vin=[5 37 46 52 54 79 125 140 192 294 318 323 333 343 346 354 360 361 372 403 414 435 445 454 471 480 482 503 514 527 583 624 645 632 726 746 760 764 771 791 801 803 812 819 846 885 893 956 976 1000 ];
vexp=[1 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
20
Pass
 
%%
vin=[28 12 36 45 50 101 113 119 131 168 237 250 254 261 281 324 343 401 421 437 442 499 500 501 512 522 523 529 532 545 561 585 586 590 623 679 695 782 798 823 830 843 852 878 891 902 923 922 972 981 ];
vexp=[2 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
21
Pass
 
%%
vin=[22 23 111 61 127 138 144 147 174 194 261 262 279 272 288 318 350 356 396 425 439 441 454 466 473 487 482 590 615 617 632 637 662 688 699 704 734 780 800 803 814 808 828 843 868 922 943 985 987 1000 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
22
Pass
 
%%
vin=[49 73 118 140 194 202 218 249 261 342 272 347 355 403 438 462 466 469 473 488 499 511 514 515 525 532 538 545 588 665 610 707 714 719 716 723 739 751 763 789 809 868 874 899 916 937 939 947 979 994 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
23
Pass
 
%%
vin=[3 14 67 76 98 107 125 150 151 194 244 248 251 270 289 271 309 354 434 453 468 454 484 487 507 523 526 569 578 601 624 684 690 696 725 752 765 800 813 815 826 906 888 948 963 970 984 993 996 1000 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
24
Pass
 
%%
vin=[15 57 92 105 110 172 125 182 202 213 233 263 282 291 289 293 353 404 421 440 447 469 491 495 504 498 505 543 549 579 597 633 655 671 693 748 768 801 798 811 838 858 859 865 883 889 901 945 959 964 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
25
Pass
 
%%
vin=[30 61 112 126 137 147 154 158 224 266 282 294 303 307 328 320 377 379 391 411 430 423 446 453 461 463 468 493 517 531 536 546 588 613 667 643 683 684 712 722 784 821 848 889 900 919 921 928 931 1000 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
26
Pass
 
%%
vin=[34 18 92 103 108 110 143 200 248 283 284 297 326 365 369 400 439 470 489 498 526 593 596 605 631 684 720 687 754 770 781 793 803 826 811 855 863 886 888 901 916 928 943 954 968 972 982 983 984 987 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
27
Pass
 
%%
vin=[13 24 74 48 137 172 199 209 224 227 234 293 297 305 324 336 338 377 418 395 432 437 446 474 505 510 529 536 541 568 613 641 645 695 677 735 792 797 805 830 853 869 882 883 888 925 910 970 982 994 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
28
Pass
 
%%
vin=[25 39 54 55 57 101 117 124 142 143 185 161 196 210 214 237 243 267 282 288 304 394 435 427 458 491 509 519 550 557 582 607 608 634 652 640 681 705 695 753 785 840 871 889 903 912 918 921 966 987 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
29
Pass
 
%%
vin=[30 75 123 160 156 176 202 215 254 264 310 318 354 368 390 435 453 457 474 476 479 510 529 532 603 623 635 637 644 671 686 706 723 725 726 730 732 767 806 807 829 852 869 902 897 912 927 957 994 996 ];
vexp=[2 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
30
Pass
 
%%
vin=[40 44 45 46 121 89 141 155 167 179 207 226 263 265 327 337 338 364 373 453 456 478 512 537 543 561 568 577 637 604 641 648 672 687 697 709 701 737 789 808 813 819 820 828 835 911 921 938 947 964 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
31
Pass
 
%%
vin=[1 ];
vexp=[0 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
32
Pass
 
%%
vin=[40 42 43 60 63 70 78 124 103 131 133 149 161 164 170 227 232 260 266 275 316 323 368 335 372 377 413 418 420 441 553 463 574 576 643 656 665 678 733 741 743 815 762 883 908 928 930 968 974 994 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
33
Pass
 
%%
vin=[16 78 79 134 151 219 224 240 251 280 295 388 406 483 489 505 507 534 538 539 549 554 555 564 573 583 609 660 672 681 687 711 732 738 745 746 783 792 812 834 837 841 887 866 908 957 961 978 987 994 ];
vexp=[1 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
34
Pass
 
%%
vin=[18 20 33 34 35 54 94 123 140 162 169 220 205 250 258 278 299 320 349 362 397 434 492 449 499 504 508 515 531 552 606 647 652 678 695 703 714 735 763 785 836 799 854 858 863 864 929 933 960 984 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
35
Pass
 
%%
vin=[3 17 37 50 66 96 99 155 107 184 218 257 260 279 285 327 332 337 354 369 398 430 423 437 574 631 656 660 668 676 680 700 709 750 747 761 789 774 813 857 860 886 898 904 949 952 964 976 984 1000 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
36
Pass
 
%%
vin=[22 78 23 90 101 106 132 141 146 191 206 222 244 270 304 325 332 379 383 392 401 412 417 436 454 465 487 551 499 553 557 562 570 581 613 650 682 691 732 781 782 789 814 816 844 890 965 971 986 998 ];
vexp=[2 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
37
Pass
 
%%
vin=[20 65 69 128 131 157 173 175 211 194 216 229 266 278 286 292 320 335 377 358 423 424 463 472 529 531 545 553 557 576 589 585 601 613 657 672 699 711 725 786 789 810 897 923 936 960 996 969 997 1000 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
38
Pass
 
%%
vin=[19 54 61 67 119 131 153 167 178 199 197 246 256 273 329 321 348 350 353 392 394 402 413 486 511 530 515 539 569 582 586 594 686 763 819 821 829 840 832 848 858 864 870 904 933 944 947 952 967 998 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
39
Pass
 
%%
vin=[29 40 106 68 118 132 148 162 180 182 200 207 246 283 287 288 320 295 321 325 338 343 349 362 364 371 378 418 503 535 554 562 568 571 577 587 682 699 760 709 769 844 920 938 941 948 960 973 977 983 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
40
Pass
 
%%
vin=[19 38 43 45 67 75 150 154 173 178 184 189 254 227 278 282 289 315 297 365 373 396 403 505 509 513 521 555 580 583 600 614 643 649 667 678 695 722 732 761 801 824 805 841 879 894 915 926 930 975 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
41
Pass
 
%%
vin=[56 65 94 119 149 165 157 166 198 220 297 302 305 316 321 327 351 347 359 368 380 386 387 403 431 447 448 449 463 528 533 556 562 590 634 610 640 658 693 750 786 759 792 800 825 842 864 889 911 994 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
42
Pass
 
%%
vin=[5 11 40 95 110 134 138 160 187 208 228 210 240 278 352 354 381 390 414 503 440 507 513 526 528 534 540 543 570 604 609 613 625 632 647 653 658 661 668 708 718 780 846 855 862 860 891 910 936 949 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
43
Pass
 
%%
vin=[6 57 71 73 100 112 134 165 173 189 190 194 197 227 239 229 246 252 278 288 316 319 371 393 450 462 521 585 567 620 625 636 654 689 675 694 701 716 720 741 743 746 820 868 873 879 935 938 979 989 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
44
Pass
 
%%
vin=[5 50 77 74 113 128 129 169 173 179 201 210 228 236 242 251 255 262 279 283 301 369 373 387 380 412 417 441 444 459 476 492 493 532 541 574 644 646 665 720 728 773 802 810 821 853 849 860 912 964 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
45
Pass
 
%%
vin=[10 21 84 97 107 109 123 120 128 137 143 161 254 266 278 301 307 315 361 389 395 408 492 517 549 584 551 597 602 603 618 648 653 657 658 682 723 753 790 799 820 824 831 844 855 866 858 894 916 918 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
46
Pass
 
%%
vin=[1 4 3 3 ];
vexp=[2 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
47
Pass
 
%%
vin=[22 43 49 54 80 84 104 107 149 171 180 197 210 226 312 340 347 356 363 387 407 420 439 463 478 465 485 499 568 590 598 627 646 654 656 675 693 707 760 761 776 798 840 853 856 909 929 947 951 984 ];
vexp=[1 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
48
Pass
 
%%
vin=[49 60 70 76 80 96 144 161 203 269 274 296 343 346 400 359 401 428 430 451 454 455 477 480 500 506 522 591 573 598 653 655 657 733 748 736 763 771 784 813 835 855 869 894 920 932 948 956 981 986 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
49
Pass
 
%%
vin=[3 4 6 7 10 ];
vexp=[0 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
50
Pass
 
%%
vin=[26 37 95 122 117 149 183 194 195 239 245 253 272 285 287 330 300 335 349 371 380 390 401 421 489 426 519 521 538 598 626 640 645 665 685 698 704 712 723 791 822 834 859 860 920 900 960 977 986 997 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
51
Pass
 
%%
vin=[70 76 80 97 102 105 113 157 141 161 163 217 251 295 310 320 323 350 355 357 390 391 397 422 428 460 486 472 487 536 570 579 631 665 666 676 681 683 690 693 705 726 813 819 821 850 874 916 935 999 ];
vexp=[2 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
52
Pass
 
%%
vin=[51 58 63 80 90 120 157 164 172 190 208 259 278 336 324 348 368 374 379 383 426 436 446 506 536 553 569 589 591 596 637 607 645 708 716 725 735 741 745 764 773 831 884 853 902 905 956 978 982 997 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
53
Pass
 
%%
vin=[33 40 65 72 122 84 130 137 156 227 255 314 333 335 343 345 350 372 373 374 387 417 404 422 433 469 470 495 499 532 571 580 603 630 622 653 660 681 698 752 801 808 816 836 859 889 909 931 961 962 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
54
Pass
 
%%
vin=[28 42 34 53 59 87 98 141 143 158 188 221 317 319 324 351 346 359 374 390 393 407 430 458 485 488 502 514 559 567 595 598 596 610 629 631 647 719 699 759 769 782 803 805 907 928 934 943 983 987 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
55
Pass
 
%%
vin=[13 ];
vexp=[0 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
56
Pass
 
%%
vin=[59 61 82 96 100 160 176 194 242 223 259 266 275 282 318 328 357 349 367 370 376 409 416 442 447 475 489 504 507 553 598 603 637 616 684 710 722 712 756 776 783 784 806 814 833 847 879 922 973 992 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
57
Pass
 
%%
vin=[13 87 98 120 173 139 184 187 214 222 276 310 333 348 356 364 376 382 401 461 422 475 501 509 524 575 579 588 594 596 622 624 652 683 699 751 737 781 827 831 844 863 868 875 892 909 910 975 977 980 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
58
Pass
 
%%
vin=[119 152 207 221 215 245 250 257 269 327 336 345 370 371 382 404 408 440 443 448 458 492 498 509 609 580 614 620 623 653 692 709 713 723 743 760 770 812 784 814 830 862 875 877 916 926 932 947 963 984 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
59
Pass
 
%%
vin=[6 25 46 48 85 102 114 126 179 223 233 238 243 294 276 330 338 386 349 387 418 423 434 463 470 474 487 523 546 559 591 634 667 671 681 696 739 752 772 791 808 830 840 873 862 882 959 965 978 995 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
60
Pass
 
%%
vin=[29 35 39 58 88 73 89 108 143 186 196 243 253 270 297 271 349 358 368 369 402 420 453 459 464 489 499 568 607 646 653 705 710 712 717 716 721 780 743 793 826 849 916 918 947 950 958 959 961 994 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
61
Pass
 
%%
vin=[11 57 88 92 162 186 187 268 297 307 310 342 332 368 391 402 408 422 435 487 447 522 530 535 546 558 571 574 594 628 631 648 651 660 664 675 693 707 715 738 718 762 794 851 853 854 870 902 935 980 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
62
Pass
 
%%
vin=[16 36 61 88 110 205 120 230 243 264 265 270 297 313 316 317 342 346 391 368 401 411 441 472 574 584 587 591 605 645 618 670 675 693 695 736 741 796 804 801 811 824 829 884 915 929 934 984 989 990 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
63
Pass
 
%%
vin=[27 41 59 70 96 145 149 175 274 264 278 297 298 358 361 392 403 413 432 444 480 498 520 542 544 622 626 631 636 641 692 704 715 736 740 805 818 823 828 856 865 875 890 891 913 931 941 966 977 991 ];
vexp=[1 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
64
Pass
 
%%
vin=[39 44 48 56 62 94 105 109 195 210 199 211 223 272 311 317 419 435 446 448 467 472 492 483 536 540 609 610 646 638 710 719 740 781 795 798 814 835 858 861 869 876 903 913 936 931 948 965 968 999 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
65
Pass
 
%%
vin=[17 19 42 49 88 94 130 149 215 250 251 288 297 326 334 335 344 372 377 411 406 425 429 436 440 478 488 496 550 554 560 578 585 594 603 607 608 610 631 796 813 820 850 901 937 979 955 989 990 997 ];
vexp=[2 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
66
Pass
 
%%
vin=[3 5 7 21 26 52 128 154 168 192 195 209 225 282 227 284 352 355 363 395 406 432 443 478 501 513 553 577 625 624 658 672 696 699 733 739 750 760 768 817 822 861 869 870 883 913 978 931 993 994 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
67
Pass
 
%%
vin=[11 18 20 78 110 111 114 117 123 126 138 180 198 214 235 250 286 316 335 409 422 475 476 525 527 593 615 634 657 672 664 682 711 727 729 740 761 781 790 820 837 840 842 853 868 896 971 981 986 995 ];
vexp=[1 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
68
Pass
 
%%
vin=[13 17 ];
vexp=[0 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
69
Pass
 
%%
vin=[8 4 42 77 104 141 158 169 192 217 234 244 340 356 343 367 374 393 427 430 433 468 475 477 481 483 507 526 549 557 609 616 611 644 645 678 695 704 758 745 772 794 803 806 825 836 841 858 885 943 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
70
Pass
 
%%
vin=[15 49 77 101 107 140 129 151 156 158 185 219 224 235 236 243 264 271 302 304 329 335 346 435 436 453 472 479 480 496 563 568 571 591 633 673 651 712 718 741 765 775 782 815 859 893 912 918 935 988 ];
vexp=[2 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
71
Pass
 
%%
vin=[26 69 77 115 121 141 151 217 243 244 275 293 301 309 313 341 345 366 365 372 391 398 510 516 518 520 542 522 553 572 652 657 660 661 674 705 717 723 789 799 810 849 856 859 876 900 906 942 996 1000 ];
vexp=[2 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
72
Pass
 
%%
vin=[7 26 40 48 55 100 118 139 205 246 235 248 269 292 297 356 361 372 393 403 417 435 491 533 544 555 569 572 582 599 597 636 676 692 730 702 758 767 802 807 808 850 884 889 903 911 912 946 968 975 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
73
Pass
 
%%
vin=[13 48 100 115 131 180 204 205 214 218 247 284 316 289 335 362 382 391 399 403 410 468 469 546 479 550 559 571 592 603 647 654 735 746 751 768 796 795 808 853 859 881 882 905 936 938 941 949 968 981 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
74
Pass
 
%%
vin=[23 57 72 82 90 121 131 165 149 228 243 252 274 285 289 290 306 349 366 385 399 394 405 464 473 530 562 568 604 665 684 693 741 759 797 800 804 805 860 861 866 881 872 885 891 904 905 972 985 995 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
75
Pass
 
%%
vin=[84 29 96 105 134 147 175 179 224 238 255 263 281 290 295 331 332 357 366 406 422 427 442 474 495 509 510 578 606 613 635 665 676 695 714 719 722 726 732 816 819 820 886 915 957 972 975 984 985 991 ];
vexp=[1 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
76
Pass
 
%%
vin=[1 61 76 82 106 122 128 142 136 164 182 183 251 263 332 325 334 385 400 402 410 446 490 504 508 556 571 609 623 629 638 644 660 709 694 714 726 776 793 794 834 842 847 857 899 901 944 919 990 997 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
77
Pass
 
%%
vin=[3 28 34 47 37 66 116 143 171 213 235 247 309 320 351 330 370 386 397 415 416 474 484 495 512 513 522 572 594 642 681 643 689 707 732 756 760 773 777 799 795 800 830 840 853 866 867 899 951 975 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
78
Pass
 
%%
vin=[4 12 16 63 79 82 104 121 109 123 141 152 164 208 243 277 327 358 363 382 410 451 483 502 516 524 590 630 633 657 687 658 696 703 706 739 745 761 774 769 780 841 872 880 883 926 929 954 956 986 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
79
Pass
 
%%
vin=[4 10 17 73 102 122 188 246 252 299 318 325 336 338 343 363 388 401 402 410 419 425 433 435 463 524 535 567 590 637 671 677 698 716 752 753 773 779 797 874 893 896 895 918 921 923 928 940 957 969 ];
vexp=[1 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
80
Pass
 
%%
vin=[41 53 50 80 104 122 127 131 148 171 198 235 254 258 299 300 312 334 355 390 404 442 424 445 469 509 545 544 598 639 647 651 653 692 702 747 800 810 822 826 865 868 871 921 938 942 949 948 960 965 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
81
Pass
 
%%
vin=[51 60 84 94 114 121 125 128 138 134 178 192 195 252 277 328 342 333 418 419 462 482 512 550 578 582 584 607 611 612 614 636 680 659 714 733 735 736 743 783 791 792 798 824 864 879 866 910 951 961 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
82
Pass
 
%%
vin=[11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 ];
vexp=[0 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
83
Pass
 
%%
vin=[29 55 33 60 118 148 253 278 287 289 308 337 339 350 359 385 392 398 417 420 462 511 555 568 587 596 602 643 655 670 692 700 696 734 766 770 793 817 818 855 859 874 884 897 911 915 920 923 938 999 ];
vexp=[2 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
84
Pass
 
%%
vin=[9 22 26 48 38 98 110 132 135 156 160 163 180 220 262 266 283 292 316 311 335 363 411 412 424 436 484 502 540 541 571 545 572 585 610 633 656 679 743 764 754 812 814 870 880 902 949 964 985 997 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
85
Pass
 
%%
vin=[4 3 2 1 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
86
Pass
 
%%
vin=[10 23 27 39 56 73 125 164 171 184 195 209 213 232 244 260 264 447 459 465 478 486 519 520 543 554 556 570 579 586 595 596 621 637 644 673 657 677 678 680 688 704 754 763 880 891 910 912 942 984 ];
vexp=[1 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
87
Pass
 
%%
vin=[18 16 37 54 59 75 91 101 142 154 194 199 205 234 259 268 317 284 342 351 363 378 417 418 425 491 505 536 563 608 617 624 649 688 709 716 727 821 824 829 850 832 893 903 950 955 957 964 979 988 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
88
Pass
 
%%
vin=[12 61 20 64 70 81 150 158 170 175 201 282 304 307 338 391 366 397 407 428 432 473 492 501 508 533 563 557 579 589 603 631 636 645 648 656 714 685 718 740 742 814 824 842 863 871 927 941 965 986 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
89
Pass
 
%%
vin=[6 14 24 31 39 48 52 60 82 125 164 141 195 213 234 239 255 287 318 334 357 387 369 410 417 421 431 444 446 510 514 547 680 653 684 709 720 765 791 802 823 840 858 871 891 892 950 927 983 1000 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
90
Pass
 
%%
vin=[12 15 37 48 71 74 101 95 104 148 153 162 208 215 269 227 320 356 359 372 406 455 463 477 486 498 559 596 645 651 664 693 665 751 756 779 785 827 804 844 852 874 887 904 905 936 961 982 983 991 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
91
Pass
 
%%
vin=[1 65 68 71 124 173 181 190 195 204 221 220 304 339 321 352 362 363 368 369 403 415 490 514 520 536 548 550 586 589 592 623 655 638 700 744 755 762 779 789 842 850 865 881 916 924 956 938 987 998 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
92
Pass
 
%%
vin=[48 52 94 107 134 113 186 202 231 233 253 257 274 296 324 332 338 351 356 357 358 393 489 482 519 527 534 537 560 568 604 612 611 617 705 707 730 755 782 812 784 828 867 916 937 948 966 967 971 988 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
93
Pass
 
%%
vin=[55 15 107 117 155 157 198 236 240 245 285 288 302 364 376 380 402 416 421 434 478 488 501 504 567 568 629 644 646 673 657 686 690 740 744 755 769 770 783 792 818 860 855 865 904 905 917 935 971 984 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
94
Pass
 
%%
vin=[80 30 92 103 143 182 200 202 217 222 229 245 273 278 283 303 360 445 446 466 486 489 505 516 547 576 614 630 624 643 671 695 697 709 715 730 739 743 746 768 786 810 872 888 949 938 951 952 959 982 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
95
Pass
 
%%
vin=[41 61 83 126 142 188 214 218 242 249 269 265 315 334 362 369 371 438 454 459 484 464 485 497 501 522 548 568 586 605 614 686 654 701 706 726 732 736 742 765 792 810 823 842 832 846 853 877 891 980 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
96
Pass
 
%%
vin=[20 22 27 74 91 77 144 147 154 269 287 327 328 348 349 386 432 433 438 470 491 550 556 586 588 592 610 640 686 716 722 733 734 736 740 758 779 796 804 805 836 857 901 912 938 940 942 981 990 989 ];
vexp=[2 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
97
Pass
 
%%
vin=[11 13 52 28 149 156 187 223 262 268 269 292 309 332 347 379 373 462 484 501 505 506 524 527 539 544 627 656 660 666 669 677 704 679 712 752 780 783 863 877 882 891 904 937 910 970 979 988 993 994 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
98
Pass
 
%%
vin=[16 46 60 67 71 77 81 102 123 140 143 145 178 249 271 260 336 366 409 470 471 489 497 529 536 596 597 610 664 662 673 677 694 698 718 742 755 759 783 807 850 844 879 880 903 913 915 922 945 959 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
99
Pass
 
%%
vin=[988 988 988 988 988 ];
vexp=[4 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))

                    
100
Pass
 
%%
vin=[7 13 14 122 128 154 170 184 193 191 224 241 260 296 299 305 311 316 375 381 424 425 429 437 476 477 488 503 546 532 564 585 665 669 677 689 823 838 831 857 859 877 883 897 918 927 935 948 973 987 ];
vexp=[3 ];
vout=Monotonic_V(vin);
assert(isequal(vout,vexp))
toc
Elapsed time is 0.211793 seconds.