#Считаем и выводим результат на консоль.
$result = "{0:n2}" -f ([math]::Sqrt([math]::Pow([math]::Floor(100*2/30),5)*4)/45)
Write-Host $result

# Создаем объект Speech Agent'а
$agent = New-Object -com Agent.Control.2
# Не знаю зачем, тупо содрал откуда то   Может и не нужно вообще  
$agent.Connected = 1
# Подгружаем персонажа.
$agent.Characters.Load("Merlin") | Out-Null
# Помещаем его в переменную.
$merlin = $agent.Characters.Character("Merlin")
# Показываем на экране.
$merlin.Show() | Out-Null
# Говорим  
$merlin.Speak("Result of equation is $result.") | Out-Null

# Преобразуем содержимое файла в массив символов, и потом снова в строки, 
# разрубив таким образом на строки по одному символу. Можно было сделать -split ""  
# Ну и эта последовательность строчек идет в switch с аргументами проверки по 
# регулярным выражениям, и чувствительности к регистру символов.
$(switch -regex -casesensitive ([string[]][char[]](gc "c:\scripts\lettercase.txt"))
{
    # Если строчная буква, то переводим в верхний регистр...
    "^[a-z]$" {$_.toUpper()}
    # ... и наоборот.
    "^[A-Z]$" {$_.toLower()}
    # Если цифра, то преобразовываем в число ([int]) и прибавляем единицу.
    "^\d$" {[int]$_ - 1}
    # Иначе - передаем без изменений.
    default {$_}
# Объединяем в строку.
}) -join ""

# Объявляем хэш-таблицу.
$h = @{}
# Получаем список WMI объектов.
Get-WmiObject -List |
# отбираем только начинающиеся на win32_ и заодно проверяем не заполнена ли уже 
# хэш-таблица.
Where-Object {$_.Name -like "win32_*" -and $h.count -ne 25}|
# Для каждого отобранного объекта...
ForEach-Object {
    # ... помещаем имя класса в переменную $Class.
    $Class=$_.name;
    # Создаем .net объект System.Management.ManagementClass для текущего класса...
    (New-Object system.management.managementClass($Class)).psbase.properties |
    # ...и отбираем из всех его свойств поле Name, которое передаем дальше по
    # конвейеру.
    ForEach-Object {$_.Name}
}|
# Для каждого полученного по конвейеру свойства...
foreach {
    #... если оно начинается с нужных букв (^ - обозначает начало строки, а [a-y]
    # любой символ от a до y. Скобки в регулярном выражении помещают первый 
    # символ слова в $Matches[1]).
    if ($_ -match "^([a-y])")
    {
        # Если в хэш-таблице еще нет указанной буквы...
        if (!$h[$matches[1]])
        {
            # Помещаем текущее свойство в переменную $Prop
            $prop = $_
            # Создаем новый объект со свойствами Letter, Property и Class, 
            # который помещаем в хэш-таблицу под соответствующей буквой.
            $h[$matches[1]]=0|select @{n="Letter";e={$matches[1]}},
                                    @{n="Property";e={$prop}},
                                    @{n="Class";e={$class}}
        }
        # Пишем в заголовке текущий сколько уже нашли свойств и текущий класс.
        $host.ui.rawui.windowtitle = "$($h.count)/25 - $Class.$_"
    }
}
# Красиво выводим результаты.
$h.values | Sort-Object letter | Format-Table -AutoSize

$(foreach($c in([char[]](gc C:\scripts\numbers.txt))){[char][int]"$c$($foreach.movenext()|out-null;$foreach.current)"})-join''

# Инициализируем переменную $Result для хранения итоговой строки.
$Result = ""
# Получаем содержимое файла в переменную.
$stringNumbers = Get-Content "C:\scripts\numbers.txt"
# Преобразуем строку в массив символов
$charNumbers = [char[]]$stringNumbers
# Для каждого символа в массиве...
foreach ($FirstNumber in $charNumbers)
{
    # Сдвигаем перебор на одну итерацию вперед с помощью метода MoveNext() 
    # специального объекта $ForEach (который доступен только внутри цикла foreach.
    $Foreach.MoveNext() | Out-Null
    # Помещаем следующий символ в переменную $SecondNumber.
    $SecondNumber = $Foreach.Current
    # Объединяем оба номера в число, которое и является кодом символа.
    [int]$CharCode = $FirstNumber+$SecondNumber
    # Преобразовываем число в символ, и добавляем к $Result.
    $Result += [char]$CharCode
}
# Выводим результат.
$Result

# Загружаем список президентов в переменную.
$Presidents = Get-Content "c:\scripts\presidents.txt"
# Объявляем переменную содержащую гласные буквы.
$Vowels = "aeiou"

# Выводим строчку "Longest first name: " без перехода на новую строку.
Write-Host "Longest first name: " -NoNewline
($Presidents |
# Сортируем президентов по имени. (оператор -replace тут удаляет текст до 
# пробела и сам пробел. Дальше используем свойство .length чтобы получить 
# длину оставшейся строки. Получившийся скриптблок {} передаем как аргумент
# командлету Sort-Object, в качестве критерия для сортировки.
sort {($_ -replace "^.+, ").length} |
# Выбираем один последний результат, и опять с помощью оператора -replace
# меняем имя и фамилию местами.
select -last 1) -replace '^(.+), (.+)$','$2 $1'

# Создаем переменную которая будет содержать все буквы алфавита от A до Z.
$Alphabet = ([char]"A"..[char]"Z"|foreach{[char]$_}) -join ""
# В переменную $Used помещаем буквы которые используются как инициалы.
# Чтоб получить все инициалы просто удаляем все маленькие буквы, и разделяем из 
# массива строк, на массив символов с помощью -split ''.
$Used = ($Presidents -creplace "[a-z, ]" -split '' |
# Выбираем только уникальные буквы (нам не нужны повторные) и объединяем в 
# строчку.
select -unique) -join ''

Write-Host "Letters are not used as initials: " -NoNewline
# Удаляем из $Alpabet все буквы которые были использованы. Результат будет 
# передан на вывод.
$Alphabet -replace "[$Used]"

Write-Host "Total vowels used: " -NoNewline
# Удаляем из списка президентов все согласные (не гласные  ) и считаем 
# получившееся количество гласных.
($Presidents -replace "[^$vowels]" | Measure-Object -Character).characters

T Sg
hWc
eirG
 nia
2tpm
0ete
0ris
8 n!

# Загружаем содержимое файла vertical.txt Командлет Get-Content возвращает 
# массив строк.
$v = Get-Content "c:\scripts\vertical.txt"
# Переменная $Cols будет содержать количество колонок которое мы получим из 
# длины первой строки.
$cols = $v[0].length
# А $Rows соответственно количество элементов в массиве $v.
$rows = $v.count
# С помощью двух for перебираем все символы: сначала первый символ всех 
# столбцов, потом второй, и так далее.
for ($c = 0; $c -lt $cols; $c++)
{
    for ($r = 0; $r -lt $rows; $r++)
    {
        # Выводим текущий символ текущей строки.
        Write-Host ($v[$r][$c]) -NoNewline
    }
}
# Делаем финальный перевод строки для красоты.
Write-Host ""

# Создаем массив карт.
[collections.arraylist]$Cards=@()
# Масти.
$Suits = "Spades","Hearts","Diamonds","Clubs"
# Хэш-таблица значений.
$Values = @{
  "Ace" = 11
  "King" = 10
  "Queen" = 10
  "Jack" = 10
  "Two" = 2
  "Three" = 3
  "Four" = 4
  "Five" = 5
  "Six" = 6
  "Seven" = 7
  "Eight" = 8
  "Nine" = 9
  "Ten" = 10
}

# Создаем карты и помещаем их в массив. Каждая карта - объект со свойствами 
# Name (например "Ace of Spades", Value (например 11) и Position (где в текущий
# момент находится карта, изначально у всех Deck (колода)).
foreach ($key in $Values.keys)
{
  foreach ($Suit in $Suits)
  {
    # Создаем объект.
    $Card = New-Object "PSObject"
    # Добавляем свойства.
    $Card | Add-Member "NoteProperty" -Name "Name" -Value "$key of $Suit"
    $Card | Add-Member "NoteProperty" -Name "Value" -Value $Values[$key]
    $Card | Add-Member "NoteProperty" -Name "Position" -Value "Deck"
    # Добавляем объект к массиву.
    $Cards += $Card
  }
}

# Тасуем колоду.
$r = New-Object random
$Cards = ($Cards.count)..1|%{$r.next(0,$Cards.count)} | %{$Cards[$_]; $Cards.removeat($_)}

# Раздаем первые 2 карты игроку, одну раздающему не показывая (DealerHidden) и
# одну раздающему которую открываем (Dealer).
$Cards[0].Position = "Player"
$Cards[1].Position = "Player"
$Cards[2].Position = "DealerHidden"
$Cards[3].Position = "Dealer"

# $n - обозначает верхнюю текущую карту в колоде.
$n = 4
# Начинаем игру.
while (1) {
  # Очищаем экран и выводим на экран карты игрока.
  cls
  Write-Host "Your cards:"
  $Cards | where {$_.Position -eq "Player"} | foreach {$_.name}

  # Считаем текущую сумму очков у игрока и показываем её.
  $PlayerScore = ($Cards | Where {$_.Position -eq "Player"} |
    Measure-Object value -Sum).sum
  Write-Host "Total: $PlayerScore"

  # Если сумма очков больше 21 то игрок проиграл, ...
  if ($playerScore -gt 21)
  {
    Write-Host "Over 21. Sorry, you lose."
    exit
  }
  # если равна 21, то выиграл,...
  elseif ($playerScore -eq 21)
  {
    Write-Host "21. You win!"
    exit
  }
  # ... а если меньше 21, то выводим карты раздающего (ту которая скрыта, не
  # показываем, лишь упоминаем о её наличии.
  Write-Host "`nDealer's cards:`n[hidden]"
  $Cards | where {$_.Position -eq "Dealer"} | foreach {$_.name}

  # Запрашиваем действие игрока.
  $Ans = (Read-Host "Stay (s) or hit (h) ?")
  if($Ans -eq "h")
  {
    # Тащим еще одну карту игроку
    $Cards[$n].Position = "Player"
    $n++
  }
  elseif($Ans -eq "s")
  {
    # Игрок закончил, выводим его карты последний раз.
    cls
    Write-Host "Your cards:"
    $Cards | where {$_.Position -eq "Player"} | foreach {$_.name}
    # Считаем очки игрока.
    $PlayerScore = ($Cards|where{$_.Position -eq "Player"}|
      Measure-Object value -Sum).sum
    Write-Host "Total: $PlayerScore`n`nDealer cards:"
    # Выводим карты раздающего (в том числе и скрытую).
    $Cards|where{$_.Position -match "Dealer"}|foreach{$_.name}
    # Теперь раздающий тянет карты.
    while(1)
    {
      # Считаем очки раздающего
      $DealerScore = ($Cards|where{$_.Position -match "Dealer"}|
        Measure-Object value -Sum).sum
      if ($DealerScore -gt 21)
      {
        # Если больше 21 - игрок победил.
        Write-Host "The dealer has $DealerScore. You win!."
        exit
      }
      elseif ($DealerScore -ge $PlayerScore)
      {
        # Если очков столько же сколько у игрока, то искусственный разум
        # победил.
        Write-Host "The dealer has $DealerScore. Sorry, you lose."
        exit
      }
      # Раздающий тащит следующую карту.
      $Cards[$n].Position = "Dealer"
      # Сразу выводим её на экран.
      Write-Host ($Cards[$n].name)
      $n++
    }
  }
}

# Получаем содержимое файла alice.txt, разделяем его на слова по пробелам, и
# передаем их в конвейер.
((Get-Content "c:\scripts\alice.txt") -split " " |
    # Для каждого слова ($_)...
    foreach {
        # ... берем все его символы начиная с последнего и заканчивая нулевым и 
        # объединяем их снова в слово.
        $_[($_.length-1)..0] -join ""
    }
# Соединяем получившийся массив слов с помощью пробелов.
) -join " "

((gc c:\scripts\alice.txt)-split" "|%{$_[($_.length-1)..0]-join""})-join" "

# Загружаем содержимое файла songlist.csv. Import-Csv использовать не получится,
# так как он берет заголовки из первой строки, а в этом файле заголовков нет, и
# в первой строке находятся данные.
$Songs = Get-Content "c:\scripts\songlist.csv" |
    # Отбираем только строки попадающие под регулярное выражение, заодно 
    # разбирая на группы.
    where {$_ -match "^(.+),(.+),(.+)$"} |
    foreach {
        # Создаем новый, пустой объект.
        $obj = New-Object "PSObject"
        # Добавляем к нему свойства со значениями полученными из регулярного
        # выражения ($Matches).
        $obj | Add-Member "noteproperty" -Name "Artist" -Value $matches[1]
        $obj | Add-Member "noteproperty" -Name "Song" -Value $matches[2]
        # Добавляя свойство Time, преобразовываем значение в тип [TimeSpan] 
        # (отрезок времени).
        $obj | Add-Member "noteproperty" -Name "Time" -Value ([TimeSpan]("0:"+$matches[3]))
        # Выводим полученный объект на конвейер.
        $obj
    }
# В результате в переменной $Songs у нас содержится массив объектов со 
# свойствами Artist, Song, Time.

# Создаем массив $Burnlist, это список песен для записи.
$Burnlist = @()
# Создаем объект класса Random для генерации произвольных чисел.
$r = New-Object random

# Запускаем бесконечный цикл.
while ($true) {
    # Получаем произвольную песню из списка.
    $song = $Songs[$r.next($Songs.length)]
    # Если в списке $BurnList содержится не более одной песни от $Song.Artist и
    # в списке еще нет конкретно этой песни...
    if ((($burnlist | where {$_.artist -eq $song.artist}).count -le 1) `
        -and (!($burnlist | where {$_.song -eq $song.song})))
    {
        # Добавляем к списку записи $Song
        $Burnlist += $song

        # Считаем какова общая продолжительность песен в $Burnlist:
        # Создаем переменную $n класса [TimeSpan]
        [timespan]$n=0
        # Добавляем к $n время всех треков из $BurnList
        $burnlist |%{$n+=$_.time}
        # Если суммарное время превышает 80 минут, то обнуляем $Burnlist, и он
        # будет заполняться заново. Не самый оптимальный алгоритм, но...  
        if ($n -gt [timespan]::FromMinutes(80)){$Burnlist = @()}
        # Если суммарное время удовлетворяет условиям задачи (Больше 75 минут и
        # меньше 80)...
        if ($n -lt [timespan]::FromMinutes(80) -and $n -gt [timespan]::FromMinutes(75))
        {
            # Cортируем список по исполнителю.
            $Burnlist | Sort artist |
            # Выбираем свойства Artist и Song, а свойство Time заменяем 
            # текстовым (вместо [TimeSpan]) с временем в формате который 
            # предпочитают Scripting Guys  
            Select Artist, Song, @{n="Time";e={$_.Time -replace "^00:"}} |
            # Выводим объекты на GridView
            Out-GridView
            # Пишем сколько всего времени заняли треки на диске.
            Write-Host "Total music time: $([int]$n.totalminutes):$($n.seconds)"
            # Завершаем работу скрипта.
            Exit
        }
    }
}

# Создаем массив с именами команд. Да, можно было просто сделать
# $Teams = [string[]][char[]]"ABCDEF" или еще проще, но мы простых путей не ищем  
$Teams = [string[]][char[]]([char]"A"..[char]"F")
# Создаем [arrayList] для хранения матчей. Отличие от обычного Array в том что 
# можно удалять элементы.
[collections.arraylist]$Games = @()
# Просто перебираем все комбинации команд...
foreach ($first in $Teams)
{
    foreach ($second in $Teams)
    {
        # ... и если такого сочетания нет в списке, и первая команда не равна
        # второй...
        if (($Games -notcontains "$first vs. $second") `
            -and ($Games -notcontains "$second vs. $first") `
            -and ($first -ne $second))
        {
            # ...то добавляем матч в список.
            $Games += "$first vs. $second"
        }
    }
}
# Создаем новый объект для генерации произвольных чисел.
$r = New-Object random
# Для каждого числа от (кол-во матчей) до 1...
($Games.count)..1|
    # ...генерируем произвольное число от 0 до (кол-во матчей) и передаем его по
    # конвейеру...
    foreach {$r.next(0,$Games.count)} |
    # выводим игру под номером $_ (произвольное число полученное по конвейеру) 
    # дальше по конвейеру, и удаляем её из списка (чтоб не вывести второй раз)
    foreach {$games[$_]; $games.removeat($_)} |
    # Создаем объект со свойством Game, и соответствующим значением полученным по
    # конвейеру
    Select @{name="Game";expression={$_}} |
    # Выводим на Grid View
    Out-GridView

function Test-Prime ($t,$prs) {
    $isprime = $true
    foreach ($i in 2..([math]::Sqrt($t))) {
        if ($t % $i -eq 0) {
            $isprime = $false
            break
        }
    }
    if ($isprime) {$prs += $t}
    $isprime
}
$Primes = 1,2;
@(2;1..200 | where {Test-prime $_ $primes}) |
    Select @{n="Prime";e={$_}} | Out-GridView 

# Объявляем строковый параметр скрипта.
param ([string]$Password)
# Стартовый рейтинг пароля.
$Score = 13
# Загружаем список слов.
$Words = Get-Content "c:ScriptsWordList.txt"

# Функция для подсчета количества вхождений указанного символа в слове.
function occs ([string]$word, [string]$letter)
{
    # Просто удаляем из слова все символы кроме указанного и смотрим длину  
    ($word -creplace "[^$($letter)]").length
}

# Оператор switch. Проверяются все условия подряд, так как break нигде не 
# указан. При совпадении условия - выводится сообщение и уменьшается $Score
switch ($Password)
{
    # Содержится ли пароль в массиве $Words, проверка простым оператором 
    # -contains. Если содержится - устанавливаем переменную $Actual = $True, 
    # чтобы уже не пытаться искать его там заменив "0" на "o" и "1" на "l"
    {$Words -contains $_} {$Score--; Write-Host "Password is actual word"; $Actual = $True}
    # Удаляем последний символ, и смотрим - содержится ли в $Words
    {$Words -contains ($_ -replace ".$")} {$Score--; Write-Host "Password minus the last letter, is actual word"}
    # Аналогично, но удаляем первый символ.
    {$Words -contains ($_ -replace "^.")} {$Score--; Write-Host "Password minus the first letter, is actual word"}
    # Если пароль не содержится в списке слов - меняем "0" на "o" и ищем снова.
    {!$Actual -and ($Words -contains ($_ -replace "0","o"))} {$Score--; Write-Host "Password is actual word that does substitute 0 (zero)"}
    # Аналогично, но меняем "1" на "l"
    {!$Actual -and ($Words -contains ($_ -replace "1","l"))} {$Score--; Write-Host "Password is actual word that does substitute 1 (one)"}
    # Проверяем длину пароля
    {$_.length -lt 10 -or $_.length -gt 20} {$Score--; Write-Host "Password length is less than 10 or more than 20 characters long"}
    # Проверяем содержатся ли в пароле цифры (группа d в регулярных выражениях
    # означает любую цифру).
    {$_ -notmatch "d"} {$Score--; Write-Host "Password does not include numbers"}
    # Проверяем содержатся ли заглавные буквы. Группа [A-Z] указывает любой
    # символ из диапазона A-Z. -Cnotmatch в отличии от -notmatch проводит 
    # сравнение учитывая регистр символов.
    {$_ -cnotmatch "[A-Z]"} {$Score--; Write-Host "No uppercase letters in password"}
    # Аналогично с маленькими буквами
    {$_ -cnotmatch "[a-z]"} {$Score--; Write-Host "No lowercase letters in password"}
    # Смотрим есть ли в пароле что то кроме букв и цифр, короче говоря символы.
    # ^ в начале группы означает "все кроме", w - любая буква, и d - цифра
    {$_ -notmatch "[^wd]"} {$Score--; Write-Host "Password does not include symbols"}
    # Проверяем содержатся ли 4 маленькие буквы подряд. {4,} после группы 
    # указывает что для совпадения элемент должен повторится 4 и более раз. 
    # Например "[z]{2,5}" будет означать "от 2 до 5 букв z". Сравнение опять 
    # чувствительно к регистру символов потому что используется -Cmatch, а не
    # просто -match
    {$_ -cmatch "[a-z]{4,}"} {$Score--; Write-Host "Four consecutive lowercase letters in password"}
    # Аналогично с заглавными буквами.
    {$_ -cmatch "[A-Z]{4,}"} {$Score--; Write-Host "Four consecutive uppercase letters in password"}
    # Для каждой буквы от "a" до "z" проверяем количество её вхождений в пароль.
    {$w=$_; [bool](([char]"a"..[char]"z" |%{occs $w ([char]$_)}) -gt 1) -or [bool](([char]"A"..[char]"Z" |%{occs $w ([char]$_)}) -gt 1)}
        {$Score--; Write-Host "Password include duplicate characters"}
}
# Выводим результат
if ($Score -le 6) {$Rating = "weak"}
elseif ($Score -ge 11) {$Rating = "strong"}
else {$Rating = "moderately-strong"}
Write-Host "`nA password score of $Score indicates a $Rating password"

# Запрашиваем месяц в формате месяц/год и присвиваем её переменной в виде 
# массива, разделив по "/". То есть первый элемент это месяц, второй - год.
$Data = (Read-Host "Enter a month") -split "/"
# В переменную $FirstDay помещаем первый день месяца.
$FirstDay = Get-Date -Year $Data[1] -Month $Data[0] -Day 1
# С помощью функции DaysInMonth класса DateTime, получаем количество дней в 
# месяце.
$TotalDays = [datetime]::DaysInMonth($Data[1],$Data[0])
# Делаем отступ в одну строчку для красоты  
Write-Host ""
# Пишем название месяца и год.
Write-Host (Get-Date $FirstDay -Format "MMMM yyyy")
# Пишем заголовки столбцов.
Write-Host "`nSun`tMon`tTue`tWed`tThu`tFri`tSat"
# Делаем отступ знаками табуляции ("`t") в количестве равном дню недели первого 
# дня месяца. Рисуем число 1.
Write-Host ("`t"*([int]($FirstDay.DayOfWeek)) + "1`t") -NoNewline
# Если первый день месяца является одновременно последним днём недели - то 
# переходим на новую строку.
if ([int]$FirstDay.DayOfWeek -eq 6) {Write-Host ""}
# Для каждого числа от 2 до $TotalDays включительно, где $_ - текущее число...
2..$TotalDays | foreach {
    # ...выводим на экран текущее число и знак табуляции.
    Write-Host "$_`t" -NoNewline
    # Если это был последний день недели, то переходим на новую строку.
    if ([int](get-date $FirstDay -Day $_).DayOfWeek -eq 6) {Write-Host ""}
}
# Финальный отступ. "`n" - символ новой строки.
Write-Host "`n"

# Помещаем содержимое файла в массив $Votes
$Votes = Get-Content "c:scriptsvotes.txt"
# Начинаем цикл и продолжаем до тех пор пока не определится победитель. 
# См. while.
do {
    $Results = $Votes |
    # Каждую строчку из $Votes...
    foreach {
        # Разделяем в массив по запятым
        $_ -split "," |
        # Выбираем первый элемент этого массива (первый столбец)
        select -First 1
    } |
    # Группируем...
    group |
    # Выбирем из каждой группы столбцы с названием группы (именем кандидата) и
    # count (количество элементов в группе.
    select name, count |
    # Сортируем по количеству элементов, в обратном порядке.
    sort count -desc
    # Вычисляем проигравшего ($Looser) взяв последний элемент массива $Results
    $Looser = $Results[-1].Name
    # Убираем из переменной $Votes все упоминания о проигравшем - в дальнейших
    # этапах выборов он уже не участвует.
    $Votes = $Votes -replace "$Looser," -replace ",$Looser$"
# Проверяем набрал ли победитель больше 50% и если не набрал - проводим 
# очередной этап.
} while ($Results[0].count -le ($Results[1..($Results.count-1)] | Measure-Object count -sum).sum)

# Присваиваем переменной $Winner имя победителя.
$Winner = $Results[0].name
# Вычисляем итоговый результат победителя.
$Score = $Results[0].Count / (($Results[0].Count + $Results[1].Count) / 100)
# Пишем на экран.
Write-Host "The winner is $Winner with $Score% of the vote."

# Читаем содержимое файла skaters.txt
$Table = Get-Content "c:scriptsskaters.txt" |
# Для каждой строки...
foreach {
    # ... создаем массив $Arr из строчки разделив её по запятым
    $Arr = $_ -split ","
    # Имя скейтера (первый элемент массива) помещаем в переменную $Name
    $Name = $Arr[0]
    # Очки (элементы массива начиная со второго) помещаем в переменную $Scores
    # предварительно отсортировав.
    $Scores = $Arr[1..($Arr.Count-1)] | Sort
    # Теперь убираем самый низки и самый высокий результаты (просто оставив в
    # массиве $Scores элементы начиная со второго по предпоследний
    $Scores = $Scores[1..($Scores.count-2)]
    # Вычисляем средний результат поделив сумму элементов на их количество.
    $FinalScore = ($Scores | Measure-Object -sum).Sum / $Scores.Count
    # Создаем новый объект
    $obj = New-Object "PSObject"
    # Добавляем к нему свойства Name и Score
    $obj | Add-Member -MemberType "NoteProperty" -Name "Name" -Value $Name
    $obj | Add-Member -MemberType "NoteProperty" -Name "Score" -Value $FinalScore
    # Отправляем объект дальше по конвейеру
    $obj
# Сортируем полученный массив объектов по свойству Score в обратном порядке
} | Sort-Object Score -Descending
# В результате все объекты помещаются в переменную $Table (см. первую строчку)

# Создаем массив медалей
$Medals="Gold medal", "Silver medal", "Bronze medal"
# Объявляем глобальную переменную $i (глобальную потому что будем её изменять
# внутри других скриптблоков. Не очень красиво, но в момент написания скрипта
# придумалось именно так  
$global:i=0
# Берем первые 3 элемента массива...
$Table[0..2]|
# Добавляем новое свойство Medal и оставляем уже имеющиеся Name и Score
select @{n="Medal";e={$global:i++;$medals[$i-1]}}, Name, Score |
# Показываем результат...
Out-GridView 

# Функция для вычисления номера соответствующего слову.
function WordToNumber ([string]$Word)
{
    # Блок switch заключен в $() для того чтобы к его результатам (массиву
    # символов сразу применить оператор -join.
    $(
        # Ключ -regex указывает что следует применять сравнение по регулярным
        # выражениям. В () помещается слово ($Word) преобразованное в массив 
        # символов ([char[]]). Switch отработает для каждого символа отдельно.
        switch -regex ([char[]]$Word)
        {
            # При совпадении символа с одним из регулярных выражений 
            # возвращается соответствующее число.
            " " {1}
            "[abc]" {2}
            "[def]" {3}
            "[ghi]" {4}
            "[jkl]" {5}
            "[mno]" {6}
            "[pqrs]" {7}
            "[tuv]" {8}
            "[wxyz]" {9}
            "+" {0}
        }
    # Оператор -join (PowerShell v2.0) объединяет возвращенный массив символов в
    # одну строку. В качестве второго аргумента указывается разделитель.
    ) -join ""
}

# Запрашиваем телефонный номер и помещаем его в переменную $Number
$Number = Read-Host "Please enter a phone number"

# Получаем все строки файла wordlist.txt, отбираем только те длинна которых
# равна 7, и результат помещаем в переменную $Words
$Words = Get-Content "C:scriptswordlist.txt" | where {$_.length -eq 7}

# Отбираем только те слова из списка, которые при преобразовании в номер с
# помощью функции WordToNumber равны переменной $Number. В случае если таких 
# будет несколько Select-Object -First 1 оставит только одно первое совпадение.
$Words | Where-Object {(WordToNumber $_) -eq $Number} | Select-Object -First 1

function Out-Random {
    $r = New-Object random
    $input | sort {$r.next()}
}
1..10 | Out-Random