35

Date due stringhe di lettere, trasferite il modello di maiuscole di ciascuna stringa sull'altra. Vince il minor numero di byte.

Input:   CodeGolf xxPPCGxx  
Output:  coDEGOlf XxppCgxx

Entrambe le stringhe saranno di uguale lunghezza e non vuote, con solo lettere a..ze A..Z.
È possibile emettere le due stringhe risultanti in entrambi gli ordini rispetto agli input.
È possibile rappresentare una coppia di stringhe come una stringa con un separatore a carattere singolo non lettera per input e / o output.
Puoi rappresentare una stringa come un elenco di caratteri o stringhe di un carattere, ma non come una sequenza di valori di punti di codice a meno che non siano semplicemente stringhe nella tua lingua.
L'input e l'output possono rappresentare le stringhe in modo diverso.

Casi test:

CodeGolf xxPPCGxx -> coDEGOlf XxppCgxx
lower UPPER -> LOWER upper
MiXeD lower -> mixed LoWeR
A A -> A A
ABcd EfGh -> AbCd EFgh

code-golf string

— XNOR
fonte

14

Java (JDK 10) , 66 byte

a->b->{for(int i=a.length,t;i-->0;b[i]^=t)a[i]^=t=(a[i]^b[i])&32;}

Provalo online!

spiegazioni

a->b->{                           // Curried lambda
 for(int i=a.length,t;i-->0;      //  Descending loop on i,
                                  //  Declare t
     b[i]^=t                      //   Apply the case difference to b[i]
   )
  a[i]^=t=(a[i]^b[i])&32;         //   Assign the case difference of the two letters to t, and apply it to a[i].
}

— Olivier Grégoire
fonte

9

Completamente estraneo a questa tua risposta, ma è più facile che creare una chat. ; p Hai notato che Java-10 TIO ha un bug durante l'utilizzo array[i++%n]+=...;? array[t=i++%n]=array[t]+...;funziona bene; e array[i%n]+=...;i++;funziona anche bene, ma usare i++o ++icon un modulo e +=aggiungere a una riga in un array non funziona. Qui un TIO Java 10 come esempio per vedere il problema. È un bug (o funzione: S) nel Java 10 JDK o nel compilatore Java 10 TIO?

— Kevin Cruijssen,

1

@KevinCruijssen Vedo il problema, ma sembra strano. Vedo che la versione utilizzata su TIO è 10.0.0_46 (del 20-03-2018). L'ultima versione è 10.0.1. Probabilmente dovremmo chiedere a TIO di aggiornare la loro versione di Java.

— Olivier Grégoire,

3

@KevinCruijssen Dennis ha aggiornato la versione alla 10.0.1 e il problema persiste (non ho ancora installato Java 10, quindi mi affido a TIO, proprio come te). Ho chiesto su Stack Overflow perché non so cosa succede qui ... È sconcertante!

— Olivier Grégoire,

5

@KevinCruijssen Va bene, non è che questa risposta attiri molti voti: P Comunque ... Il fatto è che in realtà hai trovato un bug . Dato che le specifiche dicono che dovrebbe comportarsi come penseresti, continua a scrivere la tua risposta in questo modo, ottimizzata per Java 10 se lo richiedi. In questo modo, hai una risposta Java 10 valida, ma non verificabile a causa di quel bug. Basta scriverlo e testarlo in Java 8, quindi apportare le modifiche Java 10 appropriate come passare Stringa var.

— Olivier Grégoire il

6

Penso che sia davvero bello che tu abbia trovato un bug in JDK 10. Ottimo lavoro:]

— Poke

13

C (gcc) , 86 58 55 53 byte

Risparmiato ventotto byte grazie al ciarlatano Cows .
Tre byte salvati.
Salvato due byte grazie a Olivier Grégoire .

c(a,s,e)char*a,*s;{for(;*s++^=e=(*s^*a)&32;)*a++^=e;}

Provalo online!

— Jonathan Frech
fonte

La manipolazione dei bit dàf(S,Z)char*S,*Z;{for(int d;d=(*Z^*S)&32,*Z++^=d;)*S++^=d;}

— Kritixi Lithos il

@Cowsquack Wow; molte grazie.

— Jonathan Frech,

c(a,s,e)char*a,*s;{for(;*s++^=e=(*s^*a)&32;)*a++^=e;}(53 byte)

— Olivier Grégoire il

@ OlivierGrégoire Grazie.

— Jonathan Frech,

8

Gelatina , 9 byte

O&32^/^OỌ

Provalo online!

Come funziona

O&32^/^OỌ  Main link. Argument: [s, t] (pair of strings)

O          Ordinal; replace each character with its code point.
 &32       Perform bitwise AND with 32, yielding 32 for lowercase letters, 0 for
           uppercase ones.
    ^/     Reduce by XOR, yielding 32 for letter pairs with different 
           capitalizations, 0 for letter pair with matching capitalizations.
      ^O   XOR the result with each of the code points.
        Ọ  Unordinal; replace each code point with its character.

— Dennis
fonte

1

... sapevamo che sarebbe successo: D

— Jonathan Allan,

7

APL (Dyalog Classic) , 13 12 byte

⊖⊖819⌶¨⍨∊∘⎕a

Provalo online!

l'input e l'output sono una matrice di caratteri 2 × N

⎕a è l'alfabeto inglese maiuscolo 'ABC...Z'

∊∘⎕a restituisce una matrice booleana che indica quali lettere nell'input sono maiuscole

819⌶ converte il suo argomento destro in maiuscolo o minuscolo a seconda del suo argomento booleano a sinistra ("819" è leetspeak per "BIG")

819⌶¨⍨lo fa per ogni ¨carattere ( ), scambiando (⍨ ) gli argomenti

⊖significa invertire verticalmente; uno ⊖funge da argomento di sinistra 819⌶e l'altro è l'azione finale

— NGN
fonte

1

"819" is leetspeak for "BIG"... Sul serio? Questa è la vera spiegazione del perché è l'819? 0_o

— DLosc

@DLosc sì :) vedi chat

— ngn

5

Pyth , 10 byte

rVV_mmrIk1

Provalo qui!

Spiegazione e trucchi Pyth accurati utilizzati

rVV_mmrIk1- Programma completo. L'input viene preso da STDIN come un elenco di due stringhe e l'output viene scritto in STDOUT come un elenco di due elenchi di caratteri.
mm - Per ogni carattere di ciascuna stringa:
- Ik - Controlla se è invariante in ...
- r...1- ... Conversione in maiuscolo. Resa True per caratteri maiuscoli e False per caratteri minuscoli.
_ - Invertire l'elenco.
VV - E vettorializzare due volte la seguente funzione sui due elenchi:
- r- Converti in maiuscolo se il valore è True(aka 1), altrimenti converti in minuscolo.

Questa presentazione abusa del fatto che r0e r1sono le funzioni minuscole e maiuscole in Pyth e usiamo i valori di verità (i valori ottenuti controllando se ogni carattere è maiuscolo, invertito) che danno Trueper maiuscole e Falseminuscole. Il fatto che i booleani siano sottoclassi di numeri interi in Python è molto utile per l'approccio utilizzato da questa risposta. Porting Dennis e Jonathan's Jelly si sono entrambi avvicinati a oltre 18 byte, quindi sono abbastanza contento dei trucchi specifici di Pyth usati qui.

— Mr. Xcoder
fonte

4

MATL , 11 byte

kG91<P32*-c

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

k      % Implicit input: 2-row char matrix. Convert to lower-case
G      % Push input again 
91<    % Less than 91?, element-wise. Gives 1 for upper-case
P      % Flip vertically
32*    % Multiply by 32, element-wise
-      % Subtract, element-wise
c      % Convert to char. Implicit display

— Luis Mendo
fonte

4

Haskell , 78 byte

import Data.Char
c x|isUpper x=toUpper|1<2=toLower
(!)=zipWith c
x#y=(y!x,x!y)

Provalo online!

— user28667
fonte

4

isUpper xpuò essere x<'a'.

— Lynn,

3

J , 36 31 27 byte

-9 byte grazie a FrownyFrog!

(XOR"$32*[:~:/97>])&.(3&u:)

Provalo online!

La soluzione precedente era:

J , 36 31 byte

-5 byte grazie a FrownyFrog!

|:@(XOR 32*0~:/@|:97>])&.(3&u:)

Provalo online!

Come funziona:

                          (3&u:)  converts the strings to code points
   (                    )&.       then do the following and convert back to chars
                    97>]          check if they are uppercase letters 
             0~:/@|:              transpose and check if the two values are different
          32*                     multiply by 32 (32 if different, 0 otherwise)
      XOR                         xor the code point values with 32 or 0
 |:@                              and transpose

— Galen Ivanov
fonte

La [:può essere 0 e (22 b.)può essere XOR. &.(3&u:)salva 1 byte.

— FrownyFrog,

@FrownyFrog Golf molto belli, grazie! Sei veramente bravo!

— Galen Ivanov,

27

— FrownyFrog,

@FrownyFrog Wow! Puoi spiegare l'uso di "e $? Grazie!

— Galen Ivanov,

L'input è fatto con ,:, ci sono 2 righe sul lato sinistro. Abbiamo bisogno, "(1)ma "$funziona anche, perché rappresenta "1 _. $ b.0dà il grado di $ (monadico, diadico sinistro, diadico destro).

— FrownyFrog,

3

R , 118 94 75 72 byte

m=sapply(scan(,""),utf8ToInt);w=m>96;apply(m-32*(w-w[,2:1]),2,intToUtf8)

Provalo online!

~~Ci deve essere un modo molto più golfista.~~ -43 byte grazie a Giuseppe che mi ha indicato la soluzione MATL di Luis Mendo. Il collegamento TIO contiene una soluzione funzionale per lo stesso conteggio byte.

m=sapply(a<-scan(,""),utf8ToInt)    # Turns input into a matrix of bytecode (2 columns)
w=m>96                              # Predicate : which chars are lower?
apply(m-32*(w-w[,2:1]),2,intToUtf8) # -32*w turns the string to UPPER
                                    # +32*w[,2:1] swaps capitalization
                                    # intToUtf8 turns bytecode to strings

Bonus: l'output è un vettore denominato i cui nomi sono le stringhe di input originali!

— Jayce
fonte

Dovresti essere in grado di rilasciare a<-poiché non usi aaltrove.

— Giuseppe,

@Giuseppe Mi stavi leggendo? ;)

— JayCe

3

codice macchina x86-64, 14 byte

Callable da C (convenzione di chiamata SysV x86-64) con questo prototipo:

void casexchg(char *rdi, char *rsi);  // modify both strings in place

Una versione di lunghezza esplicita con lunghezza in ha rcxle stesse dimensioni. void casexchg(char *rdi, char *rsi, int dummy, size_t len);

Questo utilizza lo stesso algo a scambio di bit delle risposte C e Java: se entrambe le lettere sono nello stesso caso, nessuna delle due deve cambiare. Se sono opposti, entrambi devono cambiare.

Utilizzare XOR per diff il bit case delle due stringhe. mask = (a XOR b) AND 0x20è 0 per lo stesso o 0x20 per diverso. a ^= mask; b ^= maskcapovolgi entrambe le lettere se fossero lettere opposte. (Poiché i codici delle lettere ASCII per le lettere superiore e inferiore differiscono solo per il bit 5.)

Elenco NASM (da nasm -felf64 -l/dev/stdout). Usa cut -b 26- <casexchg.lst >casexchg.lstper trasformare questo in qualcosa che puoi assemblare.

   addr    machine
 6         code          global casexchg
 7         bytes         casexchg:
 8                       .loop:
 9 00000000 AC               lodsb                ; al=[rsi] ; rsi++
10 00000001 3207             xor   al, [rdi]
11 00000003 2420             and   al, 0x20       ; 0 if their cases were the same: no flipping needed
12                       
13 00000005 3007             xor   [rdi], al      ; caseflip both iff their cases were opposite
14 00000007 3046FF           xor   [rsi-1], al
15                       
16 0000000A AE               scasb                ; cmp al,[rdi] / inc rdi
17                           ; AL=0 or 0x20.
18                           ; At the terminating 0 in both strings, AL will be 0 so JNE will fall through.
19                           ; 0x20 is ASCII space, which isn't allowed, so AL=0x20 won't cause early exit
20 0000000B 75F3             jne  .loop
21                       ;    loop  .loop            ; caller passes explict length in RCX
22                       
23 0000000D C3               ret

  size = 0xe bytes = 14
24 0000000E 0E           db $ - casexchg_bitdiff

Anche l' loopistruzione lenta è di 2 byte, uguale a una breve jcc. scasbè ancora il modo migliore per incrementare rdicon un'istruzione a un byte. Immagino che potremmo xor al, [rdi]/ stosb. Sarebbe la stessa dimensione ma probabilmente più veloce per illoop caso (memory src + store è più economico di memory dst + ricaricare). E impostarebbe ZF in modo appropriato per il caso di lunghezza implicita!

Provalo online! con un _start che lo chiama su argv [1], argv [2] e usa sys_write sul risultato

— Peter Cordes
fonte

2

k , 14 byte

{`c$l+|x-l:_x}

Provalo online! Input / output è un elenco di due stringhe.

— zgrep
fonte

2

Python 3 , 83 byte

lambda a,b:(g(a,b),g(b,a))
g=lambda*a:[chr(ord(x)&95|(y>'Z')<<5)for x,y in zip(*a)]

Provalo online!

-3 byte grazie a Mr. Xcoder
-3 byte grazie a Chas Brown

— HyperNeutrino
fonte

83 byte con un po 'di bit-twiddling.

— Chas Brown,

@ChasBrown Oh fantastico, carino. Grazie!

— HyperNeutrino,

2

Haskell , 78 byte

c!d=([c..'z']++[';'..])!!sum[32|(c>'Z')/=(d>'Z')]
(#)=zipWith(!)
s%t=(s#t,t#s)

Provalo online!

— Lynn
fonte

2

QBasic, 133 byte

INPUT a$,b$
FOR i=1TO LEN(a$)
c=ASC(MID$(a$,i,1))
d=ASC(MID$(b$,i,1))
s=32AND(c XOR d)
?CHR$(c XOR s);
r$=r$+CHR$(d XOR s)
NEXT
?
?r$

Prende le due stringhe separate da virgola e genera i risultati separati da una nuova riga. Utilizza l'algoritmo fervido della risposta Jelly di Dennis . A parte questo, il trucco principale del golf qui è che la prima stringa di risultati viene stampata direttamente, un carattere alla volta, un po 'più breve rispetto al salvataggio di entrambe le stringhe di risultato in variabili e alla loro stampa all'esterno del ciclo.

— DLosc
fonte

2

JavaScript, 77 74 73 byte

W=>W.map((w,x)=>w.map((c,i)=>W[+!x][i][`to${c>{}?'Low':'Upp'}erCase`]()))

Mostra snippet di codice

f=
W=>W.map((w,x)=>w.map((c,i)=>W[+!x][i][`to${c>{}?'Low':'Upp'}erCase`]()))

console.log(
    f([[...'CodeGolf'],[...'xxPPCGxx']])
)

Expand snippet

Acquisisce una matrice di array di caratteri, genera una matrice di array di caratteri.

_{-1 byte ( @Arnauld ): c>'Z'→c>{}}

— darrylyeo
fonte

1

È possibile salvare un byte con c>{}.

— Arnauld,

1

Retina , 75 byte

^
¶
+`¶(([A-Z])|(.))(.*)¶(([A-Z])|(.))
$#6*$u$1$#7*$l$1¶$4$#2*$u$5$#3*$l$5¶

Provalo online! Spiegazione: Le nuove righe vengono utilizzate come marcatori per determinare la quantità di stringa elaborata. La regex cerca di trovare una corrispondenza tra lettere maiuscole o errori di qualsiasi carattere. Se una lettera maiuscola è stata abbinata, l'altro carattere è maiuscolo, altrimenti è in minuscolo e viceversa, mentre le nuove righe passano al carattere successivo.

— Neil
fonte

1

Python 3 , 76 75 byte

lambda a,b:''.join(chr(ord(x)&95|ord(y)&32)for x,y in zip(a+' '+b,b+'a'+a))

Provalo online!

Emette il risultato come una stringa con un separatore a carattere singolo.

Grazie a Jonathon Allan per 1 byte.

— Chas Brown
fonte

(y>'Z')*32->ord(y)&32

— Jonathan Allan il

1

Assembly (nasm, x64, Linux) , 25 byte (sorgente 123 byte)

Byte esadecimali:

0x88, 0xE6, 0x30, 0xC6, 0x80, 0xE6, 0x20, 0x88
0xF2, 0x66, 0x31, 0xD0, 0x88, 0x26, 0xAA, 0xAC
0x8A, 0x26, 0x8A, 0x07, 0x08, 0xE4, 0x75, 0xE8, 0xC3

Il punto di ingresso della funzione è a a, con le stringhe passate usando RDIe RSI.

b:MOV DH,AH
XOR DH,AL
AND DH,32
MOV DL,DH
XOR AX,DX
MOV [RSI],AH
STOSB
LODSB
a:MOV AH,[RSI]
MOV AL,[RDI]
OR AH,AH
JNZ b
RET

Provalo online!

— ErikF
fonte

Ho appena realizzato che stai giocando a golf sulla fonte asm, non sulla dimensione del codice macchina. Di solito è più divertente, perché a volte è utile nella vita reale. (A parità di altre condizioni, più piccolo è in genere migliore per la densità della cache front-end e superiore.) Suggerimenti per giocare a golf nel codice macchina x86 / x64 .

— Peter Cordes,

@PeterCordes Grazie per il suggerimento. Ho aggiunto i byte esadecimali. Il mio assemblaggio è un po 'arrugginito (l'ultima volta ho dovuto scrivere un piccolo driver di dispositivo per DOS 3.3!) Ma penso di aver ottenuto la maggior parte delle ottimizzazioni.

— ErikF

Sì, sembra abbastanza buono. Interessanti hack del registro parziale. and al,32è solo 2 byte, utilizzando la speciale codifica AL, imm8 della maggior parte delle istruzioni ALU. È possibile richiedere la lunghezza della stringa in RCX e utilizzare loop. Stavo per dire che dovresti test ah,ahperché è più efficiente cheor pur avendo la stessa lunghezza, ma è più lungo nella fonte di asm, quindi il vecchio idioma crostoso in realtà ha merito per il golf asm-source: P

— Peter Cordes

Usando xor di destinazione della memoria e una struttura di loop più stretta, la mia versione è arrivata a 14 byte di codice macchina x86-64 . Lo stesso vale per le stringhe di lunghezza implicita o di lunghezza esplicita. La sua sorgente NASM potrebbe probabilmente essere giocata a golf anche più breve di 123 byte. Non sono sicuro che funzionerebbe più velocemente su una CPU moderna come Skylake o Ryzen (Ryzen non avrebbe alcun costo aggiuntivo per la fusione di DH durante la lettura di DX, ma SKL avrebbe bisogno di un ciclo aggiuntivo per inserire una fusione).

— Peter Cordes

0

Gelatina , 13 byte

=Œu=/ị"Ɱż"Œs$

Provalo online!

Anche 13: =ŒuṚ×32ạŒlO$Ọ(o =ŒuṚæ«5ạŒlO$Ọ)

— Jonathan Allan
fonte

0

Carbone , 17 byte

Ｅθ⭆ι⎇№α§§θ¬κμ↥λ↧λ

Provalo online! Il collegamento è alla versione dettagliata del codice. Accetta l'input come una matrice di due stringhe. Spiegazione:

 θ                  Input array
Ｅ                   Map over strings
   ι                Current string
  ⭆                 Map over characters
         θ          Input array
           κ        Outer loop index
          ¬         Logical Not
        §           Index into array
            μ       Inner loop index
       §            Index into array
      α             Uppercase characters
     №              Count number of matches
              λ λ   Current character
             ↥      Uppercase
               ↧    Lowercase
    ⎇               Ternary
                    Implicitly print

— Neil
fonte

0

F #, 120 byte

Bugger.

open System
let g=Seq.fold2(fun a x y->a+string(x|>if y>'Z'then Char.ToLower else Char.ToUpper))""
let b f s=g f s,g s f

Provalo online!

La funzione gaccetta le due stringhe come parametri. Seq.fold2applica una funzione con un accumulatore ( a) a ciascun elemento ( xe y) nelle stringhe. inizialmentea è una stringa vuota e aggiunge ad essa il carattere convertito in ogni iterazione.

bè la funzione principale. Prima converte frispetto a s, quindi converte srispetto a f. Quindi restituisce una tupla con entrambi i valori.

— Ciaran_McCarthy
fonte

0

Prolog (SWI) , 121 byte

[H|T]-[I|U]-[J|V]-[K|W]:-((H>96,I>96;H<92,I<92),J=H,K=I;H>96,J is H-32,K is I+32;J is H+32,K is I-32),T-U-V-W.
_-_-[]-[].

Provalo online!

— ASCII-only
fonte

0

Rubino , 74 69 byte

->a,b{a.zip(b).map{|x|x.one?{|y|y>?_}?x.map(&:swapcase):x}.transpose}

Provalo online!

L'input e l'output sono matrici di caratteri, quindi il footer fa avanti e indietro le trasformazioni dalle stringhe.

Non sono ancora sicuro se questo sia un buon approccio al problema, ma questa sfida sembra sicuramente uno scenario d'uso piacevole per il swapcasemetodo.

— Kirill L.
fonte

0

PHP 4.1.2 , 40 byte

Sostituire la coppia di virgolette con il byte A0 (in ISO-8859-1 o Windows-1252, questo è NBSP) per visualizzare il conteggio dei byte, quindi eseguire da un browser Web (o dalla riga di comando), fornendo le stringhe come gli argomenti della stringa di query (o variabili di ambiente) ae b.

<?=$a^$c=($a^$b)&str_pad("",2e5),_,$b^$c;

In questa versione di PHP, register_globals è attivo per impostazione predefinita, quindi le stringhe verranno automaticamente assegnate alle variabili $ae $b. Aumentare il valore 2e5(200000) se necessario.

PHP 7.1+, 58 byte

Esegui dalla riga di comando, usando php -r 'code here' string1 string2:

[,$a,$b]=$argv;echo("$b $a"^$a.=" $b")&str_pad("",3e5)^$a;

Il valore 3e5 (300000) viene scelto per superare (MAX_ARG_STRLEN * 2 + 1) sulla maggior parte dei sistemi Linux (in particolare, x86 e altre architetture per le quali PAGE_SIZE è 4096 e MAX_ARG_STRLEN è quindi 131072), per evitare problemi con qualsiasi possibile stringa di input. Aumentare se necessario.

Provalo online!

— Per favore alzati
fonte

0

Stax , 10 byte

▌Ö↑o╓→ì]yç

Esegui ed esegui il debug

Ecco una rappresentazione non golfata dello stesso programma per mostrare come funziona.

        Example
        ["Ab", "cd"]                    
:)      [["Ab", "cd"], ["cd", "Ab"]]    Get all rotations of input
m       ["cd", "Ab"]                    For each, run the rest of program; print result
  M     ["cA", "db"]                    Transpose matrix
  {     "cA"                            Begin block for mapping to result
    B   "A" 99                          "Pop" first element from string array; leave the rest
    96> "A" 1                           Is the character code > 96?
    :c  "a"                             Set case of string; 0 -> upper,  1 -> lower
  m     "ab"                            Perform the map using the block

Esegui questo

— ricorsivo
fonte

0

Cristallo , 108 byte

def f(a,b)r=s=""
a.zip(b){|x,y|r+="`"<x<"{"?y.downcase: y.upcase
s+="`"<y<"{"?x.downcase: x.upcase}
{s,r}end

Provalo online!

Come funziona?

def f(a, b)                       # Strings as list of characters
r = s = ""                        # Strings buffers initialization
a.zip(b) do |x, y|                # Join two arrays to paired tuples and iterate
r+="`"<x<"{"?y.downcase: y.upcase # Check if character is downcase using triple
s+="`"<y<"{"?x.downcase: x.upcase # comparison and ascii table. Then apply it to
end                               # the other character using String methods
{s, r}                            # Return two new strings using a tuple
end                               # PS: Tuples are inmutable structures in Crystal

— user80978
fonte

Capitalizzazione di scambio

Java (JDK 10) , 66 byte

spiegazioni

C (gcc) , 86 58 55 53 byte

Gelatina , 9 byte

Come funziona

APL (Dyalog Classic) , 13 12 byte

Pyth , 10 byte

Spiegazione e trucchi Pyth accurati utilizzati

MATL , 11 byte

Spiegazione

Haskell , 78 byte

J , 36 31 27 byte

J , 36 31 byte

Come funziona:

R , 118 94 75 72 byte

codice macchina x86-64, 14 byte

k , 14 byte

Python 3 , 83 byte

Haskell , 78 byte

QBasic, 133 byte

JavaScript, 77 74 73 byte

Retina , 75 byte

Python 3 , 76 75 byte

Assembly (nasm, x64, Linux) , 25 byte (sorgente 123 byte)

Gelatina , 13 byte

Carbone , 17 byte

F #, 120 byte

Prolog (SWI) , 121 byte

Rubino , 74 69 byte

PHP 4.1.2 , 40 byte

PHP 7.1+, 58 byte

Stax , 10 byte

Cristallo , 108 byte

Come funziona?