Uscita sempre della stessa lunghezza

26

Con sfide come Output con la stessa lunghezza del codice e Crea output due volte la lunghezza del codice , ho pensato a una sfida separata, ma simile.

Il compito è produrre un output. Può essere una stringa, un elenco di caratteri o qualunque sia il formato di output predefinito del programma. Tuttavia, l'output deve sempre avere la stessa lunghezza, indipendentemente dall'input. E, soprattutto, l'output dovrebbe essere diverso per input diversi .

Ingresso

Un singolo numero intero , i cui intervalli sono determinati dalla scelta della lingua. Se la tua lingua ha numeri interi di lunghezza variabile, l'intervallo è .n-231≤n<231

Produzione

Una stringa o un elenco di caratteri o una stampa su STDOUT o STDERR. È possibile utilizzare solo uno di questi metodi. L'output deve avere la stessa lunghezza indipendentemente dall'input, ma spetta a te definire quale lunghezza è. L'output potrebbe non contenere i caratteri delle cifre 0-9o il segno meno- . L'output dovrebbe essere deterministico .

Dovresti essere in grado di dimostrare che per ogni output esiste un solo input possibile , tramite una prova formale, un argomento o una ricerca di forza bruta.

Questa è una domanda di golf del codice, quindi rasati eventuali byte estranei. Tutte le lingue sono benvenute, più meglio è!

code-golf  string  integer  hashing 
— maxb
fonte
4
Il programma in teoria dovrebbe funzionare per qualsiasi input? O è sufficiente utilizzare un metodo che funziona solo per l'intervallo specificato (limitato da ±231 ), non necessariamente a causa delle limitazioni della lingua ma delle limitazioni del metodo?
— Mr. Xcoder,
4
@ Mr.Xcoder come potresti scegliere una lunghezza se dovessi lavorare con numeri interi di lunghezza arbitraria?
— Stephen,
2
@ Mr.Xcoder Devi solo provare che funziona per quell'intervallo. Questa regola aiuta lingue come Python, dove i numeri possono essere migliaia di cifre. Senza quella regola, sarebbe molto più difficile sia per Python, sia per i derivati ​​Python (che include molti linguaggi del golf).
— max
11
Se una lingua non ha numeri interi di lunghezza variabile ma può supportare valori maggiori di , possiamo usare l'intervallo limitato ? 231-231≤n<231
— Arnauld,
2
@Arnauld l'intervallo massimo è numeri interi con segno a 32 bit, indipendentemente dai limiti della lingua. La lingua non può che diminuire tale intervallo.
— max

Risposte:

15

JavaScript (ES8), 33 byte

Prevede l'input nell'intervallo di numeri interi JS sicuri : .-253≤n<253

Restituisce una stringa di 76 caratteri.

n=>btoa(n.toString(2)).padEnd(76)

Provalo online!

Come?

Passo 1

L'input viene prima convertito in binario. Ciò preserva il segno meno principale per i numeri negativi.

Esempi:

  • 123 → "1111011"
  • -77 → "-1001101"

Passo 2

La stringa risultante è codificata in base-64.

Significa che ogni blocco da 1 a 3 caratteri verrà trasformato in un nuovo blocco di 4 caratteri. Questa conversione è sicura perché nessuno dei blocchi risultanti contiene i simboli proibiti (cifre o segno meno).

Blocchi di 3 caratteri

"-10" -> "LTEw" | "011" -> "MDEx"
"-11" -> "LTEx" | "100" -> "MTAw"
"000" -> "MDAw" | "101" -> "MTAx"
"001" -> "MDAx" | "110" -> "MTEw"
"010" -> "MDEw" | "111" -> "MTEx"

Un singolo blocco finale di 1 o 2 caratteri deve essere codificato se la lunghezza della stringa binaria non è un multiplo di 3:

Blocchi di 1 carattere

"0"   -> "MA==" | "1"   -> "MQ=="

Blocchi di 2 caratteri

"-1"  -> "LTE=" | "10"  -> "MTA="
"00"  -> "MDA=" | "11"  -> "MTE="
"01"  -> "MDE=" |

Passaggio 3

L'output finale è riempito con spazi finali.

— Arnauld
fonte
1
Sapevi già che queste particolari combinazioni di caratteri non contengono numeri quando convertite in base64 o lo hai scoperto sperimentalmente?
— Tomáš Zato - Ripristina Monica il
@ TomášZato Era un'ipotesi sicura, basata sul fatto che si tratta di un set di caratteri molto piccolo nella parte inferiore della tabella ASCII.
— Arnauld,
10

Python 3 , 49 39 byte

lambda i:[chr(ord(x)*2)for x in"%9x"%i]

Provalo online!

-10 byte grazie a sette negativi

Converte l'intero in esadecimale e antepone spazi fino a un massimo di 9 caratteri. Quindi, raddoppia il codice ASCII di ciascun carattere nella stringa (alcuni si estendono all'esterno di ASCII in Unicode, ma Python lo gestisce bene), producendo un elenco di caratteri.

Questo funziona perché ogni cifra, incluso -, è mappata su un diverso carattere ASCII. Nessun numero intero tra -2147483648e 2147483648uguali, quindi convertirli in spazi esadecimali e anteporre non li renderebbe uguali. Quindi, mapparli su punti di codice diversi non porta a collisioni, quindi non ci sono ancora due valori nell'intervallo che portano a risultati uguali.

Python 3 , 59 56 47 byte

lambda i:[*map(lambda x:chr(ord(x)*2),"%9x"%i)]

Provalo online!

-3 byte grazie a Jitse

-9 byte grazie a sette negativi

Stesso algoritmo, ma usando mapinvece di un forciclo.

— Stefano
fonte
2
È possibile radere 3 byte mapnell'approccio sostituendo list( ... )con[* ... ]
— Jitse il
3
È possibile creare la stringa imbottita con"%9x"%i
— negativo sette
@negativeseven grazie, è davvero geniale
— Stephen,
1
Potrebbe rimanere all'interno di ASCII e con 39 byte in Python 2 usando`4e9+n`
— Jonathan Allan il
8

05AB1E , 11 5 byte

тjÇ·ç

-6 byte porting l'approccio di @Stephen , quindi assicurati di votarlo!

Emette un elenco di massimo 100 caratteri, con 100-(lunghezza di input) quantità di 100 - ( lunghezza di input ) pari a @(raddoppia il punto di codice spazio) e tutti -0123456789mappati su Z`bdfhjlnpr(raddoppia i punti di codice ASCII).

Provalo online.

Spiegazione:

 j     # Prepend spaces in front of the (implicit) input-integer to make it of length:
т      # 100
  Ç    # Convert each character to its unicode value
   ·   # Double each
    ç  # And convert it back to a character
       # (after which the resulting list is output implicitly)

Risposta originale di 11 byte :

Ķ×AIdè«žIj

Provalo online (limitato a 1000anziché 2147483648).

Spiegazione:

La lunghezza dell'output è sempre lunga 2.147.483.648 caratteri. Sarà uscita 2147483648-|n|-1 quantità di spazi, aggiunta con |n|quantità di newline, aggiunta con 'a' se n<0 o 'b' se n≥0 .

Ä            # Get the absolute value of the (implicit) input-integer
 ¶×          # And have a string with that many newline characters
   A         # Push the lowercase alphabet
    Id       # Check if the input is non-negative (>=0) (1 if truthy; 0 if falsey)
      è      # Use that to index into the alphabet (so "a" for <0 and "b" for >=0)
       «     # Append that to the newline-string we created earlier
          j  # And prepend spaces to make the string of a length:
        žI   # 2147483648 (this has been replaced with `₄`/1000 in the TIO)
             # (after which the result is output implicitly)
— Kevin Cruijssen
fonte
7

brainfuck , 48 29 28 16 13 byte

Questo programma richiede celle, dove cn∈N , ma se si desidera risultati coerenti, assicurarsi che cn<256

L'output sarà ovviamente unico, indipendentemente dal numero che verrà inserito ( -∞<n<∞ ). Se l'intero è più corto, il programma completerà l'output in modo che corrisponda esattamente a ∞ byte, quindi la lunghezza è sempre la stessa.

Questa risposta risolve un po 'la sfida, in quanto non ha affermato che l'output deve essere limitato.

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

Provalo online!

Risposta originale a 28 byte:

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

28-1

— Krzysztof Szewczyk
fonte
L'output infinito non
— Jo King il
@JoKing questo è stato dichiarato dopo che ho fatto questa risposta. Ma se ti senti davvero ferito da questo, posso semplicemente rinunciare alla sfida e dichiarare la prima risposta come non competitiva
— Krzysztof Szewczyk,
5

Gelatina , 4 byte

œ?ØẠ

Un collegamento monadico che accetta un numero intero che produce un elenco di 52 caratteri.

-2223≤n<222352!>2224

Provalo online!

Come?

œ?ØẠ - Link: integer, n
  ØẠ - alphabet (Jelly's longest built-in character list containing no digits
     -           or hyphen) = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
œ?   - permutation at index (n) if all 52! permutations were written out
     - in lexicographical order.
     - This indexing is modular so when n = -x we fetch the (52!-x)th entry.

Così...

-2147483648 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONIGCDAMLJKFEHB
-2147483647 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONIGCDAMLJKFHBE
-2147483646 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONIGCDAMLJKFHEB
-2147483645 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONIGCDAMLJKHBEF
    ...
         -4 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDACB
         -3 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDBAC
         -2 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDBCA
         -1 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCAB
          0 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA
          1 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
          2 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxzy
          3 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwyxz
          4 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwyzx
    ...
 2147483644 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmrtxwznoqpsvyu
 2147483645 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmrtxwznoqpsyuv
 2147483646 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmrtxwznoqpsyvu
 2147483647 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmrtxwznoqpusvy
— Jonathan Allan
fonte
5

Rubino , 27 byte

->n{('%34b'%n).tr'01','ah'}

Provalo online!

('%34b'%n)Converte un numero intero nella sua rappresentazione binaria, usando ..1per indicare un numero negativo (questo significa che rappresenta un prefisso infinitamente lungo di 1 s), e lo sposta a sinistra di 34 caratteri usando gli spazi. Quindi sostituiamo la 0s con 'a' e la 1s con 'h' per creare la rappresentazione Maniacal Base 2: stringhe come "haaahahahaaha" precedute da spazi e talvolta ... Poiché ogni passaggio qui è invertibile, questo è 1: 1.

Modifica: lascia che il record mostri che @manatwork ha pubblicato prima questa soluzione identica. Ops. Avrei dovuto rinfrescarmi.

— histocrat
fonte
3
Lol. Il tuo output è molto più divertente del mio.
— Manatwork
4

C (gcc) , 38 byte

f(a,i){for(i=32;i--;putchar(a>>i&1));}

Provalo online!

Questo espande ogni bit dell'intero di input in un byte che è 0 o 1 (che sono entrambi caratteri non stampabili, ma non esiste alcuna regola al riguardo). Quindi l'output è sempre di 32 byte e garantito per essere unico.

— G. Sliepen
fonte
Approccio intelligente, simile all'imbottitura di risposta Brainfuck con byte NUL.
— max
Non sono sicuro che un programma che non termina sia davvero all'interno delle specifiche ... ma se lo è, 28 byte? f(a){putchar(a&1);f(a/2);}
— G. Sliepen,
Ho fatto un'eccezione per Malbolge, ma in generale il programma dovrebbe terminare. Avere "infinito" come lunghezza è un po 'un imbroglio.
— max
3

Haskell, 31 byte

map(\d->[d..]!!10).show.(+2^60)

Provalo online!

Aggiunge 2^60all'input in modo che il numero risultante abbia la stessa quantità di cifre per l'intero intervallo di input. Trasformalo in una stringa e sposta ogni carattere di 10 posizioni verso destra nell'ordine ASCII ( 0-> :... 9-> C).

— Nome del modello
fonte
1
Gestisce numeri negativi?
— max
@maxb: no, ma ora è stato risolto.
— nimi,
3

C # (compilatore interattivo Visual C #) , 52 byte

x=>(new char[32]).Select(y=>(char)(x%2+65+(x/=2)*0))

Provalo online!

Approccio diverso alla soluzione ac #, sfrutta il fatto che il modulo c # è negativo per i numeri negativi. Suppongo che potresti radere uno o due byte se consenti caratteri non visualizzati ('\ 0', e così via) aggiornando il +65...per non compensare il valore del carattere con qualcosa di leggibile dall'uomo.

— Andrew Baumher
fonte
44? - Sto inviando caratteri non stampabili (che sembra ok) ma potresti convertirli in stampabili aggiungendo 65 come la tua risposta attuale.
— dana,
1
42 - Questa volta con personaggi stampabili :)
— dana,
3

Perl 5 -MDigest::MD5=md5_hex -p , 23 byte

$_=md5_hex$_;y/0-9/k-t/

Provalo online!

In precedenza:

Perl 5 -p , 29 byte

$_=sprintf'%064b',$_;y/01/ab/

Provalo online!

Converte il numero alla sua rappresentazione binaria a 64 bit, traslittera 0e 1di ae b, rispettivamente.

— Xcali
fonte
5
E hai confermato che non ci sono collisioni per tutti gli input validi?
— Sparr,
... e che nessun hash md5 produce un carattere cifra per caso?
— AlexR,
Dimenticato l'obbligo di escludere le cifre. Ho aggiornato per adattarlo.
— Xcali,
— Grimmy,
2

T-SQL, 73 70 61 byte

SELECT TRANSLATE(STR(n,11),'-0123456789','ABCDEFGHIJK')FROM t

Sto solo sostituendo direttamente le cifre (e -) con le lettere, dopo i STRpad il numero intero a 11 caratteri. Non è necessaria alcuna conversione in esadecimale o binario.

TRANSLATE è stato introdotto in SQL 2017.

tnINT-231≤n<231

EDIT : salvato 3 byte sostituendo il riempimento manuale con una conversione in CHAR (11), che è un formato di carattere a larghezza fissa che si riempie automaticamente di spazi.

EDIT 2 : salvato 9 byte utilizzando la STR()funzione anziché CAST. STRconverte un numero in una stringa di testo imbottita per la lunghezza specificata.

— BradC
fonte
2

APL (Dyalog Unicode) , 28 byte

{11↑' Z'[⍵≤0],⎕A[⍎¨'¯'~⍨⍕⍵]}

Provalo online!

Dfn semplice, prendendo un argomento intero. Usi ⎕IO←0.

TIO si collega a un caso di test da -2^10a 2^10. La 0~⍨parte rimuove il duplicato 0dagli argomenti.

Come:

{11↑' Z'[⍵≤0],⎕A[⍎¨'¯'~⍨⍕⍵]} ⍝ Dfn
              ⎕A[         ]  ⍝ Index the Uppercase Alphabet with
                        ⍕⍵   ⍝ String representation of the argument
                   '¯'~⍨     ⍝ Without the character ¯
                 ⍎¨          ⍝ Executing each digit back into integers
             ,               ⍝ Prepend
    ' Z'[   ]                ⍝ A character from the string ' Z' indexed by
         ⍵≤0                 ⍝ Argument ≤ 0. Returns 1 if true, else 0.
                             ⍝ This will prepend a whitespace to positive numbers, and a Z otherwise.
 11↑                         ⍝ Take the first 11 characters, padding with whitespace.
— J. Sallé
fonte
2

Japt , 6 byte

Penso che sia giusto Ispirato dalla soluzione Python di Stephen, per favore, per favore +1.

¤ùI cÑ

Provalo

¤ùI cÑ     :Implicit input of integer
¤          :Convert to binary string
 ù         :Left pad with spaces
  I        :  To length 64
    c      :Map codepoints
     Ñ     :  Multiply by 2
— ispido
fonte
2

Malbolge , 2708 byte

∞

bP&A@?>=<;:9876543210/.-,+*)('&%$T"!~}|;]yxwvutslUSRQ.yx+i)J9edFb4`_^]\yxwRQ)(TSRQ]m!G0KJIyxFvDa%_@?"=<5:98765.-2+*/.-,+*)('&%$#"!~}|utyrqvutsrqjonmPkjihgfedc\DDYAA\>>Y;;V886L5322G//D,,G))>&&A##!7~5:{y7xvuu,10/.-,+*)('&%$#"yb}|{zyxwvutmVqSohmOOjihafeHcEa`YAA\[ZYRW:U7SLKP3NMLK-I,GFED&%%@?>=6;|9y70/4u210/o-n+k)"!gg$#"!x}`{zyxZvYtsrqSoRmlkjLhKfedcEaD_^]\>Z=XWVU7S6QPON0LKDI,GFEDCBA#?"=};438y6543s1r/o-&%*k('&%e#d!~}|^z]xwvuWsVqponPlOjihgIeHcba`B^A\[ZY;W:UTSR4PI2MLKJ,,AFE(&B;:?"~<}{zz165v3s+*/pn,mk)jh&ge#db~a_{^\xwvoXsrqpRnmfkjMKg`_GG\aDB^A?[><X;9U86R53ONM0KJC,+FEDC&A@?!!6||3876w4-tr*/.-&+*)('&%$e"!~}|utyxwvutWlkponmlOjchg`edGba`_XW\?ZYRQVOT7RQPINML/JIHAFEDC&A@?>!<;{98yw5.-ss*/pn,+lj(!~ff{"ca}`^z][wZXtWUqTRnQOkNLhgfIdcFaZ_^A\[Z<XW:U8SRQPOHML/JIHG*ED=%%:?>=~;:{876w43210/(-,+*)('h%$d"ca}|_z\rqYYnsVTpoRPledLLafIGcbE`BXW??TY<:V97S64P31M0.J-+G*(DCB%@?"=<;|98765.3210p.-n+$)i'h%${"!~}|{zyxwvuXVlkpSQmlOjLbafIGcbE`BXW??TY<:V97S64P31M0.J-+G*(D'%A@?"=<}:98y6543,1r/.o,+*)j'&%eez!~a|^tsx[YutWUqjinQOkjMhJ`_dGEaDB^A?[><X;9U86R53O20LKJ-HG*ED'BA@?>7~;:{y7x5.3210q.-n+*)jh&%$#"c~}`{z]rwvutWrkpohmPkjihafI^cba`_^A\[>YXW:UTS5QP3NM0KJ-HGF?D'BA:?>=~;:z8765v32s0/.-nl$#(ig%fd"ca}|_]yrqvYWsVTpSQmPNjMKgJHdGEa`_B]\?ZY<WVUTMR5PO20LK.IHA))>CB%#?87}}49zx6wu3tr0qo-nl*ki'hf$ec!~}`{^yxwvotsrUponQlkMihKIe^]EEZ_B@\?=Y<:V97S64P31M0.J-+GFE(C&A@?8=<;:{876w43s10qo-&%kk"'hf$ec!b`|_]y\ZvYWsVTpSQmlkNiLgf_dcba`C^]\?ZY;WV97SLK33HM0.J-+G*(D'%A$">!};|z8yw543t1r/(-,+*)(i&%fd"!~}|_t]xwvutslqTonmPkjLhKIeHFbEC_^A?[TSX;9UT7R4JIN1/K.,H+)E(&B%#?"~<}{987x/4ussr)p-,m*)ihh}$#d!awv{^\x[YuXVrUSonQlNdchKIeHFbaD_AWV[><X;988MRQ4O1GFK.,++@ED'B$:9>!};:9zy0wuut1*/p-,mk#"hh}$#"cb}v{^\\[vunWrqTonmOkjMLgf_HcbE`_A]@>ZY<:VONS64P31M0.J-+G*(D'%A$">!}||3876wv321*/p-,mk#"'hf$ec!b`|{^y[qpuXVUUjonQOkdchKIeHFbEC_B@\?=Y<:VUT76QPONG0KJ-HGFED'%A:9!!6;:9zy654321*q.-n+*j(ig%fd"ca}`^]]rwvYtVlkpSQmPNMMbgfIdF\[`_^A@[ZYXWVUNS6443NMLKJIHG@)DC&A@?!=<}|98765432+r/.-,+k#('&%e{dy~}|uzsx[vuXsrqpoRPledLLafedGF[`C^]\?ZY;W:8T7544INM0.JCBG*(''<A@#!=65:{yxx/43tr0)(-nlkk"'&ge#zy~a_^^sxwZXtmlqTRQQfkjMKg`_dcbEZ_B]\?=SRW:8T75Q42N1/KJ-+G@?D'%A$">!};|z87x5u-,1rp.-n+k#"'hfeez!~}`_t]xwvYtsUTTinmPNjcbgJHdGEa`_BW\?ZY<WVUTS64PIH00EJIH+*?(&&;@#!!~5:{87xv.-2sq/.om+$#(ig%$e"bxw|_]y\ZvuXsUkjoRPOOdihKfH^]bEC_^A\>TS;;PUTS65JO2MLK.,BA))>CBA$9>!}}|3z765v32r0/p-m%$)jh&ge#"c~`vuz][ZZotsVqSihmPNMMbgfIdF\[`CA@@UZY<W9ONS6433HML/J,BAF)'&&;@?"=}549zx6wutt+0/.on%l)('h%$d"ca}`^z][wvYtVlkpSQmPNjiLJf_^cFDCCX]\?=YRQV9766KPO20LEDI,*))>CB%#?87<}{9zx6wu3tr0/.o&m*)('&%fA/cQ>_^;]87%54"32pRA-yejih:s_GGFDDC^{i[T<XQ9b8r_5]O20Li-zB*SdQPO%##]nml43V1TvS@cs0/_'JJH#jhg%BTd!xw_{t99J6$tV21SBR@?kjcbtJ%^F"DD21]@[xfw;)9Nqq5Jmm~LKWVyx@E't&%:]][~YkF8hgv.tssOMp:&ml6Fi&D1T"y?,O<^s\7vX#Wr2}|Rzl+j<bK`r$F"4ZCk|\?-=RQ

Provalo online!

— Krzysztof Szewczyk
fonte
1
Essendo Malbolge, potrei lasciare che scivoli ... Ottimo lavoro!
— max
2

Perl 6 , 12 byte

*~|('@'x 11)

Provalo online!

Anonimo Qualunque lambda che prende un numero e lo stringa ORs con 11 @s. Questo mappa le cifre su pqrstuvwxye il trattino su m, quindi completa la stringa di 11 caratteri con @s

— Jo King
fonte
1

PHP , 64 54 byte

-10 byte utilizzando la strtrfunzione anziché la sostituzione manuale dei caratteri.

<?=str_pad(strtr($argn,'-0123456789',ADEFGHIJKLM),20);

Provalo online!

Il più grande valore int possibile in PHP fino ad ora è 9223372036854775807che è lungo 19 cifre, considerando il segno meno nei numeri negativi, sarà 20. Il codice sopra sostituisce il segno meno ( -) con il Acarattere e ogni cifra da 0a 9con un carattere da Da Me quindi riempie la stringa a destra con lo spazio per renderla sempre lunga 20 caratteri. Ad esempio, l'output per input di -9876543210è "AMLKJIHGFED ".

L'uscita è unico per ogni ingresso intero e si può tornare all'ingresso rimuovendo tutti gli spazi, sostituendo Acon -e sostituendo Da Mcon 0a 9.

PHP , 44 byte

<?=str_pad(base64_encode(decbin($argn)),88);

Provalo online!

Questa è la stessa idea della risposta di Arnauld . Converte l'input in binario, quindi lo converte in base-64. Lo riempie anche di 88 caratteri (la lunghezza massima è di -9223372036854775807cui 88 caratteri) con lo spazio carattere a destra per ottenere sempre la stessa lunghezza nell'output.

— night2
fonte
1

Retina 0.8.2 , 21 byte

T`p`l
$
10$*o
!`.{11}

Provalo online! Emette sempre 11 caratteri della serie n.. z. Spiegazione:

T`p`l

Traduci i caratteri ASCII stampabili in lettere minuscole. Questo mappe -a ne 0.. 9a q.. z. (È davvero una fortuna che le cifre siano i caratteri ASCII stampabili dal 16 al 25!)

$
10$*o

Aggiungi 10 os. Poiché l'input avrà tra 1 e 11 caratteri, ora ci sono tra 11 e 21 caratteri.

!`.{11}

Estrarre i primi 11 caratteri. Poiché ci sono meno di 22 caratteri, questo corrisponderà solo una volta.

— Neil
fonte
1

Carbone , 9 byte

◧⍘﹪ＮＸχχαχ

Provalo online! Il collegamento è alla versione dettagliata del codice. Emette sempre 10 spazi e lettere maiuscole. Spiegazione:

   Ｎ        Input as a number
  ﹪         Modulo
     χ      10
    Ｘ       To power
      χ     10
 ⍘     α    Convert to base 26 using uppercase letters
◧       χ   Left pad to length 10
— Neil
fonte
1

R , 37 byte

set.seed(scan())
cat(sample(LETTERS))

Provalo online!

26!=4⋅1026

232≈4⋅1094⋅102610-17232

1-exp⁡(-264/26!)≈0.99999998

che è abbastanza vicino a 1 per me.

— Robin Ryder
fonte
Anche se sì, è statisticamente improbabile che ci sia una collisione, ciò non significa che sia impossibile poiché la domanda richiede
— Jo King,
2
Mi piace il calcolo delle probabilità. Immagino che potresti passare attraverso tutti e 4 i miliardi di input se davvero volessi controllare le collisioni, ma se non ti va di farlo, potrei lasciarlo scivolare. Come è ora, hai presentato un argomento convincente e se qualcuno trova un controesempio, dovresti modificare la tua proposta.
— max
1

brainfuck , 20 19 byte

-1 byte grazie a Krzysztof Szewczyk

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

Provalo online!

Emette il numero con ogni cifra e trattino mappati a 255 meno il loro valore ordinale, arrotondati a 255 caratteri con byte NUL.

— Jo King
fonte
1
È possibile salvare un byte:-[>,[->-<]>.[-]<<-]
— Krzysztof Szewczyk il
1

R , 40 37 byte

cat(gsub("S","",intToBits(scan())>0))

Provalo online!

Un'alternativa alla risposta di Robin Ryder ; questo è certamente deterministico.

Questo converte l'input in un rawvettore di 32 byte, ogni byte è un numero esadecimale 00o 01rappresenta i bit dell'intero. Quindi forziamo a a logicalconfrontandolo con 0, quindi 00è mappato su FALSEe 01su TRUE. Quindi dobbiamo rimuovere una singola lettera da ciascuna FALSEper garantire un output di uguale lunghezza, arbitrariamente selezionato per essere S. Il risultato viene stampato (con spazio) per una lunghezza di 169.

— Giuseppe
fonte
1

Zsh , 43 byte

for c (${(s::)${(l:30::0:)1}})echo \\x$[#c]
               ${(l:30:0:)1}                 # left-pad with zeroes to 30 characters
        ${(s::)             }                # split characterwise
 for c (                     )               # for each character
                                      $[#c]  # get character code (in decimal)
                              echo \\x$[#c]  # interpret as hex code, print (with newline)

Provalo online!

Questa soluzione aggira i long longlimiti degli interi di Zsh lavorando con solo caratteri. L'ho riempito solo di 30 caratteri per leggibilità, ma la sostituzione 30con 99consentirà a questo metodo di funzionare su tutti i numeri da -1E99+1a1E100-1 .

L'effetto dell'interpretazione dei codici decimali come esadecimali è il seguente:

0 => 48 => H    1 => 49 => I    2 => 50 => P    3 => 51 => Q
4 => 52 => R    5 => 53 => S    6 => 54 => T    7 => 55 => U
8 => 56 => V    9 => 57 => W    - => 45 => E

Zsh , 46 byte

integer -i2 -Z66 x=$1
<<<${${x//[02-]/a}//1/b}

Provalo online!

Dichiara x come numero binario, con spaziatura zero fino a una larghezza di 66. Quindi mappa 0→ ae 1→ b. Mappiamo anche 2e -a, poiché quei caratteri sono stampati in [[-]][base]#[num]notazione. Per vedere come $xappare prima della sostituzione e i limiti di Zsh nell'analisi dei tipi interi, controlla l'output di debug nel collegamento TIO.

— GammaFunction
fonte
1

Java (JDK) , 42 byte

n->"".format("%8x",n).chars().map(i->i|64)

Provalo online!

Innanzitutto, questo crea la rappresentazione esadecimale dell'input, riempito a sinistra con spazi che fornisce lo stesso vincolo di lunghezza (lungo 8 caratteri), rimuove il segno meno e mantiene unico ogni output intermedio.

Questo dà una stringa con 17 diversi caratteri possibili: 0123456789abcdef e spazio.

Quindi ogni carattere viene riprodotto in streaming e mappato aggiungendo 64 al suo punto di codice se è una cifra o uno spazio. In effetti, ciò si traduce nella seguente mappatura: 0123456789abcdef<space>a pqrstuvwxyabcdef`cui hanno 17 caratteri diversi, quindi non ci saranno due numeri per lo stesso output.

— Olivier Grégoire
fonte
1

Bash , 30 byte

echo $1|md5sum|tr '0-9-' 'A-K'

Provalo online!

Per dimostrare che l'output è unico, ho appena cercato su Google le collisioni MD5 e non ho trovato risultati tra i numeri interi -231 e 231. Per evitare di avere caratteri proibiti nell'output, è sufficiente tradurre i caratteri in questione in lettere maiuscole. L'output ha sempre la stessa lunghezza per definizione e garantisce di non contenere caratteri proibiti.

— maxb
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.