Dividi in tre!

16

Data una stringa, devi dividerla in gruppi di tre caratteri (riempiendoli _alla fine).

Correlato , ma è comunque diverso.

I / O di esempio:

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

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

  • '' -> [] or falsey value

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

  • Stringa da 6 MB

Questo è un codice-golf , quindi vinceranno meno byte!

Modifica: infine, l'output è illimitato .

code-golf  string  array 
— Rahul Verma
fonte
10
Perché caso speciale la stringa vuota? Possiamo scegliere quale personaggio usare per l'imbottitura?
— Shaggy,
12
Quindi il compito è in realtà: data una stringa, restituisce un valore false se è vuoto, altrimenti dividerlo in gruppi di tre, riempiendo di caratteri di sottolineatura se necessario ? Sembra una strana coppia di due attività non correlate (controllo della lunghezza della stringa e divisione).
— Adám,
14
Cose da evitare: casi limite eccezionali . In questo caso, una stringa vuota dovrebbe restituire un array vuoto o equivalente, non un valore di falso
— Jo King,
6
Molte lingue tipicamente statiche non possono restituire più di un tipo da una funzione
— Incarnazione dell'ignoranza
4
@manassehkatz Sì, ma solo in quelle lingue. In alcune lingue rende le soluzioni molto più complicate o addirittura impossibili (ad esempio lingue tipicamente statiche).
— Jo King,

Risposte:

8

Python 3, 58 47 34 byte

Sono sicuro che qualcun altro può fare di meglio Qualcun altro ha fatto di meglio. Grazie Jo King per -11 -24 byte!

L'output è senza restrizioni, benvenuti a far quadrare l'inferno. Restituisce un elenco vuoto ( falsy ) su un input vuoto

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

TIO

— Benjamin Urquhart
fonte
4

APL + WIN 36 24 22 byte

12 byte salvati in seguito alla de-restrizione dell'output e l'utilizzo del codice nel primo commento di @Adám modificato per funzionare in APL + WIN e altri 2 con il suo secondo commento. Grazie.

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

Richiede l'input della stringa e genera il risultato come un array nx3

Provalo online! Per gentile concessione di Dyalog Classic

— Graham
fonte
@Adamo. Genera un errore di dominio in APL + WIN alla destra ⍴
— Graham,
Fallisce su '', no? Penso che OP (per qualche strana ragione) richieda che il risultato sia 0(con qualsiasi grado).
— Adám,
1
@ Adám Produce un array 0 x 3. L'OP ora sembra voler "falsey" per un input nullo. Con le specifiche che continuano a cambiare, mi inchinerò a questo punto e lascerò la mia risposta così com'è! Grazie per i tuoi miglioramenti.
— Graham,
3

Perl 6 , 19 byte

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

Provalo online!

Riempie la stringa di due trattini bassi, quindi la divide in blocchi di tre caratteri. Restituisce come una matrice di oggetti Match.

— Jo King
fonte
3

Japt , 8 byte

+1 byte per il caso speciale la stringa vuota. Possiamo salvare 2 se possiamo scegliere il nostro carattere di riempimento.

©ò3 ú'_3

Provalo

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

CJam , 11 byte

q'_3*+3/);p

Provalo online!

Per input vuoto questo dà una stringa vuota, che è falsa.

Come funziona

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
— Luis Mendo
fonte
2

Retina 0.8.2 , 10 byte

$
__
!`...

Provalo online! Il link include casi di test. Spiegazione:

$
__

Aggiungi due _s, nel caso in cui l'ultimo gruppo debba essere riempito.

!`...

Abbina il maggior numero possibile di gruppi di tre, producendo gli stessi incontri anziché il conteggio. (In Retina 1 questo sarebbe Linvece di !.)

— Neil
fonte
2

Wolfram Language (Mathematica) , 28 21 byte

-7: non richiede più il Falsevalore falsy ( ) su input vuoto

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

Provalo online!

Accetta un elenco di caratteri come input. Restituisce un elenco di 3 tuple di caratteri riempiti con Blanks ( _).

34 27 byte

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

Provalo online!

Input di stringa, elenco di output di stringhe

— attinat
fonte
1

Gelatina , 9 byte

s3o€“___”

Un collegamento monadico che accetta un elenco di caratteri che produce un elenco di elenchi di caratteri (un input vuoto produce output vuoto).

Provalo online!

Come?

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

Note:
L' ۏ necessaria solo per gestire il caso limite di un ingresso vuoto.
Un programma completo può eliminare un finale ”, ma qui non possiamo farlo poiché il comportamento di stampa di un programma completo distrugge tutto insieme.

Equivalente 9:

o3ÐƤ“___”

Provalo

Alternativa 9:

;“___”s3Ṗ

Provalo

— Jonathan Allan
fonte
1

Java 10, 116 113 byte

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

Provalo online.

Oppure 104 101 byte se un array vuoto anziché falseè consentito come output ..

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

Provalo online.

Spiegazione:

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
— Kevin Cruijssen
fonte
Ora è consentito un array vuoto
— Benjamin Urquhart
1

Rubino, 73 42 byte

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

Modifica: poiché il valore di falso sembra non sia richiesto:

gets.scan(/.{1,3}/).map{|s|(s+'_'*3)[0,3]}
— Max Langerak
fonte
1
L'imbottitura massima è di 2 caratteri, quindi '_'*2sarebbe sufficiente, per cui un valore letterale '__'è più breve. Ma se si aggiunge l'imbottitura in anticipo, allora semplicemente non corrispondono i pezzi più brevi di 3 caratteri, è più breve: puts"#{gets}__".scan /.../. (Si noti che, senza la stampa esplicito che è considerato irbnon ruby.)
— manatwork
1

C (gcc) , 55 byte

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

Provalo online!

— l4m2
fonte
Usare 9 ( \t) invece di 10 ( \n) dovrebbe andare bene, ma non è questo il punto principale
— l4m2
1

bash , 90 byte

Questo utilizza le funzionalità di Bash piuttosto che una combinazione della più tradizionale shell Bourne più i comandi * nix (che una versione che ho creato è finita a 205 byte). Ho tradito usando la schivata di aggiungere due _ caratteri alla stringa. 

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

Provalo online!

— PJF
fonte
1

GNU sed , 27 byte

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

Provalo online!

Diventa un po 'complicato per quanto riguarda l'input di stringa vuota, poiché sed non ha alcun significato di un valore falso. Per far questo, ti fornisco due possibili interpretazioni delle regole per convalidare la mia richiesta:

UN. In sostanza non fornisci nulla come input, nemmeno una nuova riga finale (come nel caso di tutti gli esempi, incluso quel file da 6 Mb).

Uso:

echo -n ""|sed -f script

Output: non viene stampato nulla, perché sed non esegue nemmeno lo script senza input.

B. Si potrebbe considerare come valore errato per sed una stringa univoca, ovvero restituita solo quando l'input è una stringa vuota.

Uso:

echo ""|sed -f script

Produzione:

__

Preferisco la prima interpretazione molto di più, poiché ritengo che sia la più vicina alla regola prevista, ma l'ultima aiuta se si esegue lo script utilizzando quel collegamento TIO.

— seshoumara
fonte
0

Attache , 34 23 byte

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

Provalo online!

Spiegazione (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
— Conor O'Brien
fonte
Salveresti qualcosa riempiendo tutti gli elementi anziché solo l'ultimo?
— Shaggy,
@Shaggy Ottimo punto! Ci penserò
— Conor O'Brien,
0

Carbone , 10 byte

Ｅ⪪Ｓ³…⁺ι__³

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

  Ｓ         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
— Neil
fonte
0

Scala , 31 byte

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

Provalo online!

Spiegazione

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

Befunge-93 , 30 29 byte

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

Provalo online!

Non emette nulla per un input vuoto, altrimenti genera stringhe di lunghezza 3 separate da caratteri NUL.

Spiegazione:

~ Spingere il carattere dell'input per impilarlo
 : 1+ Input duplicato e aggiungi 1
    % Modulo primi 2 valori dello stack e del risultato push
                                Se l'input era -1 (fine del flusso), calcola -1% 0 -> arresto
                                Altrimenti calcola input% (input + 1) -> input
     , Pop e carattere di output
      ~ Spingere il carattere dell'input per impilarlo
       : 1+! Input duplicato, aggiungere 1 ed eseguire NOT logico
           "` "* Moltiplica per 96 (codice ASCII per '' ')
                                Ciò restituisce 96 o 0 a seconda del risultato di NOT
               + Aggiungi i primi 2 valori dallo stack e invia il risultato
                                Se l'input era -1 (fine del flusso), invia -1 + 96 = 95 o il codice ASCII per '_'
                                Altrimenti preme input + 0
                , Pop e carattere di output
                 ~: 1 +! "` "* +, Stesso blocco di nuovo per gestire il terzo carattere
                            , Emette un carattere NUL (lo stack è vuoto, quindi spuntare dallo stack restituisce solo 0)

Il puntatore dell'istruzione si avvolge alla fine, eseguendo il ciclo dell'intera riga.
— sette negativi
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.