EDIT J'ai modifié le libellé des règles pour rendre certaines choses implicites plus explicites. J'ai également ajouté une certaine emphase pour dissiper certains points de confusion apparente et défini explicitement l'option de créer un programme autonome au lieu d'une fonction.

Le but ici est de créer une fonction qui prend un fichier texte (ou une chaîne) et le transpose pour que les lignes deviennent des colonnes et vice versa.

Exemple:

Je suis un texte.
Transpose-moi.
Pouvez-vous le faire?

Résulte en:

ITC
 ra
aan
mn
 sy
apo
 ou
ts
eed
xo
tm
.ei
 .t
  ?

Les règles:

• Vous pouvez supposer que les seuls caractères d'espacement utilisés sont " "et "\n"et qu'il n'y a aucun espace de fin sur aucune ligne.
• Vous pouvez supposer que le fichier est ASCII. Le marqueur de fin que vous souhaitez utiliser dépend de vous (CRLF ou LF). Il doit fonctionner correctement sur l'exemple, mais il doit également fonctionner sur toute entrée qui satisfait aux hypothèses ci-dessus.
• Vous devrez peut-être insérer des espaces (comme dans l'exemple) là où il n'y en avait pas afin de maintenir les colonnes en ligne.
• Votre résultat ne doit avoir aucun espace de fin sur aucune ligne .
• Le dernier caractère de nouvelle ligne (pour la dernière ligne) est facultatif.
• Il doit s'agir soit d'une fonction, soit d'un programme complet. Si votre fonction accepte une chaîne, elle doit renvoyer les résultats sous forme de chaîne. S'il accepte un nom de fichier, vous retournez le nom du fichier dans lequel vous avez enregistré le résultat. Vous êtes également autorisé à écrire un programme complet qui accepte les entrées de STDIN et renvoie le résultat correct à STDOUT; si vous procédez ainsi, vous ne devez rien envoyer à STDERR.
• La procédure la plus courte l'emporte, mais je voterai pour toutes les réponses que j'aime.

Selon les règles, la sortie de l'exemple est longue de 53 ou 52 octets (pour les sauts de ligne LF) selon que le saut de ligne final est inclus ou non.

Remarque: Ce n'est pas une exigence spécifique, mais si votre fonction, lorsqu'elle est exécutée deux fois de suite, n'est pas identique à l'original (la nouvelle ligne finale peut être différente et toutes les lignes vides à la fin du fichier seront supprimées), alors vous êtes enfreignant probablement l' une des règles.

Japt , 6 octets

y mx1R

Essayez-le
Exécutez-le deux fois - renvoie la chaîne d'origine

Explication

y

Transposer l'entrée

m  R

Carte sur chaque ligne

x1

Couper à droite

J ( 31 40)

f=:3 :';(,&LF@dlb&.|.)&.><"1|:>LF cut y'

Il s'agit d'une fonction qui prend une chaîne et renvoie une chaîne (c'est-à-dire un vecteur de caractères avec des sauts de ligne insérés aux bons endroits, et non une matrice.)

Modifier: aucun espace de fin sur aucune ligne.

Tester:

   f=:3 :';(,&LF@dlb&.|.)&.><"1|:>LF cut y'

   string=:stdin''
I am a text.
Transpose me.
Can you do it?
^D

   $string
42
   $f string
53
   f string
ITC
 ra
aan
mn
 sy
apo
 ou
ts
eed
x o
tm
.ei
 .t
  ?

Ruby 111

Golfé:

def f t;s=t.lines;s.map{|l|l.chomp.ljust(s.map(&:size).max).chars}.transpose.map{|l|l.join.rstrip+?\n}.join;end

Non golfé:

def transpose_text(text)
  max_length = text.lines.map(&:size).max
  text.lines.map do |line|
    line.chomp.ljust(max_length).chars
  end.transpose.map do |chars|
    chars.join.rstrip + "\n"
  end.join
end

Ruby a une fonction de transposition de tableau, donc cela remplit simplement les lignes, les transforme en un tableau de caractères, utilise la fonction de transposition Array # de Ruby, puis transforme le tableau de caractères en lignes.

Pour jouer au golf, il s'agissait simplement d'utiliser des identificateurs à un seul caractère, de supprimer des espaces, d'utiliser un temporaire pour text.lines et de placer le calcul pour max_length en ligne (il n'y a pas de points pour l'efficacité).

R, 171

function(e){p=strsplit
x=t(plyr::rbind.fill.matrix(lapply(p(p(e,"\n")[[1]],""),t)))
x[is.na(x)]=" "
cat(apply(x,1,function(y)sub(" *$","",paste(y,collapse=""))),sep="\n")}

Exemple d'utilisation:

text <- "I am a text.
Transpose me.
Can you do it?"


(function(e){p=strsplit
x=t(plyr::rbind.fill.matrix(lapply(p(p(e,"\n")[[1]],""),t)))
x[is.na(x)]=" "
cat(apply(x,1,function(y)sub(" *$","",paste(y,collapse=""))),sep="\n")})(text)

ITC
 ra
aan
mn
 sy
apo
 ou
ts
eed
x o
tm
.ei
 .t
  ?

L'espace de fin est supprimé.

Python 2.7 ( 97 79 94 90)

EDIT: Omission de l'exigence de fonction;

Je suis assez sûr que cela sera amélioré puisque je suis en quelque sorte un débutant ici, mais pour commencer;

c=lambda a:'\n'.join(''.join(y or' 'for y in x).rstrip()for x in map(None,*a.split('\n')))

Le code utilise un simple splitpour diviser la chaîne en un vecteur de lignes. Il utilise ensuite mapavec une valeur de fonction as None(la fonction d'unité) et l'opérateur splat pour transposer et remplir le vecteur (fonctionnalité similaire à zip_longestPython3)

Le reste du code mappe simplement Nonevers l'espace, ajuste et réassemble la matrice en une seule chaîne à nouveau.

>>> a = 'I am a text.\nTranspose me.\nCan you do it?'
>>> c(a)                                                                            
'ITC\n ra\naan\nmn\n sy\napo\n ou\nts\need\nx o\ntm\n.ei\n .t\n  ?'
>>> len("""c=lambda a:'\n'.join(''.join(y or' 'for y in x).rstrip()for x in map(None,*a.split('\n')))""")
88
# (+2 since `\n` is considered by `len` to be a single char)

Bash + coreutils + sed, 83

eval paste `sed 's/.*/<(fold -w1<<<"&")/'`|expand -t2|sed 's/\(.\) /\1/g;s/ \+$//'

foldet pastefaire le travail important. Le reste n'est que du formatage.

Accepte les entrées de stdin et les sorties vers stdout:

$ < tr.txt ./transposefile.sh
ITC
 ra
aan
mn
 sy
apo
 ou
ts
eed
x o
tm
.ei
 .t
  ?
$ < tr.txt ./transposefile.sh | ./transposefile.sh
I am a text.
Transpose me.?
Can you do it
$ 

C (278 octets)

Edit: Cela enfreint les règles, car il prend un nom de fichier comme argument mais écrit dans stdout. Je vais le modifier plus tard pour écrire dans un fichier, puis imprimer le nom de fichier sur stdout.

Ceci est mon premier golf de code jamais, alors ayez pitié. Un peu de vieux C. Placez l'entrée test.txtet laissez-la fonctionner!

clang transpose.c -o transpose && ./transpose test.txt

#import <stdio.h>
#import <stdlib.h>
#import <string.h>

#define BUFFER_SIZE 1024

#define MAX(A,B) ((A)>(B)?(A):(B))

int main(int argc, char **argv) {
    char line[BUFFER_SIZE];

    FILE *f; int nLines, maxLen;

    f = fopen(argv[1], "r");
    while(!feof(f) && fgets(line, BUFFER_SIZE, f)) {
        nLines++;
        maxLen = MAX(maxLen, strlen(line));
    }
    fclose(f);

    for (int charPos = 0; charPos < maxLen; charPos++) {
        f = fopen(argv[1], "r");
        for (int linePos = 0; linePos < nLines; linePos++) {
            fgets(line, BUFFER_SIZE, f);
            printf("%c", charPos < strlen(line) && line[charPos] != '\xA' ? line[charPos] : ' ');
        }
        printf("\n");
        fclose(f);
    }

    return 0;
}

En utilisant des noms de variables courts, en supprimant le formatage gratuit, en autorisant les fuites de descripteurs de fichiers et en désactivant tous les avertissements, cela est réduit à 278 octets. (Puisqu'il utilise des importations implicites, il peut ne pas se lier correctement sur tous les systèmes. Fonctionne sur ma machine!)

#import <stdio.h>
int main(int C,char**V){char L[1024];int A,B,D,I,J,*F=fopen(V[1],"r");while(!feof(F)&&fgets(L,1024,F)){A++;D=strlen(L);B=B>D?B:D;}for(I=0;I<B;I++){F=fopen(V[1],"r");for(J=0;J<A;J++)fgets(L,1024,F)&&printf("%c",I<strlen(L)&&L[I]!='\n'?L[I]:' ');printf("\n");}}

AutoHotkey 210

f(i){
StringSplit,o,i,`n
m:=0
loop % o0 {
a:=A_index
if (t:=Strlen(p:=o%a%))>m
m:=t
StringSplit,l%a%,o%a%
}
loop % m {
a:=A_index,n:=""
loop % o0
n.=(j:=l%A_index%%a%)=""?" ":j
s.=Rtrim(n," ") "`n"
}
return s
}

Tester

text=
(
I am a text.
Transpose me.
Can you do it?
)
msgbox % f(text)

Rubis: 88 caractères

(Publié parce qu'il est plus court que les autres solutions Ruby. Non vérifié si mon code introduit quelque chose de nouveau par rapport à ceux-ci. Si vous avez déjà publié une solution Ruby et que vous pensez que c'est principalement une copie de la vôtre, veuillez commenter et je retirerai ma réponse. )

f=->t{l=t.split$/;r=[""]*m=l.map(&:size).max;l.map{|l|m.times{|i|r[i]+=l[i]||" "}};r*$/}

Exemple d'exécution:

irb(main):001:0> f=->t{l=t.split$/;r=[""]*m=l.map(&:size).max;l.map{|l|m.times{|i|r[i]+=l[i]||" "}};r*$/}
=> #<Proc:0x99a9e68@(irb):1 (lambda)>

irb(main):002:0> sample='I am a text.
irb(main):003:0' Transpose me.
irb(main):004:0' Can you do it?'
=> "I am a text.\nTranspose me.\nCan you do it?"

irb(main):005:0> puts f[sample]
ITC
 ra
aan
mn
 sy
apo
 ou
ts
eed
x o
tm
.ei
 .t
  ?
=> nil

irb(main):006:0> puts f[f[sample]]
I am a text.
Transpose me.
Can you do it?
=> nil

Bash, 124 octets

D=`mktemp -d`;split -l1 - $D/;for F in $D/*;do grep -o . $F>$F+
done;paste $D/*+|sed -e's/\([^\t]\)\t/\1/g;s/\t/ /g;s/ *$//'

Il lit l'entrée standard et écrit la sortie standard. Essayez-le:

echo $'I am a text.\nTranspose me.\nCan you do it?' | script.sh

Comment ça marche:

• splitentrée sur des lignes simples (fichiers dans un répertoire temporaire $D)
• diviser les lignes en caractères uniques à l'aide de grep(fichiers * +)
• mise en page côte à côte à l'aide de paste(colonnes séparées par des tabulations)
• retirer les TAB d'alignement, remplacer les TAB de remplissage par des BLANKs, couper à l'aide de sed

Modifier:

• -9: Suppression du code de rangement ;rm -r $D(merci Tim)
• -2: utilisez +au lieu de _comme suffixe et raccourcissez ${F}_à$F+
• -3: supprimer le préfixe Ldes fichiers de résultats fractionnés

Ruby - 144 caractères

Voici ma première tentative, golfée:

def f t
t.split(?\n).each{|l|l<<' 'until l.size==t.split(?\n).map(&:size).max}.map{|x|x.split('')}.transpose.map{|l|l.join.rstrip}.join(?/n)
end

Pour la sortie, exécutez puts f textoù textest une chaîne multi-lignes respectant les règles ci-dessus. La version non golfée est ci-dessous:

def text_transpose(text)
  lines = text.split(?\n)
  maxlen = lines.map(&:size).max
  lines.each { |line| line << ' ' until line.size == maxlen }
       .map  { |line| line.split('') }.transpose
       .map  { |char| char.join.rstrip }.join(?\n)
end

Pour une solution similaire, mais finalement meilleure dans Ruby, consultez le code de Wayne Conrad ci-dessus.

PHP 194

function x($a){$a.="\n";$s=strlen($a);$i=0;while($c<$s)if($a{$c}!="\n")$b[$i++].=$a{$c++};else{$c++;for(;$i<$s;$i++)$b[$i].=" ";$i=0;}ksort($b);return rtrim(implode("\n",array_map("trim",$b)));}

Non-golfé:

function x($a) {
    $a.="\n";
    $s=strlen($a);
    $i=0;
    while($c<$s)
        if($a{$c}!="\n")
            $b[$i++].=$a{$c++};
        else{
            $c++;
            for(;$i<$s;$i++)
                $b[$i].=" ";$i=0;
        }
    ksort($b);
    return rtrim(implode("\n",array_map("trim",$b)));
}

C'est ma première tentative de golf, alors soyez gentil! De plus, des conseils / suggestions seraient grandement appréciés!

MATHEMATICA 117 caractères

t = "I am a text.\nTranspose me.\nCan you do it?";

f=(m=Length/@(f=Flatten[Characters/@StringSplit[#,"\n"],{{2},{1}}])//Max;
StringJoin@@@(PadLeft[#,m," "]&/@f)//Column)&

Perl (92 + 1)

lit stdin et écrit sur stdout. ajouter 1 au score desay

@L=map[grep!/\n/,split//],<>;do{$_=join'',map shift@$_||$",@L;s/ +$//;say}while grep@$_>0,@L

CJam, 32 25 octets

CJam est plus récent que ce défi, donc cette réponse ne peut pas être acceptée.

Considérablement raccourci par user23013.

qN/_z,f{Se]}z{S+e`);e~N}%

Testez-le ici.

qN/                       "Read input, split into lines.";
   _z,                    "Transpose, get length (find maximum line length).";
      f{Se]}              "Pad each line to that length with spaces.";
            z             "Transpose.";
             {         }% "Map this block onto each line in the result.";
              S+          "Add a space to ensure there's at least one.";
                e`        "Run-length encode.";
                  );      "Discard the trailing run of spaces.";
                    e~    "Run-length decode";
                      N   "Push a newline.";

Javascript, 103

s=>[...s].map((_,i)=>s.split`
`.map(b=>r+=b[q=b[i]||q,i]||' ',r=q='')&&r.replace(/ *$/,q?`
`:q)).join``

Moins golfé

s=>[...s].map(
     // we need 'i' ranging from 0 to the length of the longest input line
     // so we scan all the input string, that is surely longer
     // but we need to check that after some point the output must be empty
     (_, i) => ( 
       r = '', // the current output row, starts empty
       q = '', // flag to check if we are beyond the longest line
       s.split('\n') // split in rows
       .map( 
         b => ( // for each input row in b
           q = b[i] || q, // if there is a char at position i in b, i goes to q
           r += b[i] || ' ' // add to output the char at position i or a fill space
         )
       ),
       q // if q is still '', we are beyond the longest input line 
       ? r.replace(/ *$/,`\n`) // trim leading space and add newline
       : '' // no output 
     )
   ).join('')

Tester

F=
s=>[...s].map((_,i)=>s.split`
`.map(b=>r+=b[q=b[i]||q,i]||' ',r=q='')&&r.replace(/ *$/,q?`
`:q)).join``

function go() {
  var text=I.value
  var output = F(text)
  O.textContent = output
}

go()

#I { width:50%; height:5em }

<textarea id=I>I am a text.
Transpose me.
Can you do it?</textarea><br>
<button onclick='go()'>Transpose</button>
<pre id=O></pre>

Rétine , 40 octets

P`.+
~L0$`.
L,$.%'vs,$.(x$%=),`.+
m` *$

Essayez-le en ligne!

Basé sur ce programme que j'ai créé pour transposer n'importe quelle taille de rectangle, qui utilise la suggestion de Leo pour transposer un rectangle d'une taille connue.

Edit: Golfé plus et n'a plus d'espaces de fin sur les lignes.

Perl 5 , 25 octets

Notez que cela utilise des séquences d'échappement ANSI et en tant que tel ne fonctionne pas sur TIO, vous pouvez cependant le voir en action ici .

$"="[1D";$_="[1;$.H@F"

Explication

Ce code modifie d'abord la valeur du séparateur de liste ( $") en un onglet vertical, suivi de la séquence d'échappement ANSI pour «revenir en arrière 1 colonne» ( \x1b[1D), puis nous définissons la variable imprimée implicitement $_comme une chaîne qui commence par la séquence d'échappement ANSI pour 'commencer l'impression à la colonne de la ligne 1 $.(où se $.trouve la ligne de texte actuelle)' ( \x1b1;$.H) et interpole la liste @F(qui est une liste de tous les caractères de cette ligne, remplie par autosplit ( -a) avec un motif de fractionnement vide ( -F)) qui place le contenu de$" entre chaque élément, en déplaçant le curseur verticalement vers le bas au lieu de continuer la sortie après le caractère précédent.

Essayez-le en ligne!

C ++ (243 caractères)

Voici une fonction qui prend et renvoie une chaîne.

J'aurais pu raser quelques dizaines de caractères, mais j'ai décidé de le garder en tant que code non stupide (fonctionne rapidement, se lit bien). Peut-être que j'ai décidé de le faire parce que c'est mon premier golf de code ... Je ne suis pas encore assez hardcore :)

string f(string s){stringstream ss(s);vector<string> v;for(size_t i=0;getline(ss,s);++i){if(v.size() < s.size())v.resize(s.size());for(size_t j=0;j<s.size();++j){v[j].resize(i,' ');v[j].push_back(s[j]);}}s="";for(auto& i:v)s+=i+'\n';return s;}

Avec formatage:

string f(string s)
{
    stringstream ss(s);
    vector<string> v;

    for(size_t i = 0; getline(ss, s); ++i)
    {
        if(v.size() < s.size())
            v.resize(s.size());

        for(size_t j = 0; j < s.size(); ++j)
        {
            v[j].resize(i, ' ');
            v[j].push_back(s[j]);
        }
    }

    s = "";
    for(auto& i : v)
        s += i + '\n';

    return s;
}

Python 2.7 - 115 caractères :

bon mot:

>>> a
'I am a text.\nTranspose me.\nCan you do it?'

>>> "".join(["".join(i)+'\n' for i in zip(*[x+" "*(len(max(a.splitlines(), key=len))-len(x)) for x in a.splitlines()])])
'ITC\n ra\naan\nmn \n sy\napo\n ou\nts \need\nx o\ntm \n.ei\n .t\n  ?\n'

et dans une impression plus propre:

>>> print "".join(["".join(i)+'\n' for i in zip(*[x+" "*(len(max(a.splitlines(), key=len))-len(x)) for x in a.splitlines()])])
ITC
 ra
aan
mn 
 sy
apo
 ou
ts 
eed
x o
tm 
.ei
 .t
  ?

en 115 caractères:

>>> len(""""".join(["".join(i)+'\n' for i in zip(*[x+" "*(len(max(a.splitlines(), key=len))-len(x)) for x in a.splitlines()])])""")
115

GolfScript, 51 caractères

n%.{,}%$-1=" "*:y;{y+y,<}%zip{n\+0{;).32=}do}%((;\+

Ceci est une première tentative; Je soupçonne que cela peut être amélioré. La majeure partie du code est de se conformer aux exigences de suppression de l'espace de remplissage et de fin - sans elles, n%zip n*cela suffirait.

Ps. La version suivante à 46 caractères fera le travail pour l'exemple d'entrée donné, mais se bloquera si une colonne d'entrée est entièrement composée d'espaces:

n%.{,}%$-1=" "*:y;{y+y,<}%zip{0{;).32=}do]}%n*

Je suppose que cela suffit pour le disqualifier, même si le défi ne le dit pas explicitement.

Schéma / Raquette 113

Le texte:

(define t (list 
    (string->list "I am a text.") 
    (string->list "Transpose me.")
    (string->list "Can you do it?")
))

Sans nouvelles lignes et espaces blancs supplémentaires:

(define s(λ(v x)(if(= x 0)'()(cons(list->string(car v))(s(cdr v)(- x 1))))))(s(apply map list t)(length(car t)))

La version conviviale

(define text (list 
    (string->list "I am a text.") 
    (string->list "Transpose me.")
    (string->list "Can you do it?")
))

(define transpose
    (λ(text length)
        (if (= length 0)
            '()
            (cons (list->string (car text)) (transpose (cdr text) (- length 1)))
)))

(transpose (apply map list text) (length (car text)))

Haskell

import Data.List
main = interact (unlines . transpose . lines)

C'était si court, j'avais besoin d'ajouter un espace blanc ...

Python 89 103 caractères

def f(a):return'\n'.join([''.join(i).rstrip()for i in zip(*[j+' '*99 for j in a.split('\n')])]).rstrip()

Je me sens sale. 90 104 caractères pour la version industrielle. : ^)

Mathematica, 95 caractères

f=""<>Riffle[Thread@PadRight@Characters@StringSplit[#,"\n"]//.{0->" ",{x___," "..}:>{x}},"\n"]&

K, 56

Cela devrait répondre aux spécifications maintenant.

Accepte une chaîne, renvoie une chaîne.

{`/:{$[" "=*|x;|(+/&\" "=|x)_|x;x]}'x@'/:!max@#:'x:`\:x}

.

k)f:{`/:{$[" "=*|x;|(+/&\" "=|x)_|x;x]}'x@'/:!max@#:'x:`\:x}
k)f"I am a text.\nTranspose me.\nCan you do it?"
"ITC\n ra\naan\nmn\n sy\napo\n ou\nts\need\nx o\ntm\n.ei\n .t\n  ?\n"
k)f f"I am a text.\nTranspose me.\nCan you do it?"
"I am a text.\nTranspose me.\nCan you do it?\n"

Groovy, 98 caractères

{i->o=[].withDefault{''};i.readLines().each{it.toList().eachWithIndex{c,d->o[d]+=c}};o.join('\n')}

en ligne

non golfé:

{i->
o=[].withDefault{''};//create list with empty string as default value 
i.readLines()
.each{
    it.toList() //split every line to characters
    .eachWithIndex{ 
        c,d->o[d]+=c //append to string from list with right index
    }
};
o.join('\n')}//join list with newlines
}

Pyth , 11 octets

# aYcw1;.tY

Essayez-le en ligne!

Prend l'entrée sous forme de chaîne, génère une liste de listes

Pyth , 25 octets

# aYcw1=+Z1;jbcj"".n.tY)Z

Prend l'entrée sous forme de chaîne, produit une chaîne.

Essayez-le en ligne!

J, 28 26 octets

Sauvegardé 2 octets grâce à frownyfrog

t=.,@:(,&LF"1)@|:@:>@cutLF

Prend une chaîne, renvoie une chaîne. Je ne sais pas s'il existe une version plus courte du verbe de la fonction 'cutopen' que je pourrais utiliser.

Il y a aussi le plus court

t=.|:@:>@cutLF

Mais je ne suis pas sûr qu'il relève des directives de l'OP, car il renvoie un tableau de caractères.

Comment ça marche:

                     cutLF   | Splits the input on new lines and boxes them
                    @        | Composes verbs (as does @:, but they're not equal)
                   >         | Unboxes this, forming an array of the lines
                 @:          |
               |:            | Transposes the array
      (      )@              |
       ,&LF                  | Appends a new line...
           "1                | To each row of the array
    @:                       |
   ,                         | Flatten the result
t=.                          | Assign this verb to t

L'autre version fonctionne de la même façon, mais ne convertit pas le tableau transposé en une chaîne correctement formatée.

Exemples:

NB. Define a multi-line string

    text =: 0 : 0
I am a text.
Transpose me.
Can you do it?
)

    t text
ITC
 ra
aan
mn    NB. There's whitespace after the 'n' here, but I assume it doesn't count as trailing since it's part of the original string
 sy
apo
 ou
ts 
eed
x o
tm 
.ei
 .t
  ?

    t t text
I am a text.     NB. Again, whitespace here, but it's part of the argument of the second 't' (added by the first 't' to keep columns straight)
Transpose me. 
Can you do it?

Lua ,203 189 octets

t={{}}i=1m=0(...):gsub(".",function(c)n=#t[i]if c=="\n"then i=i+1t[i]={}else t[i][n+1]=c end m=m<=n and n+1or m end)
for x=1,m do for p=1,i do io.write(t[p][x]or" ")end _=m<=x or print()end

Essayez-le en ligne!

J'ai vu une autre solution Lua ici, mais je ne pense pas qu'il y ait un problème avec la publication de 2 solutions dans la même langue. S'il y en a, dites-le moi :)