Comment puis-je écrire une seule boucle de course de a à z et de A à Z dans C?

Je veux combiner les deux pour des boucles en une seule boucle. Comment puis-je le faire?

Je veux faire une boucle par de a à z et A à Z, comme suit:

char ch;
for (ch = 'A' ; ch <= 'Z' ; ch++ )
{ 
}
for (ch = 'a' ; ch <= 'z' ; ch++ )
{
}

mais à l'aide d'une seule boucle.

Si vous voulez en C, pourquoi cette question est également étiqueté C++?
... et le point de ce qui est?
hopp , désolé, j'ai supprimé le c++ , qui a été par erreur.
Est-ce devoirs?
Ensuite, vous devez utiliser isalpha au lieu de le faire vous-même.

OriginalL'auteur kobe | 2011-06-15

  1. 22

    Je n'ai pas personnellement comme cette solution, mais:

    char * letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
for (char * ptr = letters; *ptr != 0; ++ptr) {
    char ch = *ptr;
    ...
}
    Heh, mais il fonctionne
    ne sera pas, mais *ptr volonté. Sinon strlen(letters) ne fonctionnerait pas.
    1. +1. 2. Fixe que l'OP code ne lettres majuscules en premier. 3. Élargi à l'ensemble de l'alphabet de la chaîne.
    Hmm, je n'ai pas fait préférer cette approche Billys. C'est moins lisible (on constate un manque de caractère dans une magie de la chaîne comme ça, ou de l'avis, si l'ordre où inhabituel?), il est probablement plus lent, et il n'est même pas tout court. Non pas que cela importe vraiment dans un cas simple...
    Moi aussi, je n'aime pas cette solution (principalement pour les raisons Eamon souligné), mais si vous vous souciez qu'il soit complètement portable et agnostique à codage de caractères, je pense que c'est à peu près la seule solution correcte. Si vous êtes heureux d'assumer en ASCII codage, utilisez l'une des autres réponses.

    OriginalL'auteur Ernest Friedman-Hill

  2. 23
    for (char ch = 'A' ; ch <= 'z' ; ch == 'Z' ? ch = 'a' : ++ch )
{
}

    Devrait fonctionner -- mais s'il vous plaît, s'il vous plaît, ne pas infliger ça à vos collègues développeurs.

    +1 pour autant renier votre propre (correct) réponse!
    Lol-Merci!
    +1: simple, fonctionne.
    Non, bien sûr, je suis sur un mainframe IBM. Mon commentaire s'adressait à @Eamon "simple, les œuvres". Ernest la solution de ne travail, et je peux même ajouter le åäö j'ai besoin de ma langue maternelle. 🙂
    Ou pour le dire d'une autre manière - l'OP dit que la boucle s'exécute de A à Z, non pas que les valeurs entre A et Z sont tous les Roman lettres majuscules 🙂 Donc, il ne le "travail" sur EBCDIC trop, c'est juste énumère un ensemble différent de char des valeurs, qui ne sont pas des points du code de caractère à tous. Insuffisance spécifications pouvez toujours être weaseled-à-dire ce que le code fait réellement. Va mal si 'z' < 'A', de l'esprit, mais à moins que la Bo de fouets rapide C mise en œuvre à l'aide d'un jeu de caractères qu'il invente aujourd'hui, ce n'est pas le cas sur la machine, il est.

    OriginalL'auteur Billy ONeal

  3. 3

    Vous pouvez le faire dans une boucle imbriquée (deux boucles, mais seulement une partie du corps):

    for (start = 'A'; start <= 'a'; start += 'a' - 'A') {
    end = start + 'Z' - 'A';
    for (ch = start; ch <= end; ++ch) {
         /* body */
    }
}
    +1 pour ce qui ressemble le plus d'esprit bendingly-le mal de réponses ici.
    Mua-ha-ha! (et merci!) La maintenance du Code folk besoin d'un défi maintenant et puis. 🙂
    Je suggère plutôt char start = 'A'; do{ char end = start + 'Z' - 'A'; char ch; for (ch = start; ch <= end; ++ch) { /* body */ } }while((start = 'A' + 'a' - start) == 'a'); qui n'a pas d'ASCII de la dépendance.
    qui a encore la dépendance qui a..z sont consécutifs; et ce n'est pas comme ASCII/unicode est d'aller n'importe où...
    Mais le but est de reproduire des OP d'origine comportement en boucle, ne pas frapper chaque lettre et ne lettres. 🙂

    OriginalL'auteur Ted Hopp

  4. 3

    Bien, la première question est pourquoi? ...et la deuxième question est de faire vous vous souciez de la non-jeux de caractères ASCII (comme vos deux boucles échoue pour EBCDIC), mais la façon rapide et sale de raccordement de l'est

    for (ch = 'A'; ch <= 'z'; ch++) {
    if (ch > 'Z' && ch < 'a') ch = 'a';
     :
    C'est fondamentalement la même chose que j'ai fait sauf que j'ai utilisé le point d'interrogation de l'opérateur. +1.

    OriginalL'auteur Chris Dodd

  5. 2
    const char diff = 'a' - 'A';
for (ch = 'A' ; ch <= 'Z' ; ch++ )
{
  char small_ch = ch + diff;
 //... 
}
    Cette itération dans un ordre différent de l'OP le code original.
    l'idée est de combiner le contenu des deux boucles, pour les caps utilisation ch et pour les petits, l'utilisation small_ch.
    Oui, c'est vrai. Cependant, à proprement parler, l'OP du code effectue une itération comme "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", bien que cet exemple va se répéter que "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpqqrrssttuuvvwwxxyyzz". Si l'ordre importe le résultat serait différent.
    merci pour tous les commentaires et de votre temps
    Je pense que ce n'est pas la question. Si vous allez répéter la logique, à la fois pour le ch et une fois pour small_ch, vous pourriez aussi bien avoir de boucles. Ce qui est voulu est la seule variable ch pour itérer sur A .. Z, a .. z, et d'appliquer une certaine logique à chaque fois.

    OriginalL'auteur iammilind

  6. 1

    Essayez ceci:

            for (int i = 0; i < 52; ++i)
            printf("%c\n", 'A' + i + ('a' - 'Z' - 1) * (i/26));
    Remplacement de 6 avec ('a' - 'Z') de supprimer l'ASCII dépendance.
    Eamon Nerbonne souligne que le simple fait que 'a' .. 'z' sont contigus est un ASCII dépendance ... seulement Ernest Friedman-Hill réponse évite que. (Encore, ('a' - 'Z') est moins obscur que 6.)

    OriginalL'auteur Scott Urban

  7. 0
    for (int i=0;i<26;++i) {

     char ch = 'A' + i;
     //Logic for Uppercase letters.

     char ch1 = 'a' + i;
     //Logic for Lowercase letters.

}
    Cette itération dans un ordre différent de l'OP de la réponse.
    ONeal Ya, mais pour imprimer le nombre de caractères, cela devrait suffire je pense.
    Euh, je crois que le but est d'éviter la duplication de la logique, qui est sans doute le même pour tous les personnages.

    OriginalL'auteur N.R.S.Sowrabh

  8. 0
    #include<stdio.h>
#include<conio.h>
int main()
{
    int i;
    char e;
    for(i=65;i<=122;i++)
    {
                        if(i<91||i>96)
                        {
                            e=i;
                        printf("%c\n",e);
                        }
                        }

    getch();
}

    OriginalL'auteur g123

  9. 0

    Une solution simple et efficace est

    int i;
for(i = 0; i < 52; i++){
  char ch = i + (i < 26? 'A' : 'a');
  /* do something with ch */
}

    bien que je préfère, surtout sensible dans les langues qui permettent des fonctions imbriquées,

    for(ch = 'A'; ch <= 'Z'; ch++)
  dosomething(ch);
for(ch = 'a'; ch <= 'z'; ch++)
  dosomething(ch);

    P. S. Kobe, je vois dans l'un de vos commentaires que votre raison pour les boucles est de vérifier si un caractère est une lettre ... mais la boucle est une horrible façon de le faire. Vous pouvez simplement faire

    if(('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z')){
    /* c is a letter */
}

    ou, beaucoup mieux,

    #include ctype.h
...
if(isalpha((unsigned char)c)){
    /* c is a letter */
}

    (Pour comprendre pourquoi que le cast est nécessaire, lire la isalpha page de man et le langage C standard. C'est l'un de plusieurs abominable aspects de C.)

    OriginalL'auteur Jim Balter

  10. 0
    for (char ch = 'A'; ch <= 'z'; ch = ch == 'Z'?'a':ch+1) {
       //loop body
}

    Cette approche est similaire à Billy, mais avec un peu moins méchant boucle-incrément de déclaration. Je ne me dérangerait pas infliger cela sur un autre dev, bien que je pourrais écrire l'incrément de déclaration d'une fonction à préciser si la valeur de l'échelon déclaration a plus complexe:

    char nextChar(char c) { return c == 'Z' ? 'a' : c+1; }

for (char ch = 'A'; ch <= 'z'; ch = nextChar(ch)) {
       //loop body
}
    Pour comparer des pommes avec des pommes, développez ch++ de Billy code et vous obtenez ch == 'Z'?ch='a':ch=ch+1; vous avez simplement pris en compte la ch= et déplacé plus de chemin depuis ses rhs, ce qui pourrait être considéré comme plus méchant. Comme pour le fait d'infliger, ni l'un ni (ni tout à fait un peu d'autres réponses ici) serait de passer mon examen de code.
    Eh bien, j'aime mes expressions sans effets secondaires; donc, je préfère de beaucoup x = some-side-effect-free-expression à un si déguisé en ternaire. Une telle formulation se prête mieux à la fonction d'extraction (sans se soucier de l'aliasing et autres joyeusetés). En outre, la quintessence de la boucle est une phase d'initialisation, un test, et un incrément, donc plus proche de ce modèle, je peux rester, plus je suis content -- bien sûr, tout est donc trivialement bref rien de tout cela ne me dérange pas, mais à chacun son propre. La mauvaise qualité dépend vraiment du contexte.

    OriginalL'auteur Eamon Nerbonne

  11. -1

    C'est inutile, il suffit d'utiliser une boucle for. Les variables sont principalement utilisés comme compteurs, ou les limites de la boucle de sorte qu'il sait quand il faut mettre fin. Faire une boucle. Deux boucles sont totalement inutiles.

    Les boucles d'eux-mêmes comme l'écrit sont inutiles, parce qu'ils ne font rien ... de toute évidence, l'OP a l'intention de mettre le code (le même code à deux reprises) à l'intérieur de ces boucles. L'OP se demande comment faire avec une boucle plutôt que deux. Votre "réponse" ne répond pas à la question, n'est pas la question, et se répète trois fois. (Et je ne suis même pas le downvoter.)

    OriginalL'auteur Jason

  12. -1
    void main()
{   
    char ch;

    for(ch= 65 ; ch <= 122 ; ch++)
    {
        if ( ch>=91 && ch<=96)
        continue;                     //hey check this out if this helps
        printf("%c \n",ch);
    }

}

    OriginalL'auteur Abhishek Nag

  13. -2
    for (ch = 'A';ch <= 'z';ch++) {

}

    Cela comprendra également quelques caractères comme '[' et ']'...

    OriginalL'auteur slartibartfast