Desafío

Dada una cadena no vacía S de la longitud L compuesto enteramente de caracteres ASCII imprimibles, la salida de otra cuerda de longitud L que se compone enteramente de caracteres ASCII imprimibles, pero no es igual a S .

Para los propósitos de este desafío, un carácter ASCII imprimible es uno entre U + 0020 y U + 007E, inclusive; es decir, de (espacio) a ~(tilde). Las líneas nuevas y las pestañas no están incluidas.

Por ejemplo, dado "abcde", algunas salidas válidas podrían ser:

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

Pero estos serían inválidos:

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

Casos de prueba

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

Reglas

• Puede suponer que la entrada consiste completamente en caracteres ASCII imprimibles.
• No puede suponer que la entrada no contiene los 95 caracteres imprimibles.
• Puede suponer que la entrada contiene al menos un carácter y tiene menos de 256 caracteres de longitud.
• La salida también debe consistir completamente en caracteres ASCII imprimibles. No podría, por ejemplo, generar el byte \ x7F para la entrada "~".
• La salida debe ser diferente a la entrada con probabilidad 1; es decir, puede generar cadenas aleatorias hasta que una sea diferente a la entrada, pero no puede simplemente generar caracteres aleatorios L y esperar que sea diferente.
• Las nuevas líneas no están permitidas en la salida, pero puede generar una nueva línea final que no se cuenta hacia la cadena.

Puntuación

Este es el código de golf , por lo que gana el código más corto en bytes en cada idioma.

Python 2 , 21 bytes

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

Pruébalo en línea!

Toma la representación de cadena de la cadena de entrada y la trunca a la longitud de la cadena de entrada. Para una cadena típica, esto la pone entre 'comillas y cortes al final:

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

Tenga en cuenta que la nueva cadena comienza con '. Demostremos que la salida siempre difiere de la entrada.

• Si la entrada no tiene ', entonces la salida comienza con 'y la entrada no.

• Si la entrada contiene un 'y pero no ", entonces Python lo usará "para las comillas externas, dando un primer carácter "que no está en la cadena de entrada.

• Si la entrada tiene ambos 'y ", entonces las comillas externas son 'y cada una 'se escapa como \'. Dondequiera que "aparezca el primero en la entrada, se desplaza a la derecha por la inicial 'en la salida y por cualquier posible escape. Esto significa que no puede coincidir con a "en la posición correspondiente en la salida.

Finalmente, tenga en cuenta que citar la entrada y posiblemente escapar caracteres siempre aumenta el número de caracteres, por lo que truncar la salida hace que tenga la misma longitud que la entrada.

Tenga en cuenta que fue crucial que Python cambie adaptativamente "en el segundo caso. Si no lo hiciera, fallaría en la entrada de tres caracteres '\'. O bien, cualquier prefijo más largo del arreglo muestra la cadena usando '. Entonces, este método no funcionará para la mayoría de los idiomas.

05AB1E , 3 bytes

ÇÈJ

Pruébalo en línea!

Ç   # 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

Pruébalo en línea!

-4 bytes gracias a ETHProductions

-7 + -5 + -2 bytes gracias a CalculatorFeline

-3 bytes gracias a Rick Hitchcock

Mueve el primer carácter al final y lo establece en 0 si es numérico y distinto de cero, y 1 en caso contrario.

Explicación

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

Prueba

Debido a que el segundo carácter se convierte en el primero, el tercer carácter se convierte en el segundo, etc. todos los caracteres deberían ser idénticos. El último carácter restante solo puede ser un 0 o un 1, por lo que el carácter repetido tendría que ser 0 o 1. Pero cualquier cadena de 0 produce un 1 al final, y viceversa; por lo tanto, es imposible crear una entrada que sea igual a su salida. -ETHProducciones

Ver ediciones para versiones anteriores y explicaciones.

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"))

Jalea , 3 bytes

~Ṿṁ

La salida es una cadena de dígitos, comas y caracteres de menos, cuyo primer carácter diferirá del primer carácter de la cadena de entrada.

Pruébalo en línea!

Cómo 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')

Pruébalo en línea!

Convierte en una cadena de Fy T. Lo que importa es que los personajes Fy Tconversos entre sí. Esto se realiza comprobando si el carácter es menor que Mobtener Trueo False, y luego tomando el primer carácter de la representación de cadena.

Haskell , 23 bytes

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

Pruébalo en línea

Reemplaza cada personaje con ~, excepto que se ~convierte en un espacio.

Espacio en blanco, 59 bytes

Representación visible

NSSNSSSTSSSSSNSNSSNSSNSTNTSTTTTSSTNTTSNSNSTSSSNSSSNTNSSNSNN

Que hace:

Por cada personaje que lee, imprime un espacio, excepto cuando es un espacio, luego imprime una @.

Desmontaje

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!

Pruébalo en línea!

Explicación

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

Una función anónima que toma y devuelve a String. Usar como (map$(!!1).show.succ) "1111".

map$(!!1).show.succ

Pruébalo en línea! (Usando el arnés de prueba de @ xnor.)

• Para cada carácter en la cadena de entrada, incrementa el carácter, luego lo convierte al formato literal de caracteres, luego toma el segundo carácter del literal, que es el carácter justo después de la 'cita inicial .
• Para casi todos los caracteres imprimibles, esto da como resultado simplemente el carácter incrementado. Las excepciones son &y ~, que en cambio dan \, porque sus sucesores 'y \DELescapan en literales de caracteres.

05AB1E , 5 bytes

žQDÀ‡

Pruébalo en línea!

Explicación

Reemplaza cada char con el siguiente ascii char imprimible, envolviendo desde la tilde hasta el espacio.

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

V , 7 bytes

íÁ/a
g?

Pruébalo en línea! o Verifique todos los casos de prueba!

¿Como funciona?

Considere todas las cadenas que consisten en ASCII imprimible. Cada cadena debe 1) contener caracteres alfabéticos o 2) no contener caracteres alfabéticos.

Entonces, la forma en que funciona este programa es convirtiendo primero un carácter no alfabético 'a'y luego realizando ROT13 en la cadena 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;}

Toma un puntero de cadena y modifica el primer carácter en su lugar.

Pruébalo en línea!

C (gcc) , 20 bytes

Vio la respuesta de Dennis, pensó en una mejora esencial de 2 bytes.

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

Pruébalo en línea! (Pie de página por Dennis.)

Al igual que el original, modifica el primer carácter de la cadena en su lugar, pero lo divide con su valor dividido entre 3 (el número más pequeño que funciona. 2 falla en el carácter único 'U'que da 127, no imprimible).

Python 2 , 25 bytes

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

Pruébalo en línea!

Anders Kaseorg salvó un byte al extraer el primer personaje de Trueo False.

Haskell, 30 26 bytes

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

Pruébalo en línea!

Reemplaza cada carácter con su predecesor y espacio con tilde.

Octava , 19 18 bytes

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

Pruébalo en línea!

Explicación:

@(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%

Pruébalo en línea!

Convierte el último carácter en su punto de código y toma ese módulo 10. Esto es claramente diferente para los caracteres que no son dígitos en la última posición. Pero los dígitos comienzan en el punto de código 48, por lo que tomar esos mod 10 los desplazará a la izquierda cíclicamente y, por lo tanto, el último carácter siempre cambia.

Retina , 10 6 bytes

4 bytes de golf gracias a @Neil

T`p`~p

Pruébalo en línea!

Esto translitera a ~, !a , "a !, ..., ~a }.

Japt , 4 bytes

®c v

Pruébalo en línea!

Explicación:

®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

Pruébalo en línea! o ¡ Míralo correr!

Para cada carácter, imprime 1si el carácter tiene un punto de código par, de lo 2contrario; 1tiene un punto de código impar y 2un par, por lo que la salida nunca será igual a la entrada.

Explicación

Este código corresponde al siguiente cubo neto:

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

El IP (puntero de instrucción) comienza en la esquina superior izquierda de la cara del extremo izquierdo, hacia el este. Sigue esta serie de instrucciones:

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@

Pruébalo en línea!

Explicación

La idea fue tomada de la presentación de Martin Ender CJam. El primer carácter se toma como un punto de código, se reduce el mod 10 y se mueve al final de la salida. Dado que se cambió exactamente un carácter, la permutación de los caracteres no puede hacer que se recupere la misma cadena.

#   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

Pruébalo en línea!

Esto convierte la cadena dada en una lista de códigos de caracteres ASCII, los indexa (indexación modular) en el alfabeto en mayúsculas, luego imprime el resultado. Esencialmente, cada personaje nestá mapeado chr(ord(n) % 26 + 65). Puede usar este programa para ver cómo funciona el mapeo.

La salida:

• Siempre tendrá la misma longitud que la entrada, ya que los caracteres se asignan directamente a otros nuevos.
• Siempre incluirá solo caracteres ASCII imprimibles (ya que solo contiene letras mayúsculas)
• Siempre será diferente a la entrada, ya que no hay un carácter de entrada posible ntal que chr(ord(n) % 26 + 65) == n, para que esto sea cierto, debe haber un número entero xtal que 26x = 65no tenga solución.

1 byte

q

Pruébalo en línea!

Esta respuesta es exactamente la misma, excepto que se asigna a caracteres del alfabeto en minúsculas en lugar de caracteres del alfabeto en mayúsculas . Esto sigue siendo válido, ya que no hay caracteres de entrada posibles ncomo ese chr(ord(n) % 26 + 97) == n.

Brain-Flak , 53 bytes

Incluye +1 para -c

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

Esto disminuirá el primer carácter a menos que sea un espacio, en ese caso incrementará el primer carácter.

Pruébalo en línea!

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

Jalea , 4 bytes

^1Ṿ€

Emite una cadena de dígitos. Ningún carácter de salida será igual al carácter de entrada correspondiente.

Pruébalo en línea!

Cómo 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 los caracteres a ~(0x20 - 0x7e) con ~, luego a }(0x7e, 0x20 - 0x7d).

Pruébalo en línea .

PHP, 30 27

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

Cambia cada uno de los caracteres igual al primer carácter con el carácter que tiene el bit menos significativo invertido.

Ruby , 20 + 1 = 21 bytes

Usa la -pbandera.

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

Pruébalo en línea!

Reemplaza el primer carácter en la entrada con un 0si es 1, o de lo 1contrario.

Brachylog , 9 bytes

{¬Ṣ|∧Ịh}ᵐ

Pruébalo en línea!

Explicación

Esto reemplaza todos los caracteres por un espacio, excepto los espacios con los que reemplaza "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;

Pruébalo en línea!

Golfscript, 3 bytes

Pruébalo en línea!

)5%

Tome el valor ASCII del último carácter, módulo 5, y reemplace el último carácter con el resultado. Obviamente, esto funciona para caracteres que no son dígitos, pero si el último carácter es un dígito, también cambia ("0" mod 5 = 3, "1" mod 5 = 4, etc.).

Esto también funcionaría con 7 o 9 manteniendo la misma longitud.

Además, ¡yay! ¡Tengo una solución Golfscript tan buena como las mejores soluciones aquí!

Funky , 26 22 bytes

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

Calcula ~acuál de los no dígitos devolverá NaN. Luego lo 1&limita a 0 o 1, para el dígito 0, esto será 1, y para 1esto será 0. Entonces esta cadena siempre es única.

Pruébalo en línea!