Conjuntos de F#
Conjuntos F# são coleções de itens que podem ser organizados em uma ordem sem preservar a ordem na qual os itens são inseridos. A coleção de entradas em um conjunto não pode ser duplicada.
Aqui, veremos mais de perto como é possível resolver uma variedade de problemas de programação usando o tipo de dados set em F# e como você pode implementá-lo em seu programa, bem como os fundamentos da criação e manipulação de conjuntos.
Criar conjuntos
Existem várias maneiras de criar conjuntos:
- Set.empty pode ser usado para criar um conjunto vazio e adicionar itens a ele usando a função add.
- Converter uma sequência ou lista em um conjunto.
Aqui estão algumas técnicas que são demonstradas no seguinte programa:
Example:
1
2
3
4
5
6
7
8
9
10
11
let set = Set.empty.Add(1).Add(3).Add(7). Add(8)
printfn"The set: %A" set
let cars = Set.ofList ["Chevrolet"; "Bentley"; "Bugatti"; "Aston Martin"; "Ford Mustang"]
printfn "The list set: %A" cars
let even = Set.ofSeq [ 2 .. 2.. 10 ]
printfn "The sequence set: %A" even
E a saída será:
The set: set [1; 3; 7; 8] The list set: set [Aston Martin; Bentley; Bugatti; Chevrolet; Ford Mustang] The sequence set: set [2; 4; 6; 8; 10]
Operações básicas em conjuntos
Abaixo está uma tabela mostrando as operações básicas que podem ser realizadas em conjuntos:
| Valor | Visão geral |
| add : 'T → Set<'T> → Set<'T> | A função retorna um novo conjunto ao qual um elemento foi adicionado. Uma exceção não será gerada se o elemento fornecido já fizer parte do conjunto. |
| contém: 'T → Set<'T> → bool | O elemento dado é avaliado como verdadeiro se fizer parte do conjunto dado. |
| contagem: Set<'T> → int | Neste método, você descobrirá quantos elementos estão presentes no conjunto. |
| diferença : Set<'T> → Set<'T> → Set<'T> | O método retorna um novo conjunto de elementos no qual os elementos do segundo conjunto foram removidos do primeiro conjunto. |
| vazio : Definir <'T> | Um conjunto que não contém elementos do tipo especificado. |
| existe : ('T → bool) → Set<'T> → bool | Existe um predicado que testa se algum elemento da coleção satisfaz os critérios fornecidos. Uma função, quando a entrada é um predicado e a entrada é um conjunto de elementos, então seu objetivo é calcular o predicado i0, ou …, ou predicado iN. |
| filtro: ('T → bool) → Definir<'T> → Definir<'T> | Esta função retorna uma nova coleção que consiste nos elementos da coleção que retornam true quando um predicado é aplicado a eles. |
| fold : ('Estado → 'T → 'Estado) → 'Estado → Set<'T> → 'Estado | Pegue os elementos do conjunto e aplique a função acumulativa a todos eles. |
| foldBack : ('T → 'Estado → 'Estado) → Set<'T> → 'Estado → 'Estado | Todos os elementos do conjunto são acumulados de acordo com a função de acumulação dada. |
| forall : ('T → bool) → Set<'T> → bool | Um elemento da coleção é testado para determinar se ele atende ao predicado fornecido na coleção. Uma função que toma p como entrada em que os elementos são i0…iN, então calcula p i0 && … && p iN. |
| intersect : Set<'T> → Set<'T> → Set<'T> | Um método para calcular a interseção entre dois conjuntos é fornecido. |
| intersectMany : seq<Set<'T>> → Set<'T> | Esta função calcula a interseção entre uma sequência de conjuntos. É necessário que a sequência não esteja vazia. |
| isEmpty : Set<'T> → bool | Se o conjunto está vazio ou não é determinado por esta função. |
| isProperSubset : Set<'T> → Set<'T> → bool | O valor é verdadeiro se pelo menos um elemento do segundo conjunto não estiver no primeiro conjunto e cada elemento do primeiro conjunto estiver no segundo conjunto. |
| isProperSuperset : Set<'T> → Set<'T> → bool | Um valor true é retornado se cada elemento do segundo conjunto fizer parte do primeiro conjunto e pelo menos um elemento do primeiro conjunto não fizer parte do segundo conjunto. |
| isSubset : Set<'T> → Set<'T> → bool | Essa expressão será avaliada como verdadeira se o primeiro conjunto também contiver todos os elementos do segundo conjunto. |
| isSuperset : Set<'T> → Set<'T> → bool | Existe um valor verdadeiro se todos os elementos do segundo conjunto corresponderem aos elementos do primeiro conjunto. |
| iter : ('T → unidade) → Set<'T> → unidade | Cada elemento do conjunto é aplicado com a função dada de acordo com a função de comparação, em ordem numérica. |
| map : ('T → 'U) → Set<'T> → Set<'U> | Nessa função, o conjunto de entrada é convertido em uma coleção de resultados que contém os resultados da aplicação da função fornecida a cada elemento dessa coleção. |
| maxElement : Set<'T> → 'T | De acordo com a ordem em que os elementos do conjunto são ordenados, esta função retorna o maior elemento do conjunto. |
| minElement : Set<'T> → 'T | De acordo com a ordem em que os elementos do conjunto são ordenados, esta função retorna o elemento mais baixo do conjunto. |
| ofArray : 'T array → Set<'T> | Ele cria um conjunto de elementos que contém os mesmos elementos que estão na matriz fornecida. |
| ofList : 'Lista T → Definir<'T> | Esta função cria um conjunto com os mesmos elementos que estão presentes na lista fornecida. |
| ofSeq : seq<'T> → Definir<'T> | Uma nova coleção será criada a partir do objeto enumerável fornecido. |
| partição: ('T → bool) → Definir<'T> → Definir<'T> * Definir<'T> | Um conjunto é dividido em dois conjuntos, que contêm os elementos que são retornados verdadeiro e falso quando o predicado fornecido é aplicado. |
| remove : 'T → Definir<'T> → Definir<'T> | A função retorna um novo conjunto que tem o elemento fornecido removido dele. Se o conjunto não contiver o elemento especificado, nenhuma exceção será levantada. |
| singleton : 'T → Definir <'T> | Conjunto contendo um elemento do tipo dado. |
| toArray : Set<'T> → 'T array | Neste método, um array contendo todos os elementos do conjunto é criado. |
| toList : Set<'T> → 'Lista T | Neste método, uma lista contendo todos os elementos do conjunto é criada. |
| toSeq : Definir <'T> → seq<'T> | Neste método, uma sequência contendo todos os elementos do conjunto é criada. |
| union : Set<'T> → Set<'T> → Set<'T> | Calcula a união entre os dois conjuntos. |
| unionMany : seq<Set<'T>> → Set<'T> | Esta função realiza a união de vários conjuntos. |
Abaixo estão alguns exemplos que demonstram as propriedades acima do conjunto:
Example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// create a set of integers
let set1 = Set.ofList [1; 2; 3; 4; 5; 6; 7; 8;]
// print the set
printfn "My Set: %A" set1
// check if the set contains an element
let contains = set1.Contains(4)
printfn "My Set contains 4: %b" contains
// add an element to the set
let addIntoSet = set1.Add(9).Add(10)
printfn "Updated Set: %A" addIntoSet
let set2 = Set.ofList [2; 4; 6; 8]
// perform a set operation (Union)
let union = Set.union set1 set2
printfn "Union is: %A" union
// perform a set operation (difference)
let diff = Set.difference set1 set2
printfn "Difference is: %A" diff
// perform a set operation (intersection)
let intersection= Set.intersect set1 set2
printfn "Intersection: %A" intersection
// check if one set is a subset of another set
let isSubset = set2.IsSubsetOf(set1)
printfn "Is set2 is subset of set1: %b" isSubset
E o resultado das seguintes propriedades de conjuntos são:
My Set: set [1; 2; 3; 4; 5; 6; 7; 8] My Set contains 4: true Updated Set: set [1; 2; 3; 4; 5; 6; 7; 8; 9; 10] Union is: set [1; 2; 3; 4; 5; 6; 7; 8] Difference is: set [1; 3; 5; 7] Intersection: set [2; 4; 6; 8] Is set2 is subset of set1: true
Exemplo de Explicação
Este exemplo F# cria dois conjuntos de números inteiros usando a função Set.ofList e, em seguida, executa uma variedade de operações de conjunto neles.
Aqui está o que cada parte do código faz:
- deixe set1 = Set.ofList [1; 2; 3; 4; 5; 6; 7; 8;] : Esta linha cria um novo conjunto chamado set1 que contém os inteiros de 1 a 8.
- printfn “My Set: %A” set1 : Esta linha imprime o conteúdo de set1 no console usando o especificador de formato %A , que é usado para imprimir arrays e coleções.
- let contains = set1.Contains(4) : Esta linha verifica se set1 contém o inteiro 4 usando o método Contains , que retorna um valor booleano. O resultado é armazenado em uma variável chamada contém .
- printfn “Meu conjunto contém 4: %b” contém : Esta linha imprime se set1 contém ou não o inteiro 4 com base no resultado da linha anterior.
- let addIntoSet = set1.Add(9).Add(10) : Esta linha adiciona os inteiros 9 e 10 a set1 usando o método Add , que cria um novo conjunto que contém os elementos atualizados. O resultado é armazenado em uma variável chamada addIntoSet .
- printfn “Updated Set: %A” addIntoSet : Esta linha imprime o conteúdo do conjunto atualizado que inclui os inteiros de 1 a 10.
- deixe set2 = Set.ofList [2; 4; 6; 8] : Esta linha cria um novo conjunto chamado set2 que contém os inteiros pares entre 2 e 8.
- let union = Set.union set1 set2 : Esta linha executa a união de set1 e set2 usando a função union , que cria um novo conjunto que contém todos os elementos únicos de ambos os conjuntos. O resultado é armazenado em uma variável chamada union.
- printfn “Union is: %A” union : Esta linha imprime o conteúdo do conjunto de união.
- let diff = Set.difference set1 set2 : Esta linha realiza a operação de diferença entre set1 e set2 usando a função de diferença, que cria um novo conjunto que contém os elementos de set1 que não estão em set2. O resultado é armazenado em uma variável chamada diff .
- printfn “A diferença é: %A” diff : Esta linha imprime o conteúdo da diferença definida.
- deixe intersecção = Set.intersect set1 set2 : Esta linha executa a operação de interseção entre set1 e set2 usando a função intersect , que cria um novo conjunto que contém os elementos que são comuns a ambos os conjuntos. O resultado é armazenado em uma variável chamada intersecção .
- printfn “Intersection: %A” cruzamento : Esta linha imprime o conteúdo do conjunto de interseção.
- let isSubset = set2.IsSubsetOf(set1) : Esta linha verifica se set2 é um subconjunto de set1 usando o método IsSubsetOf , que retorna um valor booleano. O resultado é armazenado em uma variável chamada isSubset .
- printfn “Is set2 is subset of set1: %b” isSubset : Esta linha imprime se set2 é ou não um subconjunto de set1 com base no resultado da linha anterior.
Você pode ajudar outras pessoas a aprender sobre o poder e a natureza flexível da linguagem de programação funcional F# compartilhando nosso artigo na mídia social abaixo. Isso permitirá que eles criem aplicativos da Web dinâmicos e interativos.
Vantagens dos Conjuntos F#
Conjuntos em F# têm várias vantagens que os tornam úteis para programação. Aqui estão algumas das vantagens:
- Os conjuntos F# são imutáveis, o que significa que não podemos modificar o conteúdo de um conjunto depois de criá-lo. Essa imutabilidade torna os conjuntos seguros para uso em um ambiente multiencadeado.
- Os conjuntos F# são implementados como árvores binárias balanceadas, o que significa que eles têm uma complexidade de tempo logarítmica para muitas operações, como inserções, exclusões e pesquisas.
- Conjuntos F# são fáceis de usar e fornecem uma abordagem funcional para programação. Eles suportam várias operações que podemos usar para manipulá-los sem modificar seu conteúdo.
Nós valorizamos o seu feedback.
+1
+1
+1
+1
+1
+1
+1
