ডাচ বার্গার্সভাইসেনামার (বিএসএন) এগারটি-পরীক্ষা

Question

পরিচিতি:

ডাচ বিএসএন (বার্গার সার্ভিস নুমার) বৈধ হয় যখন এটি নীচের নিয়মগুলি মেনে চলে:

• এটিতে কেবল সংখ্যা রয়েছে।
• দৈর্ঘ্যের দৈর্ঘ্য 8 বা 9 হওয়া উচিত।
• অঙ্কগুলি যখন এর Aমাধ্যমে সূচকযুক্ত হয় I, নিম্নলিখিত সংখ্যার ফলাফল: 9xA + 8xB + 7xC + 6xD + 5xE + 4xF + 3xG + 2xH + -1xI(1 এর পরিবর্তে -1 দ্রষ্টব্য!) 11 দ্বারা বিভাজ্য হওয়া উচিত, এবং 0 হওয়া উচিত নয়।

চ্যালেঞ্জ:

ইনপুট: BSN প্রতিনিধিত্বকারী একটি স্ট্রিং বা চর-অ্যারে।

আউটপুট: ইনপুটটি বৈধ BSN কিনা তা একটি সত্য বা মিথ্যা ফলাফল।

চ্যালেঞ্জ বিধি:

• ইনপুট ফর্ম্যাটটি স্ট্রিং বা চর-অ্যারে হওয়া উচিত। আপনাকে সংখ্যার কোনও আন্তঃরেে বা একটি (সম্ভবত অষ্টাল) নম্বর ব্যবহার করার অনুমতি নেই। (আপনাকে এটিকে নিজেকে সংখ্যার অন্তর্-অ্যারেতে রূপান্তর করার অনুমতি দেওয়া হয়েছে, তবে তর্ক হিসাবে সরাসরি নয়))
• উপরের ইনপুটটিতে সীমাবদ্ধতা সত্ত্বেও, আপনি ধরে নিতে পারেন যে সমস্ত পরীক্ষার ক্ষেত্রে এক বা একাধিক সংখ্যা থাকবে ( [0-9]+)
• দৈর্ঘ্য 8 পরিবর্তে 9 BSN সংক্রান্ত, ডাচ উইকিপিডিয়া মার্কিন যুক্তরাষ্ট্র নিম্নলিখিত: " এগারো-test এর জন্য এবং অন্যান্য ব্যবহারিক ব্যবহারের জন্য, একটি শূন্য দৈর্ঘ্য 9. সংখ্যা করতে যোগ করা হয় " ( উৎস )

সাধারাইওন রুল:

• এটি কোড-গল্ফ , তাই বাইট জেতে সংক্ষিপ্ত উত্তর।
  কোড-গল্ফ ভাষাগুলি আপনাকে নন-কোডগলফিং ভাষার সাথে উত্তর পোস্ট করতে নিরুৎসাহিত করবেন না। 'যে কোনও' প্রোগ্রামিং ভাষার পক্ষে যতটা সম্ভব সংক্ষিপ্ত উত্তর নিয়ে আসার চেষ্টা করুন।
• স্ট্যান্ডার্ড নিয়মগুলি আপনার উত্তরের জন্য প্রযোজ্য , সুতরাং আপনাকে সঠিক পরামিতিগুলি, সম্পূর্ণ প্রোগ্রামগুলির সাথে STDIN / STDOUT, ফাংশন / পদ্ধতি ব্যবহারের অনুমতি দেওয়া হবে। আপনার কল
• ডিফল্ট লুফোলগুলি নিষিদ্ধ।
• যদি সম্ভব হয় তবে আপনার কোডের জন্য একটি পরীক্ষার সাথে একটি লিঙ্ক যুক্ত করুন।
• এছাড়াও, প্রয়োজন হলে একটি ব্যাখ্যা যোগ করুন।

পরীক্ষার কেস:

// Truthy test cases:
111222333
123456782
232262536
010464554
10464554
44016773

// Falsey test cases:
000000000
192837465
247594057
88888888
73
3112223342
000000012

Comments

এটি কি সত্য যে যদি 8 টি সংখ্যা থাকে তবে Aপ্রদত্ত সূত্রটি থেকে একটি বাদ যায়?

— isaacg

@ আইসএইচজি আমি (ডাচ) উইকিপিডিয়া পৃষ্ঠার লিঙ্কের সাথে এ সম্পর্কিত নিয়ম যুক্ত করেছি। আপনি সত্যই বলেছেন, এটি Aসূত্রটি থেকে বাদ পড়ে (বা মূলত 0এটি দৈর্ঘ্য 9 করার জন্য একটি অগ্রণী যুক্ত করে, ফলস্বরূপ বাদ পড়ার মতো একই ফলস্বরূপ A)।

— কেভিন ক্রুইজসেন

"যোগফলের জন্য পরীক্ষার কেস [...] ০ হওয়া উচিত নয়": 000000012

— betseg

@ বিটসেগ আমি এটিকে তালিকায় যুক্ত করেছি

— কেভিন ক্রুইজসেন

Answer 1

05 এ বি 1 ই , 23 21 বাইট

`()DgLR*OD11Ö89¹gåP0Ê

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

ব্যাখ্যা

`                        # push input as individual chars onto stack
 (                       # negate top value
  )                      # wrap in list
   DgLR                  # range [len(input) ... 1]
       *O                # multiply with list of digits and sum
         D11Ö            # is evenly divisible by 11
             89¹gå       # len(input) is 8 or 9
                  P      # product of sum/divisible by 11/len in (8,9)
                   0Ê    # not equal to 0

Comments

সম্ভবত 05AB1E একটি পুরোনো সংস্করণ কারণে, কিন্তু আপনি পরিবর্তন করে 3 বাইট এখন সংরক্ষণ করতে পারবেন DgLকরার āএবং 0Êকরতে Ā। এটি অনলাইনে চেষ্টা করুন।

— কেভিন ক্রুইজসেন

Answer 2

জাভাস্ক্রিপ্ট (ES6) 57

অক্ষরের অ্যারে হিসাবে ইনপুট। reduceRightদিন বাঁচায়!

s=>!(i=1,t=s.reduceRight((t,v)=>t-v*++i),!t|t%11|(i|1)-9)

পরীক্ষা

F=
s=>!(i=1,t=s.reduceRight((t,v)=>t-v*++i),!t|t%11|(i|1)-9)


;['111222333','123456782','232262536','010464554','10464554','44016773']
.forEach(t=>{
  var r=F([...t]);console.log(t,r)
})

;['000000000','192837465','247594057','88888888','73','3112223342','3112223342']
.forEach(t=>{
  var r=F([...t]);console.log(t,r)
})

Comments

একটি reduceRightউত্তর দেখতে সর্বদা সুন্দর !

— নীল

অবশেষে 58 টির সাথে পৌঁছানোর একটি উপায় খুঁজে পেয়েছিল map(), কেবল বুঝতে পেরেছি যে আপনার উত্তরটি আসলে 57 বাইট দীর্ঘ :-)

— আর্নল্ড

@ আর্নল্ড হ্যাঁ আমি বিশ্বাস করতে পারি না আমি আবার ভুল বলে গণ্য করেছি , ধন্যবাদ

— এডসি 65

Answer 3

আর, 86 67 বাইট

সম্পাদনা করুন: ডট পণ্য প্রস্তাব দেওয়ার জন্য জারকো ডাবডেলডামকে ধন্যবাদ!

l=length(x<-scan(,""));s=as.double(x)%*%c(l:2,-1);!s%%11&s&l>7&l<10

স্টিডিন থেকে ইনপুট পড়ুন এবং অক্ষরের অ্যারে / ভেক্টর হিসাবে সঞ্চয় করুন। পরবর্তীকালে সংখ্যায় রূপান্তর করুন, ভেক্টরের সাথে গুণ করুন 9...2,-1এবং সমস্ত শর্তাদি পরীক্ষা করুন।

Comments

আমার জন্য কাজ করে না। আপনার xভেক্টর হিসাবে বিভক্ত করা উচিত ।

— djhurio

@ djhurio স্থান দ্বারা পৃথকীকৃত মানগুলি প্রবেশ করান এবং সেগুলি স্পষ্টভাবে অক্ষরের ভেক্টরে সংরক্ষণ করা হয়। বিকল্পভাবে একে একে প্রবেশ করুন এর মধ্যে প্রবেশের মাধ্যমে হিট করে।

— বিলিওব

if(l<9)x=c(0,x);s=sum(as.double(x)*c(9:2,-1))পরিণত হতে পারে s=sum(as.double(x)*c(l:2,-1))। এছাড়াও, দুটি ভেক্টরের পেয়ারওয়াই পণ্যগুলির যোগফল তাদের বিন্দু-গুণণের সমান %*%।

— জেএডি

নিবন্ধন করুন ডট পণ্য সত্যই চালাক।

— বিলিওব

Answer 4

জাভাস্ক্রিপ্ট (ES6), 61 60 59 58 বাইট

ইনপুট হিসাবে অক্ষরের একটি অ্যারে নেয়। রিটার্ন false/ true।

a=>!(a.map(c=>s-=--k?-c*k-c:c,k=a.length&9,s=0)|!s|k|s%11)

পরীক্ষার মামলা

let f =

a=>!(a.map(c=>s-=--k?-c*k-c:c,k=a.length&9,s=0)|!s|k|s%11)

// truthy
console.log(f([..."111222333"]));
console.log(f([..."123456782"]));
console.log(f([..."232262536"]));
console.log(f([..."010464554"]));
console.log(f([..."10464554"]));
console.log(f([..."44016773"]));

// falsy
console.log(f([..."000000000"]));
console.log(f([..."192837465"]));
console.log(f([..."247594057"]));
console.log(f([..."88888888"]));
console.log(f([..."73"]));
console.log(f([..."3112223342"]));

Answer 5

সি, 112 101 96 98 104 বাইট

আমার কোডটি ফিক্স করার সময় 5% বাইট সংরক্ষণ করার জন্য @ মার্টিনএেন্ডারকে ধন্যবাদ !

j,i,k,l;f(char*s){l=strlen(s);for(i=l,j=k=0;j<l;)k+=(s[j++]-48)*(i>1?i--:-1);return!(k%11)&&k&&(l^8)<2;}

অবৈধ হলে 0, বৈধ হলে 1 প্রদান করে। এটি অনলাইন চেষ্টা করুন!

Comments

এটি 61সঠিক দৈর্ঘ্যের না হলেও এটি গ্রহণ করে ।

— খ্রিস্টান সিভর্স

এটি আমার ব্যক্তিগত বিএসএন এর সাথে কাজ করে না।

— রবার্ট-এস

আশাকরি স্থির।

— betseg

অনির্ধারিত. আমার সাথেও কাজ করে না।

— ডেভিডপস্টিল

@ রবার্ট, @ ডেভিডপস্টিল; এখনই ঠিক আছে নাকি আমার হাল ছেড়ে দেওয়া উচিত? = (

— betseg

Answer 6

আর, 95 79 93 বাইট

function(x){y=as.double(el(strsplit(x,"")));z=y%*%c((q<-length(y)):2,-1);(z&!z%%11&q>7&q<10)}

যুক্তিযুক্ত ফাংশন যা যুক্তি হিসাবে একটি স্ট্রিং লাগে। প্রথমে আমি সংখ্যার পরিবর্তে ইনপুট হিসাবে স্ট্রিং থাকার প্রয়োজনীয়তাটি ছাপিয়েছি, তবে এটি ভাল, কারণ এটি রূপান্তরকরণে কিছু বাইট সংরক্ষণ করে।

আমি কীভাবে অক্ষরের অ্যারেটি ব্যাখ্যা করতে পারি তা নিশ্চিত নই, তবে এর অর্থ যদি আপনি "1" "2" "3" "4" etcইনপুট হিসাবে স্ট্রিংড ডিজিটের একটি ভেক্টর ব্যবহার করতে পারেন তবে এটি কিছুটা খাটোও হয়ে যায়:

function(x){y=as.double(x);z=y%*%c((q<-length(y)):2,-1);(z&!z%%11&q>7&q<10)}

X কে একটি সংখ্যাসূচক ভেক্টরে বিভক্ত করুন, তারপরে দৈর্ঘ্য 8 হলে একটি 0 যুক্ত করে, তারপরে ভেক্টর y এর ডটপ্রডাক্ট গণনা করে c(9,8,7,6,5,4,3,2,-1)। ফলাফল যদি উভয়ই ননজারো এবং 11 দ্বারা বিভাজ্য হয় তবে টেস্টগুলি।

@ ইনিগমা দ্বারা যুক্তিটির জন্য 16 বাইটস সংরক্ষণ করা হয়েছে, ভেক্টর তৈরিতে সুস্পষ্টভাবে 0 যুক্ত করা হয়েছে c(length(x):2,-1) ।

8/9 দৈর্ঘ্যের জন্য চেক যোগ করতে ভুলে গেছেন, সুতরাং +14 বাইট :(

Answer 7

পার্ল, 58 বাইট (52 + 6)

@N=(-1,2..9);$r+=$_*shift@N for reverse@F;$_=$r&&/^\d{8,9}$/&&!($r%11)

সাথে চালাও

perl -F// -lapE

ইনপুট এর মধ্য দিয়ে গেছে STDIN:

ব্যবহার

echo 232262536 | perl -F// -lapE '@N=(-1,2..9);$r+=$_*shift@N for reverse@F;$_=$r&&/^\d{8,9}$/&&!($r%11)'

---

আউটপুট 1truthy মান, যেমন জন্য 0বা falsey মানের জন্য কিছুই নেই।

Comments

আপনি শুরুতে কিছু বাইট সংরক্ষণ করতে পারেন: $r+=$_*(-1,2..9)[$i++]for reverse@F। এছাড়াও -F -pe(এবং echo -nউদাহরণস্বরূপ চূড়ান্ত নিউলাইন ছাড়াই সরবরাহ করা ইনপুট ) যথেষ্ট (যদি আপনার পার্ল খুব পুরানো না হয় তবে আপনার প্রয়োজন হবে -a(তবে সাম্প্রতিক পার্লসে এটি এর দ্বারা বোঝানো হবে -F) অবশেষে, আপনার কোডটি 70 বাইট দীর্ঘ ছিল , 52 নয়)

— দাদা

Answer 8

সি ++ 14, 107 106 বাইট

লুপের intপরিবর্তে autoইন -1 বাইট করুন ।

হিসাবে নামবিহীন ল্যাম্বদা রেফারেন্স প্যারামিটারের মাধ্যমে ফিরে আসছেন। ইনপুট হতে হবে std::stringবা চরের ধারক, যেমন প্রয়োজন vector<char>।

[](auto c,int&r){int i=c.size();r=7<i&&i<10?-2*c.back()+96:~1<<9;for(int x:c)r+=(x-48)*i--;r=r%11<1&&r>0;}

অবহেলিত এবং ব্যবহার:

#include<iostream>
#include<string>

auto f=
[](auto c, int& r){
 int i = c.size();
 //if the size is correct, init r to -2*I so we can add I safely later
 //otherwise such a big negative number, that the final test fails
 r = 7<i && i<10 ? -2*c.back()+96 : ~1<<9;
 for (auto x:c)
  r += (x-48)*i--;
 r = r%11<1 && r>0;
}
;

using namespace std;
using namespace std::literals;

int main(){
 int r;
 f("111222333"s,r); std::cout << r << std::endl;
 f("123456782"s,r); std::cout << r << std::endl;
 f("010464554"s,r); std::cout << r << std::endl;
 f("10464554"s,r); std::cout << r << std::endl;
 f("44016773"s,r); std::cout << r << std::endl;
 std::cout << std::endl;
 f("000000000"s,r); std::cout << r << std::endl;
 f("192837465"s,r); std::cout << r << std::endl;
 f("73"s,r); std::cout << r << std::endl;
 f("88888888"s,r); std::cout << r << std::endl;
 f("3112222342"s,r); std::cout << r << std::endl;
 std::cout << std::endl;
 f("99999999"s,r); std::cout << r << std::endl;
 f("999999999"s,r); std::cout << r << std::endl;
}

Answer 9

বেফুঞ্জ, 72 বাইট

>+~>:0`v
^1\-*68_\2/4-!00p*8>1-10p\910gv
@.!+!\%+56:*g00$  _^#!:g01+*-<<

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

ব্যাখ্যা

>+~>:0`v            Read characters from stdin until EOF, converting each digit into
^1\-*68_              a number on the stack, and keeping a count of the characters read.

      \2/4-!00p     Save !(count/2-4), which is only true for valid lengths (8 and 9).
               *    Multiply the EOF (-1) with the final digit; this is the initial total.

8>1-10p\910gv       Loop over the remaining 8 digits, multiplying each of them by 9-i and
 ^#!:g01+*-<<         add to the total; i goes from 7 down to 0, so 9-i goes from 2 to 9.

               $    Drop the loop counter.
           *g00     Multiply total by the length calculation (invalid lengths become 0).
      %+65:         Make a copy of the total, and calculate modulo 11.
    !\              Boolean not the other copy to check for zero. 
  !+                !(total%11 + !(total)) is only true for non-zero multiples of 11.
@.                  Output the result and exit.

Answer 10

এমএটিএল, 36 বাইট

আমি লিখেছি এমন দীর্ঘতম এমএটিএল প্রোগ্রাম নয়, তবে আমি পছন্দ করি if/ elseগল্ফিংয়ের ভাষাগুলিতে কীভাবে বিবৃতিগুলি খুব দীর্ঘ হয়। আমি মনে করি এই সমাধানটি এমএটিএল-এ অনুকূল নাও হতে পারে, তবে এখনও আমি এটিকে আর অনুকূল করতে পারি না। আমি কোথাও কোথাও ডাবল 0 ব্যবহার করার কথা ভাবছি এবং tএর সর্বত্রই বিচ্ছিন্ন হয়ে যেতে পারে ।

48-tn8=?0wh]tn9=?P[a2:9]*st11\~Y&}x0

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

48-                                  % Subtract 48 (ASCII '0')
   tn                                % Duplicate. Get length.
     8=?                             % If length equals 8
        0wh                          %     Prepend 0 to the duplicate
           ]                         % End if.
            t                        % Duplicate again.
             n9=?                    % If length equals 9.
                 P                   %     Reverse the duplicate
                  [a2:9]*            %     Element-wise product with [-1 2 ... 9]
                         s           %     Sum
                          t11\       %     Duplicate sum, modulus 11
                              ~Y&    %     Result on stack: modulus==0 AND sum!=0
                                 }   % Else
                                  x0 %     Remove the duplicate. Put 0 on stack.
                                     % Display implicitly.

Comments

আপনি যদি কলামের ভেক্টর দিয়ে করতে পারেন: !Uপরিবর্তে48-

— লুইস মেন্ডো

ইয়া :

— লুইস মেন্ডো

@ লুইস মেন্ডো খুব খারাপ। [a2:9]*অ-উপাদান-ভিত্তিক গুণণের ফলস্বরূপ, !আর একটির প্রয়োজন হবে যা প্রাথমিক লাভটি অফসেট করবে।

— সান্চাইসেস

Answer 11

এমএটিএল , 26 বাইট

!UGg*R!s0&)s-t11\~Gn8-tg=v

ফলাফলটি একটি খালি নয় কলামের ভেক্টর, যা সত্য যদি সত্য হয় যদি এর সমস্ত এন্ট্রি ননজারো হয় ।

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

অথবা প্রতিটি ফলাফলের সাথে সমস্ত পরীক্ষার কেসকে আলাদা লাইনে যাচাই করুন।

ব্যাখ্যা

এটি নিম্নলিখিত ক্রমে তিনটি শর্ত পরীক্ষা করে:

1. ওজনযুক্ত যোগফল ননজারো;
2. ওজনফল 11 দ্বারা বিভাজ্য;
3. দৈর্ঘ্য 8 বা 9।

'8925'ব্যাখ্যা জন্য ইনপুট বিবেচনা করুন । ;ম্যাট্রিক্সের জন্য সারি বিভাজক।

!     % Implicit input. Transpose into a column vecvtor
      % STACK: ['8'; '9'; '2'; '5']
U     % Convert each digit to number
      % STACK: [8; 9; 2; 5]
Gg    % Push a row array of ones as long as the input
      % STACK: [8; 9; 2; 5], [1 1 1 1]
*     % Multiply, element-wise with broadcast
      % STACK: [8 8 8 8; 9 9 9 9; 2 2 2 2; 5 5 5 5]
R     % Upper triangular part
      % STACK: [8 8 8 8; 0 9 9 9; 0 0 2 2; 0 0 0 5]
!     % Transpose
      % STACK: [8 0 0 0;8 9 0 0;8 9 2 0;8 9 2 5]
s     % Sum of each column. This multiplies last element by 1, second-last by 2 etc
      % STACK: [32 27 4 5]
0&)   % Split into last element and remaining elements
      % STACK: 5, [32 27 4]
s     % Sum of array
      % STACK: 5, 63
-     % Subtract
      % STACK: -58. This is the result of condition 1
t11\  % Duplicate. Modulo 11
      % STACK: -58, 8
~     % Logical negation
      % STACK: -58, 0. This gives condition 2
Gn    % Push numnber of entries in the input
      % STACK: -58, 0, 4
8-    % Subtract 8. For valid lengths (8 or 9) this gives 0 or 1
      % STACK: -58, 0, -4
tg    % Duplicate. Convert to logical: set nonzero values to 1
      % STACK: -58, 0, -4, 1
=     % 1 if equal, 0 otherwise. Lenghts 8 or 9 will give 1. This is condition 3
      % STACK: -58, 0, 0
v     % Vertically concatenate the entire stack. This is truthy iff all values 
      % are non-zero. Implicitly display
      % STACK: [-58; 0; 0]

Comments

সাবাশ. আমি অনুভব করেছি যে ছাড়া একটি পদ্ধতির ?সম্ভবত আরও দক্ষ হবে, তবে 8 বা 9. দৈর্ঘ্য কীভাবে সংক্ষিপ্ত করা যায় তা আমি বুঝতে পারি না Your আপনি Gn8-tg=খুব চালাক।

— সান্চাইজস

যাইহোক, কোনও কলামের ভেক্টর ইনপুট আপনাকে প্রথমে সংরক্ষণ করে বিএসএনের প্রতিনিধিত্বকারী চর-অ্যারে হিসাবে যোগ্যতা অর্জন করবে না !?

— সান্চাইজস

@ সাঞ্চাইজস সমস্যাটি হ'ল তারপরে Gএকটি কলাম ভেক্টরকে ধাক্কা দেয় এবং পুনরাবৃত্তিটি করার জন্য আমার এটি স্থানান্তরিত করতে হবেg*

— লুইস মেন্ডো

ওহ অবশ্যই। কিছু মনে করো না!

— Sanchises

Answer 12

হাস্কেল, 116 112 102 বাইট

f x=div(length x)2==4&&g x>0&&h x
h=((==0).(`mod`11)).g
g=sum.zipWith(*)(-1:[2..]).map(read.(:[])).reverse

gএগারো-প্রিফের জন্য ব্যবহৃত সমষ্টি গণনা করে h, fসঠিক দৈর্ঘ্যের জন্যও পরীক্ষা করে এবং এগারটি-প্রিফ 0 হয় না, বিশেষতf অনেকগুলি বাইট নেয়।

সম্পাদনা: লিন এবং divগোল করে ডাউনকে 10 টি বাইট সংরক্ষণ করা হয়েছে।

Comments

কীভাবে f x=div(length x)2==4&&g x>0&&h x?

— লিন

@ লিন: ধন্যবাদ একটি দুর্দান্ত।

— রেঞ্জি

Answer 13

জেলি , 21 বাইট

V€U×JN1¦µL:2=4×Sµ11ḍa

TryItOnline! বা সমস্ত পরীক্ষার কেস চালান

সত্যবাদী রিটার্ন মানগুলি শূন্য নয় (এবং বাস্তবে 11 টি যোগফলের একাধিক হয়)।

কিভাবে?

V€U×JN1¦µL:2=4×Sµ11ḍa - Main link: string of digits  e.g. "111222333"
V€                    - eval each - effectively cast each to an integer (keeps leading zeros)
  U                   - upend                        e.g. [ 3, 3, 3, 2, 2, 2, 1, 1, 1]
    J                 - range(length)                e.g. [ 1, 2, 3, 4, 5, 6, 7, 8, 9]
   ×                  - multiply                     e.g. [ 3, 6, 9, 8,10,12, 7, 8, 9]
      1¦              - apply to index 1 (first element)
     N                -     negate                   e.g. [-3, 6, 9, 8,10,12, 7, 8, 9]
        µ             - monadic chain separation   e.g. z=[-3, 6, 9, 8,10,12, 7, 8, 9]
         L            - length(z)                    e.g. 9
          :2          - integer divide by 2          e.g. 4
            =4        - equals 4?                    e.g. 1
               S      - sum(z)                       e.g. 66
              ×       - multiply                     e.g. 66
                µ     - monadic chain separation   e.g. z=66
                 11ḍ  - divides(11, z)               e.g. 1
                    a - and z (for z=0 case)         e.g. 66 (truthy)

Comments

দুর্ভাগ্যক্রমে আমি কেবল দুটিটির পরিবর্তে একটি উত্তর গ্রহণ করতে পারি, আপনার @ ইমিগানার 05 এবি 1 ই উত্তর হিসাবে আপনার 21 বাইট-গণনা একই । তবে যেহেতু এনিগমা তাড়াতাড়ি উত্তর দিয়েছে (এবং 21 বাইটগুলির জন্য তার সম্পাদনাটিও তাড়াতাড়ি হয়েছিল) আমি তার গ্রহণ করেছি।

— কেভিন ক্রুইজসেন

এটা আমার কাছে ফর্সা লাগে!

— জোনাথন অ্যালান

Answer 14

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

def f(i):S=sum(a*b for a,b in zip([-1]+range(2,10),map(int,i)[::-1]));return(7<len(i)<10)*(S%11<1)*S>0

Answer 15

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

def g(s):u=7<len(s)<10and sum(x*int(('0'+s)[-x])for x in range(2,10))-int(s[-1]);print(u%11<1)*u

ইনপুট হিসাবে একটি স্ট্রিং লাগে। ফাংশন যোগ করে a'0' স্ট্রিংয়ের সামনের অংশে যুক্ত করে এটির প্রয়োজন হয় বা না, এবং পাইথনের নেতিবাচক সূচকগুলি যুক্ত করে স্ট্রিংয়ের শেষ থেকে শুরু করে এবং পিছনে থেকে সামনের দিকে কাজ করে uses

-1xIআলাদাভাবে পরিচালিত হয়, এর একটি দ্বিতীয় কল ব্যবহার int()। আমার চেয়ে বেশি বাইট ব্যয় না করে কীভাবে এড়ানো যায় তা আমি বুঝতে পারি না figure

def g(s):u=7<len(s)<10and sum(x*int(('0'+s)[-x])for x in range(10))-2*int(s[-1]);print(u%11<1)*uঠিক যেমন ভাল কাজ থেকে এটি যোগ করবে 1বার s[-1]কিন্তু তারপর, এটা দুইবার বিয়োগ, এবং এটা যোগ হবে 0বার (কিছু) যা অবশ্যই সমষ্টি প্রভাব ফেলবে না।

Answer 16

মস্তিষ্ক-ফ্লাক , 345 বাইট

জন্য +3 অন্তর্ভুক্ত -a

([]){{}({}[((((()()()){}){}){}){}]<>)<>([])}{}<>([][(()()()()){}]){({}[()]){([]){{}{}([])}}}{}([{}])({}({}){})({}({})({}){})({}(({}){}){})({}(({})({})){}{})({}(({})({}){}){})({}((({}))({}){}){}{})({}((({}){}){}){})(({}(((({})){}){}){}{}{}<(((()()())()){}{})>)){{}({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{}[{}]<(())>){((<{}{}>))}{}(<()>)}{}

সত্যবাদী হ'ল 1, ফ্যালসির স্ট্যাকের শীর্ষে একটি 0 রয়েছে।

অনলাইনে চেষ্টা করে দেখুন!

আমি নিশ্চিত যে একটি লুপে গুণনের আরও ছোট উপায় আছে তবে আমি এটি এখনও পাইনি।

#reverse and subtract 48 from all numbers (ASCII -> decimal)
([]){{}({}[((((()()()){}){}){}){}]<>)<>([])}{}<> 

([][(()()()()){}])       #height - 8
{({}[()]){               #if not 0 subtract 1
   ([]){{}{}([])}        #if still not 0 pop everything
}}{}                     #this loop pops everything unless there are 8 or 9 digits

([{}])                   # -I
({}({}){})               # H*2
({}({})({}){})           # G*3
({}(({}){}){})           # F*4
({}(({})({})){}{})       # E*5
({}(({})({}){}){})       # D*6
({}((({}))({}){}){}{})   # C*7
({}((({}){}){}){})       # B*8
(({}(((({})){}){}){}{}{} # A*9 pushed twice with:
<(((()()())()){}{})>))   # 11 under it


{{} #if not 0
({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{}   # mod 11
[{}]<(())>){((<{}{}>))}{}                       # logical not
(<()>)                                          # push 0 to exit loop
}{}
                                                # implicit print

Answer 17

পাওয়ারশেল ভি 2 +, 96 বাইট

param($n)$i=8-($n.count-eq8);!(($b=($n|%{(-"$_",(($i+1)*+"$_"))[!!$i--]})-join'+'|iex)%11)-and$b

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

আমরা ইনপুট নিই $n( charঅ্যারে হিসাবে ) এবং সেখানে 8 টি আইটেম আছে কিনা তা বিয়োগের $iসমান সেট করুন । অর্থ, যদি 8 টি আইটেম থাকে তবে তা হবে ।8$n$i7

পরের অংশটি আমাদের আউটপুটের সাথে গণনা একত্রিত করে। ভিতর থেকে কাজ করছে, আমরা মাধ্যমে লুপ $nসঙ্গে$n|%{...} । প্রতিটি পুনরাবৃত্তি, আমরা দুটি ফলাফলের মধ্যে একটির সাথে আসতে সিডো-টের্নারি ব্যবহার করি - হয় -"$_"বা হয় (($i+1)*+"$_")। সূচক কিনা উপর ভিত্তি করে তৈরি $iকরা হয় 0বা না (অর্থাত, আমরা আঘাত করেছি -1xI, যা পায় চ্যালেঞ্জ সমীকরণ থেকে কেস) পরের যেতে বৃত্তাকার জন্য পোস্ট decremented। এগুলি সমস্ত প্যারেন্সে জড়ো হয় এবং তাদের -joinসাথে একত্রিত হয় +। উদাহরণস্বরূপ, ইনপুট 111222333সহ এই মুহুর্তে আমাদের 9+8+7+12+10+8+9+6+-3। এটিতে পাইপ করা হয় iex(এতে সংক্ষিপ্ত হওয়ার আগে সংক্ষিপ্ত Invoke-Expressionএবং অনুরূপeval$b । আমরা তারপরে এটি গ্রহণ করি%11 এবং একটি বুলিয়ান-না সম্পাদন করি!(...)এটির উপর (যেমন, যদি এটি 11 দ্বারা বিভাজ্য হয় তবে এই অংশটি হবে$true)। এটি শূন্য-শূন্য -and$bকিনা তা নিশ্চিত করার সাথে মিলিত হয়েছে $b। সেই বুলিয়ান ফলাফলটি পাইপলাইনে রেখে গেছে এবং আউটপুট অন্তর্ভুক্ত।

উদাহরণ

PS C:\Tools\Scripts\golfing> 111222333,123456782,232262536,010464554,10464554,44016773|%{"$_ -> "+(.\dutch-burgerservicenummer.ps1 ([char[]]"$_"))}
111222333 -> True
123456782 -> True
232262536 -> True
10464554 -> True
10464554 -> True
44016773 -> True

PS C:\Tools\Scripts\golfing> 000000000,192837465,247594057,88888888,73,3112223342,000000012|%{"$_ -> "+(.\dutch-burgerservicenummer.ps1 ([char[]]"$_"))}
0 -> False
192837465 -> False
247594057 -> False
88888888 -> False
73 -> False
3112223342 -> False
12 -> False

Answer 18

পিএইচপি 139 128 বাইট

 $u=-1;$i=$argv[1];while($u<=strlen($i)){$c+=($u*(substr($i,-(abs($u)),1)));$u +=$u<0?3:1;}echo($c>0&&!($c%11)&&$u>8&&$u<11?1:0);

কেবল মিথ্যাটির সত্য প্রতিধ্বনিত করতে সি এল এল পাচ্ছিল না। এইভাবে এটি করা ছিল। কোন ধারনা?

128 বাইট: "সত্য" এবং "মিথ্যা" 1 এবং 0 তে পরিণত হয়েছে।

Answer 19

সি #, 120 115 বাইট

এটি char[]ইনপুট হিসাবে গ্রহণ করে এটি লুপ করে এবং সত্য বা মিথ্যা ফেরত দেয়:

bool b(char[]n){int r=0,k,i=0,l=n.Length;for(;i<l;i++){k=i==l-1?-1:l-i;r+=k*(n[i]-48);}return r>0&r%11<1&l<10&l>7;}

ফিডল: https://dotnetfiddle.net/3Kaxrt

আমি নিশ্চিত যে আমি কয়েকটা বাইট ছড়িয়ে দিতে পারি, বিশেষত অগোছালো অবস্থায় return। কোন ধারণা স্বাগত!

সম্পাদনা করুন: কেভিনকে ধন্যবাদ 5 বাইট সংরক্ষিত আমি &পরিবর্তে আমি ব্যবহার করতে পারেন কোন ধারণা ছিল &&!

Comments

+1 টি! r>0&&r%11==0&&l<10&&l>7থেকে golfed যাবে r>0&r%11<1&l<10&l>7( &&থেকে &এবং r%11==0থেকে r%11<1)। এবং -'0'গল্ফ করা যেতে পারে -48।

— কেভিন ক্রুইজসেন

Answer 20

পিএইচপি, 86 85 84 83 82 79 বাইট

দ্রষ্টব্য: নেতিবাচক স্ট্রিং সূচকগুলির জন্য পিএইচপি 7.1 ব্যবহার করে।

for($l=log10($a=$argn);~$c=$a[-++$x];)$s+=$x>1?$x*$c:-$c;echo$s%11<1&$l>7&$l<9;

এভাবে চালান:

echo 010464554 | php -nR 'for($l=log10($a=$argn);~$c=$a[-++$x];)$s+=$x>1?$x*$c:-$c;echo$s%11<1&$l>7&$l<9;';echo
> 1

পিএইচপি <7.1 (+10 বাইট) এর জন্য সংস্করণ

echo 010464554 | php -nR 'for($l=log10($a=$argn);~$c=$a[strlen($a)-++$x];)$s+=$x>1?$x*$c:-$c;echo$s%11<1&$l>7&$l<9;';echo

ব্যাখ্যা

for(
  $l=log10(         # Take the log of the input number.
    $a=$argn        # Set input to $a
  );
  ~$c=$a[-++$x];    # Iterate over digits of input (reverse). Negate to
                    # change every char to extended ASCII (all truthy),
                    # without changing empty sting (still falsy, ending
                    # the loop).
)
  $s+=$x>1?         # Add current char to the sum...
     ?$x*$c:-$c;    # multiplied by $x, unless $x is 1; subtract it.
echo
  $s%11<1 &         # Check if sum is divisible by 11, and
  $l>7   &          # log of the input is greater than 7, and
  $l<9;             # log of the input is less than 9. Outputs 0 or 1.

বদলান

• খালি স্ট্রিং এবং এর মধ্যে পার্থক্য করার জন্য ছোট উপায় "0" , একটি বাইট সংরক্ষণ করা
• যেহেতু 10000000অবৈধ তাই এর সাথে তুলনা করার দরকার নেইgreater than or equals ,greater than যথেষ্ট, একটি বাইট সংরক্ষণ
• সর্বনিম্ন উল্লেখযোগ্য অঙ্ককে বিয়োগ করার জন্য ছোট উপায়
• এক্সওআরের পরিবর্তে নেগেট চর, একটি বাইট সংরক্ষণ করা
• উপলব্ধ -Rকরতে ব্যবহার করে 3 বাইট সংরক্ষণ করা হয়েছে$argn

Answer 21

জাভা 8, 115 98 বাইট

b->{int l=b.length,i=0,r=0,x;for(;l>7&l<10&i<l;r+=(b[i++]-48)*(x<2?-1:x))x=l-i;return r>0&r%11<1;}

আমি অবাক হয়েছি এখনও কেউ জাভা উত্তর পোস্ট করেনি, তাই এখানে একটি।

ব্যাখ্যা:

এখানে চেষ্টা করুন।

b->{                  // Method with character-array as parameter and boolean return-type
  int l=b.length,     //  Length of the array
      i=0,            //  Index-integer, starting at 0
      r=0,            //  The result-sum, starting at 0
      x;              //  Temp integer `x`
  for(;l>7&l<10       //  Start looping if the length is either 8 or 9
       &i<l;          //  And continue looping while the index is smaller than the length
      r+=             //    After every iteration, increase the result-sum by:
         (b[i++]-48)  //     The current digit
         *(           //     Multiplied by:
           x<2?       //      If `x` is 1:
            -1        //       Multiply by -1
           :          //      Else:
            x))       //       Simply multiply by `x` 
    x=l-i;            //   Set `x` to the length minus the current index
                      //  End of loop (implicit / single-line body)
  return r>0          //  Return if the result-sum is larger than 0,
    &r%11<1;          //   and if the result-sum is divisible by 11
}                     // End of method

Answer 22

ক্লোজার, 114 বাইট

ওয়েল এটি কিছু, -প্রথমটি থেকে বাকী আর্গুমেন্টগুলি বাদ দেয় যাতে ওজনের বিশেষ ক্ষেত্রে পরিচালনা করা হয় -1। এই ফাংশনটি nilঅবৈধ দৈর্ঘ্যের ইনপুটগুলির জন্য ফেরত দেয় , তবে ifধারাগুলিতে তারা একই হিসাবে কাজ করে false। (#{8 9}(count v))আয় nilযদি দৈর্ঘ্যের v8 বা 9 নয়।

(fn[v](if(#{8 9}(count v))(#(and(< % 0)(=(mod % 11)0))(apply -(map *(range 1 10)(reverse(map #(-(int %)48)v)))))))

পরীক্ষার কেস:

(pprint (group-by f (map str [123456782 232262536 "010464554" 10464554 44016773 "000000000" 192837465 247594057 88888888 73 3112223342 "000000012"])))
{true  ["123456782" "232262536" "010464554" "10464554" "44016773"],
 false ["000000000" "192837465" "247594057" "88888888" "000000012"],
 nil   ["73" "3112223342"]}

Answer 23

পার্ল 5 , 63 + 2 ( -F) = 65 বাইট

$F[-1]*=-1;map$s+=++$i*$_,reverse@F;say/^.{8,9}$/&&$s&&!($s%11)

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

Answer 24

স্ট্যাক্স , 23 বাইট

╪╦µΘç}<╔▼◘╞i∟~¿≥←║▐√ 4u

চালান এবং অনলাইন ডিবাগ!

ব্যাখ্যা

ব্যাখ্যা করার জন্য আনপ্যাক করা সংস্করণ ব্যবহার করে।

i%8A:byr{]ei^*mBN+|+c11%!L|A
i                               Suppress implicit eval
 %8A:b                          Length is 8 or 9 (Element #1 on the final stack)
      yr                        Reverse input
        {     m                 Map each element with
         ]e                         Its numerical value
           i^*                      Multiplied current 1-based loop index
               BN+              Negate the first element
                  |+            Sum (Element #2 on the final stack)
                    c11%!       Sum is multiple of 11 (Element #3 on the final stack)
                         L|A    Collect all the three elements and `and` them.