Orden de letras de manera alfabetica en C

[EmmanuelTR9]

Hola ante todo he estado intentando lograr ordenar las letras con su orden respectivo pero no logro hacerlo, y publico aca si me podrian ayudar. Al ingresar una letra la debe de empezar a acomodar pero no se muy bien como hacer ello.

Código [Seleccionar] Expandir

#include <stdio.h>
#include <conio.h>

int fin=27;
char Caracter;
char Abecedario[27];
main(void){
do {
printf("Solicitar Caracter: ");
scanf("%d,", &Caracter);


} while(fin != 27);
printf("\nGracias ");
getch();
}

[engel lex]

si son char, en el scanf no capturas con %d capturas con %c

te recomiendo buscar el algoritmo de ordenamiento de burbuja, es el mas simple de los algoritmos de organizacion

[EmmanuelTR9]

si son char, en el scanf no capturas con %d capturas con %c

te recomiendo buscar el algoritmo de ordenamiento de burbuja, es el mas simple de los algoritmos de organizacion

Si he intentado con ese metodo pero no logro poderlo adaptar ya que tengo que usar do while

[engel lex]

un for es un do while compacto

en resumen

Código (c) [Seleccionar] Expandir

// el for comun
for(int i = 0; i < 10; i++){

  // hacer cosas

}

// un do while de funcionamiento similar

int i = 0;
do{
 
  // hacer cosas

  i++;
}while(i < 10)




con este conocimiento puedes adaptar los codigos comunes, intentalo, muestra que lograste y si tines dudas, realizalas

aqui sobre el ordenamiento de burbuja en detalle
https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C/Algoritmos_y_Estructuras_de_Datos

[EmmanuelTR9]

un for es un do while compacto

en resumen

Código (c) [Seleccionar] Expandir

// el for comun
for(int i = 0; i < 10; i++){

  // hacer cosas

}

// un do while de funcionamiento similar

int i = 0;
do{
 
  // hacer cosas

  i++;
}while(i < 10)




con este conocimiento puedes adaptar los codigos comunes, intentalo, muestra que lograste y si tines dudas, realizalas

aqui sobre el ordenamiento de burbuja en detalle
https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C/Algoritmos_y_Estructuras_de_Datos

Ya intente pero no logro ingresar de manera manual cada una de la letra

Código [Seleccionar] Expandir

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    int main(void)
    {
      int fin;
      char ch, entrada[27], salida[27];
      int no[26] = {0}, n, c, t, x;
     
      printf("Escribe las palabras a ordenar\n");
      scanf("%s", entrada);
     
      n = strlen(entrada);
      for (c = 0; c < n; c++)
      {
        ch = entrada[c] - 'a';
        no[ch]++;
      }
      t = 0;
      for (ch = 'a'; ch <= 'z'; ch++)
      {
        x = ch - 'a';
        for (c = 0; c < no[x]; c++)
        {
          salida[t] = ch;
          t++;
        }
      }
      salida[t] = '\0';
      printf("%s\n", salida);
      return 0;
    }

[dijsktra]

si son char, en el scanf no capturas con %d capturas con %c

te recomiendo buscar el algoritmo de ordenamiento de burbuja, es el mas simple de los algoritmos de organizacion

A ver, según entiendo yo, si dice "según se lee la letra se acomoda", no se trata de ordenar, sino de insertar en un vector ordenado una letra. Pero el mayor problema, veo yo, tiene que ver con el hecho de capturar caracteres de la entrada estandard. Eso es otro problema, porque la entrada buferada exige que le des al intro, y a la vez el intro es un caracter (que a t'i no te vale para tu proposito).


Propuesta:

Código (c) [Seleccionar] Expandir

/*
P : N>0 and sorted(A,0,N-1) and V=A
Q : perm(V,A) and sorted(V,0,N)


I : perm(V,A) and sorted(V,0,n) and sorted(V,n, N)
and (0<n<N-1 - > V[n-1]<V[n+1]) and 0 <= n <= N-1

!B : n==0 || V[n]>=V[n-1]

 B : n > 0 && V[n]<V[n-1]

|- I and !B -> Q

Quote:

 C(n) = n >= 0

|- I -> C(n) >= 0

Invariant snapshot:
-------------------

0                 n           N
+-----+-----+-----+-----+-----+
|  0  |  1  |  3  |  2  |  4  |
+-----+-----+-----+-----+-----+

Init:
-----
n = N- 1

|- P -> I[n/N-1]

Step:
----
 n= n- 1

|- I and B and n=T -> (n<T)[n/n-1]

Restore:
--------

 V[n],V[n-1]=V[n-1],V[n]

Pseudocode:
-----------

  n=N-1
  while n>0 and V[n]<V[n-1] do
    V[n],V[n-1]=V[n-1],V[n]
    n=n-1
  done

*/

void *insertChar(char V[], int N)
{
 for(int n=N-1 ; (n && V[n]<V[n-1]);n--)
   {
     const int An=V[n];  /* To do swapping */
     V[n]=V[n-1];
     V[n-1]=An;
   }
 return V;
}



#include <stdio.h>
#include <string.h>


#define MAX 100000
int main(int argc, char* args[])
{
 int N;
 char V[MAX];
 memset(V,0, MAX);

  for(N=0 ; (scanf("%c",&c)==1) && c!='\n' ; )
    {
      V[N++]=c;
      printf("%d %c %s\n",strlen(V),c,insertChar(V,N));
    }
 return 0;
}

Ejemplp:

Código [Seleccionar] Expandir


gcc char.cc -o char && ./char
enunlugardelamancha
1 e e
2 n en
3 u enu
4 n ennu
5 l elnnu
6 u elnnuu
7 g eglnnuu
8 a aeglnnuu
9 r aeglnnruu
10 d adeglnnruu
11 e adeeglnnruu
12 l adeegllnnruu
13 a aadeegllnnruu
14 m aadeegllmnnruu
15 a aaadeegllmnnruu
16 n aaadeegllmnnnruu
17 c aaacdeegllmnnnruu
18 h aaacdeeghllmnnnruu
19 a aaaacdeeghllmnnnruu


[EmmanuelTR9]

A ver, según entiendo yo, si dice "según se lee la letra se acomoda", no se trata de ordenar, sino de insertar en un vector ordenado una letra. Pero el mayor problema, veo yo, tiene que ver con el hecho de capturar caracteres de la entrada estandard. Eso es otro problema, porque la entrada buferada exige que le des al intro, y a la vez el intro es un caracter (que a t'i no te vale para tu proposito).


Propuesta:

Código (c) [Seleccionar] Expandir

/*
P : N>0 and sorted(A,0,N-1) and V=A
Q : perm(V,A) and sorted(V,0,N)


I : perm(V,A) and sorted(V,0,n) and sorted(V,n, N)
and (0<n<N-1 - > V[n-1]<V[n+1]) and 0 <= n <= N-1

!B : n==0 || V[n]>=V[n-1]

 B : n > 0 && V[n]<V[n-1]

|- I and !B -> Q

Quote:

 C(n) = n >= 0

|- I -> C(n) >= 0

Invariant snapshot:
-------------------

0                 n           N
+-----+-----+-----+-----+-----+
|  0  |  1  |  3  |  2  |  4  |
+-----+-----+-----+-----+-----+

Init:
-----
n = N- 1

|- P -> I[n/N-1]

Step:
----
 n= n- 1

|- I and B and n=T -> (n<T)[n/n-1]

Restore:
--------

 V[n],V[n-1]=V[n-1],V[n]

Pseudocode:
-----------

  n=N-1
  while n>0 and V[n]<V[n-1] do
    V[n],V[n-1]=V[n-1],V[n]
    n=n-1
  done

*/

void *insertChar(char V[], int N)
{
 for(int n=N-1 ; (n && V[n]<V[n-1]);n--)
   {
     const int An=V[n];  /* To do swapping */
     V[n]=V[n-1];
     V[n-1]=An;
   }
 return V;
}



#include <stdio.h>
#include <string.h>


#define MAX 100000
int main(int argc, char* args[])
{
 int N;
 char V[MAX];
 memset(V,0, MAX);
 for(N=0 ; (scanf("%c",&V[N++])==1) ; )
   {
     if (V[N-1]=='\n') break; // Hack. I don't know how to
      // avoid '\n'  as character.
     const char c=V[N-1];
     insertChar(V,N);
     printf("%d %c %s\n",strlen(V),c,V);
   }
 return 0;
}

Ejemplp:

Código [Seleccionar] Expandir


gcc char.cc -o char && ./char
asdfdgfhj1234
1 a a
2 s as
3 d ads
4 f adfs
5 d addfs
6 g addfgs
7 f addffgs
8 h addffghs
9 j addffghjs
10 1 1addffghjs
11 2 12addffghjs
12 3 123addffghjs
13 4 1234addffghjs

Intente realizar como el mencionado pero no pude me puedes orientar un poco mas porfavor

[dijsktra]

Intente realizar como el mencionado pero no pude me puedes orientar un poco mas porfavor

Copia el programa, estúdialo y dale curso en tu computador...
Te sale ? Que parte te confunde?
Sobre todo, distingue lo esencial (el algoritmo) de lo accesorio (la entrada/salida de datos).

[@XSStringManolo]

Los char no dejan de ser números internamente. La letra A es el número 65, la B el 66...


Para ordenar yo buscaría si coincide el resultado con el esperado:

 

Código (c) [Seleccionar] Expandir

int diccionario[100];
  for(int i = 65 ; i <= 90; ++i)
  {
  diccionario[i-65] = i;
  }/* El resultado sería algo como:
diccionario[0] = 65;
diccionario[1] = 66;
...
diccionario[25] = 90;
*/

  for(int i = 97 ; i <= 122; ++i)
  {
  diccionario[i-71] = i;
  }/* El resultado sería algo como:
diccionario[0] = 65; Equivale a 'A'
diccionario[1] = 66; Equivale a 'B'
diccionario[25] = 90; Equivale a 'Z'
diccionario[26] = 97; Equivale a 'a'
diccionario[27] = 98;
...
diccionario[50]= 122; equivale a 'z'

Imprime los contenidos del array y los ajustas.*/


  if (caracter1 == diccionario[i])
  {
  resultado[x] = caracter1;
  }

Por si no queda claro, esto es lo mismo ue hacer:
HOLA

Código (c) [Seleccionar] Expandir

Está la A (int 65) en [0]? No.
{
No hacer nada.
}

Está la A (int 65) en [1]? No.
{
No hacer nada.
}

Está la A (int 65) en [2]? No.
{
No hacer nada.
}

Está la A (int 65) en [3]? Si.
{
ArrayResultado[0] = palabra[3];
}

Está la a (int 92) en [0]? No.
{
No hacer nada.
}

Está la a (int 92) en [1]? No.
{
No hacer nada.
}

Está la a (int 92) en [2]? No.
{
No hacer nada.
}

Está la a (int 92) en [3]? No
{
No hacer nada.
}

...


Básicamente vas mirando por orden alfabético cada letra del diccionario si está o no en todas las letras de la palabra.
Si encuentras la letra, esta se añade a un array resultado, que será el que contenga las letras ordenadas.

Tanto la lógica como la implementación es sencilla.


https://elcodigoascii.com.ar/
https://www.tutorialspoint.com/cprogramming/c_type_casting.htm

[CalgaryCorpus]

Es innecesario poner los codigos ASCII, o saberselos o tener una tabla.
Siempre que se quiere tener el codigo de la letra 'a' se puede usar 'a'

Código (c) [Seleccionar] Expandir

for( int i = 65; i <= 90; i++ )
puede reemplazarse por

Código (c) [Seleccionar] Expandir

for( int i = 'a'; i <= 'z'; i++ )

los caracteres literales son SIEMPRE vistos como la representacion numerica de ellos, asi que tambien seria posible expresiones como  'z'-'a' si es que se necesita saber la distancia entre el ultimo caracter a utilizar y el primero (eventualmente hay que sumarle 1 a esto, si se hace necesario).

Lo mismo con las mayusculas.