Messages de temps

temps · format audio généré

Bonjour,
J'ai déjà créé plusieurs formats audio (en bash, en addon firefox, ..) mais par manque de temps, je n'ai jamais pu finaliser et faire connaître.
J'ai repris mes travaux sur la création d'un format audio il y a peu.
La particularité de ce format est qu'il est ultra léger, que les sons sont inventés, non pas imités.
Comme les sons les plus durs à reproduire sont ceux de la voix humaine, j'ai commencé par ceux là.
Les outils utilisés sont le tableur libre office, ghex, audacity.
Je suis à la recherche de codeurs c++ afin d'améliorer le code.

La page d'accueil en construction du format est là

et voici un premier fichier audio généré avec le tableur

Je dois trouver comment générer les arguments dans la fonction en c++, de manière à ne plus avoir utiliser le tableur.

Je dois trouver comment créer une class en c++ pour chaque voyelle et chaque consonne.

Actuellement le générateur crée un bruit de fond issu de la technique du générateur. Je vais affiner le switch pour que le nombre d'unité de temps ne varie pas trop quelque soit la hauteur du front, car pour la voix humaine il faut des paquets d'unités identique, autrement nous avons l'effet comme ceux présentés sur la page du projet

Le fichier audio serai composé d'une base universelle d'environ 10 Ko, et ensuite les fichiers audio ne pèseraient que quelques dizaine d'octets
Cordialement

temps · format audio généré

Bonjour,
J'annonce la sortie de la deuxième version.
Elle est toujours à la même adresse.
Maintenant nous avons le générateur d'un coté et le fichier audio sous forme de 800 valeurs numériques de l'autre.
La troisième version sera un générateur très léger qui crée les 800 valeurs numériques.
Cordialement

temps · format audio généré

Bonjour,
Merci pour la réponse.
Ma principale motivation est de transmettre un savoir qui améliorera le monde à mon sentiment même si je le verrai pas. Car si j'arrive à transmettre, il n'y aura pas que l'audio qui sera changé.
Ma deuxième motivation est de dire merci à mes amis du libre avec qui j'ai passé de nombreuses soirées dans les restos aux débuts jusqu'à ce que la situation se dégrade en france et implique la destruction de la communauté.
Ma troisième motivation est de dire merci aux DEV qui m'ont permis de remplir mes missions en apportant des fichiers audio de qualités et vidéo à une époque ou tous déclaraient que c'était impossible. Des milliers de personnes ont pu profiter et doivent beaucoup au libre sans même le savoir.

Le format apporte la possibilité de créer, un outil de création incomparable. La création étant ce qui rempli le plus de joie l'homme, c'est ce qui me semble voir le plus de valeur.
Le format comme il est très léger, consomme très peu de ressources (économie de matière et d'énergie)
Le format n'imite pas, mais je pense que le futur pourra identifier les sons pour les écrire sous mon format sas à avoir à imiter. Le même son peut-être composé d'une multitude de manière. Autant utiliser la plus simple, la plus légère.

Le format permet de retrouver le langage transmis par nos ancêtres, une manière particulière d'associer les idées. En exemple Godard (affiche Coca avec la misère à ses pied qui passe inaperçu)trop d'informations tue l'information, ici id trop de son efface le son. Je suis née dans un monde d'encyclopédie, avec des coutumes en équilibre avec les savoir, un monde d'encyclopédie, et aujourd'hui cette richesse c'est transformé en désert, un dictionnaire(moteur de recherche) qui crée des absolue en des lieu ou il n'y en a pas. Un format audio qui ouvre l'esprit qui permet de créer en opposition à un format audio qui apprend à croire en des dieux qui n'existent pas comme les fréquences. Sans passé plus de présent, pas de futur, ce format audio c'est le passé qui frappe à la porte pour vous protéger. Une idée donnée est une idée de plus, et il est immoral de chercher à le commercialiser l'outil, mais nous pouvons commercialiser les créations.
Si j'étais plus jeune, je créerai des oeuvres d'art avec qui apporteraient des biens pour pouvoir diffuser mais j'ai plus les capacités pour cela, je serai heureux rien que d'avoir su montrer un peu des outils que j'ai utilisés.
Si un Vivaldi ou Bach lit ce texte, qu'il se mette au travail pour sa gloire et notre richesse.
Cordialement

temps

Bonjour,
je voudrais créer un exécutable qui lit les fichiers extérieurs.
Ces fichiers sont composés de 800 octets au format texte et seront eux-mêmes issus d'un exécutable de quelques octets pour les construire.
Actuellement ces fichiers sont dans l’exécutable dans une fonction nommée bascule1
ces fichiers ont l'extension .jo un format audio que j'ai créé il y a plusieurs années
Le but est de créer un format audio pour linux et accessoirement montrer des principes physiques universels que j'ai identifié comme le plus vrai du moment.
La page ou se trouve l'exécutable est ici

en detail j'ai essayé ça mais ça ne marche pas

int main (void)
{
int fait;
int k1[201];



std::ifstream vaLire("dataaudio.jo");  

if(vaLire)
{

for (fait = 0; fait < 200; fait++) {

vaLire.get(k1[fait]);
}
}
else
{
    cout << "ERREUR: Impossible d'ouvrir le fichier en lecture." << endl;
}

temps

Oups, j'ai parlé trop vite, ça compile bien, ça produit bien un fichier, mais ça ne marche pas car au lieu d'avoir un fichier son de 10ko, j'obtiens un fichier de plusieurs Go contenant de nombreux "0"

int main (void)
{
int fait;
int k9[201];


std::ifstream vaLire("dataaudio.jo", std::ios::in); 


if(vaLire)
{

for (fait = 0; fait < 200; fait++) {

vaLire >> k9[fait];
//vaLire.get(k9[fait]);
vaLire.close();
}
}
else
{

		std::cerr << "Impossible d'ouvrir le fichier en écriture !" << std::endl;
		
	
}

c'est corrigé

int main (void)
{
int fait;
int k9[801];

std::ifstream vaLire("dataaudio.jo", std::ios::in); 


if(vaLire)
{

for (fait = 0; fait < 800; fait++) {

vaLire >> k9[fait];


}
vaLire.close();
}
else
{

		std::cerr << "Impossible d'ouvrir le fichier en écriture !" << std::endl;
		
	
}




bascule1(k9[0],

temps · » Le 12/03/2024, à 23:32

Bonjour, après une longue période, je viens de reprendre mes travaux sur les générateurs vidéos et audio.
Comme je pense pouvoir dire que mon générateur d'image est presque au point, j'ai repris mes travaux sur l'audio.
J'ai commencé à expliquer le concept et indiquer les lois qui crées les sons de la voix humaine ainsi que comment générer un fichier audio avec ghex, sur le forum de présentation de framacolibri au nom de Essais sur l'audio.
Toute remarque constructive est la bienvenue.
Cordialement

temps · » Le 22/03/2024, à 18:05

Bonjour,
mille mercis pour la réponse.
c'est la bonne voie pour avancer.
J'ai 20 ans en labo audio pour les langues en enseignement et à force je me suis aperçu que les sons répondaient à un système mathématique que j'ai créé en 1993
Je ne pense pas que les fréquences fassent partie des lois fondamentales des sons. Les fréquences déforment les sons, mais ce n'est pas une loi qui permet de les construire.
Les sons sont l'effets d'un équilibre entre plusieurs dimensions aux lois différentes, il existe un multitude de possibilités pour créer le même son. Le concept de fréquence ne répond à aucune des lois que j'ai rencontré.
J'ai fait des émissions de radio et prouvé il y a plus de 10 ans que selon la distance je changeait le p en t ou en c ... que les voyelles étaient de même forme ...
J'ai eu quelques promesses, mais tout a été stoppé brutalement car soit disant "trop novateur" ! Plein de misères, un départ à la retraite plus mort que vif, mais après presque 2 ans, je refais surface.
J'arrive à produire mes fichiers audio en c++ par modélisaion (sans imitation), je dois apprendre à manipuler les fonction et les classes pour alléger les fichiers. Je peux déjà prouver que les voyelles sont de même forme et aussi, juste ajouter une onde devant la voyelle et selon comment produire un son de consonne différent. Je donne les info sur un site ami framacolibri
Bientot, tous les codes seront sur mon site internet et sur framacolibri, chacun est libre de les utiliser comme il l'entend. L'espoir est d'être le Sadi Carnot de ce siècle et relancer la production de richesses pour plusieurs siècles, mais personne ne peut dire à quoi servira l'outil qu'il crée.

je dois apprendre le fonctionnement des classes et fonctions pour alléger le code, car ce n'est qu'une suite de répétition de quelques fonctions identiques
cordialement

temps · » Le 16/04/2024, à 14:33

Bonjour, j'attendais d'avoir écris la preuve que l'algèbre n'était pas adapté aux lois physiques et à l'entendement humain, id pour les fréquences.
Sur la présentation que j'ai commencé, je l'apporte en utilisant mon système mathématique, je montre plusieurs dimensions aux lois différentes en équilibre.
Ceci implique qu'il est possible créer un format audio ultra léger pour linux. Je suis grandement diminué, et arriver à présenter les lois physiques n'a pu se faire qu'en utilisant des ressources que j'ai encore en mémoire. J'ai passé l'age de la création, et pourtant il est important d'avoir toutes ses capacités pour finir de créer le format audio. L'idée est de créer un exécutable universelle de 10ko dans lequel nous présentons un fichier audio de quelques octets. Ce fichier audio prévu construira le contenu e ce qui se trouve dans la fonction bascule du main actuellement. La page qui présente le projet est ici : Toute aide est la bienvenue. En exemple le son "C" ne pèse pas un octet, il suffit de varier brusquement la forme des ondes, id pour plusieurs consonnes, selon la force de la variation nous changeons la consonne, voir la démo dans la présentation. ici le code qui cré le "C"+"O"

122,1,134,5,121,2,132,4,120,3,131,3,121,4,132,2,122,5,134,1,121,3,132,3,120,1,131,5,121,2,132,4,122,4,134,2,122,1,134,5,122,2,134,4,122,3,134,3,109,4,139,3,117,5,147,2,121,3,135,1,121,1,135,3,96,2,144,2,112,4,160,1,120,1,136,3,120,2,136,2,83,3,149,1,107,4,173,3,119,5,137,2,119,3,137,1,70,1,154,3,102,2,186,2,118,4,138,1,118,1,138,3,57,2,159,2,97,3,199,1,117,4,139,3,117,5,139,2,44,3,164,1,92,1,212,3,116,2,140,2,116,4,140,1,31,1,169,3,87,2,225,2,115,3,141,1,115,4,141,3,18,5,169,2,82,3,225,1,111,1,142,3,18,2,169,2,82,4,225,1,111,1,142,3,18,2,169,2,82,3,225,1,111,4,142,3,18,5,169,2,82,3,225,1,111,1,142,3,18,2,169,2,82,4,225,1,111,1,142,3,18,2,169,2,82,3,225,1,111,4,142,3,18,5,169,2,82,3,225,1,111,1,142,3,18,2,169,2,82,4,225,1,111,1,142,3,18,2,169,2,82,3,225,1,111,4,142,3,18,5,169,2,82,3,225,1,111,1,142,3,18,2,169,2,82,4,225,1,111,1,142,3,18,2,169,2,82,3,225,1,111,4,142,3,18,5,169,2,82,3,225,1,111,1,142,3,18,2,169,2,82,4,225,1,111,1,142,3,18,2,169,2,82,3,225,1,111,4,142,3,18,5,169,2,82,3,225,1,111,1,142,3,18,2,169,2,82,4,225,1,111,1,142,3,18,2,169,2,82,3,225,1,111,4,142,3,18,5,169,2,82,3,225,1,111,1,142,3,18,2,169,2,82,4,225,1,111,1,142,3,18,2,169,2,82,3,225,1,111,4,142,3,18,5,169,2,82,3,225,1,111,1,142,3,18,2,169,2,82,4,225,1,111,1,142,3,18,2,169,2,82,3,225,1,111,4,142,3,18,5,169,2,82,3,225,1,111,1,142,3,18,2,169,2,82,4,225,1,111,1,142,3,18,2,169,2,82,3,225,1,111,4,142,3,18,5,169,2,82,3,225,1,111,1,142,3,18,2,169,2,82,4,225,1,111,1,142,3,18,2,169,2,82,3,225,1,111,4,142,3,18,5,169,2,82,3,225,1,111,1,142,3,18,2,169,2,82,4,225,1,111,1,142,3,18,2,169,2,82,3,225,1,111,4,142,3,18,5,169,2,82,3,225,1,111,1,142,3,18,2,169,2,82,4,225,1,111,1,142,3,18,2,169,2,82,3,225,1,111,4,142,3,18,5,169,2,82,3,225,1,111,1,142,3,18,2,169,2,82,4,225,1,111,1,142,3,18,2,169,2,82,3,225,1,111,4,142,3,18,5,169,2,82,3,225,1,83,1,223,3,84,2,221,2,85,4,219,1,86,1,217,3,87,2,215,2,88,3,213,1,89,4,211,3,90,5,209,2,91,3,207,1,92,1,205,3,93,2,203,2,94,4,201,1,95,1,199,3,96,2,197,2,97,3,195,1,98,4,193,3,99,5,191,2,100,3,189,1,101,1,187,3,102,2,185,2,103,4,183,1,104,1,181,3,105,2,179,2,106,3,177,1,107,4,175,3,108,5,173,2,109,3,171,1,110,1,169,3,111,2,167,2,112,4,165,1,113,1,163,3,114,2,161,2,115,3,159,1,116,4,157,3,117,5,155,2,118,3,153,1,119,1,151,3,120,2,149,2,121,4,147,1,122,1,145,3,123,2,143,2

, Cordialement

temps · [résolu] Comment ajuster le nombre de sorties en c++

Bonjour,
je génère des courbes pour dessiner des formes en c++
Le problème rencontré est que selon la longueur de la courbe le nombre d'unité de la forme générée varie.
Les formes dessiner peuvent avoir un nombre d'unité différent, mais j'ai besoin que toutes les courbes dessinant une forme aient le même nombre d'unité.

j'ai créé un switch qui dit de telle longueur à telle longueur tu utilise cette formule, mais je n'arrive pas à ajuster pour l'instant.
Est-ce que quelqu'un a une idée pour aider.
mes outils sont tableur libre office, editeur de texte, et ghex

le switch du moment est :

	          for (int j=0; j<139; j++)
          {
         
          
          if (((k3[j]-k1[j]) <= 15) && ((k3[j]-k5[j]) <= 15)) {mem =1;}
          if (((k3[j]-k1[j]) > 15)&&((k3[j]-k1[j]) <= 30)&&((k3[j]-k5[j]) > 15)&&((k3[j]-k5[j]) <= 30)){mem =2;}
          if (((k3[j]-k1[j]) > 30)&&((k3[j]-k1[j]) <= 60)&&((k3[j]-k5[j]) > 30)&&((k3[j]-k5[j]) <= 60)){mem =3;}
          if (((k3[j]-k1[j]) > 60)&&((k3[j]-k1[j]) <= 120)&&((k3[j]-k5[j]) > 60)&&((k3[j]-k5[j]) <= 120)){mem =4;}
          if (((k3[j]-k1[j]) > 120) && ((k3[j]-k5[j]) > 120)) {mem =5;}
          if (((k3[j]-k1[j]) <= 15) &&((k3[j]-k5[j]) > 15)&&((k3[j]-k5[j]) <= 30)){mem =6;}
          if (((k3[j]-k1[j]) <= 15) &&((k3[j]-k5[j]) > 30)&&((k3[j]-k5[j]) <= 60)){mem =7;}
          if (((k3[j]-k1[j]) <= 15) &&((k3[j]-k5[j]) > 60)&&((k3[j]-k5[j]) <= 120)){mem =8;}
          if (((k3[j]-k1[j]) <= 15) && ((k3[j]-k5[j]) > 120)) {mem =9;}
          if (((k3[j]-k1[j]) > 15)&&((k3[j]-k1[j]) <= 30)&& ((k3[j]-k5[j]) <= 15)){mem =10;}
          if (((k3[j]-k1[j]) > 15)&&((k3[j]-k1[j]) <= 30)&&((k3[j]-k5[j]) > 30)&&((k3[j]-k5[j]) <= 60)){mem =11;}
          if (((k3[j]-k1[j]) > 15)&&((k3[j]-k1[j]) <= 30)&&((k3[j]-k5[j]) > 60)&&((k3[j]-k5[j]) <= 120)){mem =12;}
          if (((k3[j]-k1[j]) > 15)&&((k3[j]-k1[j]) <= 30)&& ((k3[j]-k5[j]) > 120)) {mem =13;}
          if (((k3[j]-k1[j]) > 30)&&((k3[j]-k1[j]) <= 60)&&((k3[j]-k5[j]) > 15)&&((k3[j]-k5[j]) <= 30)){mem =14;}
          if (((k3[j]-k1[j]) > 30)&&((k3[j]-k1[j]) <= 60)&&((k3[j]-k5[j]) > 30)&&((k3[j]-k5[j]) <= 60)){mem =15;}
          if (((k3[j]-k1[j]) > 30)&&((k3[j]-k1[j]) <= 60)&&((k3[j]-k5[j]) > 60)&&((k3[j]-k5[j]) <= 120)){mem =16;}
          if (((k3[j]-k1[j]) > 30)&&((k3[j]-k1[j]) <= 60)&& ((k3[j]-k5[j]) > 120)) {mem =17;}
          if (((k3[j]-k1[j]) > 60)&&((k3[j]-k1[j]) <= 120)&&((k3[j]-k5[j]) > 15)&&((k3[j]-k5[j]) <= 30)){mem =18;}
          if (((k3[j]-k1[j]) > 60)&&((k3[j]-k1[j]) <= 120)&&((k3[j]-k5[j]) > 30)&&((k3[j]-k5[j]) <= 60)){mem =19;}
          if (((k3[j]-k1[j]) > 60)&&((k3[j]-k1[j]) <= 120)&&((k3[j]-k5[j]) > 60)&&((k3[j]-k5[j]) <= 120)){mem =20;}
          if (((k3[j]-k1[j]) > 60)&&((k3[j]-k1[j]) <= 120)&& ((k3[j]-k5[j]) > 120)) {mem =21;}
          
          

          
switch(mem) {

  case 1:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+3); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;}
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1]; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;}
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }
 

    break;

  case 2:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-2); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-2); repet1 > (k3[j]-4); repet1--) { f<<tabn[repet1];repet1--; }
  	    for (repet1 = (k3[j]-4); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--; }
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }
 

    break;
  case 3:


	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-6); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;}
  	    for (repet1 = (k3[j]-6); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1]; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k3[j]-5); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k3[j]-5); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;}
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break;
  case 4:
	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-6); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;repet1++;repet1++; repet1++;repet1++;}
  	    for (repet1 = (k3[j]-6); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;  }
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1]; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k3[j]-5); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--;repet1--; }
  	    for (repet1 = (k3[j]-5); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;repet1--;repet1--;repet1--;repet1--;}
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--; repet1--;repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }
    break;
  case 5:
	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;repet1++;repet1++; repet1++;repet1++;}
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;repet1--;repet1--;repet1--;repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }
    break;
    
   case 6:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+3); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;}
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1]; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-2); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-2); repet1 > (k3[j]-4); repet1--) { f<<tabn[repet1];repet1--; }
  	    for (repet1 = (k3[j]-4); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--; }
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break;   
    
       case 7:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+3); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;}
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1]; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k3[j]-5); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k3[j]-5); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;}
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 8:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+3); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;}
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1]; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k3[j]-5); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--;repet1--; }
  	    for (repet1 = (k3[j]-5); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;repet1--;repet1--;repet1--;repet1--;}
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--; repet1--;repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 9:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+3); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;}
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1]; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k3[j]-5); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k3[j]-5); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;}
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 10:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;}
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 11:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k3[j]-5); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k3[j]-5); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;}
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 12:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k3[j]-5); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--;repet1--; }
  	    for (repet1 = (k3[j]-5); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;repet1--;repet1--;repet1--;repet1--;}
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--; repet1--;repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 13:
	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;repet1--;repet1--;repet1--;repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 14:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-6); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;}
  	    for (repet1 = (k3[j]-6); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1]; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-2); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-2); repet1 > (k3[j]-4); repet1--) { f<<tabn[repet1];repet1--; }
  	    for (repet1 = (k3[j]-4); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--; }
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 15:
	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-6); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;}
  	    for (repet1 = (k3[j]-6); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1]; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k3[j]-5); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k3[j]-5); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;}
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 16:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-6); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;}
  	    for (repet1 = (k3[j]-6); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1]; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k3[j]-5); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--;repet1--; }
  	    for (repet1 = (k3[j]-5); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;repet1--;repet1--;repet1--;repet1--;}
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--; repet1--;repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 17:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-6); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;}
  	    for (repet1 = (k3[j]-6); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1]; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;repet1--;repet1--;repet1--;repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 18:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-6); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;repet1++;repet1++; repet1++;repet1++;}
  	    for (repet1 = (k3[j]-6); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;  }
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1]; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-2); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-2); repet1 > (k3[j]-4); repet1--) { f<<tabn[repet1];repet1--; }
  	    for (repet1 = (k3[j]-4); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--; }
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 19:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-6); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;repet1++;repet1++; repet1++;repet1++;}
  	    for (repet1 = (k3[j]-6); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;  }
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1]; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k3[j]-5); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k3[j]-5); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;}
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 20:
	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-6); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;repet1++;repet1++; repet1++;repet1++;}
  	    for (repet1 = (k3[j]-6); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;  }
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1]; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k3[j]-5); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--;repet1--; }
  	    for (repet1 = (k3[j]-5); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;repet1--;repet1--;repet1--;repet1--;}
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--; repet1--;repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 21:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-6); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;repet1++;repet1++; repet1++;repet1++;}
  	    for (repet1 = (k3[j]-6); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;  }
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1]; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;repet1--;repet1--;repet1--;repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
    
  default:
	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;}
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }
// fin descend 
} //fin switch

 } //fin boucle du for

Le tout fait partie d'un format audio jo que j'essaie de créer pour le libre

Cordialement

temps · [résolu] Comment ajuster le nombre de sorties en c++

Bonjour,
J'ai trouvé une solution, elle est encore à affiner mais suffisante pour avoir une qualité audible, j'entends bien le son "o" quand je le demande et en modifiant la deuxième valeur de bascule j'entends le son "a" comme indiqué dans un autre fils.
La solution est :

	          for (int j=0; j<139; j++)
          {
         
          
          if (((k3[j]-k1[j]) <= 15) && ((k3[j]-k5[j]) <= 15)) {mem =1;}
          if (((k3[j]-k1[j]) > 15)&&((k3[j]-k1[j]) <= 30)&&((k3[j]-k5[j]) > 15)&&((k3[j]-k5[j]) <= 30)){mem =2;} 
          if (((k3[j]-k1[j]) > 30)&&((k3[j]-k1[j]) <= 60)&&((k3[j]-k5[j]) > 30)&&((k3[j]-k5[j]) <= 60)){mem =3;}
          if (((k3[j]-k1[j]) > 60)&&((k3[j]-k1[j]) <= 120)&&((k3[j]-k5[j]) > 60)&&((k3[j]-k5[j]) <= 120)){mem =4;}
          if (((k3[j]-k1[j]) > 120) && ((k3[j]-k5[j]) > 120)) {mem =5;}
          if (((k3[j]-k1[j]) <= 15) &&((k3[j]-k5[j]) > 15)&&((k3[j]-k5[j]) <= 30)){mem =6;}
          if (((k3[j]-k1[j]) <= 15) &&((k3[j]-k5[j]) > 30)&&((k3[j]-k5[j]) <= 60)){mem =7;}
          if (((k3[j]-k1[j]) <= 15) &&((k3[j]-k5[j]) > 60)&&((k3[j]-k5[j]) <= 120)){mem =8;}
          if (((k3[j]-k1[j]) <= 15) && ((k3[j]-k5[j]) > 120)) {mem =9;}
          if (((k3[j]-k1[j]) > 15)&&((k3[j]-k1[j]) <= 30)&& ((k3[j]-k5[j]) <= 15)){mem =10;}
          if (((k3[j]-k1[j]) > 15)&&((k3[j]-k1[j]) <= 30)&&((k3[j]-k5[j]) > 30)&&((k3[j]-k5[j]) <= 60)){mem =11;}
          if (((k3[j]-k1[j]) > 15)&&((k3[j]-k1[j]) <= 30)&&((k3[j]-k5[j]) > 60)&&((k3[j]-k5[j]) <= 120)){mem =12;}
          if (((k3[j]-k1[j]) > 15)&&((k3[j]-k1[j]) <= 30)&& ((k3[j]-k5[j]) > 120)) {mem =13;}
          if (((k3[j]-k1[j]) > 30)&&((k3[j]-k1[j]) <= 60)&&((k3[j]-k5[j]) > 15)&&((k3[j]-k5[j]) <= 30)){mem =14;}
          if (((k3[j]-k1[j]) > 30)&&((k3[j]-k1[j]) <= 60)&&((k3[j]-k5[j]) > 30)&&((k3[j]-k5[j]) <= 60)){mem =15;}
          if (((k3[j]-k1[j]) > 30)&&((k3[j]-k1[j]) <= 60)&&((k3[j]-k5[j]) > 60)&&((k3[j]-k5[j]) <= 120)){mem =16;}
          if (((k3[j]-k1[j]) > 30)&&((k3[j]-k1[j]) <= 60)&& ((k3[j]-k5[j]) > 120)) {mem =17;}
          if (((k3[j]-k1[j]) > 60)&&((k3[j]-k1[j]) <= 120)&&((k3[j]-k5[j]) > 15)&&((k3[j]-k5[j]) <= 30)){mem =18;}
          if (((k3[j]-k1[j]) > 60)&&((k3[j]-k1[j]) <= 120)&&((k3[j]-k5[j]) > 30)&&((k3[j]-k5[j]) <= 60)){mem =19;}
          if (((k3[j]-k1[j]) > 60)&&((k3[j]-k1[j]) <= 120)&&((k3[j]-k5[j]) > 60)&&((k3[j]-k5[j]) <= 120)){mem =20;}
          if (((k3[j]-k1[j]) > 60)&&((k3[j]-k1[j]) <= 120)&& ((k3[j]-k5[j]) > 120)) {mem =21;}
          
          

          
switch(mem) {

  case 1:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+3); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+3); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;}
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1]; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 4; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7+1); repet++){ f<<tabn[repet1]; }
  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;}
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }
 

    break;

  case 2:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7+2); repet++){ f<<tabn[repet1]; }
  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-2); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-2); repet1 > (k3[j]-4); repet1--) { f<<tabn[repet1];repet1--; }
  	    for (repet1 = (k3[j]-4); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--; }
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }
 

    break;
  case 3:


	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;}
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k3[j]-5); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k3[j]-5); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;}
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 1; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break;
  case 4:
	    for (repet1 = (k1[j]); repet1 < (k1[j]+1); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+1); repet1 < (k1[j]+3); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++; }
  	    for (repet1 = (k1[j]+3); repet1 < (k3[j]-6); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;repet1++;repet1++; repet1++;repet1++;}
  	    for (repet1 = (k3[j]-6); repet1 < (k3[j]-1); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;  }
  	    for (repet1 = (k3[j]-1); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
  	    // fin monte 
	    
	    

  	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--;repet1--; }
  	    for (repet1 = (k3[j]-2); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;repet1--;repet1--;repet1--;repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]+1); repet1--) { f<<tabn[repet1];repet1--;repet1--; repet1--;repet1--;}
  	    for (repet1 = (k5[j]+1); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }
    break;
  case 5:
	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k3[j]-1); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;repet1++;repet1++; repet1++;repet1++;}
  	    for (repet1 = (k3[j]-1); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-2); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-2); repet1 > (k5[j]+1); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;repet1--;repet1--;repet1--;repet1--;}
  	    for (repet1 = (k5[j]+1); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }
    break;
    
   case 6:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+3); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+3); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;}
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1]; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 4; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7+1); repet++){ f<<tabn[repet1]; }
  	    // fin monte 
	    
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-2); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-2); repet1 > (k3[j]-4); repet1--) { f<<tabn[repet1];repet1--; }
  	    for (repet1 = (k3[j]-4); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--; }
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break;   
    
       case 7:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+3); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+3); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;}
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1]; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 4; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7+1); repet++){ f<<tabn[repet1]; }
  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k3[j]-5); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k3[j]-5); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;}
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 1; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 8:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+3); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+3); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;}
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1]; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 4; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7+1); repet++){ f<<tabn[repet1]; }
  	    // fin monte 
	    
	    
  	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--;repet1--; }
  	    for (repet1 = (k3[j]-2); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;repet1--;repet1--;repet1--;repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]+1); repet1--) { f<<tabn[repet1];repet1--;repet1--; repet1--;repet1--;}
  	    for (repet1 = (k5[j]+1); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 9:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+3); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+3); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;}
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1]; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 4; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7+1); repet++){ f<<tabn[repet1]; }
  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k3[j]-5); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k3[j]-5); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;}
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 10:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7+2); repet++){ f<<tabn[repet1]; }
  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-2); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-2); repet1 > (k3[j]-4); repet1--) { f<<tabn[repet1];repet1--; }
  	    for (repet1 = (k3[j]-4); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--; }
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 5; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 11:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7+2); repet++){ f<<tabn[repet1]; }
  	    // fin monte 
	    
	    
  	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--;repet1--; }
  	    for (repet1 = (k3[j]-2); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;repet1--;repet1--;repet1--;repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]+1); repet1--) { f<<tabn[repet1];repet1--;repet1--; repet1--;repet1--;}
  	    for (repet1 = (k5[j]+1); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 12:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7+2); repet++){ f<<tabn[repet1]; }
  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k3[j]-5); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--;repet1--; }
  	    for (repet1 = (k3[j]-5); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;repet1--;repet1--;repet1--;repet1--;}
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--; repet1--;repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 13:
	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7+2); repet++){ f<<tabn[repet1]; }
  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;repet1--;repet1--;repet1--;repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 14:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;}
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k3[j]-5); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k3[j]-5); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;}
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 1; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 15:
	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;}
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
  	    // fin monte 
	    
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k3[j]-5); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k3[j]-5); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;}
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 1; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 16:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;}
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
  	    // fin monte 
	    
	    
  	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--;repet1--; }
  	    for (repet1 = (k3[j]-2); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;repet1--;repet1--;repet1--;repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]+1); repet1--) { f<<tabn[repet1];repet1--;repet1--; repet1--;repet1--;}
  	    for (repet1 = (k5[j]+1); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 17:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;}
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++;repet1++; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;repet1--;repet1--;repet1--;repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 18:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+1); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+1); repet1 < (k1[j]+3); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++; }
  	    for (repet1 = (k1[j]+3); repet1 < (k3[j]-6); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;repet1++;repet1++; repet1++;repet1++;}
  	    for (repet1 = (k3[j]-6); repet1 < (k3[j]-1); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;  }
  	    for (repet1 = (k3[j]-1); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-2); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-2); repet1 > (k3[j]-4); repet1--) { f<<tabn[repet1];repet1--; }
  	    for (repet1 = (k3[j]-4); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--; }
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 19:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+1); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+1); repet1 < (k1[j]+3); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++; }
  	    for (repet1 = (k1[j]+3); repet1 < (k3[j]-6); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;repet1++;repet1++; repet1++;repet1++;}
  	    for (repet1 = (k3[j]-6); repet1 < (k3[j]-1); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;  }
  	    for (repet1 = (k3[j]-1); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k3[j]-5); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k3[j]-5); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;}
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 1; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 20:
	    for (repet1 = (k1[j]); repet1 < (k1[j]+1); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+1); repet1 < (k1[j]+3); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++; }
  	    for (repet1 = (k1[j]+3); repet1 < (k3[j]-6); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;repet1++;repet1++; repet1++;repet1++;}
  	    for (repet1 = (k3[j]-6); repet1 < (k3[j]-1); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;  }
  	    for (repet1 = (k3[j]-1); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
  	    // fin monte 
	    
	    
  	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--;repet1--; }
  	    for (repet1 = (k3[j]-2); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;repet1--;repet1--;repet1--;repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]+1); repet1--) { f<<tabn[repet1];repet1--;repet1--; repet1--;repet1--;}
  	    for (repet1 = (k5[j]+1); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
           case 21:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+1); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+1); repet1 < (k1[j]+3); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++; }
  	    for (repet1 = (k1[j]+3); repet1 < (k3[j]-6); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;repet1++;repet1++; repet1++;repet1++;}
  	    for (repet1 = (k3[j]-6); repet1 < (k3[j]-1); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;  }
  	    for (repet1 = (k3[j]-1); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;repet1--;repet1--;repet1--;repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }

    break; 
    
  default:
	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;}
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+k7); repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+k7); repet++){ f<<tabn[repet1]; }
// fin descend 
} //fin switch

 } //fin boucle du for

Je vais pouvoir commencer a présenter les dimensions et leurs lois, ensuite je chercherai à améliorer le code en générant bascule et en apportant des class

Cordialement

temps · [résolu] concaténer hexa en langage C++

Bonjour,
je cherche à générer puis concaténer en hexadecimal dans un fichier.
L'idée est d'introduire les valeurs de 50 ondes, le fichier serait du type :

4952 4646 6414 0000 4157 4556 6d66 2074
0010 0000 0001 0001 ac44 0000 5888 0001
0002 0010 6164 6174 63f0 0000 0077 0079
0076 007c 007d 0079 0081 0079 007f 0080
007b 007e 007d 0079 007f 0077 0077 007a
006f 0077 006b 006f 0068 0068 005d 0068
004d 0067 003d 005c 003f 0047 0038 003a
002a 0033 001b 0020 0016 0010 0003 0005
ffef fff8 ffe4 ffe0 ffd9 ffcd ffc4 ffbc
ffb6 ffa8 ffa4 ff94 ff8d ff86 ff79 ff6d
ff6a ff56 ff56 ff45 ff3c ff33 ff23 ff26
ff09 ff0f fefa fef0 fef2 fed2 fee2 fec0
fec8 feb2 feb2 fe9e fea8 fe87 fe92 fe7c
fe80 fe6f fe70 fe60 fe60 fe57 fe50 fe4d
 fe48 fe40 fe3e fe35 fe37 fe32 fe2c fe2b
fe27 fe24 fe27 fe1f fe20 fe1d fe1f fe1a
fe1e fe19 fe1e fe19 fe1d fe1b fe1d fe1f
fe22 fe1b fe2b fe1d fe31 fe24 fe32 fe2f
fe37 fe3c fe3e fe45 fe4c fe4f fe5a fe61
fe62 fe79 fe74 fe88 fe8e fe9b fea4 feb7

Cordialement

temps · [résolu] concaténer hexa en langage C++

Bonjour,
Merci pour les réponses. Je n'ai pas utilisé la balise code car ce sont des données ce n'est pas du code.
En détail, je reprends des travaux sur les lois de l'audio que j'avais laissé tombé par obligation.
Ici nous reconnaissons l'entête d'un fichier audio
Ma démarche est de générer la voix humaine, je donne les informations sur ma progression ici Essais sur l'audio
Je viens de me souvenir qu'avant le javascript j'utilisais le C++, ainsi je cherche à faire un code qui génère 30 ondes en suivant mes instructions.
En d'autres mots, je vais gratter mes anciennes notes orientées en c++, j'espère les retrouver

Pour résumer en entré, j'ai du savoir qui s'exprime à travers les codes, et en sortie j'ai un fichier audio en .wav

Cordialement

temps · [résolu] concaténer hexa en langage C++

Pour démarrer je cré l'exe avec

g++ '/home/x/main.cpp'  -std=c++11 -Wall -Wextra -o '/home/x/executable'

pour créer et commencer à écrire le fichier audio

#include <iostream>
#include <fstream>
using namespace std;
int main (void)
{
unsigned char cre = 0x0052;
unsigned char cre1 = 0x0049;
unsigned char cre2 = 0x0046;
unsigned char cre3 = 0x0046;

ofstream f ("son-o.wav", ios::out | ios::binary);
if(!f.is_open())
cout << "Impossible d'ouvrir le fichier en écriture !" << endl;
else
      {

                  f<<cre<<cre1<<cre2<<cre3<<endl;

      }

f.close();
return 0;
}

temps · [résolu] concaténer hexa en langage C++

Bonjour,
l'idée est dans le code qui génère le son "ou" donné précédent.
L'objectif 1 est de générer les formes sans passer par des tableaux, mais à l'aide d'une loi qui donne la variation de l'onde.
L'objectif 2 est de créer une boucle qui lance les générateurs de forme de manière à alléger le code
l'objectif 3 est de mettre la règle qui passe le son "ou", en son "o" ...
l'objectif 4 est de mettre une règle qui place les différentes consonnes au choix à la demande devant la voyelle
Il s'entend que je ne suis qu'au début du projet.
Cordialement

temps · [résolu] concaténer hexa en langage C++

Concernant les valeurs, mon principal problème est que je suis diminué par l'age et j'ai oublié le peu des techniques de codage que j'avais.
En fait ce sont plusieurs lois de plusieurs dimensions que je mets en équilibre.
L'expérience d'affinage de milliers de fichiers audio pendant ma carrière me permet d'avoir un acquis que j'essaie de donner
Il y a plusieurs règles à respecter, les équilibres entre les dimensions sont fragiles, un seul front (demie onde) fort ( comme un marteau acoustique) dans une zone d'assimilation d'une onde suffit à le détruire.
ici pour retrouver une base sur laquelle construire les voyelles, j'ai marié deux vagues, un peu comme si nous avions une vague dans la vague. Il aurait été plus simple de dessiner un m avec une bosse du m plus faible, mais comme le même son peut être créer d'une multitude de manière, j'ai préférer utiliser cette méthode pour ouvrir les portes. Cette forme se retrouve plus dans le chant de ceux qui ont des cordes vocales parfaites, le m est le plus courant.
Je vais affiner la forme pour présenter un "o" et un "a" et un ... plus audible, ensuite je vais montrer qu'avec la même forme nous produisons un grand nombre de consonnes

Pour passer du son "A" au son "O" en utilisant la construction que j'utilise, il faut doubler le nombre sur les fronts les plus forts du genre 1-2-1-2-1-2 le 1 étant dans ma construction environ 20 ce qui se traduit dans le code par

+20

dans mon exemple seul les fronts descendant fort dans case 5 sont modifiés, cela suffit. cela donne

int mem;
 
	          for (int j=0; j<139; j++)
          {
         
          
          if (((k3[j]-k1[j]) <= 45) && ((k3[j]-k5[j]) <= 45)) {mem =1;}
          if (((k3[j]-k1[j]) > 45)&&((k3[j]-k1[j]) < 100)&&((k3[j]-k5[j]) > 45)&&((k3[j]-k5[j]) < 100)){mem =2;}
          if (((k3[j]-k1[j]) > 45) && ((k3[j]-k5[j]) < 45)) {mem =3;}
          if (((k3[j]-k1[j]) < 45) && ((k3[j]-k5[j]) > 45)) {mem =4;}
          if (( (k3[j]-k1[j]) >= 100 ) && ( (k3[j]-k5[j]) >= 100 ))  {mem =5;}
          
switch(mem) {
  case 1:

	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+4); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k1[j]+4); repet1 < (k3[j]-6); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;}
  	    for (repet1 = (k3[j]-6); repet1 < (k3[j]-4); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k3[j]-4); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1]; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < k4[j]; repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k3[j]-5); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k3[j]-5); repet1 > (k5[j]+4); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;}
  	    for (repet1 = (k5[j]+4); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 3; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < k6[j]; repet++){ f<<tabn[repet1]; }
 

    break;
  case 2:




  	    for (repet1 = (k1[j]); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++; repet1++;}
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < k4[j]; repet++){ f<<tabn[repet1]; }
 	    // fin monte 
	    
	    

  	    for (repet1 = (k3[j]); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--;repet1--; repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < k6[j]; repet++){ f<<tabn[repet1]; }
// fin descend 

    break;
  case 3:
  	    for (repet1 = (k1[j]); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++; repet1++;}
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < k4[j]; repet++){ f<<tabn[repet1]; }
 	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-2); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-2); repet1 > (k3[j]-3); repet1--) { f<<tabn[repet1];repet1--;repet1--; }
  	    for (repet1 = (k3[j]-3); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;}
    	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < k6[j]; repet++){ f<<tabn[repet1]; }
 // fin descend 
    break;
  case 4:
	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k1[j]+3); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k1[j]+3); repet1 < (k3[j]-3); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++;}
  	    for (repet1 = (k3[j]-3); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++; }
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < k4[j]; repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
  	    for (repet1 = (k3[j]); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--;repet1--; repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < k6[j]; repet++){ f<<tabn[repet1]; }
// fin descend 
  	    repet1 = k5[j]; for (repet = 0; repet < k6[j]; repet++){ f<<tabn[repet1]; }
    break;
    
   case 5:

  	    for (repet1 = (k1[j]); repet1 < (k3[j]); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;repet1++; repet1++;repet1++;}
  	    repet1 = k3[j]; for (repet = 0; repet < (k4[j]+20); repet++){ f<<tabn[repet1]; }
 	    // fin monte 
	    	    
  	    for (repet1 = (k3[j]); repet1 > (k5[j]); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--;repet1--; repet1--;repet1--;}
  	    repet1 = k5[j]; for (repet = 0; repet < (k6[j]+20); repet++){ f<<tabn[repet1]; }
// fin descend 

    break;   
    
  default:
	    for (repet1 = (k1[j]); repet1 < (k1[j]+2); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k1[j]+2); repet1 < (k3[j]-2); repet1++) { f<<tabn[repet1];repet1++;repet1++; repet1++;}
  	    for (repet1 = (k3[j]-2); repet1 < (k3[j]); repet1++) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }  
  	    repet1 = k3[j]; for (repet = 0; repet < k4[j]; repet++){ f<<tabn[repet1]; }
//  	    // fin monte 
	    
	    
	    for (repet1 = (k3[j]-1); repet1 > (k3[j]-3); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } }
  	    for (repet1 = (k3[j]-3); repet1 > (k5[j]+2); repet1--) { f<<tabn[repet1];repet1--;repet1--;repet1--; repet1--;}
  	    for (repet1 = (k5[j]+2); repet1 > (k5[j]); repet1--) { for (repet = 0; repet < 2; repet++) { f<<tabn[repet1]; } } 
  	    repet1 = k5[j]; for (repet = 0; repet < k6[j]; repet++){ f<<tabn[repet1]; }
// fin descend 
} //fin switch

 } //fin boucle du for
 /**********************************************************/

Donc pour la voix humaine, il nous faut peu de valeurs au centre des fronts de crêtes, et beaucoup de valeurs vers les sommets. Pour éviter de dessinner un m avec une bosse plus petite, il faut décaler une onde sur deux, voici le tableau qui montre le delta entre point haut et point bas, puis différence de hauteur des points bas, puis différence de hauteur des points hauts. Vous remarquerez qu'il y a une onde haut puis une onde bas, puis une onde haut ... et ceci inversé de l'autre coté de la médiane pour la dépression :

61	6	188	4		127	4	-12
63	5	179	6		116	-2	9
61	6	188	3		127	2	-9
65	5	175	7		110	-4	13
64	7	180	7		116	1	-5
70	8	166	2		96	-6	14
70	2	170	3		100	0	-4
77	2	157	5		80	-7	13
75	6	161	5		86	2	-4
81	5	150	6		69	-6	11
79	6	156	8		77	2	-6
88	7	149	8		61	-9	7
84	8	153	8		69	4	-4
92	8	147	8		55	-8	6
88	11	149	10		61	4	-2
95	11	145	9		50	-7	4
90	12	146	12		56	5	-1
99	13	144	9		45	-9	2
91	10	146	11		55	8	-2
100	12	145	11		45	-9	1
94	11	148	10		54	6	-3

colonne 1 :crête basse, colonne 2 repet bas, colonne 3 crête haute, colonne 4 repet haut, colonne 5 delta entre crête haut et bas, colonne 6 delta entre crête bas, puis dernière colonne delta crête haut
A éviter imperativement ce sont les variations brusques qui produirait des marteaux accoustique, et il faut que chaque train d'ondes se marient pour éviter les chocs

temps · [résolu] concaténer hexa en langage C++

Merci pour la réponse, je suis loin d'avoir le code comme je l'entends.
en fait j'essaie de montrer, en exemple pour avoir un son "a" plus cristallin, il faut corriger les défauts induits par ma technique de construction. J'ai commencé à corriger le début :

bascule1(127,4,137,10,125,9,139,11,124,8,140,10,121,8,141,9,121,7,143,9,117,6,143,8,118,6,146,7,113,5,145,6,115,5,149,6,109,3,147,5,112,4,152,8,105,7,149,3,109,4,155,12,101,11,151,12,106,12,158,11,97,10,153,11,103,12,161,10,93,9,155,10,100,11,164,9,89,7,157,9,97,10,167,8,85,6,159,8,94,9,170,7,81,5,161,7,91,8,173,6,77,4,163,6,88,7,176,5,73,3,165,5,85,7,179,4,69,4,167,3,82,4,182,3,65,4,169,3,79,4,185,3,61,4,171,3,76,4,188,3,57,4,173,3,73,4,191,3,53,4,175,3,70,4,194,3,49,4,177,3,67,4,197,3,45,4,179,3,64,4,200,3,41,4,181,3,61,4,203,3,37,4,183,3,58,4,206,3,33,4,185,3,55,4,209,3,29,4,187,3,52,4,212,3,25,4,189,3,49,4,215,3,21,4,191,3,46,4,218,3,17,4,193,3,43,4,221,3,13,4,195,3,40,4,224,3,9,4,197,3,37,4,227,3,5,4,199,3,40,4,224,3,9,4,197,3,43,4,221,3,13,4,195,3,46,4,218,3,17,4,193,3,49,4,215,3,21,4,191,3,52,4,212,3,25,4,189,3,55,4,209,3,29,4,187,3,58,4,206,3,33,4,185,3,61,4,203,3,37,4,183,3,64,4,200,3,41,4,181,3,67,4,197,3,45,4,179,3,70,4,194,3,49,4,177,3,73,4,191,3,53,4,175,3,76,4,188,3,57,4,173,3,79,4,185,3,61,4,171,3,82,4,182,3,65,4,169,3,85,4,179,3,69,4,167,3,88,4,176,3,73,4,165,3,91,4,173,3,77,4,163,3,94,4,170,3,81,4,161,3,97,4,167,3,85,4,159,3,100,4,164,3,89,4,157,3,103,4,161,3,93,4,155,3,106,4,158,3,97,4,153,3,109,4,155,3,101,4,151,3,112,4,152,3,105,4,149,3,115,4,149,3,109,4,147,3,118,4,146,3,105,4,145,3,115,4,143,3,101,4,143,3,112,4,140,3,97,4,141,3,109,4,137,3,93,4,139,3,106,4,134,3,89,4,137,3,103,4,131,3,85,4,135,3,100,4,128,3,81,4,133,3,97,4,125,3,85,4,131,3,100,4,122,3,89,4,129,3,103,4,119,3,93,4,127,3,106,4,116,3,97,4,165,3,109,4,160,3,101,4,150,3,112,4,140,3,120,4,130,3);

de manière à obtenir de l'aide des codeurs en c++, ensuite un fois les lois assimilées, créer une class par son de voyelle et de consonne.
En fait, je cherche de l'aide en c++

Mais il faudrait qu'un modérateur juge, et si le sujet doit être indiqué en résolu et déplacé, je ferai comme il se doit ma démarche est de suivre les règles de manière à respecter un bon fonctionnement.

J'entends la remarque et la respecte, je peux effacer les messages si la demande est renouvelée, mais cela signifie pour moi , la fin d'une éventuelle aide pour finir le code.
Cordialement

P.S. Je vais regarder au mieux et rectifier en ne laissant que les messages pertinents, je m'en occupe dans la journée.

temps · [résolu] concaténer hexa en langage C++

Je cherche à créer des class qui générerons les fichiers sons.
Actuellement j'utilise une fonction qui se trouve dans le main
cette fonction doit pouvoir contenir des centaines d'arguments dont certains servirons à indiquer la class selon le son désiré
Si je montrais les lois ici, c'était pour avoir de l'aide pour créer les codes, mon intention étant ensuite de mettre les codes avec explications sur framacolibri et sur mon site en téléchargement
cordialement

temps · [résolu] concaténer hexa en langage C++

Merci pour la précision.
J'associe bien des chaînes de caractère contrains par les normes des fichiers audio. Donc en hexa concaténées.
Je dis des choses très simples, mais je me heurte aux formatages et croyances.
Il est vrai qu'un débutant en programmation m'aurait permis de montrer ce que je veux montrer dès qu'il va associer les idées comme je le décris.
Pour revenir au fil, comme dit, il est important pour moi de ne pas créer de gène dans le forum ou causer un soupçon de bruits sur les serveur.
Je pense qu'il faut protéger la communauté du libre et surtout ne pas apporter de gène.

Le temps d'effacer les bruits parasites sur mes sons, je crée sur mon site une page et je reviens en essayant de poser des questions pour résoudre les nombreux problèmes de codage qu'il me reste pour arriver à créer le format audio désiré.
Je poste en résolu, car quand je cré mes fichiers audio, maintenant j'arrive bien à concaténer.
Comme dit,
La page d'accueil du format audio est en construction ici
le code fonctionnel créé dans ce fil est ici
Cordialement

temps · [résolu] mauvaise surprise firefox

Bonjour,
Quand je clique sur le lien http://www.caue-mp.fr/espace-ressources … mique.html , c'est la page https://ma-petite-jardinerie.fr/content/8-plan-du-site qui s'ouvre.
Est-ce que quelqu'un peut m'aider ?
En détail si vous avez le temps, sur une installation d'il y trois semaines, j'ai reçu un mail bien agressif contenant mon adresse mail. Comme ma machine sert à plusieurs serveurs, j'ai tout formaté, mais j'ai remarqué des étrangetés, comme si j'étais sur un faux internet, des mails qui disparaissent ou apparaissent plusieurs jours après.
J'ai pris des mesures extrêmes, nouvel ordinateur avec nouvel ubuntu mate, nouveau smartphone lié et surprise, mais j'ai cet événement de page différente. Je rencontre le problème quelque soit le réseau (j'ai plusieurs réseaux)

temps · [résolu] mauvaise surprise firefox

Merci pour la réponse. En fait une architecte CAUE ma grandement aidé et donné des conseils très efficaces, il y plusieurs années.
Je suis retourné vers eux car j'ai effectué tous les travaux conseillé (problème ciment sur pierre des années 1960) pour aller plus loin.
De manière à faire le suivi, je monte un dossier photos pour présenter les différences (impressionnant), j'ai trouvé ce lien dans mes anciens mails CAUE.
Si je comprends bien ce serait le serveur de la préfecture qui aurait un problème et mes systèmes seraient sain ?

temps · [résolu] mauvaise surprise firefox

Merci pour la réponse, je poste en résolu et signale à mon correspondant l'événement.
Cordialement

temps · [résolu] mauvaise surprise firefox

Bonjour, pour info j'utilise web-mail, je soupçonne que le problème rencontré a été induit par mon huawei p40 qui a imposé d'avoir des droits pour fonctionner.
Depuis ce week-end nouveau PC et nouveau téléphone, mais j’envisage portable dans les 200 euros, j'ai besoin d'une machine sécurisé qui me permette de coder et je pense qu'avec cette somme ça suffit; il faut juste m’assurer compatibilité nunux.
J'ai pensé firefox, car en faisant des recherches j'obtenais des réponses bien orientés, et même une fois choquante qui n'avait rien à voir avec la demande de ma recherche (avec un firefox paramétré comme il faut)
cordialement

temps · [résolu] comment supprimer une "device" qui n'existe pas

Bonjour,
Je suis sous ubuntu mate, et j'ai reçu un mail étrange sur ma boite mail qui me fait penser que celle-ci a pu être récupérée sans que je l'utilise.
De manière à sécuriser ma machine, j'ai refais une installation. Mais surprise, quand je vais sur la racine de mon disque, je vois apparaître une "device" inaccessible portant le nom de mon adresse mail !
Est-ce que quelqu'un sait comment corriger cela, et éventuellement me dire comment la machine peut garder mon adresse mail sans que je le lui indique, (uefi bios ? ...)
Quand je fais fdisk -l , j'obtiens :

Device       Start       End   Sectors  Size Type
/dev/sda1     2048      4095      2048    1M BIOS boot
/dev/sda2     4096   1054719   1050624  513M EFI System
/dev/sda3  1054720 500117503 499062784  238G Linux filesystem

En plus de détail, j'ai fais une installation ubuntu de base, cela me permets d'avoir des applications que j'utilise, ensuite j'ai installé le bureau de mate. Dans la première partie, à un moment, à la demande de gnome, j'ai indiqué mon adresse mail, mais ne lui ai pas donné les droits d'accès, mais cette adresse n'a jamais été indiqué dans mate.

lsusb
Bus 002 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub
Bus 001 Device 003: ID 1bcf:2b96 Sunplus Innovation Technology Inc. Integrated_Webcam_HD
Bus 001 Device 002: ID 045e:00cb Microsoft Corp. Basic Optical Mouse v2.0
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

lspci
00:00.0 Host bridge: Intel Corporation Xeon E3-1200 v6/7th Gen Core Processor Host Bridge/DRAM Registers (rev 02)
00:02.0 VGA compatible controller: Intel Corporation HD Graphics 620 (rev 02)
00:04.0 Signal processing controller: Intel Corporation Xeon E3-1200 v5/E3-1500 v5/6th Gen Core Processor Thermal Subsystem (rev 02)
00:14.0 USB controller: Intel Corporation Sunrise Point-LP USB 3.0 xHCI Controller (rev 21)
00:14.2 Signal processing controller: Intel Corporation Sunrise Point-LP Thermal subsystem (rev 21)
00:15.0 Signal processing controller: Intel Corporation Sunrise Point-LP Serial IO I2C Controller #0 (rev 21)
00:15.1 Signal processing controller: Intel Corporation Sunrise Point-LP Serial IO I2C Controller #1 (rev 21)
00:15.2 Signal processing controller: Intel Corporation Sunrise Point-LP Serial IO I2C Controller #2 (rev 21)
00:16.0 Communication controller: Intel Corporation Sunrise Point-LP CSME HECI #1 (rev 21)
00:17.0 SATA controller: Intel Corporation Sunrise Point-LP SATA Controller [AHCI mode] (rev 21)
00:1c.0 PCI bridge: Intel Corporation Sunrise Point-LP PCI Express Root Port #1 (rev f1)
00:1c.2 PCI bridge: Intel Corporation Sunrise Point-LP PCI Express Root Port #3 (rev f1)
00:1c.4 PCI bridge: Intel Corporation Sunrise Point-LP PCI Express Root Port #5 (rev f1)
00:1f.0 ISA bridge: Intel Corporation Sunrise Point LPC Controller/eSPI Controller (rev 21)
00:1f.2 Memory controller: Intel Corporation Sunrise Point-LP PMC (rev 21)
00:1f.3 Audio device: Intel Corporation Sunrise Point-LP HD Audio (rev 21)
00:1f.4 SMBus: Intel Corporation Sunrise Point-LP SMBus (rev 21)
00:1f.6 Ethernet controller: Intel Corporation Ethernet Connection (4) I219-LM (rev 21)
01:00.0 Unassigned class [ff00]: Realtek Semiconductor Co., Ltd. RTS525A PCI Express Card Reader (rev 01)
02:00.0 Network controller: Intel Corporation Wireless 8265 / 8275 (rev 78)

Cordialement

temps · [résolu] comment supprimer une "device" qui n'existe pas

Bonjour,
Je ne sais pas ce qui s'est passé, mais j'ai résolu le problème.
J'ai refais une installation de mate directement et cette fois-ci j'ai sélectionné l'effacement du disque dur complet.
La "device" impossible à monter, portant en nom l'adresse mail, a disparue

temps · [résolu] comment supprimer une "device" qui n'existe pas

Bonjour,
Je pense pareil, mais ne suis pas sure.
Il existe de nombreux protocoles de communication, technologies ...
En exemple en décembre 2021, j'ai installé en provisoire un thermostat, premier prix à pile (affichage digital), équipé d'un contact sec sur une pompe à chaleur air/eau.
Le boîtier de la pompe à chaleur arrivait à lire la température du thermostat, alors qu'il est sensé fonctionner en tout ou rien ! Un contact sec, rien de plus. Aujourd'hui, j'ai remplacé par un wifi qui est alimenté par la pompe à chaleur, donc plusieurs protocole de communication possible, mais comment la pompe à chaleur a pu connaître la température du premier thermostat ? Il existe bien des protocoles qui nous sont inconnus.

En exemple, sur l'éclairage publique nous pouvons savoir combien d'ampoules fonctionnent et ou elles sont en envoyant une simple impulsion, en courant porteur.ça peut-être des fréquences, des codes en signal carré, des codes qui reprennent des formes exactement comme pour ce qui différencie les sons ...

Cordialement

Ubuntu-fr

Navigation

Liens de recherche

Annonce

#0 -1 » format audio généré » Le 09/04/2024, à 18:18

#1 Re : -1 » format audio généré » Hier à 17:23

#2 Re : -1 » format audio généré » Hier à 23:01

#3 -1 » [résolu]Comment séparer l'éxécutable de l'application qui l'exécute ? » Hier à 06:55

#4 Re : -1 » [résolu]Comment séparer l'éxécutable de l'application qui l'exécute ? » Hier à 08:55

#5 -1 » création d'un format audio qui génère les sons, voix humaine ... » Le 12/03/2024, à 23:32

#6 Re : -1 » création d'un format audio qui génère les sons, voix humaine ... » Le 22/03/2024, à 18:05

#7 Re : -1 » création d'un format audio qui génère les sons, voix humaine ... » Le 16/04/2024, à 14:33

#8 -1 » [résolu] Comment ajuster le nombre de sorties en c++ » Le 11/04/2024, à 11:58

#9 Re : -1 » [résolu] Comment ajuster le nombre de sorties en c++ » Le 11/04/2024, à 22:26

#10 -1 » [résolu] concaténer hexa en langage C++ » Le 13/03/2024, à 01:46

#11 Re : -1 » [résolu] concaténer hexa en langage C++ » Le 13/03/2024, à 18:35

#12 Re : -1 » [résolu] concaténer hexa en langage C++ » Le 13/03/2024, à 19:04

#13 Re : -1 » [résolu] concaténer hexa en langage C++ » Le 15/03/2024, à 11:19

#14 Re : -1 » [résolu] concaténer hexa en langage C++ » Le 07/04/2024, à 09:24

#15 Re : -1 » [résolu] concaténer hexa en langage C++ » Le 09/04/2024, à 00:31

#16 Re : -1 » [résolu] concaténer hexa en langage C++ » Le 09/04/2024, à 00:55

#17 Re : -1 » [résolu] concaténer hexa en langage C++ » Le 09/04/2024, à 09:14

#18 -1 » [résolu] mauvaise surprise firefox » Le 06/03/2022, à 22:44

#19 Re : -1 » [résolu] mauvaise surprise firefox » Le 06/03/2022, à 23:10

#20 Re : -1 » [résolu] mauvaise surprise firefox » Le 06/03/2022, à 23:27

#21 Re : -1 » [résolu] mauvaise surprise firefox » Le 06/03/2022, à 23:54

#22 -1 » [résolu] comment supprimer une "device" qui n'existe pas » Le 01/02/2022, à 10:27

#23 Re : -1 » [résolu] comment supprimer une "device" qui n'existe pas » Le 01/02/2022, à 12:00

#24 Re : -1 » [résolu] comment supprimer une "device" qui n'existe pas » Le 01/02/2022, à 12:15

Pied de page des forums