1. Este site usa cookies. Ao continuar a usar este site está a concordar com o nosso uso de cookies. Saber Mais.

[PHYTON] Ajuda a iniciante :D

Discussão em 'Programação' iniciada por | Blasted |, 30 de Junho de 2008. (Respostas: 20; Visualizações: 1420)

  1. Olá a todos!

    Estou a iniciar-me no mundo de phyton. Há algum tempo atrás andei, também por aqui, a pesquisar sobre com que linguagem começar e acabei por começar com Phyton pois pareceu-me a mais adequada.

    Bem, estou a ler um livro (que por sinal até estou a achar muito bom) que com o avançar da matéria vai incluindo sempre exercicios para o 'aluno' resolver.

    Um deles é este:
    Tentei resolver o exercicio e fiz este código:

    Ao tentar correr este código dá-me erro e como novato que sou ainda não estou bem na parte onde percebo exactamente onde errei e percebo o que o interpretador me diz :D
    Portanto, o que está mal?
     
  2. countzero

    countzero Power Member

    Olá,

    Não podes resolver esse problema desse modo.

    A instrução:
    Código:
    len('arg') = 70
    é ilegal.

    A ideia é transformares a palavra que rebeste, com tamanho n, numa palavra com tamanho 70; dizem-te para utilizar espaços em branco para fazeres "crescer" a palavra; também te pedem que o último caracter, da palavra que recebeste, fique na coluna 70.

    Por exemplo:
    Código:
    $ ./right_justify.py
    Palavra original: [qualquer_coisa]
    Resultado: [                                                        qualquer_coisa]
    $
    Cumps,
    JP

    Uma dica: Irás precisar de 70-#<tamanho da palavra> espaços em branco...
     
  3. Não consegui parar enquanto não cheguei à solução. (Isto consegue tornar-se viciante)
    Cheguei a isto:

    Será isto?
     
  4. shello

    shello %erador
    Staff Member

    Tens aí um erro.
    Código:
        y = 70 - len('arg')
    A arg que queres passar é uma variável e não uma string. Quando metes algum texto entre plicas ('), estás a indicar que o que envias é uma string (texto), independentemente do que estiver lá ser, por acaso, o nome de uma váriável, uma palavra reservada, o que for.
    No teu código actual irias sempre receber 67 (70-len('arg'), ou seja, 70-3) espaços, e depois a palavra passada em arg.

    Tenta resolver, é simples ;)
     
  5. Código:
    def right_justify(arg):
    
        y = 70 - len(arg)
        x = ' '     
        print ((x*y)+arg)
    
    right_justify('aaa')
    
    É só tirar os ('), certo?
    Assim indico que o len que quero medir é o arg da funçao e nao o 'arg' como string.
    Correcto?
     
  6. smpme

    smpme Power Member

    Só um aparte: É python e não phyton ;)
     
  7. Correctissimo!
    Distracção minha! :)
     
  8. Bem, continuo com a minha aprendizagem!
    :D

    Agora surgiu-me o seguinte exercicio:

    Código:
    • Write a function that draws a grid like the following:
    + - - - - + - - - - +
    |         |         |
    |         |         |
    |         |         |
    |         |         |
    + - - - - + - - - - +
    |         |         |
    |         |         |
    |         |         |
    |         |         |
    + - - - - + - - - - +
    
    Já fiz uma função que desenha a grelha e não tive problemas.
    O problema está no seguinte(alinea seguinte do exercicio): a função tem que ser "adaptável", isto é eu digo x colunas e y linhas e ela desenha uma grelha semelhante a esta mas com x colunas e y linhas.
    Estou um bocado confuso sobre como "pegar" para fazer uma função assim.
    Podiam-me dar umas dicas?

    P.S: Não quero o código. Quero apenas uma 'direcção' a seguir. Gosto de chegar ás cenas por mim.

    abraço,
     
    Última edição: 1 de Julho de 2008
  9. shello

    shello %erador
    Staff Member

    Primeiro, arranja forma de receberes esses valores na função.

    Depois, é seguires a primeiro parte da ideia dos espaços. Tens de fazer uns poucos cálculos simples (com as variáveis que recebes) para saber quantas peças tens de desenhar.

    Acho que não falei demais :D

    Boa sorte! ;)
     
  10. Acho que até falaste de menos :D

    Bem, por partes:
    Código:
    def grelha(x,y):  # x=linhas y=colunas
    
    Com isto consigo saber quantas colunas e linhas o utilizador quer. Certo?

    A partir daqui continuo um bocadinho entalado.. Acho que o que me está a complicar o raciocínio (porque até acho que isto não deve ser mt complicado) é o não encontrar um "padrão" na grelha para depois a construir. Não sei se me fiz entender :S
     
  11. shello

    shello %erador
    Staff Member

    Exacto, esse é o cabeçalho.
    Precisas de ver agora de ver como vais repetir isso, e de saber qual é o padrão.

    Não faço ideia se podes usar ciclos de repetição. Vou assumir que ainda não chegaste aí.

    Uma primeira hipótese:
    Guardar duas variáveis com os dois tipos diferentes de linha.
    Existem duas linhas nessa grelha. O primeiro tipo, a bordadura (no topo, no centro e no fundo). O segundo tipo, as outras todas. Logo, irias gerar estas duas variáveis.
    Agora a forma de pensar é igual para caracteres na linha ou para linhas em si (vou chamar elemento): Tens um primeiro elemento que é diferente (dentro da linha, é um +, na grelha é uma linha de bordadura); depois uma série deles iguais, voltas a ter um elemento diferente (centro), outra série de iguais e acaba com um diferente. Existem três diferentes a subtrair ao número total. Como tem de estar divido em igual, divides o resultado da diferença por dois e tens a quantidade de elementos em cada uma daquelas séries.

    Outra hipótese: Parecida à de cima, só que não usas variáveis e geras tudo a altura.

    São as formas mais simples, baseadas no que eu consigo entender que estão a pedir que apliques.
     
  12. Bem shello, em primeiro lugar obrigado pela ajuda e pela paciência! ;)

    Um pouco contra os meus principios, mas também para tentar "engatar" em como se faz isto, podes me deixar aí algum código?
    O cabeçalho já tá, agora o teu raciocínio para o padrão descrito em código.
    Ok? (Isto se não te importares)

    abraço,

    EDIT: Estou mesmo a tentar chegar lá sozinho.
    Até agora fiz isto:

    Código:
    def grelha(x,y):   # x = linhas y = colunas
        a = '+ - - - - '
        b = '+'
        def borda():
            print (y * a) + b
        c = '|         '
        d = '|'
        def linha():
            def linha2():
                print (y * c) + d
            linha2()
        def um_quatro(x,y):
            x()
            y()
            y()
            y()
            y()
        
        um_quatro(borda, linha)
        
        
    grelha(3,5)
    
    
    Desta forma consigo personalizar quantas colunas quero.
    Falta-me as linhas!
     
    Última edição: 2 de Julho de 2008
  13. Decidi fazer um novo post para não ficar demasiado confuso.
    Neste momento a minha função é esta:

    Código:
    def grelha(x,y):   # x = linhas y = colunas
        a = '+ - - - - '
        b = '+'
        def borda():
            print (y * a) + b
        c = '|         '
        d = '|'
        def linha():
            def linha2():
                print (y * c) + d
            linha2()
        def um_quatro(e,f):
            e()
            f()
            f()
            f()
            f()
            
        def linhas():
            um_quatro(borda, linha)
            
        linhas()
    
    
    grelha(3,5)
    
    
    A única coisa que penso que me falta é arranjar maneira de multiplicar a ultima função que aqui tenho "def linhas():" pelo numero de linhas que quero, fazendo-as aparecer sempre "verticalmente" e acresecentar depois um "borda()" no fim para fechar a grelha.
     
  14. firedrops

    firedrops Power Member

    Acho que é difícil explicar-te sem te dar o código. É mais uma questão de análise de problema do que outra coisa, viste que os + - - - se repetem sempre que o numero da linha é multiplo de 6, logo verificando essa instrução sabes que tipo de linha deves fazer print. Para o padrão em x, basta definires um elemento inicial (+ ou |) e repetir uma seq multiplicada x vezes. Espero que o código, feito à pressa, seja claro :/

    Código:
    def grelha(x,y):
        
        linhas = 6 * y
        
        multiplos = []
        
        for i in range(1,linhas):
            
            multiplo = 6 * i
            
            if multiplo > linhas:
                break
            
            multiplos.append(multiplo)
        
        for i in range(0,linhas+1):
            
            if i in multiplos or i==0:
                print '+' + ' - - - - +' * x
            else:
                print '|' + '         |' * x
    
     
    Última edição: 2 de Julho de 2008
  15. shello

    shello %erador
    Staff Member

    Ficaria assim:

    Código:
    # -*- coding: utf-8 -*-
    
    def grelha(x,y):  # x=linhas y=colunas
        # Definir os dois tipos de linhas
        tmp = ((y-3)/2)                    #Nuúmero de elementos entre as junções/bordaduras
        special = '+' + tmp*'-' + '+' + tmp*'-' + '+' + '\n'
        normal  = '|' + tmp*' ' + '|' + tmp*' ' + '|' + '\n'
        
        # Criar as linhas da grelha
        tmp = ((x-3)/2)                    #Número de linhas entre as especiais
        print 2*(special + (tmp*normal) ) + special
    
    (A primeira linha é por causa dos comentários com acentos)

    Assumi, mais uma vez, que não sabes ainda usar ciclos de repetição como o firedrops pôs. Não são realmente necessários, mas era como eu faria intuitivamente :)
     
    Última edição: 2 de Julho de 2008
  16. firedrops

    firedrops Power Member

    A minha resolução é mais 'martelada' :P
     
  17. Mais uma vez obrigado. Mas tal como o shello disse, não sei usar ciclos de repetição.
    Percebi agora o vosso método e realmente é o mais lógico. Mas já agora pegando na minha função:
    Código:
    def grelha(x,y):   # x = linhas y = colunas
        a = '+ - - - - '
        b = '+'
        def borda():
            print (y * a) + b
        c = '|         '
        d = '|'
        def linha():
            def linha2():
                print (y * c) + d
            linha2()
        def um_quatro(e,f):
            e()
            f()
            f()
            f()
            f()
            
        def linhas():
            um_quatro(borda, linha)
            
    
    A única coisa que penso faltar é mesmo conseguir multiplicar verticalmente a função linhas pelo nr de linhas que quero. E acrescentar depois um borda() pra fechar a grelha.
    É capaz de estar um pouco confuso, mas acho que também funcionava.
    Como posso fazer isso? Dá para fazer?

    brw, shello esse teu código funciona? Pelo menos aqui no meu interpretador não está completo. Deves ter esquecido alguma coisa.
     
  18. firedrops

    firedrops Power Member

    A função do Shello não está desenhada para o número de linhas/colunas mas para o número de caracteres por linha e coluna. Tenta valores mais elevados que já obtens o que desejas (ex. grelha(20,30) )

    Em relação à tua função, acho que estás a obtar por uma abordagem um pouco demasiado complexa. Pena ainda não saberes ciclos de repetição (embora não sejam nada difíceis). Eu reeditei a minha função porque vi que tu consideravas um tamanho fixo para o quadrado que eu não estava a considerar na minha primeira função (daí ter posto um argumento para o tamanho da grelha).
     
  19. Hei-de lá chegar.. Ainda estou no principio! :D
     
  20. shello

    shello %erador
    Staff Member

    Eu testei aqui e funcionou.
    Experimenta depois chamar grelha(15,30) para ver se ele desenha.
     

Partilhar esta Página