Io penso che qui non ci siano abbastanza domande facili da provare per i principianti!

La sfida: data una stringa di input casuale di 1 e 0 come:

10101110101010010100010001010110101001010

Scrivi il codice più breve che genera l'inverso bit-bit in questo modo:

01010001010101101011101110101001010110101

J, 5 byte

Presuppone che la stringa di input sia in variabile b.

b='0'

Questo non fa ciò che farebbe nella maggior parte delle lingue ...

L'operatore di confronto J è giusto =( =:e =.sono rispettivamente incarichi globali e locali). Tuttavia, =non funziona come il normale ==operatore: confronta articolo per articolo. Tenete a mente che una matrice è formata in questo modo: 0 2 3 2 3 1 2 3 4. 2 = 0 2 3 2 3 1 2 3 4dà 0 1 0 1 0 0 1 0 0ad esempio. Questo è simile per una stringa: 'a'='abcadcadda'non si limita a restituire 0, ma restituisce 1 0 0 1 0 0 1 0 0 1(può essere estrapolato per significare 0con */, il che significa sostanzialmente all). In questo caso, tuttavia, questo comportamento è eccellente, poiché vogliamo una stringa di uno e zeri, oppure vero e falso. Poiché i bool di J sono 1 e 0, ciò si traduce in una serie di 1'e'0(Non sono stringhe e ogni altro carattere diverso da quello 1comporterebbe anche 0questo array.) Non è necessario stampare: J stampa automaticamente il risultato di un'espressione. Spero che questa sia stata una spiegazione adeguata, in caso contrario, si prega di chiedere qualcosa che non è ancora chiaro nei commenti. Anche questa risposta avrebbe potuto essere '0'&=(o =&'0'), ma ho sentito che b='0'era più chiara.

GolfScript , 5 byte

{1^}%

Provalo online.

Come funziona

• GolfScript legge l'intero input da STDIN e lo posiziona nello stack come una stringa.

• {}% passa attraverso tutti i caratteri nella stringa ed esegue il blocco di codice per tutti loro.

• 1^ calcola l'OR esclusivo dei caratteri del codice ASCII con 1. “0” corrisponde al codice ASCII 48, “1” al codice ASCII 49.

  Da 48 ^ 1 = 49e 49 ^ 1 = 48, questo trasforma 0 in 1 e 1 in 0.

• Al termine, GolfScript stampa la stringa modificata.

CJam - 4

q1f^

Questo xor ha tutti i caratteri con 1.
A differenza dell'altra risposta di CJam, non presumo che l'input sia già nello stack.

Provalo su http://cjam.aditsu.net/

codice macchina x86 su DOS - 14 13 11 byte

Bene, è diventato di nuovo più corto! Dopo aver scritto una soluzione per una sfida non correlata , ho notato che lo stesso trucco poteva essere applicato anche qui. Quindi eccoci qui:

00000000  b4 08 cd 21 35 01 0a 86  c2 eb f7                 |...!5......|
0000000b

Assemblaggio commentato:

    org 100h

section .text

start:
    mov ah,8        ; start with "read character with no echo"
lop:
    ; this loop runs twice per character read; first with ah=8,
    ; so "read character with no echo", then with ah=2, so
    ; "write character"; the switch is performed by the xor below
    int 21h         ; perform syscall
    ; ah is the syscall number; xor with 0x0a changes 8 to 2 and
    ; viceversa (so, switch read <=> write)
    ; al is the read character (when we did read); xor the low
    ; bit to change 0 to 1 and reverse
    xor ax,0x0a01
    mov dl,al       ; put the read (and inverted character) in dl,
                    ; where syscall 2 looks for the character to print
    jmp lop         ; loop

Soluzione precedente - 13 byte

Penso che non sia molto più breve di questo.In realtà, lo ha fatto! Grazie a @ninjalj per aver rasato un altro byte.

00000000  b4 08 cd 21 34 01 92 b4  02 cd 21 eb f3           |...!4.....!..|
0000000d

Questa versione presenta l'interattività avanzata ™ - dopo averlo eseguito dalla riga di comando, sputa i caratteri "invertiti" fintanto che si scrivono le cifre di input (che non fanno eco); per uscire, basta fare un Ctrl-C.

A differenza della soluzione precedente, questo ha alcuni problemi nell'esecuzione in DosBox - poiché DosBox non supporta correttamente Ctrl-C , sei costretto a chiudere la finestra DosBox se vuoi uscire. In una VM con DOS 6.0, invece, funziona come previsto.

Fonte NASM:

org 100h

section .text

start:
    mov ah,8
    int 21h
    xor al,1
    xchg dx,ax
    mov ah,2
    int 21h
    jmp start

Vecchia soluzione - 27 25 22 byte

Questo ha accettato il suo input dalla riga di comando; funziona senza problemi come file .COM in DosBox.

00000000  bb 01 00 b4 02 8a 97 81  00 80 f2 01 cd 21 43 3a  |.............!C:|
00000010  1e 80 00 7c f0 c3                                 |...|..|

Input NASM:

    org 100h

section .text

start:
    mov bx, 1
    mov ah, 2
loop:
    mov dl, byte[bx+81h]
    xor dl, 1
    int 21h
    inc bx
    cmp bl, byte[80h]
    jl loop
exit:
    ret

Bash + coreutils, 8 byte

tr 01 10

Riceve input da STDIN.

O

sed, 8 byte

y/01/10/

CJam , 4 byte

:~:!

Presuppone che la stringa originale sia già nello stack. Stampa la stringa modificata.

Provalo online incollando il seguente codice :

"10101110101010010100010001010110101001010":~:!

Come funziona

• :~valuta ogni carattere della stringa, ovvero sostituisce il carattere 0 con il numero intero 0.

• :!calcola il NOT logico di ciascun numero intero. Questo trasforma 0 in 1 e 1 in 0.

Brainfuck ( 70 71)

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

Spiegazione:

>,[>,]                       Read characters until there are none left.
<[<]                         Return to start
>[<                          Loop as long as there are characters to invert
  +++++++[>-------<-]        Subtract 49 (ASCII value of 1)
  >[++<]                     If not 0, add 2
  +++[<++++>-]<[>>++++<<-]>> Add 48
  .                          Print
  [-]                        Set current cell to 0
>]                           Loop

PHP - 19 byte

<?=strtr($s,[1,0]);

Sì, non proprio originale, immagino!

Stack di pancake , 532 byte

Put this tasty pancake on top!
[]
Put this delicious pancake on top!
[#]
Put this  pancake on top!
How about a hotcake?
If the pancake is tasty, go over to "#".
Eat all of the pancakes!
Put this supercalifragilisticexpialidociouseventhoughtheso pancake on top!
Flip the pancakes on top!
Take from the top pancakes!
Flip the pancakes on top!
Take from the top pancakes!
Put this supercalifragilisticexpialidociouseventhoughthes pancake on top!
Put the top pancakes together!
Show me a pancake!
If the pancake is tasty, go over to "".

Presuppone che l'input sia terminato da un carattere null. La strategia è la seguente:

• Prendi un carattere di input
• Sottrai il valore ASCII di 1da esso.
• Sottrailo da 0(cedendo un 1se avessimo 0, o un 0se avessimo avuto 1)
• Aggiungi il valore ASCII di 0esso
• Stampa il carattere.
• Ripetere

C: 29

i(char*s){*s^=*s?i(s+1),1:0;}

Provalo online qui .

Grazie per aver segnalato il trucco XOR, Dennis.

Python 2.7 - 34 *

Oh quanto fa schifo questo primo. Abbastanza brutto, questo è. 63 caratteri.

print''.join([bin(~0)[3:] if x == '0' else bin(~1)[4:] for x in ''])

Questo è un po 'meglio ma non è poi così elegante. 44 caratteri.

print''.join([str(int(not(int(x)))) for x in ''])

Poiché int(x) and 1restituisce int(x)se non è 0 e in caso contrario Falso. La soluzione può essere ulteriormente ridotta a 36 caratteri.

print''.join([str(1-int(x)) for x in ''])

Poiché join()richiede un generatore, le parentesi possono essere rimosse. 32 caratteri.

print''.join(str(1-int(x))for x in'')

E i backtick possono essere usati invece di str()

print''.join(`1-int(x)`for x in'')

Ridotto a 44 da 34 grazie ai puntatori di @TheRare

Trovare il proprio complemento è difficile in Python poiché bin(-int)restituisce -0bxxx quindi quanto sopra.

Perl, 9 caratteri

'y/10/01/'

Il nono personaggio è la bandiera 'p'

Uso:

$ echo '10101001' | perl -pe 'y/10/01/'

Javascript ( ES6 ) 36

alert(prompt().replace(/./g,x=>x^1))

Labirinto , 6 byte

(Labyrinth è più recente di questa sfida, quindi questa risposta non compete, non che vince comunque ...)

1,
.$@

Questo codice presuppone che STDIN contenga solo le cifre (in particolare, nessuna nuova riga finale).

Il puntatore dell'istruzione (IP) inizia nell'angolo in alto a sinistra andando a destra. Mentre ci sono cifre da leggere, scorrerà a ciclo continuo attraverso il blocco 2x2 a sinistra: 1premi un 1, ,leggi una cifra, $XOR con 1 per alternare l'ultimo bit, .stampa il risultato. L'IP prende questo loop perché la parte superiore dello stack è positiva dopo l'XOR, in modo che prenderà una svolta a destra. Quando colpiamo EOF, ,ritorna -1invece. Quindi l'XOR produrrà -2e con questo valore negativo l'IP prende una svolta a sinistra @e il programma termina.

Questa soluzione dovrebbe essere ottimale per Labyrinth: è necessario ,e .per un loop I / O e @per terminare il programma. Sono necessari almeno due caratteri (qui 1e $) per attivare l'ultimo bit. E hai bisogno di almeno una nuova riga per un loop che può essere terminato.

A meno che ... se ignoriamo STDERR, ovvero consentiamo di terminare con un errore, possiamo salvare il @e inoltre non abbiamo bisogno di alcun modo per passare tra due percorsi. Continuiamo a leggere e stampare fino a quando non proviamo accidentalmente a stampare un valore negativo (il -2). Ciò consente almeno due soluzioni a 5 byte:

1,
.$

,_1$.

Rubino: 23 anni

p $<.read.tr("01","10")

Codice Turing Machine, 32 byte (1 stato - 3 colori)

Utilizzo della sintassi della tabella delle regole richiesta da questo simulatore di TM online. Preso in prestito da un post che ho pubblicato sul mio blog utente di Googology Wiki qualche mese fa.

0 0 1 r *
0 1 0 r *
0 _ _ * halt

Puoi anche testarlo usando questa implementazione java.

Python 2.x - 44 byte

print''.join(`1-int(x)`for x in raw_input())

Perché renderlo complesso o utilizzare alcune variabili economiche?

R, 27 caratteri

chartr("01","10",scan(,""))

Uso:

> chartr("01","10",scan(,""))
1: 10101110101010010100010001010110101001010
2: 
Read 1 item
[1] "01010001010101101011101110101001010110101"

APL (Dyalog Unicode) , 7 byte ^SBCS

Programma completo. Richiede stdin.

∊⍕¨~⍎¨⍞

Provalo online!

⍞ pronto stdin

⍎¨ eseguire ogni personaggio

~ NOT logico

⍕¨ formattare ogni carattere come testo

∊ ϵ nlist (appiattisci)

PHP> 5,4 - 37 caratteri

foreach(str_split($s) as $v)echo 1^$v

$s è l'input

Try it online

TI-BASIC, 7 byte

Questa è una funzione che accetta una stringa binaria (attraverso Ans) come input e restituisce l'output come stringa invertita (non invertita), come specificato. Per ulteriori informazioni, è possibile leggere l'applicazione dell'elenco tramite not(il wiki TI-BASIC. Sto usando la versione compilata perché è più piccola:

»*r>Õ¸r

In esadecimale:

BB 2A 72 3E D5 B8 72

Spiegazione

»*r - Prendi l'input della funzione come stringa e converti in elenco

> - Elenco di pipe fornite agli operatori successivi

Õ¸r - Restituisce l'inverso dell'elenco

Haskell, 22 byte

map(\c->"10"!!read[c])

Sono stato sorpreso dalla mancanza di soluzioni Haskell a questa sfida, quindi eccone una. Valuta una funzione che accetta una stringa e restituisce il suo inverso.

Spiegazione

Niente di speciale qui.

map(\c->             )  -- For each character c in the input string:
                  [c]   -- wrap c into a string,
              read      -- convert to integer,
        "10"!!          -- and index the string "10" with it.

Befunge 93, 25 byte

0>~1+:#v_$>:#,_@
 ^   -1<

Supponendo che stack vuoto ed EOF leggano entrambi -1.

0 invia un \ 0 come terminatore null

>~1+:#v_ è un ciclo di input, legge ascii, aggiunge 1, controlla EOF + 1 = 0,

^ -1< else sottrae 1 e lascia il valore ASCII spinto nello stack.

$>:#,_@ rilascia la copia aggiuntiva di zero in cima allo stack, quindi stampa la stringa binaria dall'alto verso il basso

Se lo stack vuoto legge 0, salvare 2 byte con

>~:1+#v_$>:#,_@
^   -1<

Una versione di circa 15 byte è possibile usando questo stesso algoritmo se EOF = 0, ma non ho una tale implementazione a portata di mano con cui testare.

Javascript ES6, 26 caratteri

s=>s.replace(/\d/g,x=>x^1)

Befunge-98 (PyFunge) , 7 byte

'a#@~-,

Per ogni carattere, cnell'input, stampa il carattere con un valore ASCII di94 - c , dove 94 è il valore di '0' + '1', o 'a'

Provalo online!

Python3, 39

Python non è la lingua migliore per questo. :)

for i in input():print(1-int(i),end='')

Se ti interessa avere una nuova riga dopo l'output, ecco un'alternativa di 43 caratteri:

print(''.join("01"[i<"1"]for i in input()))

J - 11 caratteri

I valori booleani in J sono rappresentati come numeri interi 0e 1, che ovviamente sono anche indici validi in array (in questo caso, l'array a 2 caratteri '01')

'01'{~'0'&=

C #, 131 byte

Un po 'tardi alla festa, ma ecco il mio. :)

using System;class R{static void Main(string[]a){foreach(var v in a[0].ToCharArray()){Console.Write(int.Parse(v.ToString())^1);}}}

MATLAB, 13 byte

@(x)[97-x '']

Dopo aver eseguito quanto sopra, basta chiamare la funzione con la stringa di input per ottenere la stringa invertita. Ad esempio in esecuzione:

ans('10101110101010010100010001010110101001010')

stampe:

01010001010101101011101110101001010110101

BotEngine , 4x8 = 32

Non competitiva poiché la lingua postdatizza la domanda.

Iv2 0 12
 >e>S SS
    e1e0
   ^< <P

Con evidenziazione: