Étant donné une chaîne, vous devez la diviser en groupes de trois caractères (en complétant _à la fin).

Lié , mais c'est toujours différent.

Exemple d'E / S:

• 'abcde' -> 'abc', 'de_'

• '1234' -> '123', '4__'

• '' -> [] or falsey value

• 'Three spree!' -> 'Thr', 'ee ', 'spr', 'ee!'

• Chaîne de 6 Mo

Il s'agit d'un code-golf , donc le moins d'octets gagnera!

Edit: Enfin, la sortie n'est pas restreinte .

05AB1E , 9 8 octets

…___«3ô¨

Essayez-le en ligne! ou comme suite de tests

Explication

…___«      # append "___" to input
     3ô    # split into groups of 3
       ¨   # discard the last group

Python 3, 58 47 34 octets

Je suis sûr que quelqu'un d'autre peut faire mieux. Quelqu'un d'autre a fait mieux. Merci Jo roi pour -11 -24 octets!

La sortie est illimitée, bienvenue dans l'enfer des tuples. Retourne une liste vide ( fausse ) sur une entrée vide

lambda x:[*zip(*[iter(x+"__")]*3)]

TIO

JavaScript, 25 octets

s=>`${s}__`.match(/.../g)

Essayez-le

Perl 5 , 16 15 octets

"@_\__"=~/.../g

Essayez-le en ligne!

APL + WIN 36 24 22 octets

12 octets enregistrés en raison de la sortie maintenant restreinte et de l'utilisation du code dans le premier commentaire de @ Adám modifié pour fonctionner dans APL + WIN et 2 autres avec son deuxième commentaire. Merci.

(⌈(↑⍴s)÷3)3⍴(s←⎕),'__'

Invite à entrer la chaîne et affiche le résultat sous forme de tableau nx3

Essayez-le en ligne! Gracieuseté de Dyalog Classic

JavaScript, 51 50 48 27 25

b=>(b+"__").match(/.../g)

Essayez-le en ligne!

Perl 6 , 19 octets

{$_~"__"~~m:g/.../}

Essayez-le en ligne!

Remplit la chaîne de deux traits de soulignement, puis divise la chaîne en morceaux de trois caractères. Renvoie un tableau d'objets Match.

Japt , 8 octets

+1 octet dans le cas spécial de la chaîne vide. Peut sauver 2 si nous pouvons choisir notre caractère de remplissage.

©ò3 ú'_3

Essayez-le

©ò3 ú'_3     :Implicit input of string
©            :Logical AND with
 ò3          :Split into chunks of 3
    ú'_3     :Right pad each with "_" to length 3

Stax , 7 octets

é☻εgP▀╪

Exécuter et déboguer

Pour une entrée de chaîne vide, le résultat est un tableau vide, qui est une valeur de falsey dans stax.

CJam , 11 octets

q'_3*+3/);p

Essayez-le en ligne!

Pour une entrée vide, cela donne une chaîne vide, ce qui est faux.

Comment ça fonctionne

q     e# Read input as a string
'_    e# Push char '_'
3*    e# String formed by that char repeated 3 times
+     e# Concatenate to input string
3/    e# Split in groups of 3, the last of which may be shorter. Gives array of strings
);    e# Detach last string from the array and delete it
p     e# Print string representation of the array

Retina 0.8.2 , 10 octets

$
__
!`...

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

$
__

Ajoutez deux _s, au cas où le dernier groupe doit être rembourré.

!`...

Faites correspondre autant de groupes de trois que possible, produisant les correspondances elles-mêmes plutôt que le nombre. (Dans Retina 1, ce serait Lau lieu de !.)

C (gcc) , 67 octets

i;f(char*_){for(;*_;puts(""))for(i=3;i--;)putchar(*_?*_++:95);_=0;}

Essayez-le en ligne!

Renvoie toujours une valeur de falsey (0).

Wolfram Language (Mathematica) , 28 21 octets

-7: Ne nécessite plus de Falsevaleur falsy ( ) sur une entrée vide

Partition[#,3,1,1,_]&

Essayez-le en ligne!

Prend une liste de caractères en entrée. Renvoie une liste de 3 tuples de caractères remplis de Blanks ( _).

34 27 octets

StringPartition[#<>"__",3]&

Essayez-le en ligne!

Entrée de chaîne, liste de sortie de chaînes

Gelée , 9 octets

s3o€“___”

Un lien monadique acceptant une liste de caractères qui donne une liste de listes de caractères (une entrée vide donne une sortie vide).

Essayez-le en ligne!

Comment?

s3o€“___” - Link: list of characters
s3        - split into chunks of three
   €      - for each chunk:
  o       -   OR (vectorises):
    “___” -     list of characters = ['_', '_', '_']

Remarques:
Le €n'est nécessaire que pour gérer le cas de bord d'une entrée vide.
Un programme complet peut supprimer une fin ”, mais ici nous ne pouvons pas le faire car le comportement d'impression d'un programme complet écrase tout ensemble.

Équivalent 9:

o3ÐƤ“___”

Essayez-le

Alternative 9:

;“___”s3Ṗ

Essayez-le

J , 16 octets

[:}:_3]\'___',~]

Essayez-le en ligne!

K (oK) , 19 17 octets

-2 octets grâce à ngn!

{-1_0N 3#x,"___"}

Essayez-le en ligne!

Java 10, 116 113 octets

s->{s+="__";int l=s.length()/3,i=l;var r=new String[l];for(;i-->0;)r[i]=s.substring(i*3,i*3+3);return l<1?0>1:r;}

Essayez-le en ligne.

Ou 104 101 octets si un tableau vide au lieu de falseest autorisé en sortie.

s->{s+="__";int l=s.length()/3;var r=new String[l];for(;l-->0;)r[l]=s.substring(l*3,l*3+3);return r;}

Essayez-le en ligne.

Explication:

s->{                             // Method with String as both parameter and return-type
  s+="__";                       //  Append two "_" to the input-String
  int l=s.length()/3;            //  Get the length, integer-divided by 3
  var r=new String[l];           //  Create a string-array with that many parts
  for(;l-->0;)                   //  Loop `l` in the range (l, 0]:
    r[l]=                        //   Set the `l`'th value of the array to:
         s.substring(l*3,l*3+3); //   Get the substring of size 3 from index `l*3` from `s`
  return r;}                     //  Return the array

Rubis, 73 42 octets

a=gets
a.length!=0?a.scan(/.{1,3}/).map{|s|(s+'_'*3)[0,3]}:'falsey value'

Edit: comme la valeur de falsey ne semble pas nécessaire:

gets.scan(/.{1,3}/).map{|s|(s+'_'*3)[0,3]}

C # (compilateur interactif Visual C #) , 74 octets

Ajoutez simplement deux traits de soulignement «_» à la fin de l'entrée pour vous assurer qu'ils sont imprimés si la longueur de l'entrée n'est pas un facteur de 3.

s=>Enumerable.Range(0,(s.Length+2)/3).Select(i=>(s+"__").Substring(i*3,3))

Essayez-le en ligne!

Kotlin , 34 octets

{"${it}__".chunked(3).dropLast(1)}

Essayez-le en ligne!

C (gcc) , 55 octets

i;f(char*s){for(;i%4|*s;)putchar(++i%4?*s?*s++:95:10);}

Essayez-le en ligne!

C (clang) , 128 126 94 67 octets

67 octets grâce à @ceilingcat

f(char*k){for(;*k;k++)printf("%c%c%c\n",*k,*++k?*k:95,*++k?*k:95);}

Essayez-le en ligne!

Frapper , 90 octets

Cela utilise les fonctionnalités de Bash plutôt qu'une combinaison de commandes Bourne shell plus * nix plus traditionnelles (dont une version que j'ai créée s'est retrouvée à 205 octets). J'ai triché en utilisant l'esquive d'ajouter deux caractères _ à la chaîne.

c=;read a;a=${a}__;while (($(echo ${#a})>2));do b=${a:0:3};c=$c\ $b;a=${a#$b};done;echo $c

Essayez-le en ligne!

PowerShell , 58 35 octets

$args-split'(...)'-ne''|% *ht 3 '_'

-23 octets grâce à mazzy .

Essayez-le en ligne!

GNU sed , 27 octets

s:$:__:
s:...:& :g
s: _*$::

Essayez-le en ligne!

Cela devient un peu délicat en ce qui concerne l'entrée de chaîne vide, car sed n'a aucune signification d'une valeur falsifiée. Donc pour y faire face, je vous propose deux interprétations possibles des règles pour valider ma soumission:

A. Vous ne fournissez essentiellement rien en entrée, pas même une nouvelle ligne de fin (comme c'est le cas avec tous les exemples, y compris ce fichier de 6 Mo).

Usage:

echo -n ""|sed -f script

Sortie: rien n'est imprimé, car sed n'exécute même pas le script sans entrée.

B. On pourrait considérer comme valeur fausse pour sed une chaîne unique, c'est-à-dire renvoyée uniquement lorsque l'entrée est une chaîne vide.

Usage:

echo ""|sed -f script

Production:

__

Je préfère beaucoup plus la première interprétation, car je pense qu'elle est la plus proche de la règle prévue, mais la dernière aide si vous exécutez le script en utilisant ce lien TIO.

JavaScript (Babel Node) , 45 octets

_=>_.match(/.{1,3}/g).map(a=>a.padEnd(3,`_`))

Essayez-le en ligne!

Gelée , 10 octets

s3;€⁾__ḣ€3

Essayez-le en ligne!

Il semble qu'un 8 ou un 9 devrait être possible, mais je n'en ai pas encore trouvé.

Attaché , 34 23 octets

PadRight&"_"&3=>@Chop&3

Essayez-le en ligne!

Explication (obsolète)

{On[#_-1,PadRight&"_"&3,_]}@Chop&3
                           @Chop&3    chop the input string into groups of 3s
{On[#_-1               ,_]}           on the last group
        ,PadRight                         pad it
                     &3                   to length three
                 &"_"                     with underscores

Fusain , 10 octets

Ｅ⪪Ｓ³…⁺ι__³

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

  Ｓ         Input string
 ⪪ ³        Split into groups of up to 3 characters
Ｅ           Map over each group
      ι     Current group
     ⁺      Concatenated with
       __   Literal `__`
    …    ³  Moulded to length 3
            Each group implicitly printed on its own line

Scala , 31 octets

(s+"___").grouped(3).toSeq.init

Essayez-le en ligne!

Explication

(s+"___")       // add "___"
  .grouped(3)   // make groups of 3
  .toSeq        // change to Seq
  .init         // take all but last

Befunge-93 , 30 29 octets

~:1+%,~:1+!"`"*+,~:1+!"`"*+,,

Essayez-le en ligne!

Outputs nothing for an empty input, otherwise outputs strings of length 3 separated by NUL characters.

Explanation:

~                               Push character of input to stack
 :1+                            Duplicate input and add 1
    %                           Modulo top 2 values of stack and push result
                                If input was -1 (end of stream), calculate -1%0 -> halt
                                Otherwise calculate input%(input+1) -> input
     ,                          Pop and output character
      ~                         Push character of input to stack
       :1+!                     Duplicate input, add 1 and perform logical NOT
           "`"*                 Multiply by 96 (ASCII code for '`')
                                This returns 96 or 0 depending on the result of the NOT
               +                Add the top 2 values from the stack and push the result
                                Si l'entrée était -1 (fin de flux), pousse -1 + 96 = 95 ou le code ASCII pour '_'
                                Sinon, pousse l'entrée + 0
                , Pop et caractère de sortie
                 ~: 1 +! "` "* +, Même bloc à nouveau pour gérer le troisième caractère
                            , Génère un caractère NUL (la pile est vide, donc le fait de sortir de la pile renvoie simplement 0)

Le pointeur d'instruction s'enroule à la fin, bouclant toute la ligne.