Mensajes

Un programador eficiente, siempre conoce la forma o via de obviar las sentencias debiles que producen inestabilidad al codigo tipo los break, goto, continue, etc....

Era entendible utilizar estas sentencias cuando existian  ENIAC, BRLESC, Edvac y las tarjetas perforadas.. vamos, ahi era obligatorio, pero a estas alturas con estos modelos de PC y estos SO con capacidad de hacer variadas cosas a la vez, y estos lenguajes de alto nivel orientado a objetos como Java en este caso, que se supone que manejan y limpian la carga de memoria, las excepciones, y un sinumero de cosas.... creo que para un programador eficiente (Que es lo que tu quieres dejar notado aqui sobre tu persona 43H4FH44H45H4CH49H56H45H) EL uso de break es inadmisible...) No es valido para la optimizacion, ni lectura limpia del codigo fuente en si. Solo eso.

-Ramc- y yo nos hemos ido de fiesta          

Lo siento 43H4FH44H45H4CH49H56H45H  no creo que queramos discutir...

Al menos esa no es mi intencion, y tampoco se me ensena eso   
 

-Ramdc-    te doy mucha razon en el uso del break en un bucle  eso es una mera violacion de un lenguaje limpio estructurado. Pero conversando con Mister Perfecto en logica y analitica no creo que llevemos mucha ventaja o si 

Si introduce 1000 cuantas líneas imprimirá en pantalla hasta llegar al número deseado.

Lo mas logico al hacer un programa de uso para otra persona es hacer los tipos de inserciones dinamicas, ya sean para vectores, arreglos o variables. Si ponemos datos meramente estaticos, para que servira tu aplicacion??? imaginate una calculadora donde este solamente predestinada a sumar 2+2 de que te sirve a ti o a otro??? Sinceramente, si te basas en que un codigo esta mal, sencillamente por aplicar la tecnica de valores dinamicos, asumo que tu no programas ninguna aplicacion para uso particular de nadie, ya que el 90% de aplicaciones teoricamente aplican el uso de valores dinamicos sino son inusables.

Y si para ti es una limitante que yo no haya colocado un numero maximo de insercion, eso no es mala logica analitica porque para datos grandes por eso se desarrollo y existe el tipo de datos para guardar una cantidad de numero infinitos.. entonces si mi teoria segun tu esta erronea, los desarrolladores que crearon el tipo de datos a guardar en una variable tambien.

Esto amigo, no es un error, cualquier programador novato si considera puede hacer una variable de valor dinamico y limitar hasta que numero maximo (En el caso del programa expuesto) tiene x usuario capacidad de realizar una insercion. Por ende, vuelvo y te repito...

Habla menos y aporta mas   

43H4FH44H45H4CH49H56H45H  yo creo que deberias hablar menos y aportar mas 

No creo que seas tu la persona mas adecuada para comentar aca como deberia y como no alguien programar un codigo, sobretodo porque observando tu pequeno 'ejemplo' lo mismo que criticas en mi lo estas aplicando en tu codigo.... yo esperaba al menos, ya que te tomas la molestia de criticar algo redundante que tu tambien estas aplicando, yo espera al menos ver que tu creases tu propia funcion independiente que funcionase como un bucle y una sentencia de control de flujo a la vez... al menos si criticas algo, ten con que respaldarlo, sino tienes con que respaldarlo mejor no digas nada.

Yo se perfectamente como funciona una sentencia de control de flujo y es totalmente valido usarlo dentro de un bucle for como lo idealize en mi codigo (aunque imprima numero pares/impares y no primos).

En lo unico que te doy la razon es en lo de numero primo. Pero no en el concepto de la forma como hice el codigo.

Un saludo.

Yo no se Java (Apenas aprendiendo)

Pero creo que igual esto te serviria :

Código [Seleccionar] Expandir


class aplicacion {

public static void main(String[] args) {

Scanner x = new Scanner(System.in);

int numero;

System.out.println("Inserte un numero!");
numero = x.nextInt();

int contador;

for ( contador = 0; contador <= numero; ++contador ) {
if ((contador%2) == 0) {
System.out.println("Es un numero primo "+contador);
} else {
System.out.println("No es un numero primo "+contador);
}
}
}
}



Bueno, Seguimos dandole continuacion adonde me he quedado

Vamos a conocer mas objetos 'widgets' de Tk dentro de Perl

Utilizo el ejemplo anteriormente ya dado  :


#!/usr/bin/perl
use strict;
use warnings;
use Tk;

my $ventana = MainWindow->new();
$ventana->minsize(qw(400 400));
$ventana->resizable('FALSE','FALSE');
$ventana->Label(-text => "Hola Mundo")->pack();
my $texto = $ventana->Text(-width => 20, -height => 15, -background => 'white')->pack();
my $entrada = $ventana->Entry(-width => 20, -background => 'white')->pack();
$ventana->Button(-text => "Copiar & Pegar", -command => \&copia)->pack();
$ventana->Button(-text => "Limpiar", -command => \&limpieza)->pack();


MainLoop();

sub copia
{
my $resultado = $entrada->get();
$texto->insert("end", "$resultado");
}

sub limpieza
{
$entrada->delete('0',"end");
$texto->delete('0.0', "end");
}

Aqui agregue otro boton nuevo y otra funcion.

* $ventana->Button(-text => "Limpiar", -command => \&limpieza)->pack();
Este es el boton nuevo, que llama a la funcion limpieza.

*sub limpieza
{
$entrada->delete('0',"end");
$texto->delete('0.0', "end");
}
- Aqui tenemos 2 lineas interesantes, llamamos a las variables ya declaradas $entrada y $texto y le pasamos una funcion de configuracion 'delete' dicha funcion de Tk soporta 2 parametros que son "end" que es hasta donde existan caracteres, y '0' quiere decir 1 linea, mas '0.0' hace referencia a varias. Recordemos que la variable $texto guarda un widget tipo Texto que ocupan varias filas y columnas, mas la variable $entrada solo ocupa 1 linea.

Ahora que ocurre si queremos poner en nuestra ventana principal que los botoncitos aparezcan alineados de forma horizontal o vertical exacta?? Creamos una ventana nueva

#!/usr/bin/perl
use strict;
use warnings;
use Tk;

my $ventana = MainWindow->new();
$ventana->minsize(qw(250 200));
$ventana->maxsize(qw(250 200));
$ventana->Button(-text => "Pinchame", -width => 10, -relief => 'groove')->grid(-row => 1, -column => 1, -padx => 2);
$ventana->Button(-text => "Clickeame", -width => 10, -relief => 'sunken')->grid(-row => 1, -column => 2, -padx => 2);
$ventana->Button(-text => "Soy un Boton", -width => 10, -relief => 'raised')->grid(-row => 2, -column => 1, -pady => 2);
$ventana->Button(-text => "Pick Me", -width => 10, -relief => 'flat')->grid(-row => 2, -column => 2, -pady => 2);

MainLoop();

* $ventana->maxsize(qw(250 200));
Esta opcion de configuracion a nuestro objeto principal, especifica cual es el tamano maximo de largo y ancho que nuestra ventana soportara.. dependiendo el valor que indiquemos el usuario podra agrandar y disminuir la ventana agarrandola con el raton por los bordes. En caso que a la ventana le digamos que el tamano minimo y maximo son iguales, nadie podra agrandar o disminuir la ventana, (igual manera ocurre si hacemos $ventana->resizable('FALSE','FALSE')) En caso que indiquemos valores distintos podremos disminuir o agrandar la ventana hasta el tamano maximo y minimo indicado.

* $ventana->Button(-text => "Pinchame", -width => 10, -relief => 'groove')->grid(-row => 1, -column => 1, -padx => 2);
Volvemos con los botones, aqui utilizamos mas opciones disponibles al objeto Button aparte de la opcion text, le indico el tamano de largo (width) y el estilo (relief) que tendra el boton. Tk posee varios estilos que podemos aplicar a nuestros objetos 'widgets' entre estos tenemos (groove, flat, sunken, raised). Tambien podemos pasarle colores de fondo y de letra a los botones, basta con utilizar dentro de las opciones.. para colorear el fondo -background => 'color' y para las fuentes -foreground => 'color'.
Por Ejemplo :

$ventana->Button(-text => "Pinchame", -width => 10, -relief => 'groove', -background => 'black', -foreground => 'yellow')

Pero vemos que ya no uso pack() para encapsular los botones dentro del objeto padre ventana sino grid()??? que es grid()???
Tanto pack y grid, son 2 paquetes de geometria especificos de Tk. Ambos tienen opciones que podemos pasarle distintas, los dos encapsulan el objeto 'widget' dentro del objeto padre principal..

Entonces para que necesito grid si pack hace lo mismo o inversa?
Por las opciones que grid ofrece que pack no grid nos permite alinear exactamente nuestro widget hijo en fila - columna (Con pack no podemos hacer esto ). Fijense que en grid utilizo 2 opciones llamada row y column (que es fila y columna) Asi puedo ir moldeando cada boton en este caso ordenadamente en la columna 1 fila 1, en la columna 1 fila 2, en la columna 2 fila 1, y asi sucesivamente

Ahi otra opcion que le estoy pasando a grid() se llama padx y pady, que hacen estas dos?
padx indica la cantidad de espacio a otorgar al widget para separarlo horizontalmente del otro widget.
pady indica la cantidad de espacio a otorgar al widget para separarlo verticalmente del otro widget.

Para probar pueden quitar a los botones las opciones padx y pady y ejecutar la aplicacion.. que ocurre?? Que salen los 4 botones pegados. Mas si aplican padx con una numeracion de espacio elegida por ustedes, podran ver como los botones se van espaciando horizontalmente.. y si le agregan pady con una enumeracion de espacio elegida por ustedes, podran ver como los botones se van separando entre ellos verticalmente...

padx y pady aplican en pack() tambien

No confundir padx y pady con ipadx y ipady, estos 2 ultimos ejercen la misma funciones que los 2 primeros solo que dentro del widget hijo (Boton en este caso) y no fuera de ellos. O sea dependiendo de la enumeraciones que pasemos a ipadx y ipady se aplicaran pero a modificar el tamano (ancho y largo) del boton en este caso.


my $ventana = MainWindow->new();
$ventana->minsize(qw(250 200));
$ventana->maxsize(qw(250 200));
my $frama = $ventana->Frame->pack();
$frama->Checkbutton(-text => "Pinchame", -borderwidth => 3, -relief => 'groove')->pack(-pady => 10);
$frama->Radiobutton(-text => "Clickeame", -borderwidth => 3, -relief => 'groove')->pack();
$frama->Label(-text => 'Soy una palabra')->pack();

Perl::Tk, Tambien soporta Frames como muchos saben dentro de los Frames podemos encapsular varios hijitos 'widgets' en este caso encapsulo 2 un Checkbutton y un Radiobutton, estos ultimos 2 igual que los botones normales, acceptan como opcion la llamada a una funcion 'command' por ejemplo :

* $frama->Checkbutton(-text => "Pinchame", -borderwidth => 3, -relief => 'groove', -command => \&copia)->pack(-pady => 10);

Asi cada vez que el usuario clickee se llamara a la funcion copia.

my $ventana = MainWindow->new();
$ventana->minsize(qw(250 200));
$ventana->maxsize(qw(250 200));
$ventana->Scrolled('Text', -background => 'white')->pack(-fill => 'both', -expand => 'true');

* $ventana->Scrolled('Text', -background => 'white')->pack(-fill => 'both', -expand => 'true');
Aqui declaramos un objeto widget del tipo Text - texto. Con la unica variante que le agregamos una barra scroll, las barras scrolls nos sirven por si abrimos un documento un poco extenso poder leerlo hasta el final. Facilidad de las cuales carecemos sino usamos barra scrolls como el primer ejemplo hacia el widget Texto por Ejemplo ::

* $ventana->Text(-width => 20, -height => 10, -background => 'white')->pack();

Tanto al widget Texto con Barra Scroll como sin esta, le podemos indicar el tamano (ancho*alto) deseado o podemos cubrir la ventana completa pasandole ciertas opciones a pack por ejemplo -fill y -expand. Estas 2 particulares opciones hacen lo siguiente, la primera 'fill' indica que ese widget ocupara el mismo tamano total verticalmente que posee la ventana principal, siempre se lo indiquemos asi a fill con la opcion 'both' que quiere decir de lado a lado en el idioma Tk.  y la opcion -expand = a verdadero indica que dicho widget hijo no solo ocupara verticalmente el tamano de la ventana sino que tambien ocupara horizontalmente el tamano total de esta...

Aqui posteo un ejemplo de un archivo un poco extenso abierto dentro del widget Texto con Barra Scroll.


#!/usr/bin/perl
use strict;
use warnings;
use Tk;


my $ventana = MainWindow->new();
$ventana->minsize(qw(250 200));
$ventana->maxsize(qw(250 200));
my $entrada = $ventana->Scrolled('Text', -background => 'white')->pack(-fill => 'both', -expand => 'true');

open(AA,"/etc/profile");
my @todo = <AA>;
$entrada->insert("end", "@todo ");
close (AA);

MainLoop();

(Nota :: Solo funciona en Linux la ubicacion '/etc/profile' Si estas en otra plataforma, indicar otro directorio
y su respetivo archivo de texto )

Ya que no he visto referencia alguna en la web sobre tutoriales de Perl/Tk en Espanol.
Aqui presento uno como parte de mi colaboracion personal......

Que necesita tu SO para ejercer esto?

1 - El interprete Perl.

Nada mas. No es requerido que tengas las librerias TK instaladas en tu SO, ya que
en este caso utilizare el modulo Perl::Tk el cual no es mas que una implementacion
de algunos 'widgets' de Tk, mas son independientes y no requieren ni trabajan directamente
con las librerias de Tk.

Si disponemos de Perl, tenemos que bajar el Modulo Perl::Tk de la web de Cpan. Para ello abrimos
una terminal Shell y hacemos con el usuario 'root' lo siguiente.

bash$ perl -MCPAN -e shell

Si es la primera vez que ejecutas la terminal de CPAN te aparecera un cuestionario de preguntas
de configuracion.. deberas responder segun tus gustos. Al terminar entramos al interprete de cpan.

cpan>

Cuando lo veas sencillamente manda a buscar he instalar el modulo requerido.

cpan> install Tk

Cpan se encargara de buscar, bajar he instalar todo. al finalizar puedes salir de alli, y abrir un editor
para comenzar a trabajar con perl y Tk.

En el editor colocamos lo siguiente :

#!/usr/bin/perl
use strict;
use warnings;
use Tk;

Expongo.. En la primera linea '#!/usr/bin/perl' indica cual sera el interprete que llamara la aplicacion.
La segunda y tercera linea 'use strict' y 'use warnings' son 2 pragmas de Perl, estas sirven la primera para
recordarnos a codear explicitamente en un lenguaje estructurado limpio (nada de break, continue, goto, etc).
Y la segunda sirve como Debugger en caso de que queramos depurar al ejecutar el script.

La tercera linea 'use Tk' sencillamente importa el modulo 'Tk' a nuestra aplicacion.

#!/usr/bin/perl
use strict;
use warnings;
use Tk;

my $ventana = MainWindow->new();
$ventana->minsize(qw(400 400));
$ventana->resizable('FALSE','FALSE');
$ventana->Label(-text => "Hola Mundo")->pack();

MainLoop();

Guardamos todo lo anterior y ejecutamos :

bash$ perl aplicacion.pl

Se abrira una ventana con un Hola Mundo.

Explicaciones ::

my $ventana = MainWindow->new();
* En esta linea declaramos una variable 'my $ventana' que inicializa un objeto que funcionara como la ventana principal.
Perl tiene 3 tipos de declaracion para las variables, las escalares siempre comienzan con simbolo de dolar $ y guardan cualquier dato caracter o numerico, los arreglos que siempre comienzan con el simbolo arroba @ y por igual guardan cualquier dato caracter o numerico y las variables hash que comienzan con el simbolo % y son variables que hacen referencia a un caracter o numero .. En resumen en Perl no hay que declarar el tipo de dato a guardar dentro de una variable. (Para mas info de tipos de variables, averiguen sobre programacion en Perl).

$ventana->minsize(qw(400 400));
* En esta linea se especifica que el tamano minimo de nuestra ventana sera 400 de ancho y 400 de largo.

$ventana->resizable('FALSE','FALSE');
* EN esta linea se especifica que la ventana no podra ser reducida ni agrandada tanto por ancho como por largo.

$ventana->Label(-text => "Hola Mundo", -font => 'Courier')->pack();
* En esta linea creamos un objeto widget Label que llevara como Texto la palabra 'Hola Mundo'. Todos los objetos de Tk tienen tienen
opciones en este caso el objeto Label le estamos pasando una opcion de Texto a presentar en la ventana, en este caso 'Hola Mundo',
al objeto Label tambien le pasamos otra opcion, -font es el tipo de fuente que llevara definido nuestro 'Hola Mundo' en este caso
utilizo Courier pero igual pueden utilizar otro soportado dentro de su SO. las opciones de los objetos widgets deben ir separadas por coma.

Luego tenemos pack(), este lo que hace es encapsular o guardar el objeto Label dentro de ventana que es nuestro objeto principal. Es obligatorio encapsular el objeto dentro de la ventana padre. En caso de que obvies encapsularla.. perl no sabra donde debe guardar a Label por ende no se presentara en pantalla cuando ejecutemos el script.. ya que lo que saldra en pantalla es el objeto padre ventana y si ventana no tiene un hijo encapsulado no lo mostrara.

pack() aparte de encapsular funciona como un manejador de tamano igual que su contraparte grid().. los cuales explicare mas adelante en otro tutorial.

* MainLoop()
- En esta ultima linea creamos un Loop del objeto principal.. cual es el objetivo de esto? el objetivo es que la linea anterior se encarga de llamar y responder a todos los eventos pasados al objeto principal ventana. Si obviamos esta ultima linea nuestro objeto principal jamas se desplegara por pantalla. Ya que MainLoop maneja todos los eventos del objeto padre.


#!/usr/bin/perl
use strict;
use warnings;
use Tk;

my $ventana = MainWindow->new();
$ventana->minsize(qw(400 400));
$ventana->resizable('FALSE','FALSE');
$ventana->Label(-text => "Hola Mundo")->pack();
my $texto = $ventana->Text(-width => 20, -height => 15, -background => 'white')->pack();
my $entrada = $ventana->Entry(-width => 20, -background => 'white')->pack();
$ventana->Button(-text => "Copiar & Pegar", -command => \&copia)->pack();

MainLoop();

sub copia
{
my $resultado = $entrada->get();
$texto->insert("end", "$resultado");
}

Comentarios :

my $texto = $ventana->Text(-width => 20, -height => 15, -background => 'white')->pack();
* Aca creamos una variable escalar, que guarda un objeto widget de tipo Texto, Texto en este caso tiene 3 opciones
que es de tamano largo y ancho y su color de fondo. Utilizamos pack() al final para especificar que el objeto Text
sera encapsulado dentro del objeto padre ventana.

my $entrada = $ventana->Entry(-width => 20, -background => 'white')->pack();
* Aca creo otra variable que guarda un objeto widget de tipo Entrada, nuevamente con 2 opciones pasadas
siempre separadas por comas, las opciones indican el color de fondo y el largo que llevara el widget.

$ventana->Button(-text => "Copiar & Pegar", -command => \&copia)->pack();
* Aqui declaro un objeto widget tipo Boton, con 2 opciones una el texto a representar el boton, y la otra el
evento que realizara el boton al ser clickeado. Al ser clickeado el boton, este llamara a la funcion 'copia'

sub copia
{
my $resultado = $entrada->get();
$texto->insert("end", "$resultado");
}
* Esta es la funcion llamada cuando el boton es clickeado. Dentro de la funcion se declara una variable escalar '$resultado'
que guardara los datos insertados dentro de la variable '$entrada', recuerden que la variable '$entrada' guarda un objeto Entry cualquier info digitada aqui sera captada get() y guardada en la variable '$resultado'.

$texto->insert("end", "$resultado");
* '$texto' es la variable que guarda al objeto widget de Texto, al llamar a 'insert' este lo que le indica que insertara cierta informacion dentro del widget, en este caso se insertara la variable '$resultado'.

El nino no se complica es normal que pregunte.

Mi caso fue peor que no comprendi en todo el post que era lo que realmente el estaba solicitando .. nisiquiera porque me lo explico con cucharitas 

Yo tenia claro en mi cabeza que el deseaba todos los registros que se repetian en ambos campos sin importar si conjugaban o no en los 2 al mismo tiempo.... y me estaba haciendo un ocho porque una peticion asi es un poco imposible... porque rompe el agrupamiento de los registros al haber mas o menos duplicados en cada campo... 

Pero me alegra sobremanera.. que otro nino haya entendido la peticion en si, y haya podido ayudarte    creo que a partir de ahora estaras mas amistoso con Mysql 

Creo que ahi tienes tu respuesta, si era eso lo que estabas buscando que aun no lo se    tengo una confusion sobre si son todos los registros que se repiten en cada campo o es todos los registros que concuerdan en los 2 campos...

Pero sea cual sea el caso, espero que la respuesta anterior te haya servido
Aunque no veo la necesidad de tantos CONCAT.

select * from tabla
where(id, grupo)
in(
select id, grupo from tabla
group by id, grupo
having count(*)>1);

Ya te entendi, aunque dejame decirte que eso que pides por NOrmalizacion, no existe o sea se da el caso que pides y es posible hacerlo en 2 tablas distintas... pero en 1 misma tabla a la vez? O sea esa condicion que pides de verdad no suele darse en una misma tabla... Estoy buscando una via factible.. aunque esto se salga de la Normalizacion puedes probar hacer esto ::

mysql> select grupo, null id
    -> from tabla
    -> group by grupo
    -> having count(grupo)>1
    -> union all
    -> select null grupo, id
    -> from tabla
    -> group by id
    -> having count(id)>1;
+-------+------+
| grupo | id   |
+-------+------+
| 1     | NULL |
| 2     | NULL |
| NULL  | 1    |
| NULL  | 2    |
| NULL  | 3    |
| NULL  | 4    |
+-------+------+
6 rows in set (0.00 sec)

Recuerda que en ambos campos hay distintos numeros de columnas con registros repetidos y por este hecho no pueden caer ambos campos juntos, por ende estoy buscando una forma de no utilizar NULL para rellenar los faltantes..... Pero realmente no es algo comun de ver.