• # okay

    Posté par  . Évalué à 8.

    okay

  • # « Complexité »

    Posté par  (site web personnel, Mastodon) . É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

    • [^] # Re: « Complexité »

      Posté par  . Évalué à 8.

      Saurez-vous me dire comment ?

      En étant interprété par la JVM ?

    • [^] # Re: « Complexité »

      Posté par  (site web personnel) . Évalué à 2.

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

      Bah il fat "juste" en compliqué ce qui est interdit pour afficher 0x20, 0x42 ou 0x0A suivant le besoin, afin de rentrer dans le joli algo, par exemple :

      Tous les nombres dont la représentation est ambigüe selon la base utilisée – donc tout nombre autre que 0 ou 1.

      1 << (1 << 1) n'est qu'une façon de dire 4, et mettre une autre lettre que O pour la variable permet de mieux voir les zéros.

      Il y a vraiment de tout chez les humains dans les plaisirs de casse-tête!

      Sinon l'avantage c'est que c'est facile à tester avec un compilo C vu que la "formule" est identique en C :-p.

      • [^] # Re: « Complexité »

        Posté par  . Évalué à 5.

        Pour ceux n'auraient pas d'environnement sous la main :

        % xclip -o > Sapin.java
% java Sapin.java 12
           *           
          ***          
         *****         
        *******        
       *********       
      ***********      
     *************     
    ***************    
   *****************   
  *******************  
 ********************* 
***********************
           #

        https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll

    • [^] # Re: « Complexité »

      Posté par  . Évalué à 3.

      Tu ferais le même avec juste des portes NON-ET ?

      (moi non :D)

      • [^] # Re: « Complexité »

        Posté par  (site web personnel, Mastodon) . Évalué à 2.

        Si tu peux garder la boucle, c'est pas très éloigné de ce que j'avais fait. Il faut juste reprendre l'expression à partir de nombres (cf plus loin dans le sujet de forum en lien) et appliquer les transformations, c'est plus fastidieux que compliqué.

        La connaissance libre : https://zestedesavoir.com

Suivre le flux des commentaires

Note : les commentaires appartiennent à celles et ceux qui les ont postés. Nous n’en sommes pas responsables.