Dada una cadena, debe dividirla en grupos de tres caracteres (rellenando _al final).

Relacionado , pero aún así es diferente.

Muestra de E / S:

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

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

• '' -> [] or falsey value

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

• Cadena de 6 MB

Este es un código de golf , ¡por lo que ganarán menos bytes!

Editar: Finalmente, la salida no está restringida .

05AB1E , 9 8 bytes

…___«3ô¨

Pruébalo en línea! o como un conjunto de pruebas

Explicación

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

Pitón 3, 58 47 34 bytes

Estoy seguro de que alguien más puede hacerlo mejor. Alguien más lo hizo mejor. Gracias Jo King para -11 -24 bytes!

La producción no tiene restricciones, bienvenido a Tuple Hell. Devuelve la lista vacía ( false ) en la entrada vacía

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

TIO

JavaScript, 25 bytes

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

Intentalo

Perl 5 , 16 15 bytes

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

Pruébalo en línea!

APL + WIN 36 24 22 bytes

12 bytes guardados como resultado de la salida ahora restringida y usando el código en el primer comentario de @Adám modificado para trabajar en APL + WIN y otros 2 con su segundo comentario. Gracias.

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

Solicita la entrada de la cadena y genera el resultado como una matriz nx3

Pruébalo en línea! Cortesía de Dyalog Classic.

JavaScript, 51 50 48 27 25

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

Pruébalo en línea!

Perl 6 , 19 bytes

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

Pruébalo en línea!

Rellena la cadena con dos guiones bajos y luego la divide en trozos de tres caracteres. Devuelve como una matriz de objetos Match.

Japt , 8 bytes

+1 byte para el caso especial de la cadena vacía. Puede guardar 2 si podemos elegir nuestro carácter de relleno.

©ò3 ú'_3

Intentalo

©ò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 bytes

é☻εgP▀╪

Ejecutar y depurarlo

Para una entrada de cadena vacía, el resultado es una matriz vacía, que es un valor falsey en stax.

CJam , 11 bytes

q'_3*+3/);p

Pruébalo en línea!

Para una entrada vacía, esto da una cadena vacía, que es falsa.

Cómo funciona

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 bytes

$
__
!`...

Pruébalo en línea! El enlace incluye casos de prueba. Explicación:

$
__

Agregue dos _s, en caso de que el último grupo necesite ser rellenado.

!`...

Haga coincidir tantos grupos de tres como sea posible, generando las coincidencias en lugar de la cuenta. (En Retina 1 esto sería en Llugar de !).

C (gcc) , 67 bytes

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

Pruébalo en línea!

Siempre devuelve un valor de falsey (0).

Wolfram Language (Mathematica) , 28 21 bytes

-7: ya no requiere el Falsevalor falso ( ) en la entrada vacía

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

Pruébalo en línea!

Toma una lista de caracteres como entrada. Devuelve una lista de 3 tuplas de caracteres rellenados con Blanks ( _).

34 27 bytes

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

Pruébalo en línea!

Entrada de cadena, lista de salida de cadenas

Jalea , 9 bytes

s3o€“___”

Un enlace monádico que acepta una lista de caracteres que produce una lista de listas de caracteres (una entrada vacía produce una salida vacía).

Pruébalo en línea!

¿Cómo?

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

Notas:
El €solo es necesario para manejar el caso de borde de una entrada vacía.
Un programa completo puede dejar un final ”, pero aquí no podemos hacerlo, ya que el comportamiento de impresión de un programa completo rompe todo junto.

Equivalente 9:

o3ÐƤ“___”

Intentalo

Alternativa 9:

;“___”s3Ṗ

Intentalo

J , 16 bytes

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

Pruébalo en línea!

K (oK) , 19 17 bytes

-2 bytes gracias a ngn!

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

Pruébalo en línea!

Java 10, 116 113 bytes

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;}

Pruébalo en línea.

O 104 101 bytes si falsese permite una matriz vacía en lugar de como salida.

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;}

Pruébalo en línea.

Explicación:

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

Ruby, 73 42 bytes

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

Editar: como parece que el valor falsey no es obligatorio:

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

C # (compilador interactivo de Visual C #) , 74 bytes

Simplemente agregue dos guiones bajos '_' al final de la entrada para asegurarse de que se impriman si la longitud de la entrada no es un factor de 3.

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

Pruébalo en línea!

Kotlin , 34 bytes

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

Pruébalo en línea!

C (gcc) , 55 bytes

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

Pruébalo en línea!

C (sonido metálico) , 128 126 94 67 bytes

67 bytes gracias a @ceilingcat

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

Pruébalo en línea!

Golpetazo , 90 bytes

Esto utiliza las funciones de Bash en lugar de una combinación de comandos Bourne shell más * nix más tradicionales (cuya versión que creé terminó en 205 bytes). Hice trampa al usar la evasión de agregar dos caracteres _ a la cadena.

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

Pruébalo en línea!

PowerShell , 58 35 bytes

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

-23 bytes gracias a mazzy .

Pruébalo en línea!

GNU sed , 27 bytes

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

Pruébalo en línea!

Se vuelve un poco complicado con respecto a la entrada de cadena vacía, ya que sed no tiene significado de un valor falso. Entonces, para lidiar con esto, le proporciono dos posibles interpretaciones de las reglas para validar mi presentación:

A. Usted esencialmente no proporciona nada como entrada, ni siquiera una nueva línea final (como es el caso con todos los ejemplos, incluido ese archivo de 6 Mb).

Uso:

echo -n ""|sed -f script

Salida: no se imprime nada, porque sed ni siquiera ejecuta el script sin entrada.

B. Uno podría considerar como valor falso para sed como una cadena única, es decir, devuelta solo cuando la entrada es una cadena vacía.

Uso:

echo ""|sed -f script

Salida:

__

Prefiero la primera interpretación mucho más, ya que creo que es la más cercana a la regla prevista, pero la última ayuda si ejecuta el script utilizando ese enlace TIO.

JavaScript (nodo de Babel) , 45 bytes

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

Pruébalo en línea!

Jalea , 10 bytes

s3;€⁾__ḣ€3

Pruébalo en línea!

Parece que un 8 o 9 debería ser posible, pero aún no he encontrado uno.

Agregado , 34 23 bytes

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

Pruébalo en línea!

Explicación (obsoleta)

{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

Carbón de leña , 10 bytes

Ｅ⪪Ｓ³…⁺ι__³

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

  Ｓ         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 bytes

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

Pruébalo en línea!

Explicación

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

Befunge-93 , 30 29 bytes

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

Pruébalo en línea!

No genera nada para una entrada vacía; de lo contrario, genera cadenas de longitud 3 separadas por caracteres NUL.

Explicación:

~ Empuje el carácter de entrada para apilar
 : 1+ Duplicar entrada y agregar 1
    % Modulo de los 2 valores principales de la pila y el resultado de inserción
                                Si la entrada fue -1 (final de la secuencia), calcule -1% 0 -> detener
                                De lo contrario, calcule la entrada% (entrada + 1) -> entrada
     , Pop y personaje de salida
      ~ Empuje el carácter de entrada para apilar
       : 1+! Duplique la entrada, agregue 1 y realice un NOT lógico
           "` "* Multiplicar por 96 (código ASCII para '' ')
                                Esto devuelve 96 o 0 dependiendo del resultado de NOT
               + Agregue los 2 valores principales de la pila y presione el resultado
                                Si la entrada fue -1 (final de la secuencia), empuja -1 + 96 = 95, o el código ASCII para '_'
                                De lo contrario, empuja la entrada + 0
                , Pop y personaje de salida
                 ~: 1 +! "` "* +, Mismo bloque nuevamente para manejar el tercer carácter
                            , Emite un carácter NUL (la pila está vacía, por lo que aparecer de la pila solo devuelve 0)

El puntero de instrucciones se ajusta al final, haciendo un bucle en toda la línea.