32

কখনও কখনও, যখন আমি সত্যিই বিরক্ত হয় আমি অ-নেতিবাচক পূর্ণসংখ্যার অ্যারের যোগফল নিতে পছন্দ করি। আমি কেবল দৈর্ঘ্যের অ্যারেগুলির যোগফল গ্রহণ করি যা দুটি শক্তি। দুর্ভাগ্যক্রমে আমি প্রায়শই ভুল করি। ভাগ্যক্রমে আমি নিম্নলিখিত উপায়ে এগিয়ে চলার সাথে সাথে আমার কাজ সম্পর্কে নজর রাখি:

কেবলমাত্র একটি বাকী না হওয়া পর্যন্ত আমি সংলগ্ন সংখ্যাগুলির জোড় যুক্ত করি। উদাহরণ স্বরূপ:

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

আমি কাজটি কোথাও ভুল করেছি কিনা তা নির্ধারণ করা আপনার কাজ। আপনি হয় আপনার কার্যক্রমে ইনপুট পাস করতে পারেন বা স্ট্যান্ডার্ড ইন থেকে পড়তে পারেন Out

ইনপুট: একটি অ্যারে / তালিকা / ইত্যাদি। অ-নেতিবাচক পূর্ণসংখ্যার এবং সম্ভবত আপনার ভাষার প্রয়োজন হলে সেই অ্যারের দৈর্ঘ্য। এই অ্যারেটি বাম থেকে ডানদিকে উপরে এবং নীচে নীচে পড়া সমস্ত সংখ্যা হবে। উদাহরণস্বরূপ উপরের অ্যারেটি হয়ে উঠবে:
[[6, 18, 9, 6, 6, 3, 8, 10], [24, 15, 9, 18], [39, 27], [66]]
বা
[6, 18, 9, 6, 6, 3, 8, 10, 24, 15, 9, 18, 39, 27, 66]আপনি যদি পছন্দ করেন।

আউটপুট: একটি ভুল হয়েছে কিনা তা উপস্থাপন করে এমন একক বুলিয়ান। বুলিয়ান যে কোনও ব্যবহার করে প্রতিনিধিত্ব করা যায় যে ম্যাপিং যদি শর্ত থাকে যে সমস্ত ইনপুট যেখানে কোনও ভুল ফেরত দেওয়া হয় / একটি অভিন্ন ফলাফল মুদ্রণ করে এবং কোনও ইনপুট যাতে কোনও ভুল থাকে না সেগুলি প্রেরণ / অভিন্ন ফলাফল মুদ্রণ করে। এটি না বলেই যাওয়া উচিত, তবে two দুটি ফলাফল একই হতে পারে না।

সঠিক সংক্ষেপণের কয়েকটি উদাহরণ:

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]]

ভুল সমষ্টি সম্পর্কিত কয়েকটি উদাহরণ:

5+4
=8

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

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

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

মনে রাখবেন যে আমি ভুল করতে পারি এবং এখনও সঠিক উত্তর পেতে পারি। যদি আমি কোনও ভুল করে থাকি তবে এটি চূড়ান্ত অ্যারেটিতে কোনও অতিরিক্ত নম্বর বা অনুপস্থিত সংখ্যার ফলস্বরূপ হবে না, কেবল একটি ভুল সংখ্যা।

স্ট্যান্ডার্ড লুফোলগুলি নিষিদ্ধ। প্রতিটি ভাষার সংক্ষিপ্ত উত্তর একটি বিজয়ী is টাইয়ের ক্ষেত্রে পুরানো উত্তরটি জিতবে। আমি "একই ভাষা" কী তা সিদ্ধান্ত নেওয়ার অধিকার বজায় রেখেছি, তবে আমি সামনেই বলব পাইথন 2 এবং পাইথন 3 উভয় ক্ষেত্রেই পয়েন্ট অর্জন করা যায় না।

— বিজন
সূত্র

1

সাইটে স্বাগতম! ভাল প্রথম চ্যালেঞ্জ।

— অ্যাডমবার্কবার্ক

কেন শেষ তারিখ? চ্যালেঞ্জের চেয়ে নতুন ভাষা ইতিমধ্যে ডিফল্টরূপে নিষিদ্ধ।

— Rɪᴋᴇʀ

আমি মনে করি আমি এটি সরিয়ে ফেলতে পারলাম, ধারণাটি ছিল আমার কিছু কাটফট থাকা উচিত যাতে আমি উত্তরগুলির সেটকে সঠিক হিসাবে মুকুট করতে পারি, তবে আমার ধারণা এটি সেভাবে হবে না।

— বিজন

1

না, আপনি যে কোনওটি গল্ফিংকে সহজ করে তুলতে পারেন।

— বিজন

উদাহরণটি [0,1,2,3,1,5,6]অবৈধ কারণ "ইনপুট: ধনাত্মক পূর্ণসংখ্যার একটি অ্যারে / তালিকা / ইত্যাদি"।

— বেন ফ্রাঙ্কেল

10

জেলি , 6 বাইট

Ṗ+2/€ẇ

এটি অনলাইন চেষ্টা করুন!

কিভাবে এটা কাজ করে

Ṗ+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.

— ডেনিস
সূত্র

9

পাইথন 2 , 51 বাইট

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

এটি অনলাইন চেষ্টা করুন! পরীক্ষার মামলার জন্য রডকে ধন্যবাদ

পুরো তালিকাটিকে ইনপুট হিসাবে ফ্ল্যাট করে। জিপ / ইটার ট্রিক ব্যবহার করে সংলগ্ন জোড়গুলিতে উপাদানগুলিকে গোষ্ঠীভুক্ত করে , জোড়ার যোগফল নিয়ে যায় এবং ফলাফলটি তালিকার দ্বিতীয়ার্ধের সমান হয় কিনা তা পরীক্ষা করে।

একটি recursive পদ্ধতি 55 বাইট কাছাকাছি এসেছিল:

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

এটি ব্যবহৃত হয় যে ইনপুট পূর্ণসংখ্যাগুলি ইতিবাচক হয়, যা থেকে শুরুতে পরিবর্তন হয়।

— xnor
সূত্র

যেহেতু প্রশ্নের শর্তাদি এখন অ-নেতিবাচক প্রবেশের অনুমতি দেয় তাই আপনার পুনরাবৃত্ত পদ্ধতিটি একটি মিথ্যা ধনাত্মক দেয় [0,0,1,1,1,1,1]।

— বেন ফ্রাঙ্কেল

7

Röda , 40 বাইট

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

এটি অনলাইন চেষ্টা করুন!

এটি একটি বেনামি ফাংশন যা ফিরে আসে 0 যদি কোনও ভুল না হয় এবং যদি ভুল থাকে তবে কিছুই হয় না।

ব্যাখ্যা:

{[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 */

এখানে একটি সংস্করণ সংক্ষিপ্ত (35 বাইট) তবে নিয়মের বিপরীতে (আমার মনে হয়):

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

এটি অনলাইন চেষ্টা করুন!

এটি একটি বেনাম ফাংশন যা স্ট্রিমের মানগুলি এবং পুশ করে TRUEবা FALSEপ্রতিটি সঠিক লাইনের জন্য পাঠ করে ।

আমি নিশ্চিত নই যে এটি (একাধিক ফেরতের মান) নিয়মে গৃহীত হয়েছে কিনা। এখানে আমার প্রতিরক্ষা: রডায় শর্তসমূহ ifএবং whileব্লকগুলি বুলিয়ান মান নয়, তবে স্ট্রিম। একটি "সত্যবাদী" স্ট্রিম হয় ফাঁকা বা এতে কেবল TRUEগুলি থাকে এবং একটি "নকল" প্রবাহে এক বা একাধিক FALSEগুলি থাকে। এইভাবে, এই ফাংশনটি একটি "বুলিয়ান" মান প্রদান করে। এবং ifকোনও হ্রাস-অপারেশন ইত্যাদি ছাড়াই একটি বিবৃতি শর্ত হিসাবে ব্যবহার করা যেতে পারে

— fergusq
সূত্র

আমি গণনা করি কিনা তা নিশ্চিত নই, তবে আপাতত আপনার কাছে একমাত্র রডা সমাধান রয়েছে, সুতরাং অন্য কেউ উপস্থিত না হওয়া পর্যন্ত বলা শক্ত। আমি মনে করি এটি ঠিক হওয়া উচিত, তবে প্রশ্নটি উঠে যাওয়ার পরে নিয়মগুলি টুইট করার ধারণাটি আমার পছন্দ হয় না। যদিও এটির ক্ষেত্রে এটি কোনও নিয়ম পরিবর্তন না করে এতটা অস্পষ্টতা পূরণের ক্ষেত্রে মামলা করতে পারে।

— বিজন

2

@ বিজান অন্যান্য ভাষাতেও একই ধরণের কাঠামো রয়েছে। এমএটিএলে, উদাহরণস্বরূপ, এর মধ্যে একটিও থাকলে পুরো অ্যারেটি মিথ্যা 0। রডা কীভাবে এটি পরিচালনা করে তা আমি নিশ্চিত নই, তবে এটি শোনা যায় না।

— অ্যাডমবর্কবার্ক

1

@Bijan Our definition of truthy/falsy depends on what the language would do for an if conditional. If this is how Röda works, it complies with our rules, unless the challenge spec overrides the defaults explicitly.

— Dennis

@Dennis It seems that the OP has forbidden this: "all inputs where a mistake is made return/print an identical result and all input which contain no mistakes return/print an identical result." The shorter variation of the program has an infinite number of outputs.

— fergusq

@fergusq Oh, right, I've overlooked that.

— Dennis

5

Python 2, 69 65 bytes

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

Try it online!
Returns :
Empty List as Falsy
Total sum as Truthy

— Rod
সূত্র

5

Mathematica, 36 bytes

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

Pure function taking a nested list as input and returning True or False. The function Tr/@#~Partition~2& takes the pairwise sums of a list, which is then applied (/@#) to each sublist of the input list. The first, second, ... sublists in the resulting list are supposed to equal the second, third, ... sublists in the original input; Most[...]==Rest@# tests for this property.

— Greg Martin
সূত্র

4

Python 2, 80 bytes

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

Try it online!

Not quite as good as the other python answer, but I felt like posting it anyway. This just goes to show why I'm not as good at golfing in regular languages.

— DJMcMayhem
সূত্র

3

JavaScript (ES6), 54 bytes

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

Takes a flattened array.

— Neil
সূত্র

3

05AB1E, 15 12 bytes

¬svyQy2ôO}\P

Try it online!

Explanation

¬             # 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
সূত্র

3

Haskell, 82 79 65 bytes

-14 bytes thanks to nimi!

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

Works by comparing the sum each pair of elements to the corresponding element on the next line down. Some bytes can probably be golfed from f, but I can't figure out where.

— Julian Wolf
সূত্র

You can add the two values directly in function p: p(x:y:z)=x+y:p z and then use zipWith(==) instead of zip and combine the list of Bool with and: f x=and.zipWith(==)(drop(length x`div`2+1)x)$p x.

— nimi

2

Python 3, 69 68 bytes

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

I know there are already two other python answers... but this one's in python 3, so it's exotic.

This works on a flattened input.

Output:

False if there is no mistake,

True if there is a mistake.

— Ben Frankel
সূত্র

2

Ruby, 50 bytes

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

Reversing the array, any element of the first half (position n) must be the sum of the elements in position n*2 and n*2+1.

— G B
সূত্র

2

Brachylog, 16 13 bytes

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

Try it online!

This is just dreadfully long! There has to be some way to not nest inline predicates here.

The predicate succeeds (printing true. as a program) if no mistakes were made and fails (printing false. as a program) otherwise.

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.

— Unrelated String
সূত্র

1

Python 2, 64 bytes

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

Try it online!

An unnamed function that takes a list of lists (one per line of working as it were), and returns True if no mistakes were made and False otherwise.

It works by using the input without the last entry, a[:-1], to form what the input without the first entry should be and checking that is what was input, ==a[1:].

This formation is achieved by mapping the integer type's addition function, int.__add__, over the pairs of numbers as yielded by two "slices", one slice being every other item starting at the 0th index, x[::2], the other slice being every other item starting at the 1st index, x[1::2].

— Jonathan Allan
সূত্র

1

Pip, 20 19 bytes

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

This is an anonymous function that takes one argument, a list of lists (e.g. [[1 2 3 4] [3 7] [10]]). Verify all test cases: Try it online!

Explanation

In a Pip function, the first two arguments are assigned to a and 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)

For example:

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
সূত্র

1

PHP, 96 95 bytes:

using builtins:

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);}

recursive functions return true or false.

breakdown for first function:

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
}

older solutions (96 bytes each) using loops:

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);}

breakdown for last function:

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)
}

iterative snippets, 81 bytes

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);}

assume array predefined in $a; exits with error if it is incorrect.

— Titus
সূত্র

1

C, 54 bytes:

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

Ungolfed:

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

Test with

#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));
}

As you see, f() returns true for invalid inputs and false (= 0) for valid ones.

As always, recursion is less bytes than iteration, so f() is recursive, even though it takes two iterators as arguments. It works by repeatedly comparing the sum of two integers at s to one integer at e, ignoring the level boundaries, and carrying on until the two iterators meet. I have also used some boolean zen together with the fact that any non-zero integer value is considered true in C to further shorten the code.

— cmaster
সূত্র

1

R, 92 77 bytes

Anonymous function which takes a flat sequence of numbers as input. Returns TRUE or FALSE as appropriate. Uses the same approach conceptually as xnor's python answer.

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

Previous solution, using the rollapply function from the zoo package, and taking input as a list, e.g. 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
সূত্র

1

JavaScript (ES6), 46 44 bytes

Takes input as a flattened array. Returns NaN for valid or 0 for invalid.

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

Test

Show code snippet

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

console.log(f([6, 18, 9, 6, 6, 3, 8, 10, 24, 15, 9, 18, 39, 27, 66])) // NaN
console.log(f([0, 1, 2, 3, 1, 5, 6]))                                 // NaN
console.log(f([1, 2, 4, 8, 3, 12, 15]))                               // NaN
console.log(f([1, 2, 3, 4, 7, 3, 10]))                                // 0
console.log(f([3, 4, 5, 6, 7, 8, 9]))                                 // 0

Expand snippet

— Arnauld
সূত্র

0

PHP, 102 Bytes

input als url parameter in this format ?0=[1,2,3]&1=[3,3]&2=[6] use this input [[int,int],[int]]

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

Breakdown

$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
সূত্র

0

Japt, 10 bytes

Takes input as a 2-D array.

äÏeXò mxÃe

Try it

äÏ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
সূত্র

সুপিরিয়র পাসটাইমস

জেলি , 6 বাইট

কিভাবে এটা কাজ করে

পাইথন 2 , 51 বাইট

Röda , 40 বাইট

Python 2, 69 65 bytes

Mathematica, 36 bytes

Python 2, 80 bytes

JavaScript (ES6), 54 bytes

05AB1E, 15 12 bytes

Haskell, 82 79 65 bytes

Python 3, 69 68 bytes

Ruby, 50 bytes

Brachylog, 16 13 bytes

Python 2, 64 bytes

Pip, 20 19 bytes

Explanation

PHP, 96 95 bytes:

C, 54 bytes:

R, 92 77 bytes

JavaScript (ES6), 46 44 bytes

Test

PHP, 102 Bytes

Breakdown

Japt, 10 bytes