Analisis programacion de pc

Ejercicios Básicos C #

Ejercicios Básicos C #

Pues eso, Como e empezado Hace pokito con C # que Heho los Típicos Ejercicios Básicos y los keria compartir con vosotros, y si kereis pues animaros y Poner

Alguno Vuestro Mini-Calculadora En Modo consola:

Código

1. utilizando System ;

2.

3. espacio de nombres Calculadora

4. {

5. clase de programa

6. {

7. pública estática vacío principal ( string [ ] args )

8. {

9. flotador Primero ; // El Primer Número

10. flotar Segundo ; // El Segundo Número

11. cadena operacion ; // La operacion un Realizar

12.

13. Consola . Título = "Mini-Calculadora" ; // Damos formato a la consola

14. Consola . BackgroundColor = ConsoleColor . Blanca ;

15. Consola . ForegroundColor =

ConsoleColor . Azul ;

16. Consola . Claro ( ) ;

17.

18. Consola . setCursorPosition ( 3 , 2 ) ; // Pedimos El Primer Número

19. Consola . WriteLine ( "Introduzca el Número de imprimación" ) ;

20. Consola . setCursorPosition ( 60 , 2 ) ;

21. Primero = float . Parse ( consola . ReadLine ( ) ) ;

22.

23. Consola . setCursorPosition ( 3 , 3 ) ; // Pedimos La operacion

24. Consola . WriteLine ( "Introduzca La operacion un Realizar (+, -, *, /)" ) ;


26. operacion = Consola . ReadLine ( ) ;

27.

28. Consola . setCursorPosition ( 3 , 4 ) ; // Pedimos El Segundo Número

29. Consola . WriteLine ( "Introduzca El Segundo Número" ) ;


31. Segundo = float . Parse ( consola . ReadLine ( ) ) ;

32.

33.


// Mostramos la solucion ...

35. Consola . WriteLine ( "__________" ) ;

36.


38. Consola . WriteLine ( "El m resultado es" ) ;


40.

41. Consola . WriteLine ( Calcular ( Primero, Segundo, operacion ) ) ;

42. Consola . ReadKey ( ) ;

43.

44. }

45.

46. privada estática cadena Calcular ( float Primero, flotador Segundo, cadena de operacion )

47. {

48. flotar temp ;

49. interruptor ( operacion ) // Estructura interruptor con

50. {

51. caso "+" :

52. temp = Primero + Segundo ;

53. volver temp . ToString ( ) ;

54. caso "-" :

55. temp = Primero - Segundo ;


57. caso "*" :

58. temp = Primero * Segundo ;


60. caso "/" :

61. temp = Primero / Segundo ;


63. }

64. volver "-1" ;

65. }

66. }

67. }

68.

Mini-Calculadora En Modo gráfico: (los Nombres de los Controles hijo faciles de

deducir viendo el código )

Código


2. utilizando System.Collections.Generic ;

3. utilizando System.Drawing ;

4. utilizando System.Windows.Forms ;

5. utilizando System.Text ;

6.

7. espacio de nombres Calculadora

8. {

9. /// <Summary>

10. /// Descripción de MainForm.

11. /// </ Summary>

12. pública parcial clase MainForm : Formulario

13. {

14. int oper ; // 1 -> + | 2 -> - | 3 -> * | 4 -> /

15. flotador Primero ;

16.

17.

18. pública MainForm ( )

19. {

20. InitializeComponent ( ) ;

21. }

22.

23. vacío Numero7Click ( objeto emisor, EventArgs e )

24. {

25. txtnum . Texto = txtnum . Texto + 7 ;

26. }

27.


29. {


31. }

32.


34. {


36. }

37.


39. {


41. }

42.


44. {


46. }

47.


49. {


51. }

52.


54. {


56. }

57.


59. {


61. }

62.


64. {


66. }

67.


69. {


71. }

72.

73. vacío CHaga clic en ( objeto emisor, EventArgs e )

74. {

75. txtnum . Texto = "" ;

76. }

77.

78. anular DivClick ( objeto emisor, EventArgs e )

79. {

80. oper = 4 ;

81. Primero = float . Parse ( txtnum . texto ) ;


83. }

84.

85. vacío MulClick ( objeto emisor, EventArgs e )

86. {

87. oper = 3 ;



90. }

91.

92. vacío ResClick ( objeto emisor, EventArgs e )

93. {

94. oper = 2 ;



97. }

98.

99. vacío SumClick ( objeto emisor, EventArgs e )

100. {

101. oper = 1 ;



104. }

105.

106. vacío SolClick ( objeto emisor, EventArgs e )

107. {

108. flotar Segundo = int . Parse ( txtnum . texto ) ;

109. float resultado m ;

110.

111. interruptor ( Oper )

112. {

113. caso 1 :

114. resultado m = Primero + Segundo ;

115. txtnum . Texto = m resultado . ToString ( ) ;

116. romper ;

117. caso 2 :

118. resultado m = Primero - Segundo ;


120. romper ;

121. caso 3 :

122. resultado m = Primero * Segundo ;


124. romper ;

125. caso 4 :

126. resultado m = Primero / Segundo ;

127. txtnum . Texto = m

resultado . ToString ( ) ;

128. romper ;

129. }

130. }

131. }

132. }

Un EJEMPLO muy sencillo resolver párr ecuaciones de seegundo Grado (Anadir 3 texto boton cuadro y un):

Código



3. utilizando System.ComponentModel ;

4. utilizando System.Data ;




8.

9. espacio de nombres Ecuaciones

10. {

11. pública parcial clase Form1 : Form

12. {

13. pública Form1 ( )

14. {


16. }

17.

18. privada vacío resolver_Click ( objeto emisor, EventArgs e )

19. {

20. Ecuacion miEcuacion = nuevo Ecuacion ( doble . Parse ( un . texto ) , doble . Parse ( b . Texto ) , doble . Parse ( c . texto ) ) ;

21. }

22. }

23. }

Exporador de Carpetas: (Anadir cuadro de texto de la ONU "txtRuta" dos Listas "lbcar" y "LBAR" y la ONU con boton nombre Por Defecto)

Código



3. utilizando System.ComponentModel ;

4. utilizando System.Data ;




8. utilizando System.IO ;

9.

10. espacio de nombres ExploradorCarpetas

11. {

12. pública parcial clase Form1 : Form

http://www.google.com/search?q=new+msdn.microsoft.com

13. {

14. pública Form1 ( )

15. {


17. }

18.

19. // El formulario de carga

20. privado void Form1_Load ( objeto emisor, EventArgs e )

21. {

22. // Iniciamos el txtRuta

23. txtRuta . Texto = Directorio . GetDirectoryRoot ( Directorio . GetCurrentDirectory ( ) ) ;

24.

25. // Listamos las Carpetas

26. Carpetas ( txtRuta . texto ) ;

27.

28. // Listamos los Archivos

29. Archivos ( txtRuta . texto ) ;

30. }

31.

32. // El Botón párr EXPLORAR Rutas

33. privado void Button1_Click ( objeto emisor, EventArgs e )

34. {



37.



40. }

41.

42. // Al Hacer doble clic Sobre Una ruta la colocamos en txtRuta

43. privada vacío lbcar_DoubleClick ( objeto emisor, EventArgs e )

44. {

45. txtRuta . Texto = lbcar . SelectedItem . ToString ( ) ;

46.



49.



52. }

53.

54. // Lista Metodo Que COLOCA las Carpetas de la ruta Indicada en el

55. // Cuadro Correspondiente

56. privados vacíos Carpetas ( string ruta )

57. {

58. lbcar . Artículos . Claro ( ) ;

59.

60. string [ ] folder = Directory . GetDirectories ( Ruta ) ;

61.

62. foreach ( string coche en folder )

63. lbcar . Artículos . Añadir ( coche ) ;

64. }

65.

66. // Lista Metodo Que COLOCA los Archivos de la ruta Indicada en el

67. // Cuadro Correspondiente

68. privados vacíos Archivos ( string ruta )

69. {

70. LBAR . Artículos . Claro ( ) ;

71.

72. string [ ] archivo = Directorio . GetFiles ( ruta ) ;

73.

74. foreach ( string ar en archivo )

75. LBAR . Artículos . Añadir ( ar ) ;

76. }

77. }

78. }

Operaciones simples matrices estafadores:

Código


2.

3. espacio de nombres Matrices

4. {

5. clase de programa

6. {

7. pública estática vacío principal ( string [ ] args )

8. {

9. flotar [ , ] mat1 ; // Las matrices

10. flotar [ , ] mat2 ;

11.

12. int f1, c1 ; // El Numero de Filas y Columnas de las matrices

13. int f2, c2 ;

14.

15. // Llamamos al menú y recojemos la Opción Seleccionada

16. byte opcion ;

17. hacer {

18. opcion = menú ( ) ;

19. } mientras que ( opcion > = 5 ) ;

20.

21. interruptor ( opcion )

22. {

23. caso 1 : // SUMA

24.

25. // Leemos El Numero de Filas y Columnas de las matrices 1 Y 2

26. Consola . WriteLine ( "Introduzca el Número de Filas de las matrices 1 y 2" ) ;

27. f1 = int . Parse ( consola .

ReadLine ( ) ) ;

28. Consola . WriteLine ( "Introduzca el Número de Columnas de las matrices 1 y 2" ) ;

29. c1 = int . Parse ( consola . ReadLine ( ) ) ;

30.

31. // Pedimos los Datos de Filas y Columnas

32. Consola . WriteLine ( "Introduzca los Datos de la matriz 1 enumerandolos FILAS POR:" ) ;

33. mat1 = leer ( f1, c1 ) ;


35. mat2 = leer ( f1, c1 ) ;

36.

37. // Mostramos la suma de Ambas matrices

38. SUMA ( mat1, mat2 ) ;

39. romper ;

40.

41. caso 2 : // RESTA

42.

43. // Leemos El Numero de Filas y Columnas de las matrices 1 Y 2

44. Consola . WriteLine ( "Introduzca el Número de Filas de las matrices 1 y 2" ) ;

45. f1 = int . Parse ( consola . ReadLine ( ) ) ;

46. Consola . WriteLine

( "Introduzca el Número de Columnas de las matrices 1 y 2" ) ;


48.

49.



52. mat1 = leer ( f1, c1 ) ;


54. mat2 = leer ( f1, c1 ) ;

55.

56. // Mostramos la resta de Ambas matrices

57. Resta ( mat1, mat2 ) ;

58. romper ;

59.

60. caso 3 : // PRODUCTO POR UN ESCALAR

61.

62. // Leemos el Número de Filas y Columnas de la matriz 1

63. Consola . WriteLine ( "Introduzca el Número de Filas de la matriz 1" ) ;

64. f1 = int . Parse ( consola . ReadLine ( ) ) ;


( "Introduzca el Número de Columnas de la matriz 1" ) ;


67.

68. flotar escalar ;

69. Consola . WriteLine ( "Introduzca el escalar POR EL Que Quiere multiplicar la matriz" ) ;

70. escalar = float . Parse ( consola . ReadLine ( ) ) ;

71.



74. mat1 = leer ( f1, c1 ) ;

75.

76. // Mostramos La Solución

77. prodEscalar ( mat1, escalar ) ;

78.

79. romper ;

80. }

81. Consola . ReadKey ( ) ;

82. }

83.

84. // Función Que Muestra el menú de Selección de Operaciones

85. pública estática byte menú ( )

86. {

87. tratar {

88. byte opcion ;


90. Consola . WriteLine ( "Menú:" ) ;


92. Consola . WriteLine ( "Elija La operacion Que Quiere Hacer:" ) ;

93. Consola . WriteLine ( "1 - Suma de matrices" ) ;

94. Consola . WriteLine ( "2 - Resta de matrices" ) ;

95. Consola . WriteLine ( "3 - Producto Por escalar ONU" ) ;

96.

97. opcion = byte . Parse ( consola . ReadLine ( ) ) ;

98.

99. si ( opcion > = 1 && opcion <= 3 ) {


101. volver opcion ;

102. }

103. otra cosa {


105. volver 5 ;

106. }

107. } catch { // En Caso de error


109. volver 5 ;

110. }

111. }

112.

113. // Que Función lee los Datos de las matrices

114. pública estática float [ , ] leer ( int Filas, int Columnas )

115. {

116. flotar [ , ] r = nuevo float [ Filas, Columnas ] ;

117. para ( int fila = 0 ; fila < Filas ; fila ++ )

118. {

119. para ( int columna = 0 ; columna < Columnas ; columna ++ )

120. {

121. ret [ fila, columna ] = float . Parse ( consola . ReadLine ( ) ) ;

122. }

123. }

124. volver ret ;

125. }

126.

127. // La Función SUMA

128. pública estática vacío suma ( float [ , ] mat1, flotar [ , ] mat2 )

129. {

http://www.google.com/search?q=new+msdn.microsoft.com

130. Consola . WriteLine ( "La suma de Sus dos matrices es (enumeradas Por Filas)" ) ;

131. para ( int fila = 0 ; fila <= mat2 . GetUpperBound ( 0 ) ; fila ++ )

132. {

133. para ( int columna = 0 ; columna <= mat2 . GetUpperBound ( 1 ) ; columna ++ )

134. {

135. flotar suma ;

136. SUMA = mat1 [ fila, columna ] + mat2 [ fila, columna ] ;

137. Consola . WriteLine ( SUMA . ToString ( ) ) ;

138. }

139. Consola . WriteLine ( "" ) ;

140. }

141. }

142.

143. // La Función resta

144. pública estática vacío Resta ( float [ , ] mat1, flotar [ , ] mat2 )

145. {

146. Consola . WriteLine ( "La resta de Sus dos matrices es (enumeradas Por Filas)" ) ;


148. {

149. para ( int columna = 0 ;

columna <= mat2 . GetUpperBound ( 1 ) ; columna ++ )

150. {

151. flotar resta ;

152. Resta = mat1 [ fila, columna ] - mat2 [ fila, columna ] ;

153. Consola . WriteLine ( resta . ToString ( ) ) ;

154. }


156. }

157. }

158.

159. // Por Producto escalar de la ONU

160. pública estática vacío prodEscalar ( float [ , ] mat1, flotar escalar )

161. {

162. Consola . WriteLine ( "La multiplicación del escalar Por Su matriz es (enumerada Por Filas)" ) ;


164. {

165. para ( int columna = 0 ; columna <= mat1 . GetUpperBound ( 1 ) ; columna ++ )

166. {

167. flotar esc ;

168. esc = mat1 [ fila, columna ] * escalar ;


( esc . ToString ( ) ) ;

170. }


172. }

173. }

174. }

175. }

Ventanas-pong, con dos Botones de radio de las Naciones Unidas y buton simulo en clasico pong, muy Cutre pero entretenido xDDD

Código





5.

6. espacio de nombres MiniJuegoPelota

7. {

8. /// <Summary>

9. /// Descripción de MainForm.

10. /// </ Summary>

11. pública parcial clase MainForm : Formulario

12. {

13. // 1 -> Derecha -1 -> Izquierda

14. // 1 -> Abajo -1 -> Arriba

15. privada int dx = - 1 , dy = 1 ;

16.

17. // Variables q Contiene la ultima Tecla Pulsada Por Cierta pala

18. // Párrafo q el rebote se efectue del una o otra direcion

19. // 'U' (arriba) -> arriba 'd' (abajo) -> abajo

20. privado carbón d1, d2 ;

21.

22.

23. pública MainForm ( )

24. {


26. }

27.

28. vacío Timer1Tick ( objeto emisor, EventArgs e )

29. {

30. // Movemos la "pelota"

31. pelota . Izquierda + = dx ;

32. pelota . Top + = dy ;

33.

34. // Para el movimiento de la pelota

35.

36. // Dx = pelota.Location.X> = this.ClientSize.Width? -1: Dx;

37. // Dx = pelota.Location.X == 0? 1: dx;

38.

39. si ( la pelota vasca . Ubicación . X + 18 > = esto . ClientSize . Ancho )

40. {

41. Timer1 . Enabled = false ;

42. MessageBox . Mostrar ( "Gana El Jugador 1" , "Felicidades" ) ;

43. }

44. si ( la pelota vasca . Ubicación . X == 0 )

45. {

46. Timer1 . Enabled = false ;

47. MessageBox . Mostrar ( "Gana El Jugador 2" , "Felicidades" ) ;

48. }

49.

50. // Si choca contra la instancia de parte inferior o el menú

51. dy = pelota . Ubicación . Y + 50 > = esto . ClientSize . Anchura ? - 1 : dy ;

52. dy = pelota . Ubicación . Y == 25 ? 1 : dy ;

53.

54. // Si choca contra la pala1

55. si ( la pelota vasca . Izquierda == pala1 . Izquierda + pala1 . Ancho )

56. {

57. si ( la pelota vasca . Top > pala1 . Top && pelota . Top < pala1 . Top + pala1 . Altura )

58. {

59. dx = 1 ; // Hacemos Que valla Hacia La Derecha

60. // Y en funcion de la ultima Tecla Pulsada Hacia arriba o abajo

61. dy = d1 == 'u' ? - 1 : 1 ;

62. }

63. }

64.

65. // Si choca contra la pala2

66. si ( la pelota vasca . Izquierda == pala2 . Izquierda - pala2 . Ancho )

67. {

68. si ( la pelota vasca . Top > pala2 . Top && pelota . Top < pala2 . Top + pala2 . Altura )

69. {

70. dx = - 1 ; // Hacemos Que valla Hacia la izq

71. // Y en funcion de la ultima Tecla Pulsada Hacia arriba o abajo

72. dy = d2 == 'u' ? - 1 : 1 ;

73. }

74. }

75.

76. }

77.

78.

79.

80. // Para mover la pala 1 A = arriba, Z = abajo

81. // Para mover la pala 2 K = arriba, M = abajo

82. vacío MainFormKeyPress ( objeto emisor, KeyPressEventArgs e )

83. {

84. interruptor ( Char . ToUpper ( e . KeyChar ) )

85. {

86. caso 'A' : // La pala1

87. pala1 . Top - = 10 ;

88. si ( pala1 . Top < 25 ) pala1 . Top = 25 ;

89. d1 = 'u' ;

90. romper ;

91. caso 'Z' :

92. pala1 . Top + = 10 ;

93. si ( pala1 . Top + pala1 . Altura > = esto . ClientSize . Altura ) pala1 . Top = esto . ClientSize . Altura - pala1 . Altura ;

94. d1 = "D" ;

95. romper ;

96.

97. caso 'K' : // La pala2

98. pala2 . Top - = 10 ;

99. si ( pala2 . Top < 25 ) pala2 . Top = 25 ;

100. d2 = 'u' ;

101. romper ;

102.

103. caso 'M' :

104. pala2 . Top + = 10 ;

105. si ( pala2 . Top + pala2 . Altura > = esto . ClientSize . Altura ) pala2 . Top = esto . ClientSize . Altura - pala2 . Altura ;

106. d2 = "D" ;

107. romper ;

108. }

109. }

110.

111.

112. // Las options del menú

113. vacío NuevoToolStripMenuItemClick ( objeto emisor, EventArgs e )

114. {

115. Timer1 . Enabled = verdadero ;

116. pelota . Izquierda = 154 ;

117. pelota . Arriba = 134 ;

118. }

119.

120. vacío ContrrolesToolStripMenuItemClick ( objeto emisor, EventArgs e )

121. {

122. MessageBox . Mostrar ( "Pulsar las Teclas A y K subir párrafo y Las Teclas Z y M párr bajar las respectivas

paletas de los Jugadores 1 y 2" , "Controles" ) ;

123. }

124.

125. vacío SalirToolStripMenuItemClick ( objeto emisor, EventArgs e )

126. {

127. Aplicación . Salir ( ) ;

128. }

129. }

130. }

Technology

Analisis programacion de pc