25

Existe um famoso algoritmo complicado para contar o número de bits definidos em um número inteiro não assinado de 32 bits:

int popcount(unsigned x) {
   x = (x & 0x55555555) + ((x >> 1) & 0x55555555);
   x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
   x = (x & 0x0F0F0F0F) + ((x >> 4) & 0x0F0F0F0F);
   x = (x & 0x00FF00FF) + ((x >> 8) & 0x00FF00FF);
   x = (x & 0x0000FFFF) + ((x >>16) & 0x0000FFFF);
   return x;
}

Não vou explicar aqui. Mas imagine um código semelhante para números inteiros de 512 bits! As constantes hexadecimais seriam enormes e formariam um padrão bonito. Sua tarefa é simplesmente imprimir esta saída exata :

0x55555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555
0x33333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333
0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f
0x00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff
0x0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff
0x00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff
0x0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff
0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff00000000000000000000000000000000ffffffffffffffffffffffffffffffff
0x0000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff

Não há espaços finais, por favor - embora uma única nova linha final seja opcional.

Isso é código-golfe , então a resposta mais curta (em bytes) vence.

— Lynn
fonte

Temos permissão para receber entrada (como em algo como 0x0x0x0x0x0x0x0x0x)?

— ouflak 31/10

@ouflak No. ———

— Lynn

3

05AB1E , 26 22 21 bytes

05AB1E usa a codificação CP-1252 .

9F„0x0NÍo×9ooNoo>÷hJ,

Experimente online!

Explicação

9F                      # for N in [0 ... 8]
  „0x                   # push the string "0x"
     0NÍo×              # push 2**(N-2) zeroes
          9oo           # 2**2**9
                 ÷      # //
             Noo>       # (2**2**N+1)
                  h     # converted to base-16
                   J    # join everything to string
                    ,   # print with a newline

Outras versões que podem ser aprimoradas

9F9ooNoo>÷h¾6o×J7o£R…0xÿ,
9F9ooNoo>÷h0žy×ìR7o£R…0xÿ,
9FX0No×1No×JCh7o×1K7o£…0xÿ,
8ÝovX0y×1y×JCh7o×1K7o£…0xÿ,
9F1NoÅ0D>)˜JCh1K7o×7o£…0xÿ,

— Emigna
fonte

21

Python 2, 52 49 46 bytes

O número k é dado por 2**512/(2**2**k + 1). Isso é para um número de 512 bits, por isso é trivial estender o padrão para larguras diferentes.

l=2;exec"print'0x%0128x'%(2**512/-~l);l*=l;"*9

3 bytes salvos graças ao Dennis.
3 bytes salvos graças ao xnor.

— orlp
fonte

2

As vantagens de números inteiros de precisão arbitrária ...

— ETHproductions

Agradável. Isso economiza alguns bytes.

— Dennis

Menor para manter a quadratura:l=2;exec"print'0x%0128x'%(2**512/-~l);l*=l;"*9

— xnor

1

Aquece meu coração ver Python na liderança :)

— Tobias Kienzler 1/16/16

4

@TuukkaX Eu só tenho muita experiência com pequenos hacks. Eu usei muito o Wolfram Alpha para simplificar somas e tal. Mas, basicamente, eu fiz o padrão 01010101, 00010001, 00000001, e depois multiplicado os de 1, 11, 1111para obter os padrões binários corretos. Por exemplo, 01010101você pode obter a fórmula para uma certa largura w, fazendo sum 2^(2*k) for k = 0, w/2 - 1e descobrindo (2**w - 1)/3.

— orlp 01/12/16

7

PHP, 111 110 108 bytes

Um byte salvo graças a @ user59178.

<?=($p=str_pad)("0x",130,5).$p($s="\n0x",131,3);for($x=1;$x<65;$x*=2)echo($p($s,131,$p(0,$x,0).$p(f,$x,f)));

Qual é o padrão para 1024 bits? : D

— Titus
fonte

1

Você pode salvar um byte usando em $x<65vez de $i++<7. Desta vez eu testei e tudo.

— precisa saber é o seguinte

6

Retina , 43 bytes

:`
0x128$*5
:`5
3
;{:`33
0f
0(f+)(0+)
0$2$1

Experimente online!

Explicação

Isso faz muito uso da :opção geralmente subutilizada, que permite imprimir resultados intermediários, porque é muito mais curto modificar uma única linha do que construir toda a saída.

:`
0x128$*5

Isso substitui a entrada vazia por 0xseguida por 128 se 5imprime para gerar a primeira linha.

:`5
3

Este substitui 5s por 3s para gerar a segunda linha e a imprime também.

;{:`33
0f

Esta é a última linha de caixa especial e transforma-se a cada dois 3s 0fpara gerar a terceira linha. Isso também inicia um loop nos dois últimos estágios ( {). No entanto, esse estágio não fará nada após a primeira iteração, exceto imprimir o estado atual. Os ;suprime a saída no final do programa para evitar a duplicação de última linha.

0(f+)(0+)
0$2$1

Esta substituição agora transforma cada linha para a seguinte, por troca de cada outro par de fs e 0s. A condição "todos os outros pares" é imposta combinando um zero na frente do f, o que torna impossível combinar pares consecutivos, pois as correspondências não podem se sobrepor.

— Martin Ender
fonte

6

Vim, 32 bytes

i5<CR>3<Esc>qqYpVrf$<C-V>{yPG1vr0q6@q<C-V>{I0x<Esc>

Eu só preciso escrever manualmente o primeiro 5e 3, e a macro cuida do resto, "duplicando a contagem de bits" cada vez que é executado. A ordem das etapas na macro é um pouco estranha (faça uma nova flinha, cópia em blocos, reutilize o tamanho do bloco visual para colocar 0s na flinha), mas é a variante mais rápida que encontrei.

— udioica
fonte

5

Pitão, 26 bytes

V9%"0x%0128x"/^2 512h^2^2N

Porta da minha resposta Python.

— orlp
fonte

5

J, 46 34 bytes

~~Estou trabalhando nisso, mas esse bebê gosta de ficar em 46 bytes ...~~ Não é mais! -12 bytes graças a milhas!

'0x',"1'5','3','0f'(128$#)"{~2^i.7

Experimente online! : D

Resultado

   '0x',"1'5','3','0f'(128$#)"{~2^i.7
0x55555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555
0x33333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333
0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f
0x00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff
0x0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff
0x00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff
0x0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff
0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff00000000000000000000000000000000ffffffffffffffffffffffffffffffff
0x0000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff

Para esta resposta, eu precisava (idealmente) de um verbo com classificação 0 1para usá-lo na u"vdefinição de classificação; no entanto, as milhas observadas 0 _eram suficientes para a tarefa em questão.

┌──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│= │< │<.│<:│> │>.│>:│+ │+.│+:│* │*.│*:│_ 0 0│_ 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│
├──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│- │-.│-:│% │%.│%:│^ │^.│$ │$.│$:│~.│~:│0 0 0│0 _ _│0 _ _│0 0 0│2 _ 2│0 0 0│0 0 0│0 0 0│_ 1 _│_ _ _│_ _ _│_ 0 0│_ 0 0│
├──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│| │|.│, │,.│,:│; │;:│# │#.│#:│! │/:│\:│0 0 0│_ 1 _│_ _ _│_ _ _│_ _ _│_ _ _│1 _ _│_ 1 _│1 1 1│_ 1 0│0 0 0│_ _ _│_ _ _│
├──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│[ │[:│] │{ │{.│{:│}.│}:│".│":│? │?.│a │_ _ _│_ _ _│_ _ _│1 0 _│_ 1 _│_ 0 0│_ 1 _│_ 0 0│1 _ _│_ 1 _│0 0 0│_ 0 0│_ _ _│
├──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│A │A.│b │C │C.│d │D │e │e.│E │E.│f │H │_ _ _│1 0 _│_ _ _│_ _ _│1 1 _│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│0 _ _│_ _ _│_ _ _│
├──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│i │i.│i:│I │I.│j │j.│L │L.│M │o │o.│p │_ _ _│1 _ _│0 _ _│_ _ _│1 _ _│_ _ _│0 0 0│_ _ _│_ 0 0│_ _ _│_ _ _│0 0 0│_ _ _│
├──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│p.│p:│q │q:│r │r.│s │s:│S │t │T │u:│x:│1 1 0│0 _ _│_ _ _│0 0 0│_ _ _│0 0 0│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘

Aqui você vê várias representações de cadeias de verbos com suas respectivas classificações. Este é o script que eu usei para gerá-lo.

— Conor O'Brien
fonte

Um verbo com classificação 0 _é bom aqui. Você pode encurtá-lo para 34 bytes com'0x',"1'5','3','0f'(128$#)"{~2^i.7

— miles

@miles Huh. Eu pensei que tentei isso ... legal! e eu esqueci o recurso de preenchimento automático de linha de J, obrigado novamente!

— Conor O'Brien

4

Na verdade , 25 bytes

9r`╙╙u9╙╙\#"0x%0128x"%`Mi

Experimente online!

Esta solução usa o fato de que f(n) = 2**512//(2**2**n + 1)(onde //é a divisão com piso) para compilar os valores.

Explicação:

9r`╙╙u9╙╙\#"0x%0128x"%`Mi
9r`╙╙u9╙╙\#"0x%0128x"%`M   for n in range(1, 10):
      9╙╙\                   2**2**9//
   ╙╙u                                (2**2**n + 1)
          #"0x%0128x"%       pad with zeroes to 128 digits, prefix with "0x"
                        i  flatten and implicitly print

— Mego
fonte

4

JavaScript (Firefox 30+), 139 113 112 92 83 80 bytes

_=>[for(x of"970123456")(f=y=>y--?f(y)+(x>6?x-4:y>>x&1&&'f'):'0x')(128)].join`
`

Por fim, atinja o ponto ideal recursivo :-) Usa uma compreensão prática de dândis para economizar 3 bytes .map:

_=>[..."970123456"].map(x=>(f=y=>y--?f(y)+(x>6?x-4:y>>x&1&&'f'):'0x')(128)).join`
`

.replace também tem 83 bytes:

_=>"970123456".replace(/./g,x=>(f=y=>y--?f(y)+(x>6?x-4:y>>x&1&&'f'):'0x')(128)+`
`)

Se uma nova linha principal fosse permitida, isso também seria 80 bytes:

_=>"970123456".replace(/./g,x=>(f=y=>y--?f(y)+(x>6?x-4:y>>x&1&&'f'):`
0x`)(128))

— ETHproductions
fonte

3

Python 2 , 60 bytes

k=1
exec"print'0x%0128x'%int(256/k*('0'*k+'1'*k),2);k*=2;"*9

Experimente online!

— Dennis
fonte

3

Chiclete , 65 bytes

00000000: c5cb 4501 0441 1043 d17b d4fc 254b d110  ..E..A.C.{..%K..
00000010: f7cb 9761 9e7a 8d45 e451 4ce4 564c 04d7  ...a.z.E.QL.VL..
00000020: 2e11 b02b 8f08 80df aa5e 11fe fc77 762c  ...+.....^...wv,
00000030: 428b 5b8e ae8b 30c1 13b6 ce8b b091 377a  B.[...0.......7z
00000040: 01                                       .

Resposta obrigatória do chiclete.

— LegionMammal978
fonte

3

Haskell, 84 72 bytes

Portando a resposta do @ orlp:

import Text.Printf
mapM(\n->printf"0x%0128x\n"$div(2^2^9)$2^2^n+1)[0..8]

Alternativas de 94 bytes sem o poder de Text.Printf:

import Data.List
mapM(putStrLn.("0x"++))$transpose$("53"++).reverse<$>sequence(["0f"]<*[1..7])

r=[0..127]
mapM(putStrLn.("0x"++))$('5'<$r):('3'<$r):[["0f"!!mod(div x(2^y))2|x<-r]|y<-[0..6]]

— Angs
fonte

@nimi whoops, deve ter carregado Control.Monadno REPL. Fixo.

— Angs 01/12/19

3

PowerShell v2 +, 68 bytes

5,3|%{"0x"+"$_"*128}
($a=1)..7|%{"0x"+('0'*$a+'f'*$a)*(128/($a*=2))}

O PowerShell não possui números inteiros de precisão arbitrários sem o uso de [bigint]chamadas, e esses não podem ser facilmente convertidos em hexadecimal; portanto, tratamos isso como um desafio baseado em string.

A primeira linha lida com a repetição 5e 3basta fazer uma multiplicação de 128caracteres para caracteres e colocar um 0xna frente.

A próxima linha faz um loop de $a=1para 7, cada iteração produzindo outra string. Novamente, temos a 0xtachinha na frente, e estamos fazendo a multiplicação de cordas no meio para construir o número apropriado de 0e fconcatenadas juntas, e depois multiplicando as cordas disso para o número apropriado de caracteres. Observe que estamos usando a variável $aaqui, e não o contador de loop $_, para que possamos dimensionar adequadamente (caso contrário, precisaríamos fazer loop como 1,2,4,8,16,32,64|%{...}, que é mais longo).

As seqüências resultantes são deixadas no pipeline e a saída via implícita Write-Outputacontece na conclusão do programa, com uma nova linha entre elementos.

— AdmBorkBork
fonte

3

V , 43 bytes

64i0fòYpÓ¨¨0«©¨f«©©û2}/²²³³òdd{3ÄÒ5jÒ3Îi0x

Experimente online!

Isso usa uma das regexes compactadas mais longas que eu já precisei em uma resposta em V. Aqui está a versão mais legível, onde adicionei um byte para expressões regulares legíveis e alterei o caractere de escape não imprimível para<esc>

64i0f<esc>òYpÓö((0+)(f+)){2}/²²³³òdd{3ÄÒ5jÒ3Îi0x

Explicação (usando a versão legível):

64i0f<esc>                                          " Insert 64 "0f"s and escape to normal mode
          ò                      ò                  " Recursively:
           Yp                                       "   Duplicate this line
             Ó                                      "   Substitute:
              ö                                     "     (Optionally Turn the readable version on)
               ((0+)(f+))                           "     One or more '0's followed by one or more 'f's
                         {2}                        "     Repeated twice
                            /                       "   With:
                             ²²                     "     The second capture group twice (the '0's)
                               ³³                   "     Followed by the third capture group twice (the 'f's)
                                                    "   Once the search is not found, the loop will break
                                  dd                " Delete a line (because we have one too many)
                                    {               " Move to the first line
                                     3Ä             " Make three copies of this line
                                       Ò5           " Replace the first one with '5's
                                         jÒ3        " Move down a line and replace the second with '3's
                                            Î       " On every line:
                                             i0x    "   Insert a '0x'

— DJMcMayhem
fonte

3

JavaScript (ES6), 74 72 70 bytes

Inclui a nova linha à direita opcional.

f=(i=1152)=>i--?f(i)+(i&127?'':`
0x`)+('53'[y=i>>7]||i&1<<y-2&&'f'):''

Mostrar snippet de código

f=(i=1152)=>i--?f(i)+(i&127?'':`
0x`)+('53'[y=i>>7]||i&1<<y-2&&'f'):''

console.log(f())

Expandir snippet

— Arnauld
fonte

2

Pitão - 31 30 bytes

Para obter o padrão, exceto os 3's e 5' s, o cumulativo é reduzido, duplicando cada vez os pedaços.

jm+"0x".[dd128+`3+`5.u.iNN6"0f

Experimente online aqui .

— Maltysen
fonte

2

Lote, 216 bytes

@echo off
set s=5
call:c
set s=3
call:c
set a=0
set b=f
for /l %%i in (1,1,7)do call:l %%i
exit/b
:l
set s=%a%%b%
:c
for /l %%j in (0%1,1,6)do call set s=%%s%%%%s%%
echo 0x%s%
set a=%a%%a%
set b=%b%%b%

— Neil
fonte

2

Vim 72 bytes

i0x128a5Ypll128r3o0x64a0fa0Ypqqffdt0fft0p@qq@qqwYp@qq@w@w@w@w:%s/0$

TryItOnline!

Não imprimíveis:

i0x^[128a5^[Ypll128r3o0x^[64a0f^[a0^[Ypqqffdt0fft0p@qq@qqwYp@qq@w@w@w@w:%s/0$

Os @w4s no final estão me incomodando, mas, como eu estava confiando em @qfalhar no final de uma linha, ele também falha no @w. Eu poderia tentar apenas executando q 32 vezes e ver se isso atrapalha as linhas posteriores.

— nmjcman101
fonte

2

C, 146 bytes

#define F for(i=0;++i<129;)s[i+1]=
#define P ;puts(s);
i,j;f(){char s[131]={'0','x'};F'5'P F'3'P for(j=1;(j*=2)<129;){F(i-1)%j<j/2?'0':'f'P}}

Ungolfed:

#define F for(i=0;++i<129;)s[i+1]=
#define P ;puts(s);
i,j;f(){
  char s[131]={'0','x'};
  F'5'P
  F'3'P
  for(j=1;(j*=2)<129;){
    F(i-1)%j<j/2?'0':'f'P 
  }
}

— Karl Napf
fonte

133 bytes

— ceilingcat 21/03

2

brainfuck , 211 bytes

+++++++>++>>-[>>>>+<<++<+<-----]>--->>++++++++++>++<<<<<<[->----[>+++<--]>-->.<.++++++++[->>>>.<<<<]>>>.>--[<]<<]+<[->>----[>+++<--]>-->.<.++++++++[<<[>+>->.<<<-]>[<+>>->>.<<<-]>]>>>.<<<<[-<+>]<[->++<]>[-<+>]<<]

Experimente online!

— ბიმო
fonte

1

197 bytes através de algumas verificações de loop diferentes. Tenho certeza de que o xgerador pode ser movido para fora do circuito agora

— Jo King

2

GNU sed 4.2.2 , 77

s/^/0x5/
:
s/x5{,127}$/&5/
t
p
y/5/3/
p
s/33/0f/gp
:a
s/(f+)(0+f+)/\2\1/gp
ta

Experimente online.

— Trauma Digital
fonte

2

Ruby , 66 60 45 bytes

x=2;9.times{puts"0x%0128x"%(2**512/-~x);x*=x}

Experimente online!

Ideia roubada da orlp

— GB
fonte

1

C #, 168 bytes

()={string R="",o="0",f="f";for(int i=0,j;i<9;i++){R+="0x";if(i>2){o+=o;f+=f;}for(j=0;j<128;){R+=i<1?"5":i<2?"3":o+f;j+=i>1?(int)Math.Pow(2,i-1):1;}R+="\n";}return R;};

— Yodle
fonte

1

Stax , 19 bytes

⌡hÅék╝94"ºé♪╛#V┐5í╒

Execute e depure

Descompactado, não jogado e comentado, parece com isso.

512r        [0..511]
{:Brm       convert each to bits and reverse each
M           transpose matrix, filling missing elements in rectangle with zero
m           map over each element of array, using the rest of the program.  outputs implicitly.
  4/        split bits into groups of 4
  {:b|Hm    convert each 4-bit binary number to single digit hex string
  .0xp      print "0x" without newline

Execute este

— recursivo
fonte

1

/// , 193 bytes

/*/\/\///X/
0x*F/5555*G/FFFF*T/3333*U/TTTT*o/0f0f*1/oooo*t/00ff*2/tttt*g/0000*h/ffff*4/ghgh*6/gghh*7/gggg*8/hhhh*9/7788/0xGGGGGGGGXUUUUUUUUX11111111X22222222X44444444X66666666X78787878X99X77988

Experimente online!

— Erik, o Outgolfer
fonte

Números mágicos de contadores

05AB1E , 26 22 21 bytes

Python 2, 52 49 46 bytes

PHP, 111 110 108 bytes

Retina , 43 bytes

Explicação

Vim, 32 bytes

Pitão, 26 bytes

J, 46 34 bytes

Resultado

Na verdade , 25 bytes

JavaScript (Firefox 30+), 139 113 112 92 83 80 bytes

Python 2 , 60 bytes

Chiclete , 65 bytes

Haskell, 84 72 bytes

PowerShell v2 +, 68 bytes

V , 43 bytes

JavaScript (ES6), 74 72 70 bytes

Pitão - 31 30 bytes

Lote, 216 bytes

Vim 72 bytes

C, 146 bytes

brainfuck , 211 bytes

GNU sed 4.2.2 , 77

Ruby , 66 60 45 bytes

C #, 168 bytes

Stax , 19 bytes

/// , 193 bytes