Dada uma sequência, você deve dividi-la em grupos de três caracteres (preenchendo _no final).

Relacionado , mas ainda assim é diferente.

E / S de amostra:

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

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

• '' -> [] or falsey value

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

• Sequência de 6 MB

Este é um código de golfe , portanto, o menor número de bytes vencerá!

Edit: Finalmente, a saída é irrestrita .

05AB1E , 9 8 bytes

…___«3ô¨

Experimente online! ou como um conjunto de testes

Explicação

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

Python 3, 58 47 34 bytes

Tenho certeza que alguém pode fazer melhor. Alguém fez melhor. Obrigado Jo King por -11 -24 bytes!

A saída é irrestrita, bem-vindo ao tuple inferno. Retorna lista vazia ( falsy ) na entrada vazia

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

TIO

JavaScript, 25 bytes

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

Tente

Perl 5 , 16 15 bytes

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

Experimente online!

APL + WIN 36 24 22 bytes

12 bytes salvos como resultado da saída sendo agora restrita e usando o código no primeiro comentário de @ Adám modificado para funcionar em APL + WIN e mais 2 com seu segundo comentário. Obrigado.

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

Solicita a entrada da sequência e gera o resultado como uma matriz nx3

Experimente online! Cortesia de Dyalog Classic

JavaScript, 51 50 48 27 25

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

Experimente online!

Perl 6 , 19 bytes

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

Experimente online!

Almofada a cadeia por dois sublinhados e depois divide a cadeia em pedaços de três caracteres. Retorna como uma matriz de objetos Match.

Japonês , 8 bytes

+1 byte para o caso especial da string vazia. Pode salvar 2 se pudermos escolher nosso personagem de preenchimento.

©ò3 ú'_3

Tente

©ò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▀╪

Execute e depure

Para uma entrada de sequência vazia, o resultado é uma matriz vazia, que é um valor falsey em stax.

CJam , 11 bytes

q'_3*+3/);p

Experimente online!

Para entrada vazia, isso fornece uma string vazia, o que é falso.

Como 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

$
__
!`...

Experimente online! O link inclui casos de teste. Explicação:

$
__

Anexe dois _s, caso o último grupo precise ser preenchido.

!`...

Faça a correspondência do maior número possível de grupos de três, produzindo as correspondências em si e não a contagem. (Na Retina 1, isso seria em Lvez de !.)

C (gcc) , 67 bytes

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

Experimente online!

Sempre retorna um valor de falsey (0).

Wolfram Language (Mathematica) , 28 21 bytes

-7: Não requer mais o Falsevalor falsy ( ) na entrada vazia

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

Experimente online!

Leva uma lista de caracteres como entrada. Retorna uma lista de três tuplas de caracteres preenchidos com Blanks ( _).

34 27 bytes

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

Experimente online!

Entrada de string, lista de saída de strings

Geléia , 9 bytes

s3o€“___”

Um link monádico que aceita uma lista de caracteres que produz uma lista de listas de caracteres (uma entrada vazia produz uma saída vazia).

Experimente online!

Quão?

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

Notas:
A €é somente necessário para manusear o caso extremo de uma entrada vazio.
Um programa completo pode deixar um rasto ”, mas aqui não podemos fazer isso, pois o comportamento de impressão de um programa completo esmaga tudo.

Equivalente 9:

o3ÐƤ“___”

Tente

Alternativa 9:

;“___”s3Ṗ

Tente

J , 16 bytes

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

Experimente online!

K (oK) , 19 17 bytes

-2 bytes graças a ngn!

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

Experimente online!

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

Experimente online.

Ou 104 101 bytes se uma matriz vazia em vez de falsefor permitida como saída.

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

Experimente online.

Explicação:

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'

Edit: Como o valor de falsey parece que não é necessário:

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

C # (compilador interativo do Visual C #) , 74 bytes

Basta anexar dois sublinhados '_' no final da entrada para garantir que sejam impressos se o comprimento da entrada não for um fator 3.

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

Experimente online!

Kotlin , 34 bytes

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

Experimente online!

C (gcc) , 55 bytes

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

Experimente online!

C (clang) , 128 126 94 67 bytes

67 bytes graças a @ceilingcat

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

Experimente online!

Bater , 90 bytes

Isso usa os recursos do Bash em vez de uma combinação dos comandos mais tradicionais do shell Bourne mais * nix (que uma versão que eu criei terminou em 205 bytes). Eu trapacei usando a esquiva de adicionar dois caracteres _ à string.

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

Experimente online!

PowerShell , 58 35 bytes

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

-23 bytes graças a mazzy .

Experimente online!

GNU sed , 27 bytes

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

Experimente online!

Fica um pouco complicado em relação à entrada da string vazia, pois sed não tem significado para um valor falso. Portanto, para lidar com isso, forneço duas interpretações possíveis das regras para validar minha submissão:

UMA. Você essencialmente não fornece nada como entrada, nem mesmo uma nova linha final (como é o caso de todos os exemplos, incluindo o arquivo de 6 Mb).

Uso:

echo -n ""|sed -f script

Saída: nada é impresso, porque o sed nem mesmo executa o script sem entrada.

B. Pode-se considerar como valor falso o sed como uma string única, ou seja, retornada apenas quando a entrada for uma string vazia.

Uso:

echo ""|sed -f script

Resultado:

__

Prefiro muito mais a primeira interpretação, pois acredito que ela seja a mais próxima da regra pretendida, mas a última ajuda se você executar o script usando esse link TIO.

JavaScript (Nó Babel) , 45 bytes

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

Experimente online!

Gelatina , 10 bytes

s3;€⁾__ḣ€3

Experimente online!

Parece que um 8 ou 9 deve ser possível, mas ainda não o encontrei.

Anexo , 34 23 bytes

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

Experimente online!

Explicação (desatualizada)

{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

Carvão , 10 bytes

Ｅ⪪Ｓ³…⁺ι__³

Experimente online! Link é a versão detalhada do código. Explicação:

  Ｓ         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

Experimente online!

Explicação

(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+!"`"*+,,

Experimente online!

Não gera nada para uma entrada vazia; caso contrário, gera seqüências de comprimento 3 separadas por caracteres NUL.

Explicação:

~ Empurre o caractere da entrada para empilhar
 : 1+ entrada duplicada e adicione 1
    % Do módulo entre os 2 principais valores do resultado da pilha e push
                                Se a entrada for -1 (final do fluxo), calcule -1% 0 -> parar
                                Caso contrário, calcule a entrada% (entrada + 1) -> entrada
     , Caractere pop e de saída
      ~ Empurre o caractere da entrada para empilhar
       : 1+! Entrada duplicada, adicione 1 e execute NOT lógico
           "` "* Multiplique por 96 (código ASCII para '' ')
                                Isso retorna 96 ou 0, dependendo do resultado do NOT
               + Adicione os 2 principais valores da pilha e empurre o resultado
                                Se a entrada foi -1 (final do fluxo), pressiona -1 + 96 = 95 ou o código ASCII para '_'
                                Caso contrário, empurra a entrada + 0
                , Caractere pop e de saída
                 ~: 1 +! "` "* +, Mesmo bloco novamente para manipular o terceiro caractere
                            , Gera um caractere NUL (a pilha está vazia, portanto, sair da pilha retorna apenas 0)

O ponteiro de instruções envolve no final, fazendo um loop em toda a linha.