Sfida

Data una stringa non vuoto S di lunghezza L costituito interamente da caratteri ASCII stampabili, uscita un'altra stringa di lunghezza L che consiste interamente di caratteri ASCII stampabili, ma non è uguale a S .

Ai fini di questa sfida, un carattere ASCII stampabile è compreso tra U + 0020 e U + 007E, incluso; cioè da (spazio) a ~(tilde). Newline e schede non sono inclusi.

Ad esempio, dato che "abcde"alcuni output validi potrebbero essere:

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

Ma questi non sarebbero validi:

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

Casi test

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

Regole

• Si può presumere che l'input sia costituito interamente da caratteri ASCII stampabili.
• Non si può presumere che l'input non contenga tutti i 95 caratteri stampabili.
• È possibile supporre che l'input contenga almeno un carattere e sia lungo meno di 256 caratteri.
• L'output deve inoltre consistere interamente di caratteri ASCII stampabili. Ad esempio, non è stato possibile emettere il byte \ x7F per l'input "~".
• L'output deve essere diverso dall'input con probabilità 1; cioè, puoi generare stringhe casuali fino a quando una è diversa dall'input, ma non puoi semplicemente emettere L caratteri casuali e sperare che sia diverso.
• Le nuove righe non sono consentite nell'output, ma è possibile generare una nuova riga finale che non viene conteggiata per la stringa.

punteggio

Questo è code-golf , quindi vince il codice più breve in byte in ogni lingua.

Python 2 , 21 byte

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

Provalo online!

Prende la rappresentazione di stringa della stringa di input e la tronca alla lunghezza della stringa di input. Per una stringa tipica, questo la mette tra 'virgolette e taglia la fine:

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

Si noti che la nuova stringa inizia con '. Mostriamo che l'output differisce sempre dall'input.

• Se l'ingresso non ha ', quindi l'uscita inizia 'e l'ingresso no.

• Se l'input contiene un 'e ma no ", Python userà "per le virgolette esterne, dando un primo carattere "che non è nella stringa di input.

• Se l'input ha entrambi 'e ", allora le virgolette esterne sono 'e ognuna 'viene salvata come \'. Ovunque il primo "appare nell'input, viene spostato a destra dall'iniziale 'nell'output e da ogni possibile escape. Ciò significa che non può corrispondere con a "nella posizione corrispondente nell'output.

Infine, nota che la citazione dell'input e l'eventuale escape dei caratteri aumenta sempre il numero di caratteri, quindi troncare l'output lo rende della stessa lunghezza dell'input.

Si noti che è stato fondamentale che Python passi in modo adattivo "nel secondo caso. Se così non fosse, fallirebbe con l'inserimento di tre caratteri '\'. Oppure, il prefisso più lungo della correzione mostra la stringa utilizzando '. Quindi, questo metodo non funzionerà per la maggior parte delle lingue.

05AB1E , 3 byte

ÇÈJ

Provalo 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 byte

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

Provalo online!

-4 byte grazie a ETHProductions

-7 + -5 + -2 byte grazie a CalculatorFeline

-3 byte grazie a Rick Hitchcock

Sposta il primo carattere alla fine e lo imposta su 0 se è numerico e diverso da zero, e 1 altrimenti.

Spiegazione

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

Poiché il secondo carattere diventa il primo, il terzo carattere diventa il secondo, ecc. Tutti i caratteri dovrebbero essere identici. L'ultimo carattere rimanente può essere solo 0 o 1, quindi il carattere ripetuto dovrebbe essere 0 o 1. Ma qualsiasi stringa di 0 produce un 1 alla fine e viceversa; pertanto, è impossibile creare un input uguale al suo output. -ETHProductions

Consulta le modifiche per le versioni precedenti e le spiegazioni.

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 byte

~Ṿṁ

L'output è una stringa di cifre, virgole e caratteri ipo-meno, il cui primo carattere differirà dal primo carattere della stringa di input.

Provalo online!

Come funziona

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

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

Provalo online!

Converte in una stringa di Fe T. Ciò che conta è che i personaggi Fe le Tconverte gli uni agli altri. Questo viene fatto controllando se il carattere è inferiore a quello Mdi ottenere Trueo False, quindi prendendo il primo carattere della rappresentazione di stringa.

Haskell , 23 byte

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

Provalo online

Sostituisce ogni personaggio con ~, tranne ~diventa uno spazio.

Spazio bianco, 59 byte

Rappresentazione visibile

NSSNSSSTSSSSSNSNSSNSSNSTNTSTTTTSSTNTTSNSNSTSSSNSSSNTNSSNSNN

Cosa fa:

Per ogni personaggio che legge stampa uno spazio, tranne quando è uno spazio, quindi stampa un @.

Smontaggio:

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

MATL , 6 5 byte

Qo!V!

Provalo online!

Spiegazione

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 byte

Una funzione anonima che accetta e restituisce a String. Usa come (map$(!!1).show.succ) "1111".

map$(!!1).show.succ

Provalo online! (Usando il cablaggio di prova di @ xnor.)

• Per ogni carattere nella stringa di input, incrementa il carattere, quindi lo converte nel formato letterale carattere, quindi prende il secondo carattere letterale, che è il carattere subito dopo la 'citazione iniziale .
• Per quasi tutti i caratteri stampabili, si ottiene semplicemente il carattere incrementato. Le eccezioni sono &e ~, che invece danno \, perché i loro successori 'e \DELscappano nei letterali dei personaggi.

05AB1E , 5 byte

žQDÀ‡

Provalo online!

Spiegazione

Sostituisce ogni carattere con il successivo carattere ASCII stampabile, avvolgendolo dalla tilde allo spazio.

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

V , 7 byte

íÁ/a
g?

Provalo online! oppure Verifica tutti i casi di test!

Come funziona?

Considera tutte le stringhe costituite da ASCII stampabile. Ogni stringa deve contenere 1) contenere caratteri alfabetici o 2) non contenere caratteri alfabetici.

Quindi il modo in cui funziona questo programma è prima convertendo un carattere non alfabetico in 'a', e quindi eseguendo ROT13 sulla stringa di input.

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

C (gcc) , 22 byte

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

Prende un puntatore a stringa e modifica il primo carattere in posizione.

Provalo online!

C (gcc) , 20 byte

Ho visto la risposta di Dennis, pensato a un miglioramento essenziale di 2 byte.

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

Provalo online! (Piè di pagina di Dennis.)

Come l'originale, modifica il primo carattere della stringa in atto, ma lo sopporta con il suo valore diviso per 3 (il numero più piccolo che funziona. 2 non riesce sul singolo carattere 'U'che dà 127, non stampabile.)

Python 2 , 25 byte

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

Provalo online!

Anders Kaseorg ha salvato un byte estraendo il primo carattere da Trueo False.

Haskell, 30 26 byte

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

Provalo online!

Sostituisce ogni carattere con il suo predecessore e lo spazio con la tilde.

Ottava , 19 18 byte

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

Provalo online!

Spiegazione:

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

l)iA%

Provalo online!

Converte l'ultimo carattere nel suo punto di codice e prende quel modulo 10. Questo è chiaramente diverso per i caratteri non numerici nell'ultima posizione. Ma le cifre iniziano dal punto di codice 48, quindi prendere quelle mod 10 le sposterà ciclicamente a sinistra e quindi l'ultimo carattere viene sempre cambiato.

Retina , 10 6 byte

4 byte giocati a golf grazie a @Neil

T`p`~p

Provalo online!

Questo si traduce in ~, !a , "a !, ..., ~a }.

Japt , 4 byte

®c v

Provalo online!

Spiegazione:

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

Cubix , 10 byte

..@|i?2%)O

Provalo online! o guardalo correre!

Per ogni carattere, stampa 1se il carattere ha un punto di codice pari, 2altrimenti; 1ha un punto di codice dispari e2 un pari, quindi l'output non sarà mai uguale all'input.

Spiegazione

Questo codice corrisponde alla seguente rete cubica:

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

L'IP (puntatore alle istruzioni) inizia nell'angolo in alto a sinistra della faccia dell'estrema sinistra, in direzione est. Segue questa serie di istruzioni:

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 byte

#oi/
t i@

Provalo online!

Spiegazione

L'idea è stata presa dalla presentazione della CJam di Martin Ender. Il primo carattere viene preso come punto di codice, ridotto mod 10 e spostato alla fine dell'output. Poiché è stato modificato esattamente un carattere, la permutazione dei caratteri non può comportare il recupero della stessa stringa.

#   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

Provalo online!

Questo converte la stringa data in un elenco di codici di caratteri ASCII, li indicizza (indicizzazione modulare) in alfabeto maiuscolo, quindi stampa il risultato. In sostanza, ogni personaggio nè mappato chr(ord(n) % 26 + 65). Puoi usare questo programma per vedere come funziona la mappatura.

L'output:

• Avrà sempre la stessa lunghezza dell'input, poiché i caratteri vengono mappati direttamente in nuovi.
• Comprenderà sempre solo caratteri ASCII stampabili (poiché contiene solo lettere maiuscole)
• Sarà sempre diverso dall'input, in quanto non è possibile alcun carattere di input in modo ntale che chr(ord(n) % 26 + 65) == n, affinché ciò sia vero, ci deve essere un numero intero xtale 26x = 65, per il quale non esiste soluzione.

1 byte

q

Provalo online!

Questa risposta è esattamente la stessa, tranne per il fatto che si associa a caratteri alfabetici minuscoli anziché a caratteri maiuscoli . Ciò è ancora valido in quanto non è possibile alcun carattere di input ntale chr(ord(n) % 26 + 97) == n.

Brain-Flak , 53 byte

Include +1 per -c

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

Questo diminuirà il primo carattere a meno che non sia uno spazio, in tal caso aumenterà il primo carattere.

Provalo online!

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

Gelatina , 4 byte

^1Ṿ€

Emette una stringa di cifre. Nessun carattere di output sarà uguale al carattere di input corrispondente.

Provalo online!

Come funziona

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

Trascrive i caratteri in ~(0x20 - 0x7e) con ~, quindi in }(0x7e, 0x20 - 0x7d).

Provalo online .

PHP, 30 27

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

Cambia ogni carattere uguale al primo carattere con il carattere che ha il bit meno significativo invertito.

Rubino , 20 + 1 = 21 byte

Usa la -pbandiera.

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

Provalo online!

Sostituisce il primo carattere nell'input con un 0se lo è 1, o 1altrimenti.

Brachylog , 9 byte

{¬Ṣ|∧Ịh}ᵐ

Provalo online!

Spiegazione

Questo sostituisce tutti i caratteri con uno spazio, ad eccezione degli spazi con cui sostituisce "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 byte

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

Provalo online!

Golfscript, 3 byte

Provalo online!

)5%

Prendi il valore ASCII dell'ultimo carattere modulo 5 e sostituisci l'ultimo carattere con il risultato. Questo ovviamente funziona con caratteri non numerici, ma se l'ultimo carattere è una cifra, cambia anche ("0" mod 5 = 3, "1" mod 5 = 4, ecc.).

Funzionerebbe anche con 7 o 9 mantenendo comunque la stessa lunghezza.

Inoltre, yay! Ho una soluzione Golfscript così come le migliori soluzioni qui!

Funky , 26 22 byte

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

Calcola ~aquale per le non cifre restituirà NaN. Quindi lo 1&limita a 0 o 1, per la cifra 0, questo sarà 1e per 1questo sarà 0. Quindi questa stringa è sempre unica.

Provalo online!