• # « Complexité »

    Posté par (site web personnel, Mastodon) . En réponse au lien OK ? Éliminer la complexité inutile des langages de programmation actuels. Évalué à 10.

    Ce « langage » supprime la complexité dans le même sens que ce que j'avais fait pour cet atelier :

    Alors pour cette version en Java, j'ai voulu faire simple. J'ai donc éliminé tout ce qui pourrait nuire à la bonne compréhension du code, à savoir :

    • Les notions compliquées de String ou pire, de StringBuffer|StringBuilder. Ou même de tableau de char. On affiche directement les caractères les uns après les autres.
    • Tout import explicite à une quelconque lib externe ou à une quelconque fonction non implicite de la JVM.
    • Tout ce qui ressemble à un objet, autre ce qui est strictement imposé en Java.
    • Toute forme de fonction.
    • Toutes variable intermédiaire inutiles.
    • Les boucles imbriquées — une seule, c'est déjà beaucoup.
    • Les variables avec un nom compliqué, donc composé de plusieurs caractères.
    • Tous les nombres dont la représentation est ambigüe selon la base utilisée – donc tout nombre autre que 0 ou 1.

    À noter que j'avais une version avec un formatage en forme de sapin et un autre sans la variable intermédiaire de la ligne 4, mais là le code devenait difficilement lisible donc peu compréhensible.

    public class Sapin {
 public static void main(String[] args) {
 final int O = Integer.valueOf(args[0]);
 for (int l = 0; l < ((1 << 1) * O * (O + 1)); l++) {
 System.out.print((char) (((((1 << (1 << 1)) | 1) << (1 << 1)) | 1) << 1
 & (l % ((1 << 1) * O) - (1 << 1) * O == -1
 ? ~((1 << (1 << (1 << 1))) << 1)
 : ~0)
 & ((1 << 1) * O != l % ((1 << 1) * O) + 1
 && (O == l / ((1 << 1) * O)
 || O > l % ((1 << 1) * O) + l / ((1 << 1) * O) + 1
 || l % ((1 << 1) * O) + 1 > O + l / ((1 << 1) * O))
 ? ~((1 << (1 << 1)) << 1)
 : ~0)
 & ((1 << 1) * O != l % ((1 << 1) * O) + 1
 && (O != l / ((1 << 1) * O)
 || O != l % ((1 << 1) * O) + 1)
 && (O == l / ((1 << 1) * O)
 || O > l % ((1 << 1) * O) + l / ((1 << 1) * O) + 1
 || l % ((1 << 1) * O) + 1 > O + l / ((1 << 1) * O))
 ? ~(1 << 1)
 : ~0)
 | (l / ((1 << 1) * O) == O
 && l % ((1 << 1) * O) == O - 1
 ? 1
 : 0)
 ));
 }
 }
}

    Vous pouvez vérifier, ce code fonctionne. Saurez-vous me dire comment ?

    La connaissance libre : https://zestedesavoir.com