Codifique a cifra da coluna

8

Dada uma sequência a ser codificada e um número de colunas (a chave), codifique a sequência da seguinte maneira:

Vou usar o exemplo Hello, world!e a chave3

Primeiro, escreva o número de colunas:

1 2 3

Em seguida, escreva o texto começando no canto superior esquerdo, um caractere por coluna e, quando ficar sem colunas, vá para a próxima linha.

1 2 3
H e l
l o ,
  w o
r l d
!

Agora, para obter seu texto codificado, leia o texto começando no canto superior esquerdo, mas desta vez, primeiro leia uma coluna e depois a próxima, e assim por diante. Se não houver um caractere no slot, coloque um espaço.

Hl r!eowl l,od 

Observe que aqui há um espaço à direita.

Este é o seu texto codificado.

Outro caso de teste é Programming Puzzles and Code Golf SEcom a chave 5:

1 2 3 4 5
P r o g r
a m m i n
g   P u z
z l e s  
a n d   C
o d e   G
o l f   S
E

O texto codificado é PagzaooErm lndl omPedef gius rnz CGS.

Mais casos de teste

"abcdefghijklmnopqrstuvwxyz", 2 -> "acegikmoqsuwybdfhjlnprtvxz"
"codegolf.stackexchange.com", 4 -> "cg.ccgoooskhemdltea. efaxnc "
"Pen Pineapple Apple Pen!!!", 7 -> "PeAeeapnnpp! pl!Ple!ie  n P "
"1,1,2,3,5,8,13,21,34,55,89", 10 -> "18,,,5115,3,2,8,2931 ,, 53 ,4 "

Lembre-se, isso é , então o código com o menor número de bytes vence.

Oliver Ni
fonte
Opa, não, minha culpa é #
Oliver Ni
Relacionado .
AdmBorkBork 28/10
@TimmyD Fixed ..
Oliver Ni
5
Acho que você deve incluir mais alguns casos de teste para verificar se o preenchimento é tratado corretamente.
Dennis
Seu novo caso de teste segue exatamente o mesmo padrão que o antigo. Um caso extremo potencial ocorre quando o comprimento da corda é um múltiplo da chave, por exemplo, Programming Puzzles and Code Golf, 3.
Dennis

Respostas:

5

MATL , 4 bytes

e!1e

Experimente online!

Isso é o mais direto possível. eé um built-in que reformula uma matriz em n linhas. Então, lemos na entrada1 como uma string e formamos uma matriz com as linhas input2 :

Hl r!
eowl 
l,od 

Em seguida, transpomos para obter isso:

Hel
lo,
 wo
rld
!  

Depois disso, chamamos 1epara remodelá-lo em uma única linha e exibi-lo como uma sequência.

Como você pode ver neste programa de exemplo , a função "remodelar" adiciona convenientemente quantos zeros forem necessários para que a matriz seja um retângulo perfeito. Ao exibir como uma seqüência de caracteres, o MATL trata os zeros como espaços, portanto, ele preenche automaticamente o número necessário de espaços para nenhum trabalho extra.

James
fonte
e o código é quase palindrômico! :-)
Luis Mendo
1
@LuisMendo Oh, é definitivamente um palíndromo, é só que minha tecla Shift está quebrada. : P
James
5

Gelatina , 3 bytes

sz⁶

TryItOnline!

Quão?

sz⁶ - Main link: string, columns
s   - split string (a list of characters) into chunks of length column
 z  - transpose the resulting list of lists with filler
  ⁶ - literal ' '
    - implicit print
Jonathan Allan
fonte
Isso não inclui os espaços de preenchimento.
Xnor
Apenas não incluí o espaço à direita quando digitei o argumento para o exemplo.
Jonathan Allan
A entrada não tem um espaço à direita. Você deve inserir espaços extras como preenchimento quando o comprimento da string não for múltiplo do número.
Xnor
Está correto agora?
Jonathan Allan
1
Sim, parece ser bom.
Xnor
2

PHP, 85 bytes

for(;$i<$x=$argv[2];$i++)for($j=0;$j<strlen($t=$argv[1])/$x;)echo$t[$i+$j++*$x]??" ";

PHP, 90 bytes

for(;$i<$x=$argv[2];$i++)foreach(array_chunk(str_split($argv[1]),$x)as$a)echo$a[+$i]??" ";
Jörg Hülsermann
fonte
2

Ruby, 78 67 65 bytes

->s,k{s.gsub!(/(.)(.{,#{k-=1}})/){$><<$1
$2.ljust k}while s=~/./}

Veja-o em eval.in: https://eval.in/668412

Ungolfed

->s,k{
  s.gsub!(/(.)(.{,#{ k -= 1 }})/) {
    $> << $1
    $2.ljust k
  } while s =~ /./
}
Jordânia
fonte
2

Pitão - 5 bytes

s.tcF

Experimente online aqui .

Maltysen
fonte
+1 Muito melhor que a minha solução feia. :)
boboquack
@boboquack não se preocupe, o pyth tem seu próprio "estilo idiomático", que na verdade é bem diferente do python, e você o aprenderá à medida que escreve mais programas (e começa a se lembrar da lista de comandos: P). Boa sorte!
Maltysen
2

Python 2, 46 bytes

lambda s,n:(s[0]+(s[1:]+-len(s)%n*' ')*n)[::n]

A idéia é pegar a string de entrada, copiá-la ncom o primeiro caractere removido e, em seguida, pegar todos nos caracteres.

Vejamos, por exemplo s="abcdef", n=3, onde o comprimento é múltiplo de n:

abcdefbcdefbcdef
^  ^  ^  ^  ^  ^
a  d  b  e  c  f

O primeiro ciclo através da string leva todos os ncaracteres do primeiro. Em seguida, cada ciclo subsequente muda um índice para a direita, porque o primeiro caractere é ignorado. Para garantir que o comprimento seja múltiplo de n, a cadeia inicial é preenchida com espaços.

xnor
fonte
1

Japonês, 15 bytes

U+SpV f'.pV)y q

Teste online!

Japt possui um "todas as subseções de comprimento N" interno, mas nem "todas as subseções não sobrepostas" nem "todo enésimo caractere". De repente, há um buraco na minha vida ...

Explicação

U+SpV            // Take U concatenated with V spaces.
      f'.pV)     // Take every substring of 3 chars.
            y    // Transpose the resulting array.
              q  // Join on the empty string.
                 // Implicit: output last expression
ETHproductions
fonte
1

Python 2, 58 bytes

lambda s,n:`sum(zip(*zip(*n*[iter(s+' '*~-n)])),())`[2::5]

Teste em Ideone .

Dennis
fonte
1
Eu realmente gosto def f(s,n):t=[*s,' '];del t[print(end=s[::n]):f(''.join(t),n-1):n], mas é muito ...
Dennis
1

JavaScript (ES6), 84 bytes

É uma solução recursiva.

f=(s,k,i=0,r=Math.ceil(s.length/k),c=s[i%r*k+i/r|0])=>k*r==i?'':(c?c:' ')+f(s,k,++i)
Huntro
fonte
1

R, 92 81 bytes

function(x,n)cat(t(matrix(c(el(strsplit(x,"")),rep(" ",-nchar(x)%%n)),n)),sep="")

Experimente no R-fiddle

Isso acabou sendo uma dor de cabeça, porque R recicla automaticamente o vetor de entrada quando as linhas ou colunas especificadas na criação da matriz não são um múltiplo do comprimento da entrada. Portanto, temos que preencher o vetor com -nchar(x)%%nespaços antes de passá-lo para a função matriz.

O último passo é apenas transpor a matriz e imprimi-la.

Billywob
fonte
Qual é o propósito l=nchar(x)? Você parece não estar usando em llugar algum. A função elé bastante a descoberta, +1.
plannapus
@ Plannapus Eu sinceramente não sei por que coloquei lá. Eu acredito que é um remanescente de como eu calculei o número de vezes que o espaço em branco estava sendo repetido. Boa captura embora.
Billywob # 30/16
1

Perl, 61 bytes

54 bytes de códigos e -F -pisinalizadores.

for$l(1..$^I){$\.=$F[$^I*$_+~-$l]//$"for 0..$#F/$^I}}{

Pega a sequência de entrada sem nova linha final e a chave deve ser colocada após o -isinalizador:

$ echo -n "Hello, World!" | perl -F -pi3 -E 'for$l(1..$^I){$\.=$F[$^I*$_+~-$l]//$"for 0..$#F/$^I}}{'
Hl r!eoWl l,od 
dada
fonte
1

Mathematica, 43 40 bytes

Graças a milhas por economizar três bytes!

Join@@Thread@Partition[##,#2,{1,1}," "]&

Função sem nome, recebendo dois argumentos, uma matriz de caracteres e um número inteiro; retorna uma matriz de caracteres. A maior parte do trabalho pesado é realizada pela Threadfunção, que (neste contexto) troca linhas e colunas. Partitionprecisa ser chamado com alguns argumentos inúteis para que ele atenda ao quinto argumento " ".

Greg Martin
fonte
Você pode usar Threadtambém, em vez deTranspose Join@@Thread@Partition[##,#2,1," "]&
milhas
Uau. Agora eu entendi!
Greg Martin
0

Ruby, 89 bytes

->s,i{t="";i.times{|n|s.ljust(i*(s.size*1.0/i).ceil).scan(/#{?.*i}/).each{|j|t<<j[n]}};t}

Pontuação terrível, dicas apreciadas.

dkudriavtsev
fonte
Use em sizevez de lengthpara um byte.
Jordânia
@ Jordan Não seriam dois?
dkudriavtsev
0

Perl, 87 bytes

($a,$b)=@ARGV;for$c(1..$a){for(0..(length$a)/$b){$e.=substr($a,$b*$_+$f,1)}$f++;}say$e;

Aceita dois argumentos como parâmetros e Uso:

perl -M5.010 encol.pl "Hello, World!" 3
Hl r!eoWll,od
Gabriel Benamy
fonte
@ Dadá Por que você não o publica como sua própria resposta?
boboquack
0

Pitão, 40 bytes

=Zw=+Z*d+Q-*Q/lZQlZV*QlZIq%%NlZQ/NlZp@ZN

Teste aqui

Provavelmente o código Pyth mais feio de todos os tempos, mas esta é minha primeira tentativa em Pyth.

=Zw=+Z*d+Q-*Q/lZQlZV*QlZIq%%NlZQ/NlZp@ZN
         Q                               Set Q to eval(input())
=Zw                                      Initialises Z to next input string
              lZ                         Gets the length of Z
             /lZQ                        Integer divides lZ by Q
           *Q/lZQ                        Multiplies that result by Q
          -*Q/lZQlZ                      Subtracts the length of Z from that
        +Q-*Q/lZQlZ                      Adds Q to that
                                         (This is how many spaces to pad)
      *d+Q-*Q/lZQlZ                      Gets that many spaces (d is set to ' ')
   =+Z*d+Q-*Q/lZQlZ                      Appends that to Z
                    *QlZ                 Multiplies Q by lZ
                   V*QlZ                 Does a for loop for integers in that range, on N
                           %NlZ          Gets N modulo lZ
                          %%NlZQ         Gets that modulo Q
                                         This is the column of the letter at index N mod Q
                                /NlZ     Gets the column that is being printed
                        Iq%%NlZQ/NlZ     If they are equal...
                                    p@ZN Print the index of N into Z without a newline
                                         (This is implicitly modulo the length of Z)

Se alguém tiver dicas para melhorar meu golfe, por favor, deixe um comentário!

boboquack
fonte
Não se preocupe, minha primeira tentativa com Pyth foi tão longa :) O número de espaços a serem preenchidos é igual a (-len(Z))%Q, para que você possa substituí-lo +Q-*Q/lZQlZpor %_lZQ. (Alternativamente, você pode reorganizar +Q-*Q/lZQlZa +-*/lZQQlZQNão é mais curto, mas. +-*/Parece legal;))
ETHproductions
0

Na verdade , 12 bytes

Sugestões de golfe são bem-vindas, especialmente se você puder descobrir uma maneira de jogar golfe para preencher espaços. Experimente online!

;' *(q╪dX┬ΣΣ

Ungolfing

      Implicit input s, then n.
;     Duplicate n. Stack: n, n, s
' *   Push n spaces.
(q    Rotate s to TOS and append the spaces to the end of s.
╪     Split s into n-length substrings.
dX    Dequeue and discard any extra spaces that remain after chunking.
      This works even when we didn't need to add spaces in the first place.
┬     Transpose the remaining substrings. This returns a list of lists of chars.
Σ     Sum the transposed substrings into one list of chars.
Σ     Sum the list of chars into one string.
      Implicit return.

Outra versão de 12 bytes

Nesta versão, a ordem das entradas é revertida, mas isso pode ser alterado se isso não for permitido. Sugestões de golfe são bem-vindas. Experimente online!

│l±%' *o╪┬ΣΣ

Ungolfing

      Implicit input n first, then s.
│     Duplicate stack. Stack: s, n, s, n
l±    Push -len(s).
%     Push -len(s)%n, which gets the number of spaces we need to pad with. Call this m.
' *   Push m spaces to the stack.
o     Append the spaces to the end of s.
╪     Split s into n-length substrings.
┬     Transpose these substrings. This returns a list of lists of chars.
Σ     Sum the transposed substrings into one list of chars.
Σ     Sum the list of chars into one string.
      Implicit return.
Sherlock9
fonte
0

C #, 161 bytes

Eu sinto muitíssimo.

(s,i)=>String.Join("",Enumerable.Range(0,i).SelectMany(x=>Enumerable.Range(0,s.Length/i+1).Select(n=>(n*3+x)).Where(m=>m<s.Length).Select(o=>s.Substring(o,1))));
downrep_nation
fonte
0

GolfSharp , (não competindo) 82 bytes

(s,i)=>r(0,i).m(x=>r(0,s.L()/i+1).s(n=>(n*3+x)).w(m=>m<s.L()).s(o=>s.R(o,1))).j();
downrep_nation
fonte
0

Groovy, 90 bytes

{s,n->(s.padRight((int)(s.size()/n+1)*n) as List).collate(n).transpose().flatten().join()}

Preencher a entrada pelo teto do tamanho dividido em npedaços.

Obtenha a string preenchida como uma lista de caracteres.

Agrupe em n pedaços e transponha.

({s,n->(s.padRight((int)(s.size()/n+1)*n) as List).collate(n).transpose().flatten().join()})("Programming Puzzles and Code Golf SE",5)

Resulta em:

PagzaooErm lndl omPedef gius    rnz CGS
Urna de polvo mágico
fonte
0

Python 3, 48 bytes

lambda c,k:''.join([c[i:-1:k]for i in range(k)])
0WJYxW9FMN
fonte
0

PowerShell, 57 bytes

param($s,$n)$r=,''*$n
$s|% t*y|%{$r[$i++%$n]+=$_}
-join$r

Script de teste:

$f = {

param($s,$n)$r=,''*$n
$s|% t*y|%{$r[$i++%$n]+=$_}
-join$r

}

@(
    ,("abcdefghijklmnopqrstuvwxyz", 2  , "acegikmoqsuwybdfhjlnprtvxz")
    ,("codegolf.stackexchange.com", 4  , "cg.ccgoooskhemdltea.efaxnc")
    ,("Pen Pineapple Apple Pen!!!", 7  , "PeAeeapnnpp! pl!Ple!ie n P")
    ,("1,1,2,3,5,8,13,21,34,55,89", 10 , "18,,,5115,3,2,8,2931,,53,4")
) | % {
    $s,$n,$expected = $_
    $result = &$f $s $n
    "$($result-eq$expected): $result"
}

Resultado:

True: acegikmoqsuwybdfhjlnprtvxz
True: cg.ccgoooskhemdltea.efaxnc
True: PeAeeapnnpp! pl!Ple!ie n P
True: 18,,,5115,3,2,8,2931,,53,4
confuso
fonte
0

SINCLAIR ZX81 / TIMEX TS-1000/1500 BASIC, 134 bytes BASIC tokenizados

 1 INPUT A$
 2 INPUT A
 3 LET C=-SGN PI
 4 FOR I=SGN PI TO A
 5 PRINT I;
 6 NEXT I
 7 PRINT
 8 FOR I=SGN PI TO LEN A$
 9 LET C=C+SGN PI
10 IF C=A THEN LET C=NOT PI
11 IF NOT C AND I>SGN PI THEN PRINT
12 PRINT A$(I);
13 NEXT I

O primeiro parâmetro A$é o valor da string que você deseja codificar e o segundo Aé o número de colunas que você deseja codificar. A variável Cé usada para adicionar uma nova linha após os Acaracteres.

As linhas 4 a 6, inclusive, imprimem os números das colunas na parte superior da área da tela.

A linha 7 adiciona uma nova linha ( "\r\n"equivalente).

As linhas 8 - 13 imprimirão cada caractere de A$ .

Este programa não requer uma expansão de RAM para funcionar.

Cifra de coluna ZX81 usando o avançado Sinclair BASIC

Shaun Bebbers
fonte
0

K (OK) , 27 bytes

Solução:

{,/+(0N;y)#(y*-_-(#x)%y)$x}

Experimente online!

Explicação:

{,/+(0N;y)#(y*-_-(#x)%y)$x} / the solution
{                         } / lambda taking implicit x and y
                        $x  / pad x 
           (           )    / do this together
                     %y     / divide by y
                 (  )       / do this together
                  #x        / count (#) length of x
                -           / negate \
               _            / floor   | ceiling
              -             / negate /
            y*              / multiply by y
          #                 / reshape
    (0N;y)                  / null by y grid
   +                        / transpose
 ,/                         / flatten
rua
fonte
0

05AB1E (herdado) , 3 bytes

ôζJ

A versão herdada do Python é usada em vez da reescrita do Elixir, porque a nova versão não converte implicitamente seqüências de caracteres em caracteres ao usar zip , o que a versão antiga fez.

Experimente online ou verifique todos os casos de teste .

Explicação:

ô      # Split the (implicit) input-String into chunks of size (implicit) input-integer
       #  i.e. "Hello, world!" and 3 → ['Hel','lo,',' wo','rld','!']
 ζ     # Zip, swapping rows and columns (with space filler by default)
       #  i.e. ['Hel','lo,',' wo','rld','!'] → ['Hl r!','eowl ','l,od ']
  J    # Join the list of strings together (and output implicitly)
       #  i.e. ['Hl r!','eowl ','l,od '] → 'Hl r!eowl l,od '
Kevin Cruijssen
fonte