Ir para conteúdo


Revista PROGRAMAR - Edição 45 (Maio 2014): Download já disponível! Visita também o novo website da revista.

- - - - -

Dúvida Como escrever por extenso.


  • Por favor inicie sessão para responder
4 respostas a este tópico

#1 programadorvb6

programadorvb6

    CRLF

  • Membro
  • PipPipPipPipPip
  • 817 mensagens

Publicado 25 de Fevereiro de 2011 - 11:25

Olá bom dia.
Estou a fazer um programa em VB.Net e gostaria de saber se é correcto escrever então o numerário por extenso desta forma.
Após ter consultado o Blog do JPaulino sobre este assunto e lido os comentários que foram lá colocados sobre possiveis erros, houve alguns que me chamaram a atenção, nomeadamente a unidade dos Biliões (Brasil)

Citar

Anónimo disse...
Obrigado, está excelente mas:
Os biliões estão à brasileira.
Em Portugal e alguns países da Europa
um bilião =1.000.000.000.000

1.000.000.000 deve ler-se mil milhões

14 Dezembro, 2009 
jpaulino disse...
Então mas não existe bilião ???

Bem, é só corrigir nesse ponto.


Indo pelo posts colocados no blog resolvi fazer assim :

Imagem Colocada
´

É assim que se escreve em Português (PT-PT) ?

#2 tiago40812

tiago40812

    void

  • Membro
  • PipPip
  • 37 mensagens

Publicado 28 de Fevereiro de 2011 - 11:58

Exprimenta utilizar um conversor da net que faça isso e compara os resultados...

#3 programadorvb6

programadorvb6

    CRLF

  • Membro
  • PipPipPipPipPip
  • 817 mensagens

Publicado 03 de Março de 2011 - 23:37

Olá boa noite.
Tentei acrescentar até aos Trilhões (100.000.000.000.000,00) e dá-me este erro: 'System.StackOverflowException'   na variavel Decimal.
Como posso resolver este problema?
- Já tentei substituir a variavel Decimal por Int64 e dá o mesmo erro.

Código (vb.net):
Public Class Form1

    ''' <summary>
    ''' Função principal que recolhe o valor e chama as duas funções
    ''' auxiliares para a parte inteira e para a parte decimal
    ''' </summary>
    ''' <param name="number">Número a converter para extenso (Reais)</param>
    '''
    Public Function NumeroToExtenso(ByVal number As Decimal) As String
        Dim cent As Integer
        Try
            ' se for =0 retorna 0 reais
            If number = 0 Then
                Return "Zero Reais"
            End If
            ' Verifica a parte decimal, ou seja, os centavos
            cent = Decimal.Round((number - Int(number)) * 100, MidpointRounding.ToEven)
            ' Verifica apenas a parte inteira
            number = Int(number)
            ' Caso existam centavos
            If cent > 0 Then
                ' Caso seja 1 não coloca "Reais" mas sim "Real"
                If number = 1 Then
                    Return "Um Real e " + getDecimal(cent) + "centavos"
                    ' Caso o valor seja inferior a 1 Real
                ElseIf number = 0 Then
                    Return getDecimal(cent) + "centavos"
                Else
                    Return getInteger(number) + "Reais e " + getDecimal(cent) + "centavos"
                End If
            Else
                ' Caso seja 1 não coloca "Reais" mas sim "Real"
                If number = 1 Then
                    Return "Um Real"
                Else
                    Return getInteger(number) + "Reais"
                End If
            End If
        Catch ex As Exception
            Return ""
        End Try
    End Function

    ''' <summary>
    ''' Função auxiliar - Parte decimal a converter
    ''' </summary>
    ''' <param name="number">Parte decimal a converter</param>
    Public Function getDecimal(ByVal number As Byte) As String
        Try
            Select Case number
                Case 0
                    Return ""
                Case 1 To 19
                    Dim strArray() As String = _
                       {"Um", "Dois", "Três", "Quatro", "Cinco", "Seis", _
                        "Sete", "Oito", "Nove", "Dez", "Onze", _
                        "Doze", "Treze", "Quatorze", "Quinze", _
                        "Dezasseis", "Dezessete", "Dezoito", "Dezenove"}
                    Return strArray(number - 1) + " "
                Case 20 To 99
                    Dim strArray() As String = _
                        {"Vinte", "Trinta", "Quarenta", "Cinquenta", _
                        "Sessenta", "Setenta", "Oitenta", "Noventa"}
                    If (number Mod 10) = 0 Then
                        Return strArray(number \ 10 - 2) + " "
                    Else
                        Return strArray(number \ 10 - 2) + " e " + getDecimal(number Mod 10) + " "
                    End If
                Case Else
                    Return ""
            End Select
        Catch ex As Exception
            Return ""
        End Try
    End Function

    ''' <summary>
    ''' Função auxiliar - Parte inteira a converter
    ''' </summary>
    ''' <param name="number">Parte inteira a converter</param>

    Public Function getInteger(ByVal number As Decimal) As String
        Try
            number = Int(number)
            Select Case number
                Case Is < 0
                    Return "-" & getInteger(-number)
                Case 0
                    Return ""
                Case 1 To 19
                    Dim strArray() As String = _
                        {"Um", "Dois", "Três", "Quatro", "Cinco", "Seis", _
                        "Sete", "Oito", "Nove", "Dez", "Onze", "Doze", _
                        "Treze", "Quatorze", "Quinze", "Dezasseis", _
                        "Dezessete", "Dezoito", "Dezenove"}
                    Return strArray(number - 1) + " "
                Case 20 To 99
                    Dim strArray() As String = _
                        {"Vinte", "Trinta", "Quarenta", "Cinquenta", _
                        "Sessenta", "Setenta", "Oitenta", "Noventa"}
                    If (number Mod 10) = 0 Then
                        Return strArray(number \ 10 - 2)
                    Else
                        Return strArray(number \ 10 - 2) + " e " + getInteger(number Mod 10)
                    End If
                Case 100
                    Return "Cem"
                Case 101 To 999
                    Dim strArray() As String = _
                           {"Cento", "Duzentos", "Trezentos", "Quatrocentos", "Quinhentos", _
                           "Seiscentos", "Setecentos", "Oitocentos", "Novecentos"}
                    If (number Mod 100) = 0 Then
                        Return strArray(number \ 100 - 1) + " "
                    Else
                        Return strArray(number \ 100 - 1) + " e " + getInteger(number Mod 100)
                    End If
                Case 1000 To 1999
                    Select Case (number Mod 1000)
                        Case 0
                            Return "Mil"
                        Case Is <= 100
                            Return "Mil e " + getInteger(number Mod 1000)
                        Case Else
                            Return "Mil, " + getInteger(number Mod 1000)
                    End Select
                Case 2000 To 999999
                    Select Case (number Mod 1000)
                        Case 0
                            Return getInteger(number \ 1000) & "Mil"
                        Case Is <= 100
                            Return getInteger(number \ 1000) & "Mil e " & getInteger(number Mod 1000)
                        Case Else
                            Return getInteger(number \ 1000) & "Mil, " & getInteger(number Mod 1000)
                    End Select
                Case 1000000 To 1999999
                    Select Case (number Mod 1000000)
                        Case 0
                            Return "Um Milhão"
                        Case Is <= 100
                            Return getInteger(number \ 1000000) + "Milhão e " & getInteger(number Mod 1000000)
                        Case Else
                            Return getInteger(number \ 1000000) + "Milhão, " & getInteger(number Mod 1000000)
                    End Select
                Case 2000000 To 999999999
                    Select Case (number Mod 1000000)
                        Case 0
                            Return getInteger(number \ 1000000) + " Milhões"
                        Case Is <= 100
                            Return getInteger(number \ 1000000) + "Milhões e " & getInteger(number Mod 1000000)
                        Case Else
                            Return getInteger(number \ 1000000) + "Milhões, " & getInteger(number Mod 1000000)
                    End Select
                Case 1000000000 To 1999999999
                    Select Case (number Mod 1000000000)
                        Case 0
                            Return "Um Bilhão"
                        Case Is <= 100
                            Return getInteger(number \ 1000000000) + "Bilhão e " + getInteger(number Mod 1000000000)
                        Case Else
                            Return getInteger(number \ 1000000000) + "Bilhão, " + getInteger(number Mod 1000000000)
                    End Select
                Case 2000000000 To 9999999999
                    Select Case (number Mod 1000000000)
                        Case 0
                            Return getInteger(number \ 1000000000) + " Bilhões"
                        Case Is <= 100
                            Return getInteger(number \ 1000000000) + "Bilhões e " + getInteger(number Mod 1000000000)
                        Case Else
                            Return getInteger(number \ 1000000000) + "Bilhões, " + getInteger(number Mod 1000000000)

                            Return getInteger(number \ 1000000000) + "Bilhões, " + getInteger(number Mod 1000000000)
                    End Select
                Case 10000000000 To 19999999999
                    Select Case (number Mod 1000000000000)
                        Case 0
                            Return getInteger(number \ 1000000000000) + " Trilhão "
                        Case Is <= 100
                            Return getInteger(number \ 1000000000000) + "Trilhão e " + getInteger(number Mod 1000000000000)
                        Case Else
                            Return getInteger(number \ 1000000000000) + "Trilhão, " + getInteger(number Mod 1000000000000)

                            Return getInteger(number \ 1000000000000) + "Trilhão, " + getInteger(number Mod 1000000000000)
                    End Select
                Case Else
                    Select Case (number Mod 2000000000000)
                        Case Is < 0
                            Return getInteger(number \ 1000000000000) + " Trilhão "

                        Case 1 To 100
                            Return getInteger(number \ 1000000000000) + "Trilhões e " + getInteger(number Mod 1000000000000)

                        Case Else
                            Return getInteger(number \ 1000000000000) + "Trilhões, " + getInteger(number Mod 1000000000000)
                    End Select
            End Select
        Catch ex As Exception
            Return ""
        End Try
    End Function

    Private Sub btnConverter_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnConverter.Click
        If txtValor.Text = String.Empty Then
            MsgBox("Informe um valor válido. Ex: 123.456.258,99")
        Else
            Me.txtExtenso.Text = NumeroToExtenso(Me.txtValor.Text)
        End If
    End Sub

    Private Sub txtValor_KeyPress(ByVal sender As Object, ByVal e As System.Windows.Forms.KeyPressEventArgs) Handles txtValor.KeyPress
        If Not Char.IsNumber(e.KeyChar) And Not e.KeyChar = vbBack And Not e.KeyChar = "." And Not e.KeyChar = "," Then
            e.Handled = True
        End If
    End Sub
End Class
Obrigado desde já pela vossa atenção.
Programadorvb6

#4 jpaulino

jpaulino

    Stack Overflow

  • Staff
  • 10622 mensagens

Publicado 04 de Março de 2011 - 00:24

Mas onde dá-te o erro? Por exemplo, aqui:

Código (vb.net):
Public Function getInteger(ByVal number As Decimal) As String

Defines com decimal (tudo bem) mas depois convertes para Integer

Código (vb.net):
number = Int(number)

Entre outros locais que fazes o mesmo!


EDIT: Já agora, Int64 é o mesmo que definires como Long. Vê aqui http://msdn.microsoft.com/en-us/library/47zceaw7(v=vs.71).aspx

#5 MSOlhao

MSOlhao

    void

  • Membro
  • PipPip
  • 89 mensagens

Publicado 04 de Março de 2011 - 00:39

Viva,

Eu executei o teu programa no meu PC e não tive qualquer problema em converter os 100.000.000.000.000,00.
Julgo que o problema pode ter a ver com a tua arquitectura, se tiveres a usar 32-bits não vais conseguir converter esse valor por inteiro.

Edit: Tive a oportunidade de testar em arquitectura 32-bits e não houve qualquer problema em converter os Cem Trilhões.  :hmm: