Défi

Étant donné une chaîne non vide S de longueur L se composant entièrement de caractères ASCII imprimables, sortie une autre chaîne de longueur L qui est entièrement constitué de caractères ASCII imprimables, mais est différent de S .

Pour les besoins de ce défi, un caractère ASCII imprimable est un caractère compris entre U + 0020 et U + 007E inclus. c'est-à-dire de (espace) à ~(tilde). Les nouvelles lignes et les onglets ne sont pas inclus.

Par exemple, étant donné que "abcde"certaines sorties valides pourraient être:

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

Mais ceux-ci seraient invalides:

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

Cas de test

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

Règles

• Vous pouvez supposer que la saisie est entièrement composée de caractères imprimables ASCII.
• Vous ne pouvez pas supposer que l’entrée ne contient pas les 95 caractères imprimables.
• Vous pouvez supposer que l’entrée contient au moins un caractère et moins de 256 caractères.
• La sortie doit également être entièrement composée de caractères imprimables ASCII. Vous ne pouvez pas, par exemple, générer l'octet \ x7F pour l'entrée "~".
• La sortie doit être différente de l'entrée avec la probabilité 1; Autrement dit, vous pouvez générer des chaînes aléatoires jusqu'à ce que l'une d'elles soit différente de l'entrée, mais vous ne pouvez pas simplement générer L caractères aléatoires et espérer que ce soit différent.
• Les nouvelles lignes ne sont pas autorisées dans la sortie, mais vous pouvez générer une nouvelle ligne qui ne compte pas dans la chaîne.

Notation

C'est du code-golf , donc le code le plus court en octets dans chaque langue gagne.

Python 2 , 21 octets

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

Essayez-le en ligne!

Prend la représentation sous forme de chaîne de la chaîne en entrée et la tronque à la longueur de la chaîne en entrée. Pour une chaîne typique, cela le met entre 'guillemets et coupe la fin:

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

Notez que la nouvelle chaîne commence par '. Montrons que la sortie diffère toujours de l'entrée.

• Si l'entrée n'a pas ', la sortie commence par 'et l'entrée ne le fait pas.

• Si l'entrée contient un 'et mais non ", alors Python utilisera "les guillemets extérieurs en donnant un premier caractère "qui ne figure pas dans la chaîne d'entrée.

• Si l'entrée a les deux 'et ", alors les guillemets extérieurs sont 'et chacun 'est échappé comme \'. Où que le premier "apparaisse dans l'entrée, il est décalé de l'initiale 'dans la sortie et de toute fuite éventuelle. Cela signifie qu'il ne peut pas correspondre à a "dans la position correspondante dans la sortie.

Enfin, notez que le fait de citer l'entrée et éventuellement les caractères d'échappement augmente toujours le nombre de caractères. Par conséquent, le fait de tronquer la sortie lui donne la même longueur que l'entrée.

Notez qu'il était crucial que Python passe de manière adaptative à "dans le second cas. Sinon, la saisie à trois caractères échouerait '\'. Ou, tout préfixe plus long de la chaîne d'affichage du correctif à l' aide de '. Donc, cette méthode ne fonctionnera pas pour la plupart des langues.

05AB1E , 3 octets

ÇÈJ

Essayez-le en ligne!

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

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

Essayez-le en ligne!

-4 octets grâce à ETHProductions

-7 + -5 + -2 octets grâce à CalculatorFeline

-3 octets grâce à Rick Hitchcock

Déplace le premier caractère à la fin et le définit sur 0 s'il est numérique et différent de zéro, et sur 1 sinon.

Explication

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

Preuve

Parce que le deuxième caractère devient le premier, le troisième caractère devient le deuxième, etc. Tous les caractères doivent être identiques. Le dernier caractère restant ne peut être qu'un 0 ou un 1; le caractère répété doit donc être 0 ou 1. Mais toute chaîne de 0 génère un 1 à la fin, et inversement; par conséquent, il est impossible de créer une entrée égale à sa sortie. -ETHProductions

Voir les modifications des versions précédentes et des explications.

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

Gelée , 3 octets

~Ṿṁ

La sortie est une chaîne de chiffres, de virgules et de caractères très faibles, dont le premier caractère sera différent du premier.

Essayez-le en ligne!

Comment ça fonctionne

~Ṿṁ  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 octets

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

Essayez-le en ligne!

Convertit en une chaîne de Fet T. Ce qui importe est que les personnages Fet Tconvertis les uns aux autres. Ceci est fait en vérifiant si le caractère est inférieur Mà get Trueou False, puis en prenant le premier caractère de la représentation sous forme de chaîne.

Haskell , 23 octets

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

Essayez-le en ligne

Remplace chaque caractère par ~, sauf ~devient un espace.

Espaces blancs, 59 octets

Représentation visible

NSSNSSSTSSSSSNSNSSNSSNSTNTSTTTTSSTNTTSNSNSTSSSNSSSNTNSSNSNN

Ce qu'il fait:

Pour chaque caractère lu, il imprime un espace, sauf s'il s'agit d'un espace, il imprime ensuite un @.

Démontage:

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

MATL , 6 5 octets

Qo!V!

Essayez-le en ligne!

Explication

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 octets

Une fonction anonyme qui prend et retourne un String. Utiliser comme (map$(!!1).show.succ) "1111".

map$(!!1).show.succ

Essayez-le en ligne! (Utilisation du harnais de test de @ xnor.)

• Pour chaque caractère de la chaîne d'entrée, incrémente le caractère, le convertit au format littéral de caractère, puis prend le deuxième caractère du littéral, qui est le caractère juste après la 'citation de départ .
• Pour presque tous les caractères imprimables, il en résulte simplement le caractère incrémenté. Les exceptions sont &et ~, qui donnent à la place \, parce que leurs successeurs 'et \DELse sont échappés dans les littéraux de caractère.

05AB1E , 5 octets

žQDÀ‡

Essayez-le en ligne!

Explication

Remplace chaque caractère par le prochain caractère imprimable ascii, passant d’un tilde à l’espace.

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

V , 7 octets

íÁ/a
g?

Essayez-le en ligne! ou Vérifiez tous les cas de test!

Comment ça marche?

Considérez toutes les chaînes constituées d’ASCII imprimable. Chaque chaîne doit soit 1) contenir des caractères alphabétiques, ou 2) ne pas contenir de caractères alphabétiques.

Ce programme fonctionne donc en convertissant d'abord un caractère non alphabétique en 'a', puis en exécutant ROT13 sur la chaîne d'entrée.

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

C (gcc) , 22 octets

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

Prend un pointeur de chaîne et modie le premier caractère en place.

Essayez-le en ligne!

C (gcc) , 20 octets

Vu la réponse de Dennis, pensa à une amélioration essentielle de 2 octets.

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

Essayez-le en ligne! (Pied de page de Dennis.)

Comme l'original, modifie le premier caractère de la chaîne en place, mais la modifie avec sa valeur divisée par 3 (le plus petit nombre qui fonctionne. 2 échoue sur le caractère unique 'U'qui donne 127, non imprimable.)

Python 2 , 25 octets

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

Essayez-le en ligne!

Anders Kaseorg a sauvegardé un octet en extrayant le premier caractère de Trueou False.

Haskell, 30 26 octets

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

Essayez-le en ligne!

Remplace chaque caractère par son prédécesseur et l'espace par un tilde.

Octave , 19 18 octets

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

Essayez-le en ligne!

Explication:

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

l)iA%

Essayez-le en ligne!

Convertit le dernier caractère en son point de code et prend celui de modulo 10. Ceci est clairement différent pour les caractères non numériques situés en dernière position. Mais les chiffres commencent au point de code 48. Par conséquent, si vous prenez le mod 10, ils seront décalés cycliquement vers la gauche et le dernier caractère sera donc toujours changé.

Retina , 10 à 6 octets

4 octets joués au golf grâce à @Neil

T`p`~p

Essayez-le en ligne!

Ceci translittère vers ~, !vers , "vers !, ..., ~vers }.

Japt , 4 octets

®c v

Essayez-le en ligne!

Explication:

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

Cubix , 10 octets

..@|i?2%)O

Essayez-le en ligne! ou regardez-le courir!

Pour chaque caractère, imprime 1si le caractère a un point de code pair, 2sinon; 1a un point de code impair et 2un pair, ainsi la sortie ne sera jamais égale à l'entrée.

Explication

Ce code correspond au cube suivant:

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

L’IP (pointeur d’instruction) commence dans le coin supérieur gauche de la face extrême gauche et se dirige vers l’est. Il suit cette série d'instructions:

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 octets

#oi/
t i@

Essayez-le en ligne!

Explication

L'idée a été reprise de la soumission de Martin Ender à CJam. Le premier caractère est considéré comme un point de code, mod 10 réduit, et déplacé à la fin de la sortie. Comme exactement un caractère a été modifié, permuter les caractères ne peut pas avoir pour résultat de récupérer la même chaîne.

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

Q

Essayez-le en ligne!

Ceci convertit la chaîne donnée en liste de codes de caractères ASCII, les indexe (indexation modulaire) en alphabet majuscule, puis affiche le résultat. Essentiellement, chaque personnage nest mappé sur chr(ord(n) % 26 + 65). Vous pouvez utiliser ce programme pour voir comment fonctionne le mappage.

Le résultat:

• Aura toujours la même longueur que l'entrée, car les caractères sont directement mappés dans de nouveaux.
• Comprend toujours uniquement des caractères ASCII imprimables (car il ne contient que des lettres majuscules)
• Sera toujours différent de l’entrée, car il n’existe pas de caractère en entrée ntel que chr(ord(n) % 26 + 65) == n, pour que ce soit vrai, il doit exister un entier xtel que 26x = 65, pour lequel il n’existe aucune solution.

1 octet

q

Essayez-le en ligne!

Cette réponse est exactement la même, sauf qu'elle correspond à des caractères alphabétiques minuscules plutôt qu'à des caractères alphabétiques majuscules . Ceci est toujours valable car il n'y a aucun caractère d'entrée possible ntel que chr(ord(n) % 26 + 97) == n.

Brain-Flak , 53 octets

Comprend +1 pour -c

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

Cela décrémentera le premier caractère sauf s'il s'agit d'un espace. Dans ce cas, il incrémentera le premier caractère.

Essayez-le en ligne!

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

Gelée , 4 octets

^1Ṿ€

Affiche une chaîne de chiffres. Aucun caractère de sortie ne sera égal au caractère d'entrée correspondant.

Essayez-le en ligne!

Comment ça fonctionne

^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 \ -~ ~\ -}

Translittère les caractères en ~(0x20 - 0x7e) avec ~, puis en }(0x7e, 0x20 - 0x7d).

Essayez-le en ligne .

PHP, 30 27

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

Modifie chaque caractère égal au premier caractère avec le caractère dont le bit le moins significatif a été inversé.

Ruby , 20 + 1 = 21 octets

Utilise le -pdrapeau.

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

Essayez-le en ligne!

Remplace le premier caractère de l'entrée par un 0si c'est le cas 1ou 1autrement.

Brachylog , 9 octets

{¬Ṣ|∧Ịh}ᵐ

Essayez-le en ligne!

Explication

Ceci remplace tous les caractères par un espace, à l'exception des espaces qu'il remplace "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 octets

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

Essayez-le en ligne!

Golfscript, 3 octets

Essayez-le en ligne!

)5%

Prenez la valeur ASCII du dernier caractère modulo 5 et remplacez le dernier caractère par le résultat. Cela fonctionne évidemment pour les caractères non numériques, mais si le dernier caractère est un chiffre, il change également ("0" mod 5 = 3, "1" mod 5 = 4, etc.).

Cela fonctionnerait également avec 7 ou 9 tout en conservant la même longueur.

De plus, oui! J'ai une solution Golfscript aussi bonne que les meilleures solutions ici!

Funky , 26 à 22 octets

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

Calcule ~alequel pour les non-chiffres retournera NaN. La 1&limite ensuite à 0 ou 1, pour le chiffre 0, ce sera 1et pour 1ce sera 0. Donc, cette chaîne est toujours unique.

Essayez-le en ligne!