Membuat koin adil

36

Anda memiliki koin yang menghasilkan 0atau 1. Tetapi Anda mencurigai koin itu bias , artinya kemungkinan 0(atau 1) tidak harus 1/2.

Sebuah terkenal prosedur untuk "mengubah" koin bias menjadi koin (yaitu untuk mendapatkan hasil yang sama mungkin), seperti yang diusulkan oleh von Neumann, adalah sebagai berikut. Menghasilkan (tidak tumpang tindih) blok dari dua lemparan koin sampai dua nilai blok berbeda; dan output nilai pertama di blok itu (nilai kedua juga akan dilakukan, tetapi untuk tujuan tantangan ini kita memilih yang pertama). Secara intuitif, 1mungkin lebih mungkin daripada 0, tetapi 01dan 10akan sama mungkin.

Misalnya, input 1110...akan membuang blok pertama, lalu menghasilkan 1dari blok kedua, ...

Prosedur ini mahal , karena beberapa lemparan koin dikonsumsi untuk menghasilkan hasil tunggal.

Tantangan

Ambil urutan nol dan satu yang terbatas, mewakili lemparan koin asli, dan hasilkan jumlah hasil maksimum sesuai dengan prosedur di atas, sampai semua input dikonsumsi.

Blok terakhir mungkin tidak lengkap, jika jumlah nilai input ganjil. Misalnya, urutan input tidak 11111akan menghasilkan hasil (dua blok pertama memiliki nilai yang sama, dan blok ketiga tidak lengkap).

Aturan

Input dapat memiliki jumlah nilai non-negatif, tidak harus positif atau bahkan.

Format input mungkin:

  • sejumlah nol dan satu;
  • string nol dan yang dengan pemisah opsional.

Format output mungkin:

  • serangkaian nol dan satu, dengan atau tanpa pemisah;
  • sejumlah nol dan satu;
  • string yang mengandung nol tunggal atau satu, dipisahkan oleh baris baru;
  • format serupa yang wajar dan sesuai dengan bahasa Anda.

Golf kode. Bytes paling sedikit menang.

Uji kasus

Input dan output di sini diasumsikan sebagai string.

Input         -->  Output

'1110'        -->  '1'
'11000110'    -->  '01'
'1100011'     -->  '0'
'00'          -->  ''
'1'           -->  ''
''            -->  ''
'1101001'     -->  '0'
'1011101010'  -->  '1111'
Luis Mendo
sumber
Bukankah seharusnya ada dua kemungkinan output untuk setiap input (yaitu bitwise bukan dari output saat ini)?
wizzwizz4
1
@ wizzwizz4 Anda dapat mengambil satu atau yang lain, tetapi tidak keduanya (karena mereka tidak akan mandiri secara statistik). Dalam tantangan ini saya secara sewenang-wenang memilih yang pertama
Luis Mendo
2
@IGoBest Saya tidak begitu yakin :-D
Luis Mendo
1
@DonMuesli Man, daftar peringatan di koran itu sangat mengesankan : P
Geobits

Jawaban:

5

Jelly, 6 byte

s2Q€Ṗ€

Cobalah online!

Bagaimana itu bekerja

s2Q€Ṗ€  Main link. Argument: S (string)

s2      Split the string into pairs of characters.
  Q€    Deduplicate each pair.
        This removes the second character iff it is equal to the first.
    Ṗ€  Pop each; remove the last character of each pair/singleton.
Dennis
sumber
14

Retina , 16 14 byte

(.)\1|(.)?.
$2

Cobalah online!

Penjelasan

Ini cukup sederhana. Kode mendefinisikan satu penggantian substitusi tunggal menggantikan semua kecocokan (tidak tumpang tindih) (.)\1|(.)?.dengan apa pun yang ditangkap kelompok kedua. Ini menggabungkan tiga kasus berbeda menjadi satu:

(.)\1 --> <empty>

Jika dua digit berulang sama, kami menghapusnya dari string (karena grup 2 tidak digunakan).

(.).  --> $2

Kalau tidak, jika kita dapat mencocokkan dua karakter, hapus yang kedua, dengan mengganti keduanya dengan yang pertama. Jika bukan itu masalahnya maka ?akan menghilangkan grup:

.     --> <empty>

Ini hanya terjadi jika ada karakter trailing tidak berpasangan, yang juga dihapus.

Martin Ender
sumber
Ini mungkin jawaban Retina terpendek yang pernah saya lihat :-)
Luis Mendo
9
@ DonMuesli ummm ...
Martin Ender
11

Labirin , 21 12 byte

"(. :
""*$,@

Contoh langka dari program Labirin kompak yang juga tidak memiliki larangan. Di |versi sebelumnya sama sekali tidak perlu, dan menghapusnya secara besar-besaran mengurangi ukuran program. Faktanya, Lab mengalahkan Retina!

Cobalah online!

Kiri bawah "juga bisa menjadi ruang, tetapi memiliki di sana sangat menyederhanakan penjelasan.

Penjelasan

Yang ini agak rumit, jadi disertai dengan gambar. Tapi pertama-tama, primer cepat:

  • Labyrinth adalah bahasa 2D berbasis stack. Memori terdiri dari tumpukan utama dan tumpukan tambahan.
  • Tumpukan Labyrinth tidak memiliki dasar dan diisi dengan angka nol, jadi melakukan operasi pada tumpukan kosong bukanlah kesalahan.
  • Di setiap persimpangan, di mana ada dua atau lebih jalur untuk penunjuk instruksi untuk pergi, bagian atas tumpukan utama diperiksa untuk mencari tahu ke mana harus pergi selanjutnya. Negatif belok kiri, nol lurus ke depan dan positif belok kanan. Jika belokan gagal, penunjuk mencoba berbelok ke arah lain.

Mendirikan

masukkan deskripsi gambar di sini

Program dimulai di kiri atas ", yang merupakan no-op. Lalu kami melakukan:

(        Decrement a bottom zero to -1. Since -1 is negative we try to turn 
         left at this junction, fail, and turn right instead.
"        No-op junction, turn left
*        Multiply top of stack (-1) with a 0 at bottom of stack, giving 0.
         This makes us go straight ahead at this junction.
$        Bitwise xor (of 0 and 0)

Ini meninggalkan tumpukan dengan 0 tunggal di atasnya, yang sama baiknya dengan kosong untuk keperluan Labirin.

Masukan dan terminasi bacaan

masukkan deskripsi gambar di sini

,membaca char dari input, menghasilkan 48 atau 49 untuk 0atau 1masing - masing, dan -1 pada EOF. Karena ini bukan nol, bagaimanapun kita berubah menjadi: , yang menduplikasi bagian atas tumpukan.

Jalan :buntu, jadi kami berbalik dan mengeksekusi ,sekali lagi. Sekarang jika input terakhir adalah EOF, maka kita berbelok ke kiri dan mengakhiri dengan @, kalau tidak kita berbelok ke kanan, dengan tumpukan tampak seperti [a a b](di mana a, badalah dua karakter).

Menafsirkan lemparan koin

masukkan deskripsi gambar di sini

Jika kami tidak berhenti, langkah selanjutnya adalah mengeksekusi $(bitwise xor) lagi. Ini menghasilkan 0 jika karakter inputnya sama, 1 sebaliknya. Kami kemudian gandakan adengan hasil ini, memberikan 0 atau a. Sejak* berada di persimpangan, nilai tumpukan teratas ini menentukan apa yang terjadi selanjutnya.

Dalam 0 case, kita langsung saja menjalankan tiga "no-ops, sebelum melakukan (decrement. Seperti pengaturan, ini membuat kita berbalik dan mengeksekusi "*$, membuat kita siap untuk membaca lebih banyak karakter.

masukkan deskripsi gambar di sini

Kalau tidak, dalam akasus ini, kita belok kanan di persimpangan karena apositif (48 atau 49). .output char, membiarkan stack kosong, dan (mengurangi bagian atas stack, memutar 0 ke -1. Sekali lagi, ini membuat kita berbelok ke kiri, menjalankan "*$seperti pada pengaturan, juga membuat kita siap untuk membaca lebih banyak input.

Sp3000
sumber
...Wow. Cuma wow. Karena penasaran ... apa yang terjadi jika Anda menghapus kutipan utama dari setiap baris?
ETHproduk
@ ETHproductions Kolom kedua tidak lagi persimpangan, sehingga IP mulai mengeksekusi (kemudian ., menghasilkan char 255 (-1 modulo 256). Jadi sudah salah mulai dari sana, sayangnya: P
Sp3000
8

CJam, 10 8 byte

l2/{)-}%

Uji di sini.

Penjelasan

Ini adalah solusi yang sangat sederhana: di setiap pasangan, hapus semua instance dari karakter terakhir. Digit berulang dan digit trailing tidak berpasangan akan dihapus, seperti halnya digit kedua dari setiap pasangan digit yang tidak sama:

"0"  --> ""
"1"  --> ""
"00" --> ""
"01" --> "0"
"10" --> "1"
"11" --> ""

Ini hanya menyisakan digit yang kita cari. Inilah cara kode menghitung ini:

l     e# Read input.
2/    e# Split into pairs. Odd inputs will yield a single-character string at the end.
{     e# Map this block over the pairs...
  )   e#   Pull the last character off the string.
  -   e#   Remove all occurrences of that character from the remainder (which is either
      e#   an empty string to begin with or a single-digit string).
}%

Ketika daftar dicetak secara otomatis di akhir program, string kosong dihilangkan.

Martin Ender
sumber
3
Anda dan @DonMuesli adalah satu-satunya orang dengan penjelasan dalam jawaban mereka selain kode itu sendiri. Terima kasih.
Rɪᴋᴇʀ
7

Perl, 19 18 17 byte

Solusi @Martin Büttner Retina menginspirasi gain 2 byte

Termasuk +1 untuk -p

Jalankan dengan input pada STDIN, mis perl -p fair.pl <<< 11000110

fair.pl:

s/(.)\1|.?\K.//g

Tidak banyak yang bisa dijelaskan di sini karena ini merupakan terjemahan spesifikasi (tidak langsung):

  • (.)\1 Jika 2 digit pertama sama, jatuhkan
  • .\K. Kalau tidak, dua digit pertama berbeda. Simpan ( \K) yang pertama
  • .?\K.Kecuali bahwa yang pertama .adalah opsional. Hal ini memungkinkan untuk satu pertandingan di ujung string yang kemudian dibuang karena bagian yang disimpan kosong
Ton Hospel
sumber
5

Mathematica, 36 38 byte

-2 setelah mencuri fungsi @ LegionMammal978 untuk menentukan apakah daftar 2-elemen adalah {0,1} atau {1,0}

#&@@@Select[#~Partition~2,Tr@#==1&]&

Argumen diharapkan menjadi daftar bilangan bulat.

feersum
sumber
Oh tidak, tiga jawaban Mathematica pada satu pertanyaan!
CalculatorFeline
5

Hexagony , 23 21 byte

,){,/;(_\/'%<\{)/>~$>

Dibuka:

    , ) { ,
   / ; ( _ \
  / ' % < \ {
 ) / > ~ $ > .
  . . . . . .
   . . . . .
    . . . .

Ini berakhir dengan kesalahan, tetapi pesan kesalahan pergi ke STDERR.

Cobalah online!

Menilai dari jumlah mirror, mungkin saja cukup untuk memasangnya menjadi side-length 3 tapi sejauh ini saya belum beruntung.

Penjelasan

Berikut diagram yang biasa, dihasilkan dengan HexagonyColorer Timwi :

masukkan deskripsi gambar di sini

Program ini hanya menggunakan tiga sisi memori, diberi label A , B , dan C di sini (diagram milik Timwi's EsotericIDE ):

masukkan deskripsi gambar di sini

Eksekusi dimulai di jalur biru. The /hanya cermin yang mengarahkan pointer instruksi (IP), kode aktual adalah:

,   Read character from STDIN into memory edge A.
)   Increment.
{   Move to memory edge B.
,   Read character from STDIN into memory edge B.
)   Increment.
'   Move to memory edge C.
%   Compute A mod B in memory edge C.

The ,akan mengatur tepi untuk -1bukan kode karakter jika kita telah memukul EOF. Karena kami menambah kedua input yang tidak mengubah apakah mereka sama atau tidak, tetapi mengubah EOF menjadi 0.

Kami menggunakan modulo untuk memeriksa persamaan, karena itu 1atau 49(positif) untuk karakter yang tidak sama dan 0karakter yang sama. Ini juga berfungsi sebagai akhir dari program, karena ketika kita memiliki 0dari EOF, pembagian yang dicoba dengan nol akan menyebabkan kesalahan.

Sekarang yang <membedakan nol dari hasil positif. Yang sederhana pertama: jika karakternya sama, IP mengambil jalur merah. _adalah cermin, \juga cermin tetapi diabaikan, dan >membelokkan IP sedemikian rupa sehingga membungkus tepi dan mulai dari atas lagi. Namun, pada iterasi ini, peran A , B dan C bertukar secara siklis ( C sekarang mengambil peran A dan seterusnya).

Jika karakter berbeda, jalur hijau diambil sebagai gantinya. Yang ini agak berantakan. Pertama-tama melompati no-op dengan $, kemudian membungkus ke sekitar /di tepi kiri, kemudian melintasi baris kedua-ke-terakhir dari kanan ke kiri dan akhirnya kembali memasuki bagian yang menarik dari kode sumber di {. Ada sedikit kode yang pada dasarnya linier, yang akan saya jelaskan sebentar lagi, sebelum $IP melompati >untuk menggabungkan dua jalur lagi.

Inilah potongan kode linear:

{    Move to memory edge A.
(    Decrement to recover the actual character we read.
;    Print the character back to STDOUT.
'    Move to memory edge B.
~    Multiply the value there by -1, making it negative. This is
     necessary to ensure that the path correctly wraps back to the top.

Perhatikan bahwa dalam kasus ini, peran tepi untuk iterasi berikutnya juga ditukar secara siklikal, tetapi dengan B mengambil peran A dan seterusnya.

Martin Ender
sumber
4

Haskell, 71 44 29 byte

p(a:b:r)=[a|a/=b]++p r
p _=[]

Golf ekstrim oleh nimi .

joeytwiddle
sumber
4

> <> , 11 byte

i:i:0(?;-?o

> <> sangat cocok untuk tantangan membaca-a-char-at-a-time seperti ini :) Coba online!

i:            Read char and duplicate
i             Read char
:0(?;         Halt if last char was EOF
-             Subtract
?o            Output first char if the subtraction was non-zero (i.e. not equal)

Ini semua terjadi dalam satu lingkaran karena pointer instruksi membungkus begitu mencapai akhir baris.

Sp3000
sumber
-1 untuk program>>> yang tidak mengandung >atau<
Luis Mendo
3

Python, 42 byte

f=lambda L:L[1:]and L[:L[0]^L[1]]+f(L[2:])

Bersenang-senang dengan rekursi dan bitor xor. Mengambil daftar 1s dan 0s sebagai input.

Sp3000
sumber
3

JavaScript (ES6), 33 byte

s=>s.filter((c,i)=>++i%2&c!=s[i])

Bagaimana itu bekerja

s=>s                // Take the input array.
.filter((c,i)=>   ) // Filter to only the chars that are both:
++i%2&              //  on an even index, and
c!=s[i]             //  not equal to the one after them.
Produksi ETH
sumber
Anda dapat menyimpan beberapa byte dengan meminta input untuk menjadi array. (Diizinkan dengan pertanyaan.)
Mama Fun Roll
@MamaFunRoll Terima kasih atas tipnya!
Produk ETH
3

Pendahuluan , 12 byte

11(-(#!)?^?)

Ini mengasumsikan seorang juru bahasa yang membaca dan mencetak karakter. Anda dapat mengurutkannya secara online. Tapi juru bahasa itu mencetak bilangan bulat, jadi untuk setiap 0Anda akan mendapatkan 48dan untuk masing-masing 1Anda akan mendapatkan 49sebaliknya (dan linefeed).

Penjelasan

Sangat jarang Anda dapat menulis program non-sepele pada satu baris di Prelude (karena Prelude membutuhkan lebih dari satu baris untuk menyelesaikan Turing).

11      Push two 1s. We need something non-zero on the stack to enter the loop, and by
        pushing the same value twice, we make sure that the loop doesn't print anything
        on the first iteration.
(       Main loop...
  -       Subtract the last two values. This will be zero for equal values, and non-zero
          otherwise...
  (       This "loop" is simply used as a conditional: if the last two values were
          were equal, skip the code inside...
    #       Discard the conditional.
    !       Print the value below.
  )       The loop is exited because the value below is always zero.
  ?       Read the first character of the next pair from STDIN.
  ^       Duplicate it, so the lower copy can be printed.
  ?       Read the second character of the pair. This returns 0 at EOF, which
          terminates the loop.
)
Martin Ender
sumber
3

Perl, 27 21 byte

say grep$_-chop,/../g

Byte ditambahkan untuk -nbendera.

                /../g  match groups of two chars
    grep       ,       select/filter on...
           chop        remove the last character, mutating the string
        $_-            is it different than the remaining char?
                         (subtract it, empty string is falsy)
say                    output if so

Uji:

llama@llama:~$ perl -nE 'say grep$_-chop,/../g'
1110
1
11000110
01
1100011
0
00

1



1101001
0
1011101010
1111

Terima kasih kepada @TonHospel untuk 6 byte!

Gagang pintu
sumber
Anda bisa mendapatkan beberapa byte dengan mempersingkat tes:say grep$_-chop,/../g
Ton Hospel
@TonHospel Sangat bagus, terima kasih!
Gagang pintu
3

Menuju 93 , 16 byte

~:~:0`!#@_->#,_$

Satu liner untuk kekompakan. Diuji menggunakan juru bahasa online ini .

~:                     Read input char a and dup
  ~                    Read input char b (-1 on EOF)
   :0`!                Push 1 if b <= 0, 0 otherwise
       #@_             Halt if b <= 0 (i.e. EOF)
          -            Subtract to check whether a != b
           >#,_$       Output a if so

Bagian terakhir memanfaatkan fakta itu muncul dari tumpukan Befunge-93 yang kosong menghasilkan 0 .

Jika a != b, kami tampil

>                      Move rightward
#                      Bridge: skip next
_                      Horizontal if - go right if 0, else left. But a != b, so we go left
,                      Output a
#                      Bridge: skip next
-                      Subtract (0 - 0 = 0)
_                      If: go right since 0 is popped
>#                     Go right and skip next
_                      If: go right since 0 is popped
$                      Pop top of stack, stack is now empty

Kalau tidak, jika a == b, kami melakukan:

>                      Move rightward
#                      Bridge: skip next
_                      If: go right since a == b (i.e. a-b is 0)
$                      Pop top of stack and discard, keeping stack empty
Sp3000
sumber
2

Pyth, 10 9 byte

jkPM{Mcz2

Algoritma dicuri tanpa malu-malu dari jawaban Dennis's Jelly .

       z    input
      c 2   chunks of 2
    {M      dedup each chunk
  PM        all-but-last element of each chunk
jk          join on empty string; can't use `s' because that gives `0' for []
Gagang pintu
sumber
2

Python 2, 48 byte

lambda n:[s for s,t in zip(*[iter(n)]*2)if s!=t]

Cobalah online

Terima kasih untuk Dennis dan vaultah karena menunjukkan hal-hal yang saya lewatkan

Mego
sumber
Saya pikir Anda bisa menggunakan resep 'Kerapu' tua yang baik:zip(*[iter(n)]*2)
vaultah
Bukankah lambda bekerja?
Dennis
2

Mathematica, 41 39 byte

Select[#~Partition~2,Tr@#==1&][[1]]&

Kurang rumit dan lebih pendek dari jawaban lainnya. Kotak adalah karakter transpose.

CalculatorFeline
sumber
2

JavaScript (ES6), 33 byte

s=>s.replace(/(.)\1|(.)?./g,"$2")

Port yang membosankan dari jawaban Retina.

Neil
sumber
2

sed, 34 33 byte

s/../& /g;s/00\|11//g;s/.\b\| //g

Uji:

llama@llama:~$ sed 's/../& /g;s/00\|11//g;s/.\b\| //g'             
1110
1
11000110
01
1100011
0
00

1



1101001
0
1011101010
1111
Gagang pintu
sumber
1
Saya mencoba menggunakan fold(1)perintah untuk berpisah. Itu juga keluar di 34! fold -s2|sed 's+01+0+p;s+10+1+p;d'
joeytwiddle
@ Joeytwiddle fold -s2setara dengan fold -2, membuat 33 byte ... yang merupakan dasar dari solusi sed murni, juga. : P
Gagang Pintu
Saya menggabungkan subtitusi kedua dan ketiga untuk mencukur 4 byte lagi:s/../& /g;s/00\|11\|.\b\| //g
Toby Speight
2

Labirin , 31 byte

Tidak sesingkat dan serapi solusi Sp3000, tapi saya pikir saya tetap akan memposting ini sebagai pendekatan yang berbeda:

"" @
,, :{"
)  { $;
*"})";.
 ""

Penjelasan

Loop pertama sederhana

""
,,

yang bertuliskan dua karakter sekaligus ( "tidak ada op). Setelah EOF, ,akan kembali -1, tetapi hanya memeriksa EOF di setiap karakter kedua. Itu berarti dalam hal apapun bagian atas tumpukan kemudian akan menjadi -1dan nilai di bawahnya adalah baik-1 atau beberapa kode karakter yang tidak kita pedulikan, karena itu adalah lemparan koin yang tidak berpasangan.

Kemudian )*ubah -1dan nilai di bawah ini menjadi tunggal 0yang kita perlukan a) untuk menyingkirkan kedua nilai tersebut dan b) untuk memasukkan loop berikutnya dengan benar. Lingkaran berikutnya itu sederhana

"}
""

Yang menggeser semua nilai ke tumpukan tambahan. Ini diperlukan karena kami ingin mulai memproses pasangan yang kami baca terlebih dahulu. Sekarang loop terakhir:

:{"
{ $;
)";.

The )hanya penambahan beberapa nilai dummy untuk memastikan bahwa itu positif dan instruksi pointer bergantian utara. {menarik digit pertama dari pasangan berikutnya dan :menduplikatnya. Sekarang ketika kita selesai memproses, ini akan menjadi 0dari dasar tumpukan tambahan. Kalau tidak salah 48atau 49. Dalam hal nol, kita keluar dari loop dan berakhir@ , jika tidak, IP berbelok ke timur.

{menarik digit lain dari pasangan saat ini. $mengambil XOR di antara mereka. Jika itu 0, yaitu keduanya sama, IP hanya terus bergerak ke selatan, ;membuang nol, dan IP berubah ke barat ke iterasi berikutnya. Jika XOR itu 1, yaitu mereka berbeda, IP berubah menjadi barat, membuang 1dengan ;dan mencetak digit pertama dengan ..

Martin Ender
sumber
2

MATL , 11 9 8 byte

`-?6MD]T

Input dan output adalah angka yang dipisahkan oleh baris baru. Berakhir dengan kesalahan (diizinkan secara default) ketika semua input telah dikonsumsi.

Cobalah online!

`         % do...while loop
  -       %   take two inputs implicitly. Compute difference
  ?       %   if nonzero
    6M    %     push first of the two most recent inputs again
    D     %     display (and remove from stack)
  ]       %   end if
  T       %   true. Used as loop condition, so the loop is infinite
          % end loop implicitly

Pendekatan lama, 11 byte

2YCd9L)Xz0<

Input adalah sebuah string. Output adalah angka yang dipisahkan oleh baris baru.

Cobalah online!

2YC      % implicitly take input as a string. Generate 2D array of length-2
         % overlapping blocks as columns, padding with a zero if needed.
d        % difference of the two values in each column of that array
9L       % predefined literal [1 2 0]. This corresponds to "1:2:end" indexing
)        % keep only values at indices 1, 3, 5, ... This reduces the set of blocks
         % to non-overlapping, and discards the last (padded) block if the input had
         % odd length
Xz       % keep only nonzero entries, corresponding to blocks that had different values
0<       % 1 if negative, 0 if possitive. Implicitly display
Luis Mendo
sumber
2

Ruby, 46 byte

Ini memisahkan l[0], l[1]dan l[2..{end}]sebagai a, bdan c. Kemudian ia menciptakan string dengan ajika a!=batau ''sebaliknya dan f[c]jika c[0]ada atau ''sebaliknya.

f=->l{a,b,*c=l;"#{a!=b ?a:''}#{c[0]?f[c]:''}"}

Tidak Disatukan:

def f(l)
  a = l[0]
  b = l[1]
  c = l[2..l.length]
  s = ''
  if a!=b
    s += a.to_s
  end
  if c[0]       # equivalent to !c.empty?
    s += f[c]   # no .to_s because the output will be a string
  end
  puts s
end
Sherlock9
sumber
2

brainfuck, 33 byte

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

Dibandingkan dengan Jawa, ini sangat ringkas, namun, saya takut dengan penjawab brainfuck-pegolf. Dan jangan ragu untuk menyebutkan jika ada bug. Dengan asumsi EOF adalah 0, input tidak mengandung input yang tidak valid, sel awalnya nol, dan rentang nilai sel terbatas dan siklik. Tidak ada asumsi lain.

Penjelasan:

Peta Sel Memori

+---------+---------+-----------------+
|1st input|2nd input|copy of 1st input|
+---------+---------+-----------------+

Petunjuk

,>,                               read two instruction at once | first to first cell |
                                  second to second cell
   [                              Until the input is EOF
    <                             look at first cell
     [->->+<<]                    move the first cell to additional cells while
                                  subtracting the second cell with this at same
                                  time
              >[                  if the second cell is nonzero (it means that first cell and
                                  the second cell is the same)
                [-]>.<            Print the copied first input
                      ]
                       >[-]       clear the first input to prevent it polluting next input
                           <<,>,  continue with next two input
                                ]
Akangka
sumber
1
Sangat bagus! Saya telah mencoba untuk menulis jawaban BF sendiri. Tapi saya menemukannya juga BF-ing
Luis Mendo
1

Mathematica, 41 byte

Cases[#~Partition~2,a_/;Tr@a==1:>a[[1]]]&

Fungsi anonim yang input dan output daftar nol dan yang.

LegionMammal978
sumber
Tunggu, Anda bisa menggunakan Tr untuk menjumlahkan vektor? Harus mengedit sejumlah jawaban ...
CalculatorFeline
#&@@alebih pendek 1 byte dari a[[1]].
CalculatorFeline
@CatsAreFluffy Saya memikirkan hal itu, tetapi gagal RuleDelayed.
LegionMammal978
Tidak bekerja dengan jawaban saya juga karena Transpose:(
CalculatorFeline
1

Pyth, 10 byte

hMf!qFTcz2

Suite uji

isaacg
sumber
Anda dapat mengganti !qdengan nlalu filter fnFTdengan nF#. ( hMnF#cz2; ini adalah hal yang saya pikirkan ketika saya melihat tantangan, tetapi milik Anda cukup dekat bagi saya untuk tidak mempostingnya secara terpisah)
PurkkaKoodari
@ Pietu1998 Saya mencobanya. Gagal pada misalnya1
isaacg
1

C, 66 byte

main(char*p,char**x){for(p=x[1];*p&p[1];p+=2)write(1,p,*p^p[1]);}

Asumsi sizeof(int) == sizeof(char *)

"pintar" solusi - 84 81 byte

main(int c,short**x){while(!((c=*x[1]++-12336)&~511))c>>8^c&1&&putchar(48|c&1);}

Bekerja pada mesin little-endian dengan asumsi short2 byte. Masukan diberikan sebagai argumen. Program ini mengulangi pasangan karakter dan mencetak 0 untuk 0x3130 dan 1 untuk 0x3031. Pada big-endian hasilnya akan terbalik (ganti 48|c&1dengan 49^c&1untuk memperbaikinya).

aragaer
sumber
1

C, 57 byte

f(char*p,char*r){for(;*p*p[1];)*r=*p++,r+=*r!=*p++;*r=0;}

Kami sementara menyalin karakter dari input pke hasil r, tetapi hanya memajukan rpointer jika berbeda dari karakter berikutnya. Jika tidak, maka kami akan menimpanya di pasangan yang tidak cocok berikutnya, atau dengan NULdi akhir.

Program uji:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char **argv) {
    while (*++argv) {
        char *result = malloc(1+strlen(*argv));
        f(*argv, result);
        printf("%s => %s\n", *argv, result);
        free(result);
    }
    return EXIT_SUCCESS;
}

Hasil tes:

$ ./74864 1110 11000110 1100011 00 1 "" 1101001 1011101010
1110 => 1
11000110 => 01
1100011 => 0
00 => 
1 => 
 => 
1101001 => 0
1011101010 => 1111
Toby Speight
sumber
1

Befunge-93 , 40 byte

v  ,-1<
      | -<
>~1+:~1+:|
^     <  @

Anda bisa mencobanya di sini . Tempel kode di ruang di bawah tombol "tampilkan", tekan "tampilkan", tentukan input, tekan "jalankan". Kami menggunakan tombol "langkah" untuk melihat cara kerja program.

Luis Mendo
sumber
1
Jawaban Befunge pertama saya!
Luis Mendo
1

DOS / Windows Batch, 201 162 byte

@echo off
set/pi=
:a
for /f "tokens=2" %%a in ("%i%") do goto l
exit/b
:l
for /f "tokens=1,2" %%a in ("%i:~0,4%") do if %%a neq %%b echo %%a
set "i=%i:~4%"
goto a

Input adalah string yang dipisahkan ruang, misalnya 1 0 0 1 1. Mulai dari cmd, jika tidak layar segera keluar

Dennis van Gils
sumber
1

lilin lebah ,45 35 byte

Saya bisa menurunkannya dengan 10 byte — tidak terlalu buruk.

pgy~1z;L?gAF1<<?V_
>&?@yg&?~@ KQd{b

Saya mengambil bacaan penuh dengan pendekatan lemparan koin , yang membuat program ini cukup besar. Hanya dengan membaca bilangan bulat satu per satu akan membuat program lebih kecil — mungkin sekitar 22 byte atau lebih — tetapi juga sangat tidak nyaman untuk digunakan.

Contoh:

julia> beeswax("FairCoin.bswx")
s1110
1
Program finished!

julia> beeswax("FairCoin.bswx")
s11000110
01
Program finished!

julia> beeswax("FairCoin.bswx")
s1100011
0
Program finished!

julia> beeswax("FairCoin.bswx")
s00

Program finished!

julia> beeswax("FairCoin.bswx")
s10101001010111111100000010011001110100010110101110100001011
1110001010000111100
Program finished!

Gudang lilin GitHub saya.

Contoh lilin lebah saya di Rosetta Code.

ML
sumber