25

Esiste un famoso algoritmo complicato per contare il numero di bit impostati in un numero intero senza segno a 32 bit:

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

Non lo spiegherò qui. Ma immagina un codice simile per numeri interi a 512 bit! Le costanti esadecimali sarebbero enormi e formerebbero un modello grazioso. Il tuo compito è semplicemente stampare questo risultato esatto :

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

Nessuno spazio finale, per favore, anche se una singola riga finale è facoltativa.

Questo è code-golf , quindi vince la risposta più breve (in byte).

— Lynn
fonte

Ci è permesso prendere input (come in qualcosa come 0x0x0x0x0x0x0x0x0x)?

— ouflak

@ouflak No. ———

— Lynn,

3

05AB1E , 26 22 21 byte

05AB1E utilizza la codifica CP-1252 .

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

Provalo online!

Spiegazione

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

Altre versioni che potrebbero essere migliorate

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 byte

Il kth numero è dato da 2**512/(2**2**k + 1). Questo è per un numero di 512 bit, quindi è banale estendere il modello a diverse larghezze.

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

3 byte salvati grazie a Dennis.
3 byte salvati grazie a xnor.

— orlp
fonte

2

I vantaggi degli interi di precisione arbitraria ...

— ETHproductions

Bello. Ciò consente di risparmiare alcuni byte.

— Dennis

Più breve per continuare a quadrare:l=2;exec"print'0x%0128x'%(2**512/-~l);l*=l;"*9

— xnor

1

Mi scalda il cuore vedere Python in testa ai voti :)

— Tobias Kienzler,

4

@TuukkaX Ho solo molta esperienza con gli hack di bit twiddling. Ho usato molto Wolfram Alpha per semplificare somme e cose del genere. Ma in fondo ho fatto il modello 01010101, 00010001, 00000001, e poi moltiplicato per quelli 1, 11, 1111per ottenere i modelli binari corretti. Ad esempio 01010101puoi ottenere la formula per una certa larghezza w facendo sum 2^(2*k) for k = 0, w/2 - 1e scoprendo che è (2**w - 1)/3.

— orlp,

7

PHP, 111 110 108 byte

Un byte salvato grazie 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 è il modello per 1024 bit? : D

— Titus
fonte

1

È possibile salvare un byte utilizzando $x<65anziché $i++<7. Questa volta l'ho provato e tutto il resto.

— user59178

6

Retina , 43 byte

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

Provalo online!

Spiegazione

Questo fa molto uso :dell'opzione generalmente sottoutilizzata che consente di stampare risultati intermedi, perché è molto più breve modificare una singola riga che costruire l'intero output.

:`
0x128$*5

Questo sostituisce l'input vuoto con 0xseguito da 128 5se lo stampa per generare la prima riga.

:`5
3

Questo sostituisce la 5s con 3s per generare la seconda riga e la stampa pure.

;{:`33
0f

Questa è l'ultima riga a casing speciale e si trasforma ogni due 3s in modo 0fda generare la terza riga. Questo avvia anche un ciclo attraverso le ultime due fasi ( {). Tuttavia, questa fase non farà nulla dopo la prima iterazione tranne la stampa dello stato corrente. Le ;sopprime l'uscita alla fine del programma per evitare duplicazione l'ultima riga.

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

Questa sostituzione ora trasforma ogni riga nella successiva, scambiando ogni altra coppia di fs e 0s. La condizione "ogni altra coppia" viene applicata abbinando uno zero davanti a f, il che rende impossibile abbinare coppie consecutive poiché le partite non possono sovrapporsi.

— Martin Ender
fonte

6

Vim, 32 byte

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

Ho solo bisogno di scrivere manualmente il primo 5e 3, e la macro si occupa di tutto il resto, "raddoppiando il conteggio dei bit" ogni volta che viene eseguito. L'ordine dei passaggi nella macro è un po 'strano (crea una nuova flinea, copia a blocchi, riutilizza la dimensione del blocco visivo per inserire 0s nella friga), ma è la variante più veloce che ho trovato.

— udioica
fonte

5

Pyth, 26 byte

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

Port of my Python answer.

— orlp
fonte

5

J, 46 34 byte

~~Sto lavorando a golf questo, ma a questo bambino piace stare a 46 byte ...~~ Non più! -12 byte grazie alle miglia!

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

Provalo online! : D

Risultato

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

Per questa risposta, avevo bisogno (idealmente) di un verbo con rango in 0 1modo da usarlo nella u"vdefinizione di rango; tuttavia, miglia hanno osservato che 0 _era sufficiente per il compito da svolgere.

┌──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│= │< │<.│<:│> │>.│>:│+ │+.│+:│* │*.│*:│_ 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│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘

Qui puoi vedere un gruppo di rappresentazioni di stringhe di verbi con i loro rispettivi ranghi. Questo è lo script che ho usato per generarlo.

— Conor O'Brien
fonte

Un verbo con rango 0 _va bene qui. Puoi accorciarlo a 34 byte con'0x',"1'5','3','0f'(128$#)"{~2^i.7

— miglia

@miles Huh. Pensavo di averlo provato ... fantastico! e mi sono dimenticato della funzione di riempimento automatico delle righe di J, grazie ancora!

— Conor O'Brien,

4

In realtà , 25 byte

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

Provalo online!

Questa soluzione utilizza il fatto che f(n) = 2**512//(2**2**n + 1)(dov'è la //divisione floored) per calcolare i valori.

Spiegazione:

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 83 byte

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

Finalmente ha colpito il punto dolce ricorsivo :-) Utilizza una comprensione di stringa a portata di mano per salvare 3 byte su .map:

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

.replace è anche 83 byte:

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

Se fosse consentita una nuova riga iniziale, anche questi sarebbero 80 byte:

_=>"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 byte

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

Provalo online!

— Dennis
fonte

3

Bubblegum , 65 byte

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                                       .

Risposta obbligatoria Bubblegum.

— LegionMammal978
fonte

3

Haskell, 84 72 byte

Porting @ orlp's answer:

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

94 byte alternative senza la potenza di 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 aver caricato Control.Monadnel REPL. Fisso.

— Angs,

3

PowerShell v2 +, 68 byte

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

PowerShell non ha numeri interi di precisione arbitraria senza usare le [bigint]chiamate e questi non possono essere facilmente convertiti in esadecimali, quindi stiamo trattando questo come una sfida basata su stringhe.

La prima riga gestisce la ripetizione 5e 3semplicemente eseguendo una moltiplicazione di stringa verso i 128caratteri e virando a 0xsul davanti.

La riga successiva $a=1passa da a 7, ogni iterazione genera un'altra stringa. Ancora abbiamo la 0xvirato sul fronte, e stiamo facendo stringa moltiplicazione in mezzo per costruire il numero appropriato di 0e fconcatenati tra loro, e quindi fa stringa di moltiplicazione che verso il numero appropriato di caratteri. Nota che stiamo usando la variabile $aqui, e non il contatore del loop $_, quindi possiamo ridimensionare correttamente (altrimenti avremmo bisogno di fare un ciclo come 1,2,4,8,16,32,64|%{...}, che è più lungo).

Le stringhe risultanti vengono lasciate sulla pipeline e l'output tramite implicito Write-Outputavviene al completamento del programma, con una nuova riga tra gli elementi.

— AdmBorkBork
fonte

3

V , 43 byte

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

Provalo online!

Questo utilizza uno dei regex compressi più lunghi di cui abbia mai avuto bisogno in una risposta V. Ecco la versione più leggibile, in cui ho aggiunto un byte per regex leggibili e ho cambiato il carattere di escape non stampabile in<esc>

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

Spiegazione (utilizzando la versione leggibile):

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 byte

Include la nuova riga finale facoltativa.

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

Mostra snippet di codice

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

console.log(f())

Espandi frammento

— Arnauld
fonte

2

Pyth - 31 30 byte

Per ottenere lo schema ad eccezione di 3'e 5', si riduce cumulativamente, ogni volta raddoppiando i blocchi.

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

Provalo online qui .

— Maltysen
fonte

2

Lotto, 216 byte

@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 byte

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

TryItOnline!

Unprintables:

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

I 4 @ws alla fine mi stanno infastidendo, ma poiché mi affidavo @qal fallimento alla fine di una linea, fallisce anche il @w. Potrei provare a eseguire q 32 volte e vedere se rovina le righe successive.

— nmjcman101
fonte

2

C, 146 byte

#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 byte

— ceilingcat

2

Brainfuck , 211 byte

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

Provalo online!

— ბიმო
fonte

1

197 byte attraverso alcuni controlli di loop diversi. Sono abbastanza sicuro che il xgeneratore possa essere spostato al di fuori del ciclo ora

— Jo King il

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

Provalo online.

— Trauma digitale
fonte

2

Rubino , 66 60 45 byte

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

Provalo online!

Idea rubata da orlp

— GB
fonte

1

C #, 168 byte

()={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 byte

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

Esegui ed esegui il debug

Disimballato, non golfato e commentato, sembra così.

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

Esegui questo

— ricorsivo
fonte

1

/// , 193 byte

/*/\/\///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

Provalo online!

— Erik the Outgolfer
fonte

Numeri magici di popcount

05AB1E , 26 22 21 byte

Python 2, 52 49 46 byte

PHP, 111 110 108 byte

Retina , 43 byte

Spiegazione

Vim, 32 byte

Pyth, 26 byte

J, 46 34 byte

Risultato

In realtà , 25 byte

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

Python 2 , 60 byte

Bubblegum , 65 byte

Haskell, 84 72 byte

PowerShell v2 +, 68 byte

V , 43 byte

JavaScript (ES6), 74 72 70 byte

Pyth - 31 30 byte

Lotto, 216 byte

Vim 72 byte

C, 146 byte

Brainfuck , 211 byte

GNU sed 4.2.2 , 77

Rubino , 66 60 45 byte

C #, 168 byte

Stax , 19 byte

/// , 193 byte