Alfabeto per numero e numero per alfabeto

26

Sfida

In questa sfida devi prendere un numero come input e produrre la lettera dell'alfabeto corrispondente e viceversa. (1 <=> A, 2 <=> B) ecc.

1 -> A
2 -> B
...
26 -> Z

A -> 1
B -> 2
...
Z -> 26

Regole

  • Questo è code-golf , quindi vince il codice più breve in byte.
  • L'input consisterà solo di una lettera maiuscola da Aa Zo di un numero intero da 1a 26compreso.
  • Sono consentiti gli spazi bianchi finali (spazio e newline).
code-golf  string  number  alphabet 
— Chad
fonte
1
Perché duplicare? Oo Non è uguale.
— Chad,
3
Benvenuti in Puzzle di programmazione e Code Golf! Questa sfida potrebbe usare un po 'di chiarimenti. Ad esempio, è possibile specificare quali input dovremmo gestire, poiché sono presenti input non validi. Raccomando di pubblicare sfide future su Sandbox, dove possono ricevere feedback significativi prima di essere pubblicati sul sito principale.
— Leaky Nun,
1
Riceveremo 26come numero intero o "26"come stringa o sono entrambi consentiti?
— Leaky Nun,
2
Deve essere in maiuscolo o è accettabile in minuscolo?
— Mego
1
Scherzi a parte, un'altra sfida di alfabeto? (͡ ° ͜ʖ ͡ °)
— shooqie

Risposte:

6

In realtà, 7 byte

ú' +ûEí

Provalo online!

Spiegazione:

ú' +ûEí
ú' +     lowercase English alphabet, prepend space
    û    uppercase
     E   element (pushes the nth letter if input is an integer, leaves stack alone otherwise)
      í  index (pushes index of input if input is a string, leaves stack alone otherwise)

Se è accettabile la minuscola, si tratta di 6 byte:

ú' +Eí

Provalo online!

— Mego
fonte
1
Al momento stai vincendo, penso che nessuno potrebbe fare un programma con meno 7 byte.
— Ciad
1
Mi sono unito solo per chiedere questo. @Mego che lingua è questa?
— FoldedChromatin
2
@FoldedChromatin sembra github.com/Mego/Seriously
— Alfred Bez
1
@FoldedChromatin In realtà, lo è Actually. Quindi Actually, 7 bytes. : P
— Dan,
2
Momenti come questi mi rendono felice dei nomi che ho scelto per le mie lingue :)
— Mego
9

Erlang, 26 byte

f([X])->X-64;f(X)->[X+64].

Una delle poche volte in cui il comportamento delle stringhe di Erlang è utile.

— uno spaghetto
fonte
7

Python 3, 43 byte

lambda x:x!=str(x)and chr(64|x)or ord(x)^64

La cosa interessante di questa soluzione è che incorpora tutti i sensi di OR, OR bit a bit |, OR logico or, XOR bit a bit ^e XOR logico !=...

— cdlane
fonte
6

2 file , 9 8 byte

Codice:

.bAu¹kr,

Spiegazione:

.b        # Convert 1 -> A, 2 -> B, etc.
  A       # Push the alphabet.
   u      # Convert it to uppercase.
    ¹k    # Find the index of the letter in the alphabet.
      r   # Reverse the stack.
       ,  # Pop and print with a newline.

Utilizza la codifica CP-1252 . Provalo online! .

— Adnan
fonte
1
Non puoi cancellare? Quali byte sono senza,? Non è necessario stampare una nuova riga.
— Ciad
@Chad No, che non funzionerà per gli input numerici :(
— Adnan,
6

Rubino, 47 39 + nbandiera = 40 byte 33 34 31 byte

Funzione anonima. Utilizza un trucco di gestione delle eccezioni come nella soluzione Python di @ KarlNapf .

-3 byte da @manatwork

Provalo online

->i{(64+i).chr rescue i.ord-64}

Versione originale del programma completo con il nflag per 40 byte e legge da STDIN:

puts$_!~/\d/?$_.ord-64:(64+$_.to_i).chr
— Value Ink
fonte
Ricevo un errore di sintassi quando provo a eseguire su ideone , puoi dire come testare?
— Leibrug,
@Leibrug oops! Ora è stato risolto
— Value Ink
È possibile ridurre più applicando spudoratamente Karl Napf 's trucco dalla sua soluzione Python : ->i{(64+i).chr rescue i.ord-64}.
— arte
5

Cheddar, 34 32 byte

Salvato 2 byte grazie a @LeakyNun

n->"%s"%n==n?n.ord()-64:@"(n+64)

Vorrei che ci fosse un modo più breve per verificare se stringa o numero.

Provalo online! o Test Suite

Spiegazione

n ->                // func with arg `n`
    "%s"%n==n ?     // if n is string... (see below)
       n.ord() - 64  // return code point - 64
    :               // else...
    @"(n+64)         // chr(n+64)

"%s"%n==ncontrolla se è una stringa in modo semplice. "%s"è un formato stringa, posso formattare con %eg "a %s c" % "b"è uguale a "a b c". %sspecifica che è una stringa, se una cifra viene passata rimarrà come %s.

— Downgoat
fonte
"%s"%n==nsalva 2 byte
— Leaky Nun
@LeakyNun oh che è intelligente! Stavo provando a farlo "%d"%n==nma non funzionava: /
— Downgoat
5

Mathematica 54 41 byte

Con un suggerimento assolutamente intelligente di LegionMammal978 che consente di risparmiare 13 byte.

If[#>0,FromLetterNumber,,LetterNumber]@#&

If[#>0,FromLetterNumber,,LetterNumber]serve al solo scopo di decidere se applicare FromLetterNumbero LetterNumberall'input.

#>0sarà soddisfatto se l'ingresso,, #è un numero, nel qual caso FromLetterNumberverrà selezionato.

Tuttavia #>0non sarà né vero né falso se #è una lettera e LetterNumberverrà selezionato invece.

If[#>0,FromLetterNumber,,LetterNumber]@#&["d"]

4 

If[#>0,FromLetterNumber,,LetterNumber]@#&[4]

d

In Mathematica, FromLetterNumbere LetterNumberfunzionerà anche con altri alfabeti. Ciò richiede solo qualche byte in più.

If[# > 0, FromLetterNumber, , LetterNumber][#, #2] &[4, "Greek"]
If[# > 0, FromLetterNumber, , LetterNumber][#, #2] &[4, "Russian"]
If[# > 0, FromLetterNumber, , LetterNumber][#, #2] &[4, "Romanian"]

δ
г
b

If[# > 0, FromLetterNumber, , LetterNumber][#, #2] &[δ, "Greek"]
If[# > 0, FromLetterNumber, , LetterNumber][#, #2] &[г, "Russian"]
If[# > 0, FromLetterNumber, , LetterNumber][#, #2] &[b, "Romanian"]

4
4
4

— DavidC
fonte
1
Un po 'di golf, portandolo a 41 byte:If[#>0,FromLetterNumber,,LetterNumber]@#&
— LegionMammal978,
Interpreto il tuo suggerimento: If[#>0,FromLetterNumber[#],LetterNumber@#]‌&. Anche se If[#>0,FromLetterNumber[#],LetterNumber@#]‌&[4]funziona, If[#>0,FromLetterNumber[#],LetterNumber@#]‌&["c"]no. Apparentemente non può risolversi "c">0. Ho frainteso?
— DavidC
Il doppio ,,è intenzionale, così come l'esterno @#; valuta come If[# > 0, FromLetterNumber, Null, LetterNumber][#]&, che utilizza la forma a 4 argomenti di If(cercare).
— LegionMammal978,
Incredibile come funziona la forma a 4 argomenti If.
— DavidC
4

Haskell, 54 byte

f s|s<"A"=[['@'..]!!read s]|1<2=show$fromEnum(s!!0)-64

Esempio di utilizzo: map f ["1","26","A","Z"]-> ["A","Z","1","26"].

Il rigido sistema di tipi di Haskell è un vero dolore qui. Inoltre, tutti i caratteri brevi <-> int funzionano chre ordrichiedono un'importazione, quindi devo farlo a mano. Per la lettera -> int caso, ad esempio devo convertire String-> Char(via !!0) -> Integer(via fromEnum) -> String(via show).

— Nome del modello
fonte
4

C, 55 byte

i;f(char*s){i=atol(s);printf(i?"%c":"%d",64^(i?i:*s));}
— orlp
fonte
4

Perl 6 , 25 byte

{+$_??chr $_+64!!.ord-64}

Spiegazione:

# bare block lambda with implicit parameter of ｢$_｣
{
    +$_         # is the input numeric
  ??
    chr $_ + 64 # if it is add 64 and get the character
  !!
    $_.ord - 64 # otherwise get the ordinal and subtract 64
}

Esempio:

say ('A'..'Z').map: {+$_??chr $_+64!!.ord-64}
# (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26)

say (1..26).map: {+$_??chr $_+64!!.ord-64}
# (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z)
— Brad Gilbert b2gills
fonte
2
Anche se la sintassi è così diverso, lo stesso meccanismo è lo stesso numero di byte in Perl 5: perl -pe '$_=/\d/?chr$_+64:-64+ord'!
— Dom Hastings,
3

C #, 32 byte

n=>(n^=64)>26?(object)(char)n:n;

Lancia verso Func<int, object> .

Input: si charconverte implicitamente in intmodo che possa essere chiamato con int(1-26) ochar ('A'-Z').

Uscita: a charo int.

— latte
fonte
3

PHP, 49 41 40 byte

<?=+($i=$argv[1])?chr($i+64):ord($i)-64;

Non penso che ci sia una buona alternativa a is_numericdestra?

Viene eseguito dalla riga di comando ( $argv[1]è la prima variabile fornita)

Grazie a:

@inserireusernamehere: golfed 8 byte. Sostituzione is_numeric($i=$argv[1])con 0<($i=$argv[1]). Questo funziona perché (int)"randomLetter" == 0.

@manatwork: ridotto con 1 byte. Sostituisci 0<con +. Quello che succede in questo caso è che il segnale + lancerà la "Z" (o qualunque lettera) a 0. Ciò si tradurrà in falso. Pertanto ogni lettera è sempre falsa e un numero è sempre vero.

— Jeroen
fonte
2
L'utilizzo 0<($i=$argv[1])invece di is_numeric($i=$argv[1])consente di risparmiare 8 byte .
— insertusernamehere
1
Continuando su quell'idea: 0<→ +.
— arte
2

Python 2, 61 byte

i=raw_input()
try:o=chr(int(i)+64)
except:o=ord(i)-64
print o

Sì, potrei passare a Python 3 per input

— Karl Napf
fonte
Usa input()comunque e cambia int(i)in i.
— Leaky Nun,
Quindi gli input di caratteri non funzionano.
— Karl Napf,
2
Prendi input come"A"
— Leaky Nun
3
Che schifo. Ao niente.
— Karl Napf,
Potresti eliminare alcuni byte riformulandolo come una funzione: linea 1:, def f(i):linea 2: <spazio> try:o=chr(i+64), linea 3 <spazio> altrimenti invariata, linea 4: <spazio> return o In quella forma, funzionerebbe in entrambi i Python 2 o Python 3
— cdlane il
2

PowerShell v2 +, 42 byte

param($n)([char](64+$n),(+$n-64))[$n-ge65]

Accetta input $n(come numero intero o carattere esplicito) e utilizza uno pseudo-ternario per scegliere tra due elementi di un array. Il condizionale è $n-ge65(cioè, è l'ingresso ASCII Ao superiore). In tal caso, semplicemente lanciamo l'input come int e sottraggiamo 64. Altrimenti, aggiungiamo 64l'intero di input e lo lanciamo come a [char]. In entrambi i casi, il risultato viene lasciato sulla pipeline e la stampa è implicita.

Esempi

PS C:\Tools\Scripts\golfing> ([char[]](65..90)|%{.\alphabet-to-number.ps1 $_})-join','
1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26

PS C:\Tools\Scripts\golfing> (1..26|%{.\alphabet-to-number.ps1 $_})-join','
A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z
— AdmBorkBork
fonte
2

Befunge-98 *, 19 byte

&:39*\`'@\j;+,@;-.@

Poiché la domanda diceva che riceverai un 1-26o un A-Zho assunto che significasse il numero 26 o il carattere AZ. La maggior parte degli interpreti fatica a inserire i codici alt, quindi è più facile da usare &e inserisci valori come 26 per 26 o 90 per "Z", al contrario di ~.

Pseudo-codice

int c = get stdin
push the value of 27
bool is_number =  27 > c
push the value of `@` (64)
if is_number == 1
   jump to adding 64 to c //putting it the ASCII range
   print as ASCII
   end
else
   jump to subtracting 64 from c //putting it in the numerical range
   print as number
   end

Provalo (su Windows) qui!

* Questo è tecnicamente Unefunge-98 perché utilizza solo 1 dimensione, ma quel nome potrebbe non essere familiare.

— tngreene
fonte
2

Befunge 93 , 144 90 66 54 36 19 byte

Non sono sicuro al 100% se questo è consentito, ma se ti è permesso digitare A come 65, B come 66, ecc., Quindi (per amor di [mia] convenienza):

&:"@"`"@"\#. #-_+,@

Altrimenti, a 36 byte:

~:0\"A"-`#v_88*-.@
**~28*++,@>68*-52

(Grazie a tngreene per i suggerimenti!)

~:0\567+*-`#v_88*-.>$28*+,@
52**\28*++,@>~:0`!#^_\68*-

(Grazie a Sp3000 per aver salvato 12 byte riorganizzando!)

~:0\567+*-`#v_88*-.>$82*+,@
            >~:0`!#^_\68*-52**\28*++,@


v                   >$28*+,@
             >~:0`!#^_\68*-52**\28*++,@
>~:0\567+*-`#^_88*-.@


v                    >$28*+,@
~           >11g~:0`!|
1                    >\68*-52**\28*++,@
1
p           
>011g567+*-`|
            >11g88*-.@

Ungolfed:

v                       >$ 28* + , @
                 >~:0 `!|
                        >\ 68* - 52* * \ 28* + + , @
>~:0\ 5 67+ * - `|
                 >88* - . @

Questo è il mio primo programma Befunge funzionante in assoluto, e sento il bisogno di continuare a giocare a golf. Qualsiasi aiuto sarebbe molto apprezzato.

Puoi testare il codice Befunge qui .

— Daniel
fonte
1
Passando un breve sguardo d'occhio: Befunge si avvolge, così puoi spostare gli ultimi 12 caratteri della seconda riga in primo piano e ottenere52**\28*++,@>~:0`!#^_\68*-
— Sp3000
@ Sp3000, oh non l'ho notato. Grazie!
— Daniel,
Congratulazioni per il tuo primo programma in assoluto! Una cosa da considerare sarebbe quella di generare grandi numeri spingendo i valori ASCII in una stringa. Confronta 567+*con "A". Inoltre, non dimenticare ge pistruzioni per riutilizzare un valore invece di doverlo costruire ripetutamente. Inoltre, non sono riuscito a trovare alcun input che avrebbe portato l'IP al ramo >$ 28* + , @. A cosa serve? Sei sicuro che sia necessario?
— tngreene,
Infine, ammiro la tua dedizione all'analisi di "26" o "08". Il tuo metodo, come l'ho letto, prevede molti simboli <-> conversione matematica dei numeri, come in (da '2' a 2 di nuovo a '2'). Avere il tuo primo e secondo input come numero prima di iniziare a confrontarli potrebbe ridurre la quantità di aritmetica ASCII che stai facendo. In alternativa, forse c'è un modo per gestire in modo efficiente gli input come simboli ('2' come in '2'), senza la conversione in numeri necessari!
— tngreene,
@tngreene, Gli input interi <10 vanno al ramo $28*+,@mentre quelli> = 10 vanno all'altro. Questo alla fine è stato fatto perché non è possibile leggere l'input più di una volta per quanto ne so.
— Daniel,
2

Brainfuck, 445 personaggi

Più una prova di concetto che un codice golfizzato. Richiede Brainfuck non firmato, non avvolgente.

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

Con commenti

,[>+>+<<-] Firstly Duplicate it across two buffers
>[<+>-] Move the second buffer back to the first buffer
>>++[->++++++<]>[-<<<+++++>>>] Establish 60 in the second buffer
<<<<
Compare Buffers 1 and 2
[->-<]
>
[ If there's still data in buffer 2
, Write the value in the units column to buffer two
<
++++
[->------------<] Subtract 12 from the units buffer
++++
[->>------------<<] Subtract 12 from the tens buffer
[-<<++++++++++>>] Multiply buffer three by ten into buffer 1
>
[-<+>] Add the units
>
[-<<++++++++++>>] Add the tens
>++ Add 65 to the buffer
[->++++++<]>+
[-<+++++>]
<- Actually we need 64 because A is 1
[-<<<+>>>] Add 64 to the first buffer
<<<
. Print the new letter
> Move to blank buffer
]
>
[ Otherwise we're a letter
[-<+<+>>] Copy it back over the first two buffers
>++ Write 64 to the buffer
[->++++++<]>+
[-<+++++>]
<-
[-<<->>] Subtract 64 from the letter
<<[->+>+<<]
>>>++++++++++< Copy pasted Division step x = current buffer y = 10 rest of the buffers are conveniently blank

+
[>[->+>+<<]>[-<<-[>]>>>[<[-<->]<[>]>>[[-]>>+<]>-<]<<]>>>+<<[-<<+>>]<<<]>>>>>[-<<<<<+>>>>>]<<<<<
-
[->+>+<<]
>[-<++++++++++>]
<[-<->]
++++
[-<++++++++++++>]
++++
[->>++++++++++++<<]
>>.<<<.>
]
— ATACO
fonte
2

Java, 104 98 97 83 54 53 51 50 30 byte

x->(x^=64)>64?(char)x+"":x+"";

Programma test :

IntFunction<String> f = x -> (x ^= 64) > 64 ? (char) x + "" : x + "";
out.println(f.apply('A')); // 1
out.println(f.apply('Z')); // 26
out.println((f.apply(1))); // A
out.println((f.apply(26))); //Z
— Shaun Wild
fonte
1
È possibile eliminare circa 20 byte utilizzando un operatore ternario in questo modo:return(s.matches("\\d+")?(char)(Integer.parseInt(s)+64)+"":(s.charAt(0)-64)+"");
— yitzih
puoi rimuovere anche il casting su int, che ti consente di ridurre di 7 byte.
— user902383
Il programma non accetta alcun input. Il programma non fornisce alcun output. Non c'è nemmeno nessun programma!
— Nicolas Barbulesco,
@NicolasBarbulesco Non è necessario scrivere un programma completo se non diversamente specificato.
— Shaun Wild,
1

R, 73 byte

f=function(x){L=LETTERS;if(is.numeric(x)){i=L[(x)]}else{i=which(L==x)};i}
— Mamie
fonte
Non ce n'è bisogno f=e tu cloud provi a usare la ifelsefunzione per golfare qualche byte!
— Frédéric,
1

MATL, 10 byte

6WZ~t42>?c

Spiegazione:

6W              % 2**6 = 64, but golfier looking
  Z~            % bit-wise XOR with input
    t42>?       % if result is greater than 42
         c      % convert it to a character 
                % else, don't

Provalo online! con input numerici.
Provalo online! con input alfabetici.

— coppa
fonte
1

Python 3, 49 48 53 50 byte

In qualche modo ho sbagliato il conteggio dei byte; _; grazie dahuglenny

isalpha è più corto di isnumeric

lambda x:x.isalpha()and ord(x)-64or chr(int(x)+64)

accetta l'input come stringa, che potrebbe essere una lettera o un numero

— Limone Distruttibile
fonte
1
È possibile rimuovere lo spazio tra x.isnumeric()e elseper salvare un byte.
— acrolith,
1

Java, 61 byte

int f(char c){return c^64;}char f(int i){return(char)(i^64);}

Ungolf'd:

int f(char c) {
    return c^64;
}

char f(int i) {
    return (char) (i^64);
}

La chiamata f('A')richiama la prima funzione, risintonizzando un int1; la chiamata f(1)richiama la seconda funzione, restituendo la char"A".

— AJNeufeld
fonte
`devi prendere un numero come input e produrre la corrispondente lettera dell'alfabeto, e viceversa. (1 <=> A, 2 <=> B) ecc. »Non credo che un insieme di funzioni sia idoneo per questo.
— Shaun Wild,
1
@SeanBean è un sovraccarico di funzioni.
— NoOneIsHere il
1
Questo non richiede alcun input. Questo non dà risultati. Non c'è programma!
— Nicolas Barbulesco,
Si supponga che l'ingresso sia "A" .. "Z" o "0" .. "9". Poiché una stringa è l'unica primitiva che può contenere (non sai quale sarà l'input), la tua funzione dovrebbe aspettarsi un argomento stringa.
— RobIII,
1

Javascript 86 77 66 60 byte

i=>typeof i<'s'?String.fromCharCode(i+64):i.charCodeAt(0)-64
  • salvato 7 byte dopo i commenti sull'utilizzo delle funzioni freccia
  • salvato altri 11 byte rimuovendo return / parentesi come notato da @manatwork
  • salvato altri 6 byte grazie a @manatwork
— Dylan Meeus
fonte
1
Usa le funzioni freccia
— Bald Bantha,
@BaldBantha evviva, lo ha cambiato :-)
— Dylan Meeus il
Non c'è bisogno di returndichiarazione: i=>typeof i=='number'?String.fromCharCode(i+64):i.charCodeAt(0)-64.
— arte
@manatwork Cheers!
— Dylan Meeus,
1
Secondo la descrizione typeofdell'attività, l' input può essere solo "numero" o "stringa". Quindi non c'è bisogno di controllare =='number', lo <'s'farà anche.
— arte
1

ASM: 10 byte 

3C 40 77 04 2C 40 EB 02 04 40

Spiegazione: Questa è la rappresentazione assemblata di un programma che fa esattamente ciò che viene richiesto. Non è completamente funzionale, perché ha bisogno di alcune direttive, ma se viene aggiunto al segmento di codice di un programma di assemblaggio dovrebbe funzionare. Riceve l'input nel registro AL e se è una lettera sottrae 40h dal valore del codice ASCII, lasciando solo il numero (cioè B = 42h, 42h-40h = 2h). Se l'input è un numero, esegue la procedura opposta aggiungendo 40 ore. Lascia il risultato nel registro AL. Di seguito è riportato il codice sorgente dell'assembly

cmp al,40h
ja letter_to_number
sub al,40h
jmp continue
letter_to_number: add ax,40h
continue:

Inoltre, se converti tutte le altre risposte in codice macchina, sono sicuro che la mia sarebbe la più piccola.

— 6a75616e
fonte
Penso che ci siano alcuni problemi: 77 02 2Cdovrebbe essere 77 **04** 2C; i sube addsono al contrario.
— ceilingcat,
Ho applicato le correzioni precedenti e ho creato una "funzione" che puoi chiamare da un programma C su una macchina x86_64. #define F(x) ((int(*)(int))"\x89\xf8\x3c\x40\x76\4\x2c\x40\xeb\2\4\x40\xc3")(x)
— ceilingcat,
Che tipo di assemblaggio è questo?
— mbomb007,
Turbo Assembler
— 6a75616e,
1

Japt , 11 byte

;BbU Ī´UgB

Provalo

;BbU Ī´UgB     :Implicit input of integer or string U
;B              :Uppercase alphabet
  bU            :0-based index of U (-1 if not found)
     Ä          :Add 1
      ª         :Logical OR with
       ´U       :Decrement U
         gB     :Index into the uppercase alphabet
— ispido
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.