ฉันคิดว่ามีคำถามง่าย ๆ ไม่เพียงพอที่นี่ที่ผู้เริ่มต้นสามารถลอง!

ความท้าทาย: กำหนดสตริงอินพุตแบบสุ่มของ 1 และ 0 เช่น:

10101110101010010100010001010110101001010

เขียนโค้ดที่สั้นที่สุดที่ให้ผลในทางกลับกันแบบบิตฉลาด:

01010001010101101011101110101001010110101

J, 5 ไบต์

bถือว่าสายป้อนที่อยู่ในตัวแปร

b='0'

สิ่งนี้ไม่ได้ทำในภาษาส่วนใหญ่ ...

ตัวดำเนินการเปรียบเทียบ J เป็นเพียง=( =:และ=.เป็นระดับโลกและระดับท้องถิ่นตามลำดับ) อย่างไรก็ตาม=ไม่ทำงานเหมือน==โอเปอเรเตอร์ปกติ: มันเปรียบเทียบ item-by-item 0 2 3 2 3 1 2 3 4โปรดทราบว่าอาร์เรย์จะเกิดขึ้นเช่นนี้ 2 = 0 2 3 2 3 1 2 3 4ให้0 1 0 1 0 0 1 0 0ยกตัวอย่างเช่น สิ่งนี้คล้ายกับสตริง: 'a'='abcadcadda'ไม่เพียงแค่ส่งคืน0มันจะส่งคืน1 0 0 1 0 0 1 0 0 1(ซึ่งสามารถอนุมานได้ว่าหมายถึง0ด้วย*/ซึ่งโดยทั่วไปหมายถึงall) ในกรณีนี้อย่างไรก็ตามพฤติกรรมนี้เป็นเลิศเพราะเราต้องการสตริงของและศูนย์หรือ จริงและเท็จ ตั้งแต่ bools เจมี 1และ0นี้ส่งผลในอาร์เรย์ของ1'และ0(นั่นไม่ใช่สตริงและอักขระอื่นทุกตัวที่นอกเหนือจาก1นี้จะส่งผลให้ใน0อาร์เรย์นี้) ไม่จำเป็นต้องพิมพ์: J จะพิมพ์ผลลัพธ์ของนิพจน์โดยอัตโนมัติ ฉันหวังว่านี่เป็นคำอธิบายที่เพียงพอถ้าไม่โปรดขอสิ่งที่ยังไม่ชัดเจนในความคิดเห็น คำตอบนี้อาจเป็นไปได้'0'&=(หรือ=&'0') แต่ฉันรู้สึกว่าb='0'ชัดเจน

GolfScript 5 ไบต์

{1^}%

ลองออนไลน์

มันทำงานอย่างไร

• GolfScript อ่านอินพุตทั้งหมดจาก STDIN และวางลงบนสแต็กเป็นสตริง

• {}% ผ่านตัวละครทั้งหมดในสตริงและดำเนินการบล็อกรหัสสำหรับพวกเขาทั้งหมด

• 1^ คำนวณรหัส ASCII แบบเอกสิทธิ์เฉพาะบุคคลหรืออักขระด้วย 1“ 0” สอดคล้องกับรหัส ASCII 48,“ 1” ถึงรหัส ASCII 49

  ตั้งแต่48 ^ 1 = 49และ49 ^ 1 = 48สิ่งนี้จะเปลี่ยน 0 เป็น 1 และ 1 เป็น 0

• เมื่อเสร็จแล้ว GolfScript จะพิมพ์สตริงที่ถูกดัดแปลง

CJam - 4

q1f^

xor นี้เป็นตัวละครทุกตัวที่มี 1
ซึ่งแตกต่างจากคำตอบ CJam อื่น ๆ ฉันไม่ได้สมมติว่าอินพุตอยู่ในสแต็ก

ลองที่http://cjam.aditsu.net/

รหัสเครื่อง x86 บน DOS - 14 13 11 ไบต์

มันสั้นลงอีกแล้ว! หลังจากเขียนวิธีแก้ปัญหาสำหรับความท้าทายที่ไม่เกี่ยวข้องฉันสังเกตเห็นว่าสามารถใช้กลอุบายแบบเดียวกันได้ที่นี่ ดังนั้นเราไปที่นี่:

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

ประกอบความเห็น:

    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

โซลูชันก่อนหน้า - 13 ไบต์

ฉันคิดว่ามันไม่ได้สั้นไปกว่านี้อีกมากจริงๆแล้วมันทำ! ขอบคุณ @ninjalj สำหรับการลบทิ้งอีกหนึ่งไบต์

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

รุ่นนี้มีการโต้ตอบขั้นสูง™ - หลังจากเรียกใช้จากบรรทัดคำสั่งมันจะคายอักขระ "คว่ำ" ตราบเท่าที่คุณเขียนตัวเลขอินพุต (ซึ่งไม่ได้สะท้อน); เพื่อออกเพียงแค่กด Ctrl-C

ซึ่งแตกต่างจากโซลูชันก่อนหน้านี้มีปัญหาในการทำงานใน DosBox - เนื่องจาก DosBox ไม่สนับสนุน Ctrl-C อย่างถูกต้องคุณจะถูกบังคับให้ปิดหน้าต่าง DosBox หากคุณต้องการออก ใน VM ด้วย DOS 6.0 แต่จะทำงานตามที่ต้องการ

แหล่งที่มาของ NASM:

org 100h

section .text

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

โซลูชั่นเก่า - 27 25 22 ไบต์

สิ่งนี้ยอมรับอินพุตจากบรรทัดคำสั่ง ทำงานอย่างราบรื่นเป็นไฟล์. COM ใน 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                                 |...|..|

อินพุต 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 ไบต์

tr 01 10

รับอินพุตจาก STDIN

หรือ

sed, 8 ไบต์

y/01/10/

CJam , 4 ไบต์

:~:!

ถือว่าสตริงเดิมอยู่ในสแต็กแล้ว พิมพ์สตริงที่แก้ไข

ลองออนไลน์โดยวางรหัสต่อไปนี้:

"10101110101010010100010001010110101001010":~:!

มันทำงานอย่างไร

• :~ประเมินอักขระแต่ละตัวของสตริงกล่าวคือแทนที่อักขระ 0 ด้วยจำนวนเต็ม 0

• :!คำนวณ NOT ตรรกะของแต่ละจำนวนเต็ม นี่จะเปลี่ยน 0 เป็น 1 และ 1 เป็น 0

Brainfuck ( 70 71)

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

คำอธิบาย:

>,[>,]                       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 ไบต์

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

ใช่ไม่ใช่ต้นฉบับจริงๆฉันเดา!

Pancake Stackขนาด 532 ไบต์

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

มันจะถือว่าอินพุตถูกยกเลิกด้วยอักขระ null กลยุทธ์มีดังนี้:

• ใช้อักขระของอินพุต
• ลบค่า ascii ของ1จากมัน
• ลบออกจาก0(ให้ผล1ถ้าเรามี0หรือ0ถ้าเรามี1)
• เพิ่มค่า ascii ของ0มัน
• พิมพ์ถ่าน
• ทำซ้ำ

C: 29

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

ลองออนไลน์ได้ที่นี่

ขอบคุณที่ชี้ให้เห็นถึงเคล็ดลับ XOR Dennis

Python 2.7 - 34 *

โอ้อันแรกมันดูดแค่ไหน ค่อนข้างน่าเกลียดอันนี้คือ 63 ตัวอักษร

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

อันนี้ค่อนข้างดีกว่า แต่ก็ไม่แฟนซีเลย 44 ตัวอักษร

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

เนื่องจากint(x) and 1ส่งคืนint(x)ถ้าไม่ใช่ 0 และมิฉะนั้นเป็นเท็จ วิธีการแก้ปัญหาสามารถลดลงได้ถึง 36 ตัวอักษร

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

เนื่องจากjoin()ใช้ตัวกำเนิดไฟฟ้าสามารถลบวงเล็บได้ 32 ตัวอักษร

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

และสามารถใช้ backticks แทน str()

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

ลดลงเหลือ 44 จาก 34 ด้วยตัวชี้จาก @TheRare

การค้นหาส่วนประกอบของตัวใดตัวหนึ่งเป็นเรื่องยากในไพ ธ อนเนื่องจากbin(-int)ส่งกลับค่า -0bxxx ดังนั้นจึงเป็นข้างต้น

Perl, 9 ตัวอักษร

'y/10/01/'

อักขระที่ 9 คือการตั้งค่าสถานะ 'p'

การใช้งาน:

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

Javascript ( ES6 ) 36

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

เขาวงกต 6 ไบต์

(เขาวงกตนั้นใหม่กว่าความท้าทายนี้ดังนั้นคำตอบนี้จะไม่แข่งขัน - ไม่ใช่ว่ามันจะชนะอยู่ดี ... )

1,
.$@

รหัสนี้อนุมานว่า STDIN มีเฉพาะตัวเลข (โดยเฉพาะอย่างยิ่งไม่มีการขึ้นบรรทัดใหม่)

ตัวชี้คำแนะนำ (IP) เริ่มต้นที่มุมซ้ายบนไปทางขวา ในขณะที่มีตัวเลขที่จะอ่านมันจะวนเป็นวงวนแน่นผ่านบล็อก 2x2 ทางซ้าย: 1กด 1 ,อ่านตัวเลข$XOR ด้วย 1 เพื่อสลับบิตสุดท้าย.พิมพ์ผลลัพธ์ IP ใช้ลูปนี้เนื่องจากด้านบนสุดของสแต็กเป็นบวกหลังจาก XOR เช่นนั้นจะเลี้ยวขวา เมื่อเรากด EOF ให้,ส่งคืน-1แทน จากนั้น XOR จะให้ผลลัพธ์-2และด้วยค่าลบนี้ IP จะเลี้ยวซ้ายเข้าสู่@และโปรแกรมจะสิ้นสุดลง

วิธีการแก้ปัญหานี้ควรจะดีที่สุดสำหรับเขาวงกต: คุณต้องการ,และ.สำหรับ I / O วนและ@เพื่อยุติโปรแกรม คุณต้องมีอักขระอย่างน้อยสองตัว (ที่นี่1และ$) เพื่อสลับบิตสุดท้าย และคุณต้องการ newline อย่างน้อยหนึ่งรายการสำหรับลูปที่สามารถยกเลิกได้

เว้นแต่ ... ถ้าเราเพิกเฉย STDERR นั่นคืออนุญาตให้ยกเลิกด้วยข้อผิดพลาดที่เราสามารถบันทึกได้@และเราก็ไม่จำเป็นต้องสลับไปมาระหว่างสองเส้นทาง เราแค่อ่านและพิมพ์ต่อไปเรื่อย ๆ จนกว่าเราจะพยายามพิมพ์ค่าลบ ( -2) สิ่งนี้ช่วยให้โซลูชัน 5 ไบต์อย่างน้อยสองตัว:

1,
.$

,_1$.

ทับทิม: 23

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

รหัสเครื่องจักรทัวริง 32 ไบต์ (1 สถานะ - 3 สี)

การใช้ไวยากรณ์ตารางกฎที่ต้องการโดยโปรแกรมจำลอง TM ออนไลน์นี้ ยืมมาจากโพสต์ที่ฉันทำกับบล็อกผู้ใช้ของ Google Googology Wiki ไม่กี่เดือนหลัง

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

คุณสามารถทดสอบสิ่งนี้ได้โดยใช้การติดตั้งจาวานี้

Python 2.x - 44 ไบต์

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

ทำไมต้องทำให้มันซับซ้อนหรือใช้ตัวแปร cheaty?

R, 27 ตัวอักษร

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

การใช้งาน:

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

APL (Dyalog Unicode) , 7 ไบต์^SBCS

โปรแกรมเต็มรูปแบบ แสดง stdin

∊⍕¨~⍎¨⍞

ลองออนไลน์!

⍞ พร้อมรับคำ stdin

⍎¨ รันตัวละครแต่ละตัว

~ ตรรกะไม่

⍕¨ จัดรูปแบบอักขระแต่ละตัวเป็นข้อความ

∊ ϵ รายการ (แผ่)

PHP> 5.4 - 37 ตัวอักษร

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

$s คืออินพุต

Try it online

TI-BASIC ขนาด 7 ไบต์

นี่คือฟังก์ชั่นที่รับสตริงไบนารี (ผ่านAns) เป็นอินพุตและส่งคืนเอาต์พุตเป็นสตริงกลับหัว (ไม่กลับด้าน) ตามที่ระบุ สำหรับความช่วยเหลือเพิ่มเติมคุณสามารถอ่านรายการแอปพลิเคชันโดยใช้not(บน TI-BASIC wiki ฉันกำลังใช้เวอร์ชั่นที่คอมไพล์แล้วเพราะมันเล็กกว่า:

»*r>Õ¸r

ในรูปหกเหลี่ยม:

BB 2A 72 3E D5 B8 72

การอธิบาย

»*r - รับฟังก์ชั่นอินพุตเป็นสตริงและแปลงเป็นรายการ

> - ไปป์ที่ให้ลิสต์แก่โอเปอเรเตอร์ถัดไป

Õ¸r - ส่งคืนค่าผกผันของรายการ

Haskell, 22 ไบต์

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

ฉันรู้สึกประหลาดใจกับการไม่มีโซลูชั่น Haskell สำหรับความท้าทายนี้ดังนั้นนี่คือหนึ่งในนั้น มันประเมินให้กับฟังก์ชั่นที่ใช้สตริงและส่งกลับค่าผกผันของมัน

การอธิบาย

ไม่มีอะไรแฟนซีที่นี่

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 ไบต์

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

สมมติว่าสแต็คว่างเปล่าและ EOF ทั้งคู่อ่าน -1

0 ดัน \ 0 เป็นเทอร์มิเนเตอร์ null

>~1+:#v_ เป็นอินพุตวนซ้ำมันอ่าน ascii เพิ่ม 1 ตรวจสอบ EOF + 1 = 0

^ -1< มิฉะนั้นจะลบ 1 และออกจากค่า ascii ที่กดไว้บนสแต็ก

$>:#,_@ ปล่อยสำเนาพิเศษของศูนย์ที่ด้านบนของสแต็กจากนั้นพิมพ์ไบนารีสตริงบนลงล่าง

ถ้าสแต็กที่ว่างเปล่าอ่าน 0 ให้บันทึก 2 ไบต์ด้วย

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

รุ่นประมาณ 15 ไบต์เป็นไปได้โดยใช้อัลกอริทึมเดียวกันนี้ถ้า EOF = 0 แต่ฉันไม่มีการติดตั้งที่สะดวกในการทดสอบ

Javascript ES6, 26 ตัวอักษร

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

Befunge-98 (PyFunge) , 7 ไบต์

'a#@~-,

สำหรับอักขระทุกตัวcในอินพุตมันพิมพ์อักขระที่มีค่า ascii 94 - cโดยที่ 94 คือค่า '0' + '1' หรือ 'a'

ลองออนไลน์!

Python3, 39

Methinks Python ไม่ใช่ภาษาที่ดีที่สุดสำหรับสิ่งนี้ :)

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

หากคุณสนใจที่จะมีการขึ้นบรรทัดใหม่หลังผลลัพธ์นี่คือตัวเลือก 43 ตัวอักษร:

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

J - 11 ตัวอักษร

ค่าบูลีนใน J ถูกแทนด้วยจำนวนเต็ม0และ1แน่นอนว่าเป็นดัชนีที่ถูกต้องในอาร์เรย์ (ในกรณีนี้คืออาร์เรย์ 2 อักขระ'01')

'01'{~'0'&=

C #, 131 ไบต์

สายไปงานเลี้ยงเล็กน้อย แต่นี่เป็นของฉัน :)

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 ไบต์

@(x)[97-x '']

หลังจากเรียกใช้ข้างต้นเพียงแค่เรียกใช้ฟังก์ชันด้วยอินพุตสตริงของคุณเพื่อรับค่าสตริงกลับด้าน ตัวอย่างการรัน:

ans('10101110101010010100010001010110101001010')

พิมพ์:

01010001010101101011101110101001010110101

BotEngine , 4x8 = 32

การไม่คอมไพล์เป็นภาษาโพสต์คำถาม

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

ด้วยการเน้น: