Ir ao conteúdo
  • Cadastre-se

Tati Schein

Membro Pleno
  • Posts

    20
  • Cadastrado em

  • Última visita

posts postados por Tati Schein

  1. Parece que o código não está conseguindo encontrar os cantos da imagem de tabuleiro:

    import cv2
    import numpy as np
    import os
    import glob
    from google.colab.patches import cv2_imshow
     
    # Defining the dimensions of checkerboard
    CHECKERBOARD = (6,9)
    criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)
     
    # Criação de vetor para armazenar vetores de pontos 3D para cada imagem de tabuleiro de xadrez
    objpoints = []
    # Criação de vetor para armazenar vetores de pontos 2D para cada imagem de tabuleiro de xadrez
    imgpoints = [] 
     
     
    # Definindo as coordenadas mundiais para pontos 3D
    objp = np.zeros((1, CHECKERBOARD[0] * CHECKERBOARD[1], 3), np.float32)
    #objp é um array que armazena os pontos 3D para cada imagem do tabuleiro de xadrez.
    #np.zeros cria uma matriz de zeros nas dimensões que aparecem na sequência
    #o 3 representa as coordenadas x, y e z de cada ponto.
    objp[0,:,:2] = np.mgrid[0:CHECKERBOARD[0], 0:CHECKERBOARD[1]].T.reshape(-1, 2)
    #Atribuição de coordenada 2D ao objp
    prev_img_shape = None
    #Esta variável (None) será usada posteriormente no código para acompanhar a forma da imagem anterior.
     
    # Extraindo o caminho da imagem individual armazenada em um determinado diretório
    images = glob.glob('/content/drive/MyDrive/xadrez/fot*.jpg')
    for fname in images:
        img = cv2.imread(fname)
        gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
        # Encontre os cantos do tabuleiro de xadrez
        # Se o número desejado de cantos for encontrado na imagem, então ret = true
        ret, corners = cv2.findChessboardCorners(gray, CHECKERBOARD, cv2.CALIB_CB_ADAPTIVE_THRESH + cv2.CALIB_CB_FAST_CHECK + cv2.CALIB_CB_NORMALIZE_IMAGE)
         
        """
        If desired number of corner are detected,
        we refine the pixel coordinates and display 
        them on the images of checker board
        """
        if ret == True:
            objpoints.append(objp)
            # refining pixel coordinates for given 2d points.
            corners2 = cv2.cornerSubPix(gray, corners, (11,11),(-1,-1), criteria)
             
            imgpoints.append(corners2)
     
            # Draw and display the corners
            img = cv2.drawChessboardCorners(img, CHECKERBOARD, corners2, ret)
         
        #cv2.imshow('img',img)
        #cv2_imshow(img)  #BOTAR ESSA LINHA DEPOIS
    
    
        cv2.waitKey(0)
     
    cv2.destroyAllWindows()
     
    h,w = img.shape[:2]
     
    """
    Performing camera calibration by 
    passing the value of known 3D points (objpoints)
    and corresponding pixel coordinates of the 
    detected corners (imgpoints)
    """
    ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, gray.shape[::-1], None, None)
     
    print("Camera matrix : \n")
    print(mtx)
    print("dist : \n")
    print(dist)
    print("rvecs : \n")
    print(rvecs)
    print("tvecs : \n")
    print(tvecs)

     

    • Curtir 1
  2. Esse código está plotando 3 imagens iguais, e na verdade eu quero que ele plote 4 imagens: a imagem original, a imagem com o histograma expandido, a imagem com o histograma comprimido e a imagem final melhorada. Podem me ajudar? 

    OBS: estou rodando o código no google colab

    import os
    import numpy as np
    import cv2 as cv
    import matplotlib.pyplot as plt
    
    #Funcao para expansao do histograma
    def hst(img):
        vmax = np.amax(img, axis=(0,1))
        vmin = np.amin(img, axis=(0,1))
        #vmdn = np.median(img, axis=(0,1))
        #vmed = np.mean(img, axis=(0,1))
        bw = (vmax - vmin)  #*np.sqrt(vmed/vmdn)
        cena = np.clip((img - vmin)/(bw +0.001), 0., 1.0)
        return cena
    
    #Funcao para compressão do histograma
    def hsk(img):
        vmin = np.amin(img, axis=(0,1))
        vmax = np.amax(img, axis=(0,1))
        #bw = vmax*vmax - np.sqrt(vmin)
        bw = vmax - vmin
        haze = img*(bw) + (vmin)
        return haze
    
    #Funcao para plotar uma imagem
    def plot(img):
        tx = 1.0
        plt.subplots_adjust(left=0.2, bottom=0.1, right=1.5, top=tx, wspace=None, hspace=0.1)
        plt.subplot(1, 1, 1)
        plt.axis('off')
        plt.imshow(img)      #mostrando via maplotlib
        plt.title('')
        plt.show()
        return
    
    # Funcao para carregar uma imagem 
    def load(img_char, path, rsz):
        os.chdir(path)
        img = cv.imread(img_char, 1)
        img = img[:,:,::-1]   #Converte para o formato RGB
        if(rsz): img = cv.resize(img, (256,256), interpolation = cv.INTER_AREA)
        img = np.nan_to_num(img, nan = 0.001, posinf = 255, neginf = 0)
        img = np.array(img/255, dtype=float)
        return img
    
    # Carrega a imagem
    caminho = '/content'
    img_a = load('img.jpg', caminho, 0)
    img_exp = hst(img_a)        # Imagem com histograma expandido
    img_comp = hsk(img_a)       # Imagem com histograma contraido
    
    #Plota as imagens
    plot(img_a)
    plot(img_exp)
    plot(img_comp)

     

    • Curtir 1
    • Confuso 1
  3. Esse código está plotando a mesma imagem as 3 vezes.. e eu gostaria que plotasse 4 imagens, a imagem original, a imagem expandida, a imagem comprimida e a imagem final melhorada. Alguém pode me ajudar? Faz muito tempo que não mexo em códigos e por isso to sofrendo aqui. 

     

    import os
    import numpy as np
    import cv2 as cv
    import matplotlib.pyplot as plt
    
    #Funcao para expansao do histograma
    def hst(img):
        vmax = np.amax(img, axis=(0,1))
        vmin = np.amin(img, axis=(0,1))
        #vmdn = np.median(img, axis=(0,1))
        #vmed = np.mean(img, axis=(0,1))
        bw = (vmax - vmin)  #*np.sqrt(vmed/vmdn)
        cena = np.clip((img - vmin)/(bw +0.001), 0., 1.0)
        return cena
    
    #Funcao para compressão do histograma
    def hsk(img):
        vmin = np.amin(img, axis=(0,1))
        vmax = np.amax(img, axis=(0,1))
        #bw = vmax*vmax - np.sqrt(vmin)
        bw = vmax - vmin
        haze = img*(bw) + (vmin)
        return haze
    
    #Funcao para plotar uma imagem
    def plot(img):
        tx = 1.0
        plt.subplots_adjust(left=0.2, bottom=0.1, right=1.5, top=tx, wspace=None, hspace=0.1)
        plt.subplot(1, 1, 1)
        plt.axis('off')
        plt.imshow(img)      #mostrando via maplotlib
        plt.title('')
        plt.show()
        return
    
    # Funcao para carregar uma imagem 
    def load(img_char, path, rsz):
        os.chdir(path)
        img = cv.imread(img_char, 1)
        img = img[:,:,::-1]   #Converte para o formato RGB
        if(rsz): img = cv.resize(img, (256,256), interpolation = cv.INTER_AREA)
        img = np.nan_to_num(img, nan = 0.001, posinf = 255, neginf = 0)
        img = np.array(img/255, dtype=float)
        return img
    
    # Carrega a imagem
    caminho = '/content'
    img_a = load('img.jpg', caminho, 0)
    img_exp = hst(img_a)        # Imagem com histograma expandido
    img_comp = hsk(img_a)       # Imagem com histograma contraido
    
    #Plota as imagens
    plot(img_a)
    plot(img_exp)
    plot(img_comp)

     

    • Curtir 1
  4. @Swalls Seria o gráfico da Difusão de cloretos em 50 anos (D(50y)) X O fator de envelhecimento do concreto que deve variar de 0.10 até 0.80.

    Não sei se consegui deixar mais claro a ideia hehe

    @Swalls Acho que consegui algo mais próximo do que o esperado..

     

    Citação
    import matplotlib.pyplot as plt
    import numpy as np
    from scipy.special import erf
    import math
    
    D0 = 55188000 #coeficiente de difusão de cloretos
    t = 50 #anos
    EA=5000.00 #EA é a ativação de energia para a difusão do cloreto [kcal/mol]
    R = 1.00 #R é a constante universal dos gases perfeitos 
    T=18
    t0 =np.float(28./365.) #anos
    tl =np.float(28./365.) #t′ a idade do concreto quando exposto aos íons [anos]
    
    mediaalpha= [0.10, 0.20, 0.30, 0.40, 0.50, 0.60, 0.70, 0.80];
    alpha = np.array(mediaalpha)
    # Cálculo do fator 
    ke=np.exp(EA/R*(1./293.-1./(273.+T)));
    # Cálculo do coeficiente de difussão no tempo t
    D=D0/(1.-alpha)*((1.+tl/t)**(1.-alpha)-(tl/t)**(1.-alpha))*(t0/t)**alpha*ke;
    
    
    plt.plot(alpha,D,color="orange")
    plt.title('Envelhecimento do concreto x Difusão de cloretos')
    plt.grid()
    plt.legend()
    plt.ylabel("D(50y)")
    plt.xlabel("Alpha")
    plt.show()

    Só fico na dúvida agora quanto a impressão do gráfico.. o eixo Y Representa o Coeficiente de difusão de cloretos em 50 anos. E na impressão do gráfico o Y só vai até um pouco além de 2.5.. n sei se está correto.

     

    • Curtir 1
  5. Preciso imprimir um gráfico onde o eixo y é D(50y) e o eixo x é alpha.

    E o Valor da Média de alpha deve ser de 0.10, 0.20, 0.30, 0.40, 0.50, 0.60, 0.70, 0.80.

    Alguém consegue me ajudar a organizar esse código?

    import numpy as np
    import matplotlib.pyplot as plt
    from scipy.stats import norm
    from scipy.special import erf
    
    # Nº de anos de vida útil
    nt=50
    # Tempo até a despassivassão da armadura
    td=np.zeros(nt)
    # Probabilidade de falha até o tempo de despassivassão
    Pf=np.zeros(nt)
    
    # Cálculo da probabilidade de falha
    # Nº de simulações de Monte Carlo
    n=np.int(1e6)
    # Dados de entrada determiní­sticos
    D0=269.9482 #Coeficiente de difusão de referência [m2/ano] medido 
    #no instante t0 [anos] 
    EA=5000.00 #EA é a ativação de energia para a difusão do cloreto [kcal/mol]
    R = 1.00 #R é a constante universal dos gases perfeitos
    t0 =np.float(28./365.) #anos
    tl =np.float(28./365.) #t′ a idade do concreto quando exposto aos íons [anos]
    
    for i in range(nt):
        t=np.float(i+1)
        # Geracão das variáveis aleatórias do problema
        # Concentrassão crí­tica de cloretos
        mediaCcr=0.40;
        desvioCcr=0.10*mediaCcr; #0.10 coeficiente de variação, razão entre desvio padrão e média
        Ccr=np.random.normal(mediaCcr,desvioCcr,n);
        # Concentração superficial de cloretos #lognormal
        mediaCs=2.07;
        desvioCs=0.23*mediaCs;
        zetaCs=(np.log(1.+(desvioCs/mediaCs)**2))**(1./2.);
        lambdaCs=np.log(mediaCs)-1/2*zetaCs**2;
        Cs=np.random.lognormal(lambdaCs,zetaCs,n);
        # Cobrimento da armadura 
        mediaxc=60.00;
        desvioxc=0.05*mediaxc;
        xc=np.random.normal(mediaxc,desvioxc,n);
        # Temperatura média anual
        mediaTemp=18.; 
        desvioTemp=0.20*mediaTemp;
        Temp=np.random.normal(mediaTemp,desvioTemp,n);
        # alpha = fator de envelhecimento do concreto
        mediaalpha=0.10, 0.20, 0.30, 0.40, 0.50, 0.60, 0.70, 0.80; #mm
        desvioalpha=0.10*mediaalpha;
        alpha=np.random.normal(mediaalpha,desvioalpha,n);
        # Cálculo do fator ke
        ke=np.exp(EA/R*(1./293.-1./(273.+Temp)));
        # Cálculo do coeficiente de difussão no tempo t
        mediaD=1.75;
        desvioD=0.09143*mediaD;
        D=np.random.normal(mediaD,desvioD,n);
        D=D0/(1.-alpha)*((1.+tl/t)**(1.-alpha)-(tl/t)**(1.-alpha))*(t0/t)**alpha*ke;
    
    
    plt.plot(alpha,D,color="orange")
    plt.title('Envelhecimento do concreto x Difusão de cloretos')
    plt.grid()
    plt.show()

     

  6. Preciso encontrar o valor de cxtp para todos os valores de x. Como faço??

     

    import pandas as pd
    import matplotlib.pyplot as plt
    import numpy as np
    from scipy.special import erf
    from scipy.optimize import least_squares
    import math
    import cv2
    
    D = 0.148 #coeficiente de difusão de cloretos
    t = 1 #anos 
    Cs = 1.5 #concentração de cloretos na superfície da estrutura
    #x é o cobrimento da armadura = 2.0
    x = [0.10, 0.20, 0.30, 0.40, 0.50, 0.60, 0.70, 0.80, 0.90, 1.00, 1.10, 1.20, 1.30, 1.40, 1.50, 1.60, 1.70, 1.80, 1.90, 2,00];
      
    cxtp = (Cs * (1-(erf((x) / (2 * math.sqrt(D*t))))))
       #cxtp é perfil de concentração 
    print(cxtp);

     

  7. Preciso encontrar o valor de cxtp para todos os valores de x. Como faço??

     

    import pandas as pd
    import matplotlib.pyplot as plt
    import numpy as np
    from scipy.special import erf
    from scipy.optimize import least_squares
    import math
    import cv2
    
    D = 0.148 #coeficiente de difusão de cloretos
    t = 1 #anos 
    Cs = 1.5 #concentração de cloretos na superfície da estrutura
    #x é o cobrimento da armadura = 2.0
    x = [0.10, 0.20, 0.30, 0.40, 0.50, 0.60, 0.70, 0.80, 0.90, 1.00, 1.10, 1.20, 1.30, 1.40, 1.50, 1.60, 1.70, 1.80, 1.90, 2,00];
      
    cxtp = (Cs * (1-(erf((x) / (2 * math.sqrt(D*t))))))
       #cxtp é perfil de concentração 
    print(cxtp);

     

    • Obrigado 1
  8. import cv2
    import numpy as np
    from skimage.io import imsave
    import matplotlib.pyplot as plt
    from statsmodels.graphics.tsaplots import plot_pacf
    import statsmodels as sm
    from PIL import Image 
    from PIL.Image import NEAREST
    from PIL.Image import BICUBIC
    import numpy as np
    import matplotlib.pyplot as plt
    import pandas as pd
    import seaborn as sns
    from sys import argv
    from math import pi, sin
    from scipy import fftpack
    from PIL import Image 
    
    #fs é a frequência de amostragem
    fs = 20.0
    
    t = np.linspace(0,17,17); 
    #t= np.array([0,1,2,3,4,5,6,78,9,10,11,12,13,14,15,16,17])#np.linspace(0,1 , int(1*fs), endpoint=False) #números com intervalos especificados.
    #precisa especificar onde começar e onde parar.
    
    #s is the sum of sine wave(1Hz) and cosine wave(10 Hz)
    s = np.array([0, 0.707, 1, 0.707, 0, -0.707, -1, -0.707, 0, 0.707, 1, 0.707, 0, -0.707, -1, -0.707, 0]) #np.asarray #1.0*np.sin(8 * 2.0 * np.pi * t) #np.sin(np.pi*t)+ np.sin(np.pi*t*2)
    plt.plot(t, s)
    plt.xlim(0,17) #(0,10)
    plt.xlabel("tempo")
    plt.title('Original Signal in Time Domain')
    plt.show()
    
    # Compute the one-dimensional discrete Fourier Transform.
    fft_wave = np.fft.fft(s)
    
    # Compute the Discrete Fourier Transform sample frequencies.
    fft_fre = np.fft.fftfreq(n=s.size, d=1/fs) 
    
    plt.subplot(111)#(211) #linhas, colunas e o número do gráfico.
    plt.plot(fft_fre, fft_wave.real, label="Real part")
    plt.xlim(-5,5)
    plt.ylim(-10,10)
    #plt.legend(loc=1) 
    plt.title("FFT in Frequency Domain")
    
    plt.subplot(212) 
    plt.plot(fft_fre, fft_wave.imag,label="Imaginary part")
    #plt.legend(loc=1)
    plt.xlim(-5,5)
    plt.ylim(-10,10)
    plt.xlabel("frequency (Hz)")
    
    plt.ylabel("Amplitude")
    plt.xlabel("Time [s]")
    plt.bar(fft_fre, np.abs(fft_wave), width=0.5) #np.abs é uma matriz de entrada
    plt.show()
    
    frequencias = fft_fre #Retorne as frequências de amostra da Transformada Discreta de Fourier. 
    period_time = 1 / frequencias
    amplitudes = np.abs(fft_wave) #(0, 0.707, 1, 0.707, 0, -0.707, -1, -0.707) np.abs= calcula o valor absoluto por elemento
    
    fpos=frequencias[frequencias>0] #mascara para só pegar valores positivos
    apos=amplitudes[frequencias>0]
    
    plt.ylabel("Amplitude")
    plt.xlabel("Frequency [Hz]")
    plt.bar(fpos,apos, width=0.1) #plt.scatter p gráfico ser de pontos
    plt.show()
    
    idx=np.argmax(apos) #Retorna os índices dos valores máximos ao longo de um eixo.
    print("Máxima amplitude corresponde a=",apos[idx])
    tpCount     = len(apos)
    timePeriod  = tpCount/fs
    
    #peiodo = ii_arr[apos_max[0]:apos_max[1]] #priodo é a distancia entre duas amplitudes maximas
    #print("O período corresponde a=", tpCount/fs)

    Quero encontrar o período desta onda seno.. alguém consegue me ajudar a organizar o código para que isso seja possível?

     

  9. @Shaman93  Vou postar o código que tenho, ai você vê se consegue me ajudar.. Tenho dificuldade com os códigos ainda 

    import cv2
    import numpy as np
    from skimage.io import imsave
    import matplotlib.pyplot as plt
    from statsmodels.graphics.tsaplots import plot_pacf
    import statsmodels as sm
    from PIL import Image 
    from PIL.Image import NEAREST
    from PIL.Image import BICUBIC
    import numpy as np
    import matplotlib.pyplot as plt
    import pandas as pd
    import seaborn as sns
    from sys import argv
    from math import pi, sin
    from scipy import fftpack
    from PIL import Image 
    
    #fs é a frequência de amostragem
    fs = 20.0
    
    t = np.linspace(0,17,17); 
    #t= np.array([0,1,2,3,4,5,6,78,9,10,11,12,13,14,15,16,17])#np.linspace(0,1 , int(1*fs), endpoint=False) #números com intervalos especificados.
    #precisa especificar onde começar e onde parar.
    
    #s is the sum of sine wave(1Hz) and cosine wave(10 Hz)
    s = np.array([0, 0.707, 1, 0.707, 0, -0.707, -1, -0.707, 0, 0.707, 1, 0.707, 0, -0.707, -1, -0.707, 0]) #np.asarray #1.0*np.sin(8 * 2.0 * np.pi * t) #np.sin(np.pi*t)+ np.sin(np.pi*t*2)
    plt.plot(t, s)
    plt.xlim(0,17) #(0,10)
    plt.xlabel("tempo")
    plt.title('Original Signal in Time Domain')
    plt.show()
    
    # Compute the one-dimensional discrete Fourier Transform.
    fft_wave = np.fft.fft(s)
    
    # Compute the Discrete Fourier Transform sample frequencies.
    fft_fre = np.fft.fftfreq(n=s.size, d=1/fs) 
    
    plt.subplot(111)#(211) #linhas, colunas e o número do gráfico.
    plt.plot(fft_fre, fft_wave.real, label="Real part")
    plt.xlim(-5,5)
    plt.ylim(-10,10)
    #plt.legend(loc=1) 
    plt.title("FFT in Frequency Domain")
    
    plt.subplot(212) 
    plt.plot(fft_fre, fft_wave.imag,label="Imaginary part")
    #plt.legend(loc=1)
    plt.xlim(-5,5)
    plt.ylim(-10,10)
    plt.xlabel("frequency (Hz)")
    
    plt.ylabel("Amplitude")
    plt.xlabel("Time [s]")
    plt.bar(fft_fre, np.abs(fft_wave), width=0.5) #np.abs é uma matriz de entrada
    plt.show()
    
    frequencias = fft_fre #Retorne as frequências de amostra da Transformada Discreta de Fourier. 
    period_time = 1 / frequencias
    amplitudes = np.abs(fft_wave) #(0, 0.707, 1, 0.707, 0, -0.707, -1, -0.707) np.abs= calcula o valor absoluto por elemento
    
    fpos=frequencias[frequencias>0] #mascara para só pegar valores positivos
    apos=amplitudes[frequencias>0]
    
    plt.ylabel("Amplitude")
    plt.xlabel("Frequency [Hz]")
    plt.bar(fpos,apos, width=0.1) #plt.scatter p gráfico ser de pontos
    plt.show()
    
    idx=np.argmax(apos) #Retorna os índices dos valores máximos ao longo de um eixo.
    print("Máxima amplitude corresponde a=",apos[idx])
    tpCount     = len(apos)
    timePeriod  = tpCount/fs
    
    #peiodo = ii_arr[apos_max[0]:apos_max[1]] #priodo é a distancia entre duas amplitudes maximas
    #print("O período corresponde a=", tpCount/fs)

     

  10. Estou rodando esse código:

     

    import matplotlib.pyplot as plt
    import numpy as np
    from scipy import fftpack
    from skimage import util
    from scipy import signal
    import time
    from sympy import factorint
    from skimage import io
    image = io.imread('arv.jpeg')
    
    N = image.shape
    M = image.shape
    
    f, ax = plt.subplots(figsize=(4.8, 4.8))
    ax.imshow(image)
    
    print((M, N), image.dtype)
    F = fftpack.fftn(image)
    
    F_magnitude = np.abs(F)
    F_magnitude = fftpack.fftshift(F_magnitude)
    
    ax.imshow(np.log(1 + F_magnitude), cmap='viridis', extent=(-N//2, N//2, -M//2, M//2)),
    ax.set_title('Spectrum magnitude');

    e gera o seguinte erro:

    bad operand type for unary -: 'tuple'

    alguém sabe como posso resolver?

    Att

  11. Estou rodando esse código:

     

    import matplotlib.pyplot as plt
    import numpy as np
    from scipy import fftpack
    from skimage import util
    from scipy import signal
    import time
    from sympy import factorint
    from skimage import io
    image = io.imread('arv.jpeg')
    
    N = image.shape
    M = image.shape
    
    f, ax = plt.subplots(figsize=(4.8, 4.8))
    ax.imshow(image)
    
    print((M, N), image.dtype)
    F = fftpack.fftn(image)
    
    F_magnitude = np.abs(F)
    F_magnitude = fftpack.fftshift(F_magnitude)
    
    ax.imshow(np.log(1 + F_magnitude), cmap='viridis', extent=(-N//2, N//2, -M//2, M//2)),
    ax.set_title('Spectrum magnitude');

    e aparece o seguinte erro:

    bad operand type for unary -: 'tuple'

    alguém pode me ajudar a resolver?

    Att

  12. Agora estou tentando organizar a impressão em ordem alfabética, mas algo da errado.. o nome da certo, mas a parte do cpf não.

    #include <stdio.h>
    #include <string.h>
    int main () /* Declara a funcao principal de inicio do programa, seu tipo de retorno e seu argumento */
    {
    int count, i, j, t;
    char mat[10][2][100], aux[10][2][100]; 
    char *p;
    
    /* Entrada de dados e armazenamento na matriz tridimensional de 10 linhas e duas colunas com 100 char cada */
    for (count = 0; count < 10; count++)
    {
    printf ("\nEntre com o nome da pessoa %d: ", count+1); /* Função que imprime na tela e solicita ao usuário a entrada de dados*/
    gets (mat[count][0]); /* Armazena a entrada de dados na variavel nome */
    printf ("\nEntre com o cpf da pessoa %d: ", count+1); /* Função que imprime na tela e solicita ao usuário a entrada de dados*/
    gets (mat[count][1]); /* Armazena a entrada de dados na variavel nome */
    }
    
    /* Organização dos dados atraves do retorno da função strcmp */
    for (i = 1; i < 10; i++) 
    { 
       for (j = 1; j < 10; j++) 
       {
             if (strcmp(mat[j - 1][0], mat[j][0]) > 0)
          {
             strcpy(aux[j - 1][0], mat[j - 1][0]);
             strcpy(aux[j - 1][1], mat[j - 1][1]);
             strcpy(mat[j - 1][0], mat[j][0]);
             strcpy(mat[j - 1][1], mat[j][1]);
             strcpy(mat[j][0], aux[j][0]);
             strcpy(mat[j][1], aux[j][1]);
             
          }
       }
    }
    
    /* Impressão dos dados com a utilização de ponteiros */
    p=mat[0]; /* Inicialização do ponteiro p para a linha inicial de mat */
    for (count=0;count<20;count++) /* Função que inicia um contador*/
    {
    printf (" %s\n", *p); /* Imprime o conteudo do ponteiro */
    p++; /* Incrementa o endereço do ponteiro */
    }
    
     
    return(0); /* Retorno da funcao main */
    }

     

  13. Estou tentando inicialmente fazer a entrada intercalada de dados.. mas nem isso não sei muito bem! Depois que isso estiver ok eu vejo como fazer para imprimir em ordem alfabética e como utilizar ponteiros.

    #include <stdio.h>
    
    int main(){
          
       char matriz[10][30][12];
       int i, j, k;
        printf("Digite o Nome: \n");
        scanf("%c", j); 
        printf("Digite o CPF: \n");
        scanf("%c", k); 
        
         for( i =0 ; i<10 ; i++)
        {
            for(j =0; j<30 ; j++)
            {
                
                for(k=0; k<12 ; k++)
                {
                  
             scanf("%c",&matriz[i][j][k]);
          
                }
                
            }
        }
    
            printf("\n\n\n");
        
        
        for( int  i =0 ; i<10 ; i++)
        {
            for(int  j =0; j<30 ; j++)
            {
                
                for(int  k=0; k<12 ; k++)
                {
                  
             printf("%c\n" ,matriz[i][j][k]) ;
                }
             
            }
        }
    
            
        
        return 0;
        
    }

     

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×
×
  • Criar novo...