Superior Passtimes

32

Kadang-kadang, ketika saya benar-benar bosan, saya suka mengambil jumlah array bilangan non-negatif. Saya hanya mengambil jumlah array panjang yang merupakan kekuatan dua. Sayangnya saya sering melakukan kesalahan. Untungnya saya melacak pekerjaan saya karena saya mengikuti cara berikut:

Saya menambahkan pasangan angka yang berdekatan sampai hanya ada satu yang tersisa. Sebagai contoh:

 6 + 18 + 9 + 6 + 6 + 3 + 8 + 10
=  24   +   15  +   9   +   18
=       39      +       27
=               66

Tugas Anda adalah menentukan apakah saya telah membuat kesalahan di suatu tempat. Anda bisa mendapatkan input yang diteruskan ke fungsi Anda atau membaca dari standar masuk. Output dapat dicetak atau dikembalikan.

Input: Array / daftar / dll. bilangan bulat non-negatif, dan mungkin juga panjang array jika bahasa Anda membutuhkannya. Array itu adalah semua angka yang dibaca dari kiri ke kanan lalu atas ke bawah. Misalnya array di atas akan menjadi:
[[6, 18, 9, 6, 6, 3, 8, 10], [24, 15, 9, 18], [39, 27], [66]]
atau
[6, 18, 9, 6, 6, 3, 8, 10, 24, 15, 9, 18, 39, 27, 66]jika Anda suka.

Keluaran: boolean tunggal yang menunjukkan apakah ada kesalahan atau tidak. Boolean dapat direpresentasikan menggunakan pemetaan apa pun asalkan semua input di mana kesalahan dibuat mengembalikan / mencetak hasil yang identik dan semua input yang tidak mengandung kesalahan mengembalikan / mencetak hasil yang identik. Ini harus berjalan tanpa mengatakan, tetapi dua output tidak bisa sama.

Beberapa Contoh Penjumlahan yang Benar:

6

5+6
=11

  3 + 2 + 4 + 5
=   5   +   9
=       14

[0, 1, 2, 3, 1, 5, 6]

[[1, 2, 4, 8], [3, 12], [15]]

Beberapa Contoh Penjumlahan Tidak Benar:

5+4
=8

4 + 4 + 4 + 4
= 9   +   7
=     16

[[1, 2, 3, 4], [7, 3], [10]]

[3, 4, 5, 6, 7, 8, 9]

Ingatlah bahwa saya dapat membuat kesalahan dan masih mendapatkan jawaban yang benar. Jika saya melakukan kesalahan, itu tidak akan menghasilkan angka tambahan atau nomor hilang dalam array terakhir, hanya nomor yang salah.

Celah standar dilarang. Jawaban terpendek dalam setiap bahasa adalah pemenang. Jawaban yang lebih lama akan menang dalam kasus seri. Saya memiliki hak untuk memutuskan apa "bahasa yang sama" itu, tetapi saya akan mengatakan di muka bahwa suatu titik tidak dapat diperoleh dalam Python 2, dan Python 3.

Bijan
sumber
1
Selamat datang di situs ini! Tantangan pertama yang bagus.
AdmBorkBork
Kenapa tanggal akhirnya? Bahasa yang lebih baru daripada tantangan sudah dilarang secara default.
Rɪᴋᴇʀ
Saya kira saya bisa menghapusnya, idenya adalah bahwa saya perlu memiliki beberapa cuttoff sehingga saya dapat memahkotai satu set jawaban sebagai benar, tapi saya kira tidak harus seperti itu.
Bijan
1
Tidak, Anda bisa menggunakan mana saja yang membuat bermain golf lebih mudah.
Bijan
Contoh [0,1,2,3,1,5,6]tidak valid karena "Input: Array / daftar / etc. Dari bilangan bulat positif".
Ben Frankel

Jawaban:

10

Jelly , 6 byte

Ṗ+2/€ẇ

Cobalah online!

Bagaimana itu bekerja

Ṗ+2/€ẇ  Main link. Argument: A (2D array)

Ṗ       Pop; yield A without its last element. Let's call the result B.
  2/    Pairwise reduce...
    €     each array in B...
 +          by addition.
     ẇ  Window exists; test if the result appears in A as a contiguous subarray.
Dennis
sumber
9

Python 2 , 51 byte

lambda l:map(sum,zip(*[iter(l)]*2))==l[len(l)/2+1:]

Cobalah online! Terima kasih kepada Rod untuk kasus uji.

Membuat seluruh daftar datar sebagai masukan. Grup elemen menjadi pasangan yang berdekatan menggunakan trik zip / iter , mengambil jumlah pasangan, dan memeriksa apakah hasilnya sama dengan bagian kedua dari daftar.

Sebuah metode rekursif datang dekat pada 55 byte:

f=lambda l:len(l)<2or l[0]+l[1]==l[len(l)/2+1]*f(l[2:])

Ini digunakan bahwa bilangan bulat input positif, yang sejak itu berubah dalam spesifikasi.

Tidak
sumber
Karena kondisi pertanyaan sekarang memungkinkan entri non-negatif, metode rekursif Anda akan memberikan hasil positif palsu [0,0,1,1,1,1,1].
Ben Frankel
7

Röda , 40 byte

{[0]if{|x|[[x()|[_+_]]=y]if tryPeek y}_}

Cobalah online!

Ini adalah fungsi anonim yang mengembalikan 0jika tidak ada kesalahan dan tidak ada jika ada kesalahan.

Penjelasan:

{[0]if{|x|[[x()|[_+_]]=y]if tryPeek y}_}
{                                      } /* Anonymous function */
      {|x|                           }_  /* Loop over lists in the stream */
                         if tryPeek y    /* If there are lists left after this */
            x()                          /* Push values in list x to the stream */
               |[_+_]                    /* Sum every pair of numbers in x */
           [         ]                   /* Create a list of sums */
                      =y                 /* If the list equals to the next list */
          [             ]                /* Push the result */
    if                                   /* If all results are TRUE */
 [0]                                     /* Return 0 */
                                         /* Otherwise return nothing */

Berikut adalah versi yang lebih pendek (35 byte) tetapi bertentangan dengan aturan (saya pikir):

{{|x|[[x()|[_+_]]=y]if tryPeek y}_}

Cobalah online!

Ini adalah fungsi anonim yang membaca nilai dari aliran dan mendorong TRUEatau FALSEuntuk setiap baris yang benar.

Saya tidak yakin apakah ini (nilai pengembalian berganda) diterima dalam aturan. Inilah pertahanan saya: di Reda, kondisi ifdan whileblok bukan nilai boolean, tetapi stream. Aliran "benar" kosong atau hanya berisi TRUEs, dan aliran "falsy" berisi satu atau lebih FALSEs. Dengan cara ini, fungsi ini mengembalikan nilai "boolean". Dan dapat digunakan sebagai kondisi ifpernyataan tanpa mengurangi operasi, dll.

fergusq
sumber
Saya tidak yakin apakah itu diperhitungkan, tetapi untuk sekarang Anda memiliki satu-satunya solusi Roda, jadi sulit untuk mengatakannya sampai orang lain datang. Saya pikir itu seharusnya baik-baik saja, tetapi saya tidak begitu suka ide untuk mengubah aturan setelah pertanyaan naik. Meskipun mungkin seseorang bisa membuat kasus untuk itu bukan perubahan dalam aturan, sama seperti mengisi ambiguitas.
Bijan
2
@ Bijan Ada bahasa lain yang memiliki konstruksi serupa. Dalam MATL, misalnya, seluruh array adalah falsey jika ada satu 0di dalamnya. Saya tidak yakin persis bagaimana Reda menangani itu, tetapi itu tidak pernah terdengar.
AdmBorkBork
1
@ Bijan Definisi kami tentang kebenaran / kepalsuan bergantung pada apa yang akan dilakukan bahasa untuk suatu ifkondisi. Jika beginilah cara Röda bekerja, itu sesuai dengan aturan kami, kecuali jika spec tantangan mengabaikan default secara eksplisit.
Dennis
@ Dennis Tampaknya OP telah melarang ini: "semua input di mana kesalahan dibuat mengembalikan / mencetak hasil yang identik dan semua input yang tidak mengandung kesalahan mengembalikan / mencetak hasil yang identik." Variasi yang lebih pendek dari program ini memiliki jumlah keluaran yang tak terbatas.
fergusq
@fergusq Oh, benar, saya telah mengabaikan hal itu.
Dennis
5

Python 2 , 69 65 byte

lambda x:reduce(lambda a,b:(b==map(sum,zip(a[::2],a[1::2])))*b,x)

Cobalah online!
Pengembalian:
Daftar Kosong sebagai Falsy
Jumlah total sebagaiTruthy

tongkat
sumber
5

Mathematica, 36 byte

Most[Tr/@#~Partition~2&/@#]==Rest@#&

Fungsi murni mengambil daftar bersarang sebagai input dan kembali Trueatau False. Fungsi ini Tr/@#~Partition~2&mengambil jumlah berpasangan dari suatu daftar, yang kemudian diterapkan ( /@#) ke setiap sublist dari daftar input. Sublist pertama, kedua, ... dalam daftar yang dihasilkan seharusnya sama dengan sublist kedua, ketiga, ... di input asli; Most[...]==Rest@#tes untuk properti ini.

Greg Martin
sumber
4

Python 2 , 80 byte

lambda l:all(l[i+1]==map(sum,zip(l[i][::2],l[i][1::2]))for i in range(len(l)-1))

Cobalah online!

Tidak sebagus jawaban python lainnya, tapi saya merasa ingin mempostingnya. Ini hanya untuk menunjukkan mengapa saya tidak pandai golf dalam bahasa biasa .

DJMcMayhem
sumber
3

JavaScript (ES6), 54 byte

a=>!a.slice(-a.length/2).some((n,i)=>a[i+=i]+a[i+1]-n)

Mengambil array yang diratakan.

Neil
sumber
3

05AB1E , 15 12 byte

¬svyQy2ôO}\P

Cobalah online!

Penjelasan

¬             # get the first element from input without popping
 sv      }    # for each element y in input
   yQ         # compare y to the top of the stack 
              # leaves 1 on the stack if equal and otherwise 0
     y2ô      # split y in pieces of 2
        O     # sum each pair in the list
          \   # discard the top of the stack (the left over final element of the list)
           P  # product of stack (all the 1's and/or 0's from the comparisons)
Emigna
sumber
3

Haskell , 82 79 65 byte

-14 byte terima kasih kepada nimi!

p(x:y:z)=x+y:p z
f x=and.zipWith(==)(drop(length x`div`2+1)x)$p x

Bekerja dengan membandingkan jumlah setiap pasangan elemen dengan elemen yang sesuai pada baris berikutnya ke bawah. Beberapa byte mungkin bisa dipasangkan dari golf f, tapi saya tidak tahu di mana.

Julian Wolf
sumber
Anda dapat menambahkan dua nilai langsung dalam fungsi p: p(x:y:z)=x+y:p zdan kemudian menggunakan zipWith(==)bukannya zipdan menggabungkan daftar Booldengan and: f x=and.zipWith(==)(drop(length x`div`2+1)x)$p x.
nimi
2

Python 3 , 69 68 byte

lambda v:any(x+v[i-1]-v[(len(v)+i)//2]for i,x in enumerate(v)if i%2)

Saya tahu sudah ada dua jawaban python lain ... tapi yang ini dalam python 3, jadi ini eksotis.

Ini bekerja pada input yang diratakan.

Keluaran :

False jika tidak ada kesalahan,

True jika ada kesalahan.

Ben Frankel
sumber
2

Ruby, 50 byte

->x{a=b=0;b&&=x[a/2]==x[a]+x[a-1]while x[-a-=2];b}

Membalikkan array, elemen apa pun dari babak pertama (posisi n) harus merupakan jumlah elemen di posisi n * 2 dan n * 2 + 1.

GB
sumber
2

Brachylog , 16 13 byte

s₂ᵘ{{ġ₂+ᵐ}ᵈ}ᵐ

Cobalah online!

Ini sangat lama! Harus ada cara untuk tidak menempatkan predikat inline di sini.

Predikat berhasil (mencetak true.sebagai program) jika tidak ada kesalahan dibuat dan gagal (mencetak false.sebagai program) sebaliknya.

s₂ᵘ              Every length 2 substring of the input
   {       }ᵐ    for every element satisfies the following:
    {ġ₂          the pairs of elements of the input
       +ᵐ        when each pair is summed is the output
         }ᵈ      where the input is the first item and the output is the second.
String yang tidak terkait
sumber
1

Python 2 , 64 byte

lambda a:[map(int.__add__,x[::2],x[1::2])for x in a[:-1]]==a[1:]

Cobalah online!

Fungsi yang tidak disebutkan namanya yang mengambil daftar daftar (satu per baris bekerja seolah-olah), dan mengembalikan Benar jika tidak ada kesalahan dibuat dan Salah sebaliknya.

Ini bekerja dengan menggunakan input tanpa entri terakhir a[:-1],, untuk membentuk apa input tanpa entri pertama seharusnya dan memeriksa apa itu input ==a[1:],.

Formasi ini dicapai dengan memetakan fungsi penambahan tipe integer int.__add__,, pada pasangan angka yang dihasilkan oleh dua "irisan", satu irisan menjadi setiap item lainnya mulai dari indeks 0,, x[::2]irisan lainnya menjadi setiap item lainnya mulai dari tanggal 1 indeks x[1::2],.

Jonathan Allan
sumber
1

Pip , 20 19 byte

$*{{b=$+*Ya<>2}MPa}

Ini adalah fungsi anonim yang mengambil satu argumen, daftar daftar (misalnya [[1 2 3 4] [3 7] [10]]). Verifikasi semua kasus uji: Coba online!

Penjelasan

Dalam fungsi Pip, dua argumen pertama ditugaskan ke adan b.

  {               }  Anonymous function:
   {          }MPa    To each pair of sublists from a, map this helper function:
          a<>2         Group the 1st member of the pair into 2-item sublists
         Y             Yank that value (no-op used to override precedence order)
      $+*              Map (*) the fold ($) on addition (+) operator
    b=                 If the 2nd member of the pair is = to the result, 1; else 0
$*                   Modify the outside function by folding its return value on *
                     (makes a list containing all 1's into 1 and any 0's into 0)

Sebagai contoh:

a
[[1 2 3 4] [7 3] [10]]

{...}MP
a:[1 2 3 4] b:[7 3]
a:[7 3]     b:[10]

a<>2
[[1 2] [3 4]]
[[7 3]]

$+*
[3 7]
[10]

b=
0
1

Final result of {...}MPa
[0 1]

$*
0
DLosc
sumber
1

PHP, 96 95 byte:

menggunakan builtin:

function f($a){return!$a[1]||array_pop($a)==array_map(array_sum,array_chunk(end($a),2))&f($a);}
// or
function f($a){return!$a[1]||array_map(array_sum,array_chunk(array_shift($a),2))==$a[0]&f($a);}

fungsi rekursif kembali trueatau false.

kerusakan untuk fungsi pertama:

function f($a){
    return!$a[1]||      // true if array has no two rows ... or
    array_pop($a)==     // remove last row, true if equal to
    array_map(array_sum,    // 3. sum up every chunk
        array_chunk(        // 2. split to chunks of 2
            end($a)         // 1. new last row
        ,2))
    &f($a);             // and recursion returns true
}

solusi yang lebih lama (masing-masing 96 byte) menggunakan loop:

function f($a){foreach($a[0]as$k=>$v)$b[$k/2]+=$v;return$b==$a[1]&&!$a[2]|f(array_slice($a,1));}
//or
function f($a,$y=0){foreach($a[$y]as$k=>$v)$b[$k/2]+=$v;return$b==$a[++$y]&&!$a[$y+1]|f($a,$y);}

kerusakan untuk fungsi terakhir:

function f($a,$y=0){
    foreach($a[$y]as$k=>$v)$b[$k/2]+=$v;    // build $b with correct sums from current row
    return$b==$a[++$y]                      // true if $b equals next row
    &&!$a[$y+1]                             // and (finished
        |f($a,$y);                          //      or recursion returns true)
}

cuplikan berulang, 81 byte

for(;$a[1];)if(array_pop($a)!=array_map(array_sum,array_chunk(end($a),2)))die(1);
for(;$a[1];)if(array_map(array_sum,array_chunk(array_shift($a),2))!=$a[0])die(1);
for(;$a[++$y];$b=[]){foreach($a[$y-1]as$k=>$v)$b[$k/2]+=$v;if($a[$y]!=$b)die(1);}

menganggap array sudah ditentukan sebelumnya dalam $a; keluar dengan kesalahan jika salah.

Titus
sumber
1

C, 54 byte:

f(int*s,int*e){return e-s>1?*s+s[1]-*e||f(s+2,e+1):0;}

Tidak Disatukan:

int f(int*s,int*e) {
    if(e-s>1) {
        return *s+s[1] != *e || f(s+2,e+1);
    } else {
        return 0;
    }
}

Tes dengan

#include <assert.h>
int main() {
    int input1[15] = {6, 18, 9, 6, 6, 3, 8, 10, 24, 15, 9, 18, 39, 27, 66};
    assert(!f(input1, input1+8));

    int input2[7] = {3, 4, 5, 6, 7, 8, 9};
    assert(f(input2, input2+4));
}

Seperti yang Anda lihat, f()mengembalikan true untuk input yang tidak valid dan false (= 0) untuk input yang valid.

Seperti biasa, rekursi lebih kecil byte daripada iterasi, begitu f()juga rekursif, meskipun dibutuhkan dua iterator sebagai argumen. Ia bekerja dengan berulang kali membandingkan jumlah dari dua bilangan bulat pada ssatu bilangan bulat di e, mengabaikan batas level, dan melanjutkan sampai dua iterator bertemu. Saya juga telah menggunakan beberapa boolean zen bersama dengan fakta bahwa nilai integer non-nol dianggap benar dalam C untuk lebih memperpendek kode.

cmaster
sumber
1

R, 92 77 byte

Fungsi anonim yang mengambil urutan angka datar sebagai input. Pengembalian TRUEatau yang FALSEsesuai. Menggunakan pendekatan yang sama secara konseptual dengan jawaban python xnor.

function(x,l=sum(1|x)/2)all(rowSums(cbind(x[1:l*2-1],x[1:l*2]))==tail(x,l-1))

Solusi sebelumnya, menggunakan rollapplyfungsi dari zoopaket, dan mengambil input sebagai daftar, misalnya list(c(6, 18, 9, 6, 6, 3, 8, 10), c(24, 15, 9, 18), c(39, 27), c(66)):

function(l,T=1){for(i in 2:length(l))T=T&all(zoo::rollapply(l[[i-1]],2,sum,by=2)==l[[i]]);T}
rturnbull
sumber
1

JavaScript (ES6), 46 44 byte

Mengambil input sebagai array yang diratakan. Pengembalian NaNuntuk yang valid atau 0tidak valid.

f=([a,b,...c])=>a+b==c[c.length>>1]?f(c):b-b

Uji

Arnauld
sumber
0

PHP, 102 Bytes

masukan juga parameter url dalam format ?0=[1,2,3]&1=[3,3]&2=[6] ini menggunakan input ini[[int,int],[int]]

<?$r=[$_GET[0]];for(;count(end($r))>1;)$r[]=array_map(array_sum,array_chunk(end($r),2));echo$r==$_GET;

Kerusakan

$r=[$_GET[0]]; # Set the first item of the input in the result array 
for(;count(end($r))>1;) # till the last item in the result array has only one int
$r[]=array_map(array_sum,array_chunk(end($r),2));# add the next item to the result array
echo$r==$_GET; # compare the input array with the result array
Jörg Hülsermann
sumber
0

Japt, 10 byte

Mengambil input sebagai array 2-D.

äÏeXò mxÃe

Cobalah

äÏeXò mxÃe     :Implicit input of 2-D array
ä              :Reduce each consecutive pair of sub-arrays
 Ï             :By passing them through the following function as X & Y, respectively
  e            :  Test Y for equality with
   Xò          :    Split X on every 2nd element
      m        :    Map
       x       :      Reduce by addition
        Ã      :End function
         e     :All true?
Shaggy
sumber