Saída com o mesmo comprimento sempre

26

Em desafios como Saída com o mesmo tamanho do código e Criar saída com o dobro do tamanho do código , pensei em um desafio separado, mas semelhante.

A tarefa é produzir uma saída. Pode ser uma string, uma lista de caracteres ou qualquer que seja o formato de saída padrão do seu programa. No entanto, sua saída deve sempre ter o mesmo comprimento, independentemente da entrada. E mais importante, a saída deve ser diferente para diferentes entradas .

Entrada

Um único número inteiro , cujos intervalos são determinados pela escolha do idioma. Se o seu idioma tiver números inteiros de comprimento variável, o intervalo será .n231n<231

Saída

Uma sequência ou uma lista de caracteres ou uma impressão em STDOUT ou STDERR. Você pode usar apenas um desses métodos. A saída deve ter o mesmo comprimento, independentemente da entrada, mas cabe a você definir qual o comprimento. A saída pode não conter os caracteres de dígito 0-9ou o sinal de menos- . A saída deve ser determinística .

Você deve poder provar que, para cada saída, existe apenas uma entrada possível , seja por uma prova formal, um argumento ou uma busca por força bruta.

Esta é uma questão de código de golfe, portanto, retire todos os bytes estranhos. Todos os idiomas são bem-vindos, quanto mais, melhor!

maxb
fonte
4
O programa em teoria deve funcionar para qualquer entrada? Ou basta usar um método que funcione apenas para o intervalo especificado (delimitado por ±231 ), não necessariamente devido a limitações de idioma, mas a limitações de métodos?
Sr. Xcoder
4
@ Mr.Xcoder, como você poderia escolher um comprimento se tivesse que trabalhar com números inteiros arbitrários?
Stephen
2
@ Mr.Xcoder Você deve apenas provar que funciona para esse intervalo. Esta regra é para ajudar idiomas como Python, onde os números podem ter milhares de dígitos. Sem essa regra, seria muito mais difícil para os derivativos Python e Python (que inclui muitas linguagens de golfe).
maxb 16/08
11
Se um idioma não tiver números inteiros de comprimento variável, mas puder suportar valores maiores que , podemos usar o intervalo restrito ? 231231n<231
Arnauld
2
@Arnauld, o intervalo máximo é de números inteiros assinados em 32 bits, independentemente das limitações do idioma. O idioma pode apenas diminuir esse intervalo.
maxb

Respostas:

15

JavaScript (ES8), 33 bytes

Espera a entrada no intervalo de inteiros JS seguros : .-253n<253

Retorna uma sequência de 76 caracteres.

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

Experimente online!

Quão?

Passo 1

A entrada é primeiro convertida em binário. Isso preserva o sinal de menos à esquerda para números negativos.

Exemplos:

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

Passo 2

A sequência resultante é codificada na base-64.

Isso significa que cada bloco de 1 a 3 caracteres será transformado em um novo bloco de 4 caracteres. Essa conversão é segura porque nenhum dos blocos resultantes contém os símbolos proibidos (dígitos ou sinal de menos).

Blocos de 3 caracteres

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

Um único bloco final de 1 ou 2 caracteres deve ser codificado se o comprimento da cadeia binária não for múltiplo de 3:

Blocos de 1 caractere

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

Blocos de 2 caracteres

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

etapa 3

A saída final é preenchida com espaços à direita.

Arnauld
fonte
1
Você já sabia que essas combinações particulares de caracteres não contêm números quando convertidas em base64, ou você descobriu experimentalmente?
Tomáš Zato - Restabelecer Monica
@ TomášZato Esse foi um palpite confiante, com base no fato de ser um charset muito pequeno na parte inferior da tabela ASCII.
Arnauld
10

Python 3 , 49 39 bytes

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

Experimente online!

-10 bytes graças a sete negativos

Converte o número inteiro em hexadecimal e precede espaços com até 9 caracteres no total. Em seguida, duplica o código ASCII de cada caractere na string (alguns se estendem para fora do ASCII em Unicode, mas o Python lida com isso), produzindo uma lista de caracteres.

Isso funciona porque cada dígito, inclusive -, é mapeado para um caractere ASCII diferente. Nenhum número inteiro entre -2147483648e 2147483648é igual, portanto, convertê-los em espaços hexadecimais e anteriores não os tornaria iguais. Em seguida, o mapeamento para diferentes pontos de código não leva a colisões, portanto ainda não existem dois valores no intervalo que levam a saídas iguais.

Python 3 , 59 56 47 bytes

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

Experimente online!

-3 bytes graças ao Jitse

-9 bytes graças a sete negativos

O mesmo algoritmo, mas usando em mapvez de um forloop.

Stephen
fonte
2
Você pode cortar 3 bytes na mapabordagem substituindo list( ... )por[* ... ]
Jitse
3
Você pode criar a string acolchoada com"%9x"%i
negativa seven
@negativeseven obrigado, isso é realmente genial
Stephen
1
Poderia permanecer no ASCII e em 39 bytes no Python 2 usando`4e9+n`
Jonathan Allan
8

05AB1E , 11 5 bytes

тjÇ·ç

-6 bytes portando a abordagem de @Stephen , por isso não deixe de votar nele!

Produz uma lista de até 100 caracteres, com uma quantidade de 100-(comprimento de entrada) de @(o dobro do ponto de código do espaço) e todos -0123456789mapeados para Z`bdfhjlnpr(o dobro dos pontos de código ASCII).

Experimente online.

Explicação:

 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)

Resposta original de 11 bytes :

Ķ×AIdè«žIj

Experimente online (limitado a em 1000vez de 2147483648).

Explicação:

O comprimento da saída sempre tem 2.147.483.648 caracteres. Ele produzirá 2147483648-|n|-1 quantidade de espaços, anexada com |n|quantidade de novas linhas, anexada com um 'a' se n<0 0 ou 'b' se n0 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 bytes

Este programa requer células, onde cnN , mas se você deseja resultados consistentes, verifique se cn<256

A saída será obviamente única, independentemente do número que você digitar ( -<n< ). Se o número inteiro for menor, o programa preencherá a saída para corresponder exatamente a bytes, portanto o comprimento é sempre o mesmo.

Essa resposta está um pouco ultrapassando o desafio, pois não afirmava que a saída deveria ser finita.

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

Experimente online!


Resposta original de 28 bytes:

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

Este irá preencher a saída com exatamente 28-1 bytes. O mecanismo de conversão de números funciona da mesma maneira aqui. Este programa assume o mesmo que o programa acima.

Krzysztof Szewczyk
fonte
Saída infinita não
Jo King
@ JoKing isso foi afirmado depois que eu fiz esta resposta. Mas se você realmente se machucar com isso, posso simplesmente optar por não aceitar o desafio e declarar a primeira resposta como não competitiva
Krzysztof Szewczyk
5

Python 3 , 39 bytes

lambda n:f"{n:33b}".translate("abc"*99)

Experimente online!

Transforma o número fornecido em uma representação de sequência binária (preenchida com espaços) e mapeia os caracteres (space)-01para caabcom a str.translatefunção

sete negativos
fonte
5

Gelatina , 4 bytes

œ?ØẠ

Um link monádico que aceita um número inteiro que gera uma lista de 52 caracteres.

-2223n<222352!>2224

Experimente online!

Quão?

œ?ØẠ - 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.

Tão...

-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

Ruby , 27 bytes

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

Experimente online!

('%34b'%n)Converte um número inteiro em sua representação binária, usando ..1para indicar um número negativo (isto significa representar um prefixo infinitamente longo de 1s), e o coloca à esquerda em 34 caracteres usando espaços. Em seguida, substituímos 0s por 'a' e 1s por 'h' para criar a representação da base maníaca 2: strings como "haaahahahaaha" são precedidos por espaços e algumas vezes ... Como cada passo aqui é invertível, é 1: 1.

Editar: deixe o registro mostrar que a @manatwork postou esta solução idêntica primeiro. Opa Eu deveria ter me refrescado.

histocrata
fonte
3
Ri muito. Sua produção é muito mais engraçada que a minha.
manatwork
4

C (gcc) , 38 bytes

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

Experimente online!

Isso expande cada bit do número inteiro de entrada em um byte que é 0 ou 1 (que são caracteres não imprimíveis, mas não há regra contra isso). Portanto, a saída é sempre de 32 bytes e garantida como única.

G. Sliepen
fonte
Abordagem inteligente, semelhante ao preenchimento de resposta Brainfuck com bytes NUL.
maxb 17/08
Não tenho certeza se um programa que não termina é realmente dentro das especificações ... mas se for, 28 bytes? f(a){putchar(a&1);f(a/2);}
G. Sliepen
Eu fiz uma exceção para Malbolge, mas em geral o programa deve terminar. Ter "infinito" como o comprimento é meio que uma trapaça.
maxb 17/08
4

C # (compilador interativo do Visual C #) , 35 bytes

x=>$"{x,11}".Select(n=>(char)(n+n))

Experimente online!

Modalidade de ignorância
fonte
Falha x = int.MinValueporque não pode ser negado.
Hand-E-Food
1
@ Hand-E-Food Corrigido mudando para uma versão totalmente diferente
Modalidade de Ignorância
3

Haskell, 31 bytes

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

Experimente online!

Adiciona 2^60à entrada para que o número resultante tenha a mesma quantidade de dígitos para todo o intervalo de entrada. Transforme-se em uma string e mude cada caractere 10 lugares para a direita na ordem ASCII ( 0-> :... 9-> C).

nimi
fonte
1
Ele lida com números negativos?
maxb 16/08
@ maxb: não, mas agora está corrigido.
nimi 16/08
3

C # (compilador interativo do Visual C #) , 52 bytes

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

Experimente online!

Uma abordagem diferente da solução ac # aproveita o fato de que o módulo c # é negativo para números negativos. Suponho que você poderia cortar um byte ou dois se você permitir caracteres não exibidos ('\ 0' e assim por diante) atualizando o +65...para não compensar o valor do caractere para algo legível por humanos.

Andrew Baumher
fonte
44? - Estou imprimindo caracteres não imprimíveis (o que parece ok), mas você pode converter em imprimível adicionando 65 como sua resposta atual.
dana
1
42 - Desta vez com caracteres imprimíveis :)
dana
3

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

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

Experimente online!

Anteriormente:

Perl 5 -p , 29 bytes

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

Experimente online!

Converte o número em sua representação binária de 64 bits, depois translitera 0e 1para ae b, respectivamente.

Xcali
fonte
5
E você confirmou que não há colisões para todas as entradas válidas?
Sparr
... e que nenhum hash md5 produz um caractere de dígito por acaso?
AlexR
Esqueceu o requisito de excluir dígitos. Eu atualizei para acomodar isso.
Xcali
2

T-SQL, 73 70 61 bytes

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

Estou apenas substituindo diretamente os dígitos (e -) por letras, depois STRo número inteiro é preenchido com 11 caracteres. Nenhuma conversão para hexadecimal ou binária é necessária.

TRANSLATE foi introduzido no SQL 2017.

tnINT-231n<231

EDIT : economizou 3 bytes substituindo o preenchimento manual por uma conversão para CHAR (11), que é um formato de caractere de largura fixa que preenche automaticamente os espaços.

EDIT 2 : salvou 9 bytes usando a STR()função em vez de CAST. STRconverte um número em uma sequência de texto preenchida no comprimento especificado.

BradC
fonte
2

APL (Dyalog Unicode) , 28 bytes

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

Experimente online!

Dfn simples, usando um argumento inteiro. Usos ⎕IO←0.

O TIO vincula a um caso de teste de -2^10para 2^10. A 0~⍨parte remove a duplicata 0dos argumentos.

Quão:

{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

Japonês , 6 bytes

Eu acho que isso está certo. Inspirado na solução Python de Stephen, então, por favor +1.

¤ùI cÑ

Tente

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

Malbolge , 2708 bytes

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

Experimente online!

Krzysztof Szewczyk
fonte
1
Sendo Malbolge, posso deixar passar ... Trabalho fantástico!
maxb 17/08
2

Perl 6 , 12 bytes

*~|('@'x 11)

Experimente online!

Anônimo Qualquer que seja o lambda que pega um número e string ORs com 11 @s. Isso mapeia os dígitos para pqrstuvwxye o traço para m, em seguida, preenche a string com 11 caracteres com @s

Brincadeira
fonte
2

Perl 5 (-p), 9 bytes

$_^=A x$=

Experimente online!

Bitwxise-xor da entrada com a sequência AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.

Grimmy
fonte
2

Wolfram Language (Mathematica) , 44 33 bytes

Echo@Table[Or[i>#+13!,],{i,14!}]&

Experimente com um domínio menor

-2 graças a Greg Martin

>> 13!+n NullTrue14![-13!,14!-13!)[-231,231)

[-24,24)

attinat
fonte
Bom :) Acho que você pode salvar dois bytes alterando 2^31e 2^32para 13!e 14!respectivamente. Com a perda de alguma "brevidade" na saída ....
Greg Martin
1

Stax , 6 bytes

11){Hm

Execute e depure

Procedimento:

  1. Entrada do teclado esquerdo para 11 caracteres.
  2. Duplique cada caractere ascii não espacial.
recursivo
fonte
1

PHP , 64 54 bytes

-10 bytes usando a strtrfunção em vez da substituição manual de caracteres.

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

Experimente online!

O maior valor int possível no PHP a partir de agora é 9223372036854775807que tem 19 dígitos, considerando o sinal de menos em números negativos, será 20. O código acima substitui o sinal de menos ( -) pelo Acaractere e todos os dígitos de 0para 9com um caractere de Daté Me, em seguida, aperta a corda à direita com caracteres de espaço para sempre ter 20 caracteres. Por exemplo, a saída para entrada de -9876543210é "AMLKJIHGFED ".

A saída é exclusiva para cada entrada inteira e você pode retornar à entrada removendo todos os espaços, substituindo Apor -e substituindo Dpor Mcom 0por 9.


PHP , 44 bytes

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

Experimente online!

Essa é a mesma idéia que a resposta de Arnauld . Converte a entrada em binário e depois em base-64. Também possui 88 caracteres (o comprimento maior -9223372036854775807corresponde a 88 caracteres), com o caractere de espaço à direita para obter sempre o mesmo comprimento na saída.

Night2
fonte
1

Retina 0.8.2 , 21 bytes

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

Experimente online! Sempre envia 11 caracteres da gama n.. z. Explicação:

T`p`l

Converta os caracteres ASCII imprimíveis em letras minúsculas. Isso mapeia -para ne 0.. 9para q.. z. (É realmente uma sorte que os dígitos tenham entre 16 e 25 caracteres ASCII imprimíveis!)

$
10$*o

Acrescente 10 os. Como a entrada terá entre 1 e 11 caracteres, agora existem entre 11 e 21 caracteres.

!`.{11}

Extraia os 11 primeiros caracteres. Como existem menos de 22 caracteres, isso corresponderá apenas uma vez.

Neil
fonte
1

Carvão , 9 bytes

◧⍘﹪NXχχαχ

Experimente online! Link é a versão detalhada do código. Sempre gera 10 espaços e letras maiúsculas. Explicação:

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

R , 37 bytes

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

Experimente online!

26!=41026

232.41094102610-17232.

1-exp(-264/26!)0.99999998

que está perto o suficiente para 1 para mim.

Robin Ryder
fonte
Embora sim, é estatisticamente improvável que haja uma colisão, isso não significa que é impossível, conforme a pergunta pede
Jo King
2
Eu gosto do cálculo de probabilidade. Eu acho que você poderia percorrer todos os 4 bilhões de entradas se realmente quisesse verificar colisões, mas se não quiser fazer isso, eu posso deixar passar. No momento, você apresentou um argumento convincente e, se alguém encontrar um contra-exemplo, você precisará modificar seu envio.
maxb 17/08
1

brainfuck , 20 19 bytes

-1 byte graças a Krzysztof Szewczyk

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

Experimente online!

Gera o número com cada dígito e traço mapeado para 255 menos seu valor ordinal, preenchido com 255 caracteres com bytes NUL.

Brincadeira
fonte
1
Você pode salvar um byte:-[>,[->-<]>.[-]<<-]
Krzysztof Szewczyk
1

R , 40 bytes 37

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

Experimente online!

Uma alternativa à resposta de Robin Ryder ; isso é certamente determinístico.

Isso converte a entrada em um rawvetor de 32 bytes, cada byte sendo um número hexadecimal 00ou 01representando os bits do número inteiro. Em seguida, coagimos a a logicalcomparando com 0, portanto, 00é mapeado para FALSEe 01para TRUE. Em seguida, precisamos remover uma única letra de cada uma FALSEpara garantir uma saída de igual comprimento, selecionada arbitrariamente para ser S. O resultado é impresso (com espaço) para um comprimento de 169.

Giuseppe
fonte
1

Zsh , 43 bytes

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)

Experimente online!

Essa solução long longultrapassa os limites dos números inteiros do Zsh trabalhando apenas com caracteres. Eu preenchi apenas 30 caracteres para facilitar a leitura, mas a substituição 30por 99permitirá que esse método funcione em todos os números de -1E99+1até 1E100-1.

O efeito de interpretar os códigos decimais como hexadecimais são os seguintes:

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 bytes

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

Experimente online!

Declara x como um número binário, preenchido com zero para uma largura de 66. Em seguida, mapeia 0ae 1b. Também mapeamos 2e -para a, uma vez que esses caracteres são impressos em [[-]][base]#[num]notação. Para ver a $xaparência antes da substituição e os limites do Zsh na análise de tipos inteiros, verifique a saída Debug no link TIO.

GammaFunction
fonte
1

Java (JDK) , 42 bytes

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

Experimente online!

Primeiro, isso cria a representação hexadecimal da entrada, preenchida à esquerda com espaços que fornecem a mesma restrição de comprimento (8 caracteres), remove o sinal de menos e mantém cada saída intermediária exclusiva.

Isso fornece uma sequência com 17 caracteres possíveis diferentes: 0123456789abcdefe espaço.

Cada caractere é transmitido e mapeado adicionando 64 ao seu ponto de código, se for um dígito ou um espaço. Efetivamente, isso resulta no seguinte mapeamento: 0123456789abcdef<space>para o pqrstuvwxyabcdef`qual possui 17 caracteres diferentes, portanto, dois números não resultarão na mesma saída.

Olivier Grégoire
fonte