Desafio

Dado um não-vazia cadeia S de comprimento L que consiste inteiramente de caracteres ASCII imprimível, a produção de outra cadeia de comprimento L que consiste inteiramente de caracteres ASCII imprimível, mas não é igual a S .

Para os propósitos deste desafio, um caractere ASCII imprimível é aquele entre U + 0020 e U + 007E, inclusive; isto é, de (espaço) a ~(til). Novas linhas e guias não estão incluídas.

Por exemplo, dado "abcde", algumas saídas válidas podem ser:

• "11111"
• "abcdf"
• "edcba"

Mas estes seriam inválidos:

• "abcde"
• "bcde"
• "abcde0"

Casos de teste

"asdf"
"1111"
"       "
"~~~~~"
"abcba"
"1"
" "
"~"
" ~"
"~ "
"  0"
"!@#$%^&*()ABCDEFGhijklmnop1234567890"
" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"

Regras

• Você pode assumir que a entrada consiste inteiramente em caracteres ASCII imprimíveis.
• Você não pode assumir que a entrada não contém todos os 95 caracteres imprimíveis.
• Você pode assumir que a entrada contém pelo menos um caractere e tem menos de 256 caracteres.
• A saída também deve consistir inteiramente em caracteres ASCII imprimíveis. Não foi possível, por exemplo, gerar o byte \ x7F para entrada "~".
• A saída deve ser diferente da entrada com probabilidade 1; isto é, você pode gerar seqüências aleatórias até que uma seja diferente da entrada, mas não pode simplesmente gerar caracteres aleatórios L e esperar que seja diferente.
• As novas linhas não são permitidas na saída, mas você pode gerar uma nova linha à direita que não é contada na sequência.

Pontuação

Isso é código-golfe , então o código mais curto em bytes em cada idioma vence.

Python 2 , 21 bytes

lambda s:`s`[:len(s)]

Experimente online!

Pega a representação da string de entrada e a trunca para o comprimento da string de entrada. Para uma sequência típica, isso coloca-a entre 'aspas e desbota:

abc  ->   'abc'  ->  'ab
     rep        chop

Observe que a nova string começa com '. Vamos mostrar que a saída sempre difere da entrada.

• Se a entrada não tiver ', a saída começará com 'e a entrada não.

• Se a entrada contiver um 'e mas não ", o Python usará "para as aspas externas, fornecendo um primeiro caractere "que não está na string de entrada.

• Se a entrada tiver ambos 'e ", as aspas externas serão 'e cada uma 'será escapada como \'. Onde quer que o primeiro "apareça na entrada, ele é deslocado para a direita pela inicial 'na saída e por qualquer possível escape. Isso significa que ele não pode corresponder a um "na posição correspondente na saída.

Por fim, observe que citar a entrada e, possivelmente, caracteres de escape sempre aumentam o número de caracteres, portanto, truncar a saída faz com que ela tenha o mesmo comprimento que a entrada.

Observe que era crucial que o Python alternasse adaptativamente "no segundo caso. Se não o fizesse, falharia na entrada de três caracteres '\'. Ou, qualquer prefixo mais longo da correção mostra a cadeia usando '. Portanto, esse método não funcionará na maioria dos idiomas.

05AB1E , 3 bytes

ÇÈJ

Experimente online!

Ç   # Convert to ASCII values
 È  # is even? (0 is 48 and 1 is 49 therefore 0 -> 1 and 1 -> 0)
  J # Join

JavaScript (ES6), 37 33 36 29 26 18 21 19 bytes

s=>s.slice(1)+ +!+s

Experimente online!

-4 bytes graças ao ETHProductions

-7 + -5 + -2 bytes graças ao CalculatorFeline

-3 bytes graças a Rick Hitchcock

Move o primeiro caractere para o final e o define como 0 se for numérico e diferente de zero e 1 caso contrário.

Explicação

s=>                    anonymous function with parameter s
                 +s    convert s to a number
                !      not (converts to boolean; relevant: 0->true,1->false)
               +       convert !+s back to number (true->1, false->0)
   s.slice(1)+         prefix the rest of the string
              ␣        needed to avoid the +s combining

Prova

Como o segundo caractere se torna o primeiro, o terceiro caractere se torna o segundo, etc. todos os caracteres teriam que ser idênticos. O último caractere restante pode ser apenas 0 ou 1, portanto, o caractere repetido deve ser 0 ou 1. Mas qualquer sequência de 0s produz um 1 no final e vice-versa; portanto, é impossível criar uma entrada igual à sua saída. -ETHProductions

Veja edições para versões anteriores e explicações.

f=
s=>s.slice(1)+ +!+s

console.log(f("000"))
console.log(f("111"))
console.log(f("001"))
console.log(f("110"))
console.log(f("~"))
console.log(f("111111111111111111111111111111111111111111111111111"))
console.log(f("Hello world!"))
console.log(f("23"))
console.log(f(" "))
console.log(f("1x"))

Gelatina , 3 bytes

~Ṿṁ

Saída é uma sequência de dígitos, vírgulas e caracteres de hífen-menos, cujo primeiro caractere será diferente do primeiro caractere da sequência de entrada.

Experimente online!

Como funciona

~Ṿṁ  Main link. Argument: s (string)

~    Map bitwise NOT over the characters c in s.
     This attempts to cast c to int and then apply bitwise NOT, mapping
     '0', ..., '9' to 0, ..., 9 (before ~), then -1, ..., -10 (after ~).
     For non-digits, the attempt fails, mapping c to 0.
 Ṿ   Uneval, yielding a comma-separated string of integers in [-10, ..., 0].
     The first character will be '-' if s starts with a digit and '0' if not.
  ṁ  Mold; truncate the result to the length of s.

Haskell , 20 bytes

map$head.show.(<'M')

Experimente online!

Converte em uma sequência de Fe T. O que importa é que os personagens Fe Tconvertidos para o outro. Isso é feito verificando se o caractere é menor do Mque get Trueor ou False, em seguida, obtendo o primeiro caractere da representação de string.

Haskell , 23 bytes

q '~'=' '
q _='~'
map q

Experimente online

Substitui todos os caracteres por ~, exceto ~se torna um espaço.

Espaço em branco, 59 bytes

Representação visível

NSSNSSSTSSSSSNSNSSNSSNSTNTSTTTTSSTNTTSNSNSTSSSNSSSNTNSSNSNN

O que faz:

Para cada caractere que lê, imprime um espaço, exceto quando é um espaço, e imprime um @.

Desmontagem:

loop:
    push 32
     dup
      dup
       dup
        ichr
       get
       sub
      jn not_32
     dup
      add
not_32:
     pchr
    jmp loop

MATL , 6 5 bytes

Qo!V!

Experimente online!

Explicação

Q     % Implicitly input a string. Add 1 to each code point.
o     % Parity: 0 if odd, 1 if even. Note that '0' has ASCII code 48, so after
      % having added 1 it now gives 1. Similarly. '1' has ASCII code 49, so it
      % now gives 0. All other chars give 0 or 1. 
!V!   % Convert each number to the corresponding char. Implicitly display

Haskell , 19 bytes

Uma função anônima que recebe e retorna a String. Use como (map$(!!1).show.succ) "1111".

map$(!!1).show.succ

Experimente online! (Usando o equipamento de teste do @ xnor.)

• Para cada caractere na sequência de entrada, incrementa o caractere, converte-o no formato literal do caractere e pega o segundo caractere do literal, que é o caractere logo após a 'citação inicial .
• Para quase todos os caracteres imprimíveis, isso resulta simplesmente no caractere incrementado. As exceções são &e ~, que em vez disso dão \, porque seus sucessores 'e \DELescapam em literais de caracteres.

05AB1E , 5 bytes

žQDÀ‡

Experimente online!

Explicação

Substitui cada caractere pelo próximo caractere ascii imprimível, passando de til para espaço.

žQ     # push a string of printable acsii chars (space to tilde)
  D    # duplicate
   À   # rotate left
    ‡  # translate

V , 7 bytes

íÁ/a
g?

Experimente online! ou Verifique todos os casos de teste!

Como funciona?

Considere todas as strings que consistem em ASCII imprimível. Cada string deve 1) conter caracteres alfabéticos ou 2) não conter caracteres alfabéticos.

Portanto, a maneira como esse programa funciona é primeiro convertendo um caractere não alfabético 'a'e, em seguida, executando o ROT13 na sequência de entrada.

í       " Substitute:
 Á      "   A non-alphabetic character ([^a-zA-Z])
  /     "   with
   a    "   the letter 'a'
g?      " Perform ROT13 on...
        "   (Implicit) the current line.

C (gcc) , 22 bytes

f(char*s){*s=65+*s%2;}

Pega um ponteiro de seqüência de caracteres e modifica o primeiro caractere no lugar.

Experimente online!

C (gcc) , 20 bytes

Viu a resposta de Dennis, pensou em uma melhoria essencial de 2 bytes.

f(char*s){*s^=*s/3;}

Experimente online! (Rodapé de Dennis.)

Como o original, modifica o primeiro caractere da string no lugar, mas o exorta com seu valor dividido por 3 (o menor número que funciona. 2 falha no caractere único 'U'que fornece 127, não imprimível).

Python 2 , 25 bytes

lambda s:`s<'T'`[0]+s[1:]

Experimente online!

Anders Kaseorg salvou um byte, extraindo o primeiro caractere de Trueou False.

Haskell, 30 26 bytes

f ' '='~'
f c=pred c
map f

Experimente online!

Substitui cada caractere por seu antecessor e espaço por til.

Oitava , 19 18 bytes

@(s)['',(s<66)+65]

Experimente online!

Explicação:

@(s)                 % Anonymous function taking a string s as input
         s<66        % A boolean vector with `1` for all characters below ASCII-66.
        (s<66)+65    % Add 65 to this, so that all elements that are 32-65 are now 66.
                     % All other elements are 65 
    ['',         ]   % Implicitly convert the list of 65 and 66 to the letters A and B

CJam , 5 bytes

l)iA%

Experimente online!

Converte o último caractere em seu ponto de código e leva esse módulo 10. Isso é claramente diferente para caracteres que não são dígitos na última posição. Mas os dígitos começam no ponto de código 48, portanto, pegar esses mod 10 mudará para a esquerda ciclicamente e, portanto, o último caractere é sempre alterado.

Retina , 10 6 bytes

4 bytes de golfe graças a @Neil

T`p`~p

Experimente online!

Isso translitera para ~, !para , "para !, ..., ~para }.

Japonês , 4 bytes

®c v

Experimente online!

Explicação:

®c v
®    At each char:
 c     Convert to its ASCII value
   v   Return 1 if divisible by 2, otherwise return 0

Cubix , 10 bytes

..@|i?2%)O

Experimente online! ou Assista correr!

Para cada caractere, imprime 1se o caractere tiver um ponto de código par, 2caso contrário; 1possui um ponto de código ímpar e 2um par, portanto a saída nunca será igual à entrada.

Explicação

Este código corresponde à seguinte rede de cubos:

    . .
    @ |
i ? 2 % ) O . .
. . . . . . . .
    . .
    . .

O IP (ponteiro de instrução) começa no canto superior esquerdo da face esquerda, indo para leste. Segue esta série de instruções:

i     Grab a char-code from STDIN and push it to the stack (-1 if there is no more input).
?     If the top item is negative, turn left and hit @ which ends the program.
      If it's positive (any printable ASCII char), turn right. The IP runs through a bunch
        of no-ops, then hits:
)     Increment the top item.
|     Mirror the IP's direction horizontally (turns it around).
)     Increment the top item again. The IP then wraps around again until it hits:
?     The top item is positive, so turn right.
2     Push a 2 to the stack.
%     Push the modulus of the top two items (0 for even char-code, 1 for odd).
)     Increment the result (now 1 for even char-code, 2 for odd).
O     Output as a number. The IP wraps back around to the i and the process starts again.

Alice , 9 bytes

#oi/
t i@

Experimente online!

Explicação

A idéia foi tirada da submissão de Martin Ender ao CJam. O primeiro caractere é tomado como um ponto de código, mod 10 reduzido e movido para o final da saída. Como exatamente um caractere foi alterado, a permutação dos caracteres não pode resultar na obtenção da mesma string de volta.

#   skip next command
o   (skipped)
i   push first byte onto stack
    STACK: [97]
/   reflect to SE, switch to ordinal mode (implicit reflect to SW)
i   push remaining input onto stack as string (implicit reflect to NW)
    STACK: [97, "sdf"]
o   output top of stack (implicit reflect to SW)
    STACK: [97]
t   implicitly convert code point to decimal string, and extract last character
    (implicit reflect to NE)
    STACK: ["9", "7"]
o   output this last digit (implicit reflect to SE)
i   push empty string, since there is no more input to take (implicit reflect to NE)
/   reflect to S, switch to cardinal mode
@   terminate

Pushy , 1 byte

Q

Experimente online!

Isso converte a sequência especificada na lista de códigos de caracteres ASCII, indexa-os (indexação modular) no alfabeto maiúsculo e depois imprime o resultado. Essencialmente, cada personagem né mapeado para chr(ord(n) % 26 + 65). Você pode usar este programa para ver como o mapeamento funciona.

A saída:

• Sempre terá o mesmo comprimento da entrada, pois os caracteres serão mapeados diretamente em novos.
• Sempre incluirá apenas caracteres ASCII imprimíveis (pois contém apenas letras maiúsculas)
• Sempre será diferente da entrada, pois não há um caractere de entrada possível, de nmodo que chr(ord(n) % 26 + 65) == n, para que isso seja verdade, deve haver um número inteiro xcomo aquele 26x = 65, para o qual não há solução.

1 byte

q

Experimente online!

Essa resposta é exatamente a mesma, exceto que ela é mapeada para caracteres do alfabeto em minúsculas , em vez de caracteres do alfabeto em maiúsculas . Isso ainda é válido, pois não há um caractere de entrada possível ncomo esse chr(ord(n) % 26 + 97) == n.

Brain-Flak , 53 bytes

Inclui +1 para -c

([(((()()()()){}){}){}()]({}())){{}(<({}[()()])>)}{}

Isso diminuirá o primeiro caractere, a menos que seja um espaço, nesse caso, incrementará o primeiro caractere.

Experimente online!

([(((()()()()){}){}){}()]      )                     # Push: input + 1 != 33 on top of...
                         ({}())                      #    input + 1
                                {{}(<          >)}{} # If (input + 1 != 33)
                                     ({}[()()])      #   Push: (input + 1) - 2

Gelatina , 4 bytes

^1Ṿ€

Emite uma sequência de dígitos. Nenhum caractere de saída será igual ao caractere de entrada correspondente.

Experimente online!

Como funciona

^1Ṿ€  Main link. Argument: s (string)

^1    XOR each character c in with 1.
      This attempts to cast c to int, mapping '0', ..., '9' to 0, ..., 9.
      For non-digits, the attempt fails, mapping c to 0.
      After XORing with 1, we get 1, 0, 3, 2, 5, 4, 7, 6, 9, 8 for '0', ..., '9', 
      and 1 for all non-digits.
  Ṿ€  Uneval each; mapping 0, ..., 9 to '0', ..., '9'. This yields a character
      array, which is Jelly's string type.
      Note that no character is mapped to itself.

Bash + coreutils, 13

tr \ -~ ~\ -}

Translitera os caracteres para ~(0x20 - 0x7e) com ~, depois para }(0x7e, 0x20 - 0x7d).

Experimente online .

PHP, 30 27

<?=strtr($a=$argn,$a,$a^1);

Altera cada caractere igual ao primeiro caractere pelo caractere que possui o bit menos significativo invertido.

Ruby , 20 + 1 = 21 bytes

Usa a -pbandeira.

sub(/./){$&=~/1/||1}

Experimente online!

Substitui o primeiro caractere na entrada por a, 0se estiver 1, ou 1não.

Braquilog , 9 bytes

{¬Ṣ|∧Ịh}ᵐ

Experimente online!

Explicação

Isso substitui todos os caracteres por um espaço, exceto os espaços com os quais ele substitui "0".

{      }ᵐ      Map on each char of the Input
 ¬Ṣ              The Input char is not " ", and the Output char is " "
   |             Or
    ∧Ịh          The Output char is "0"

PHP <7,1, 31 bytes

for(;~$c=$argn[$i++];)echo$c^1;

Experimente online!

Golfscript, 3 bytes

Experimente online!

)5%

Pegue o módulo 5 do valor ASCII do último caractere e substitua o último caractere pelo resultado. Obviamente, isso funciona para caracteres que não são dígitos, mas se o último caractere for um dígito, ele também será alterado ("0" mod 5 = 3, "1" mod 5 = 4, etc.).

Isso também funcionaria com 7 ou 9, mantendo o mesmo comprimento.

Além disso, yay! Eu tenho uma solução Golfscript tão boa quanto as melhores soluções aqui!

Funky , 26 22 bytes

s=>s::gsub("."a=>1&~a)

Calcula ~aque, para não dígitos, retornará NaN. Em seguida, 1&limita-o a 0 ou 1, para o dígito 0, este será 1e, para 1isso, será 0. Portanto, essa sequência é sempre única.

Experimente online!