डच बर्गर्सविरेनिनमर (BSN) ग्यारह-परीक्षण

Question

परिचय:

एक डच BSN (बर्गरसर्वर न्यूमर) तब मान्य होता है जब वह निम्नलिखित नियमों का अनुपालन करता है:

• इसमें केवल अंक होते हैं।
• लंबाई या तो लंबाई 8 या 9 होनी चाहिए।
• जब अंकों को निम्न के रूप में अनुक्रमित किया Aजाता है I, तो निम्नलिखित योग का परिणाम: 9xA + 8xB + 7xC + 6xD + 5xE + 4xF + 3xG + 2xH + -1xI(नोट 1 के बजाय -1!) को 11 से विभाज्य होना चाहिए, और 0 नहीं होना चाहिए।

चुनौती:

इनपुट: बीएसएन का प्रतिनिधित्व करने वाला एक स्ट्रिंग या चार-सरणी।

आउटपुट: एक सत्य या गलत परिणाम यह है कि इनपुट एक वैध बीएसएन है।

चुनौती नियम:

• इनपुट प्रारूप एक स्ट्रिंग या चार-सरणी होना चाहिए। आपको अंको के एक सरणी का उपयोग करने की अनुमति नहीं है, या एक (संभवतः अष्टाधारी) संख्या। (आपको इसे स्वयं के अंकों के अंतर-सरणी में बदलने की अनुमति है, हालांकि, सीधे तर्क के रूप में नहीं।)
• उपरोक्त इनपुट पर प्रतिबंध के बावजूद, आप मान सकते हैं कि सभी परीक्षण मामलों में एक या अधिक अंक होंगे ( [0-9]+)
• बीएसएनएल की लंबाई 9 के बजाय 8 के बारे में, डच विकिपीडिया में निम्नलिखित कहा गया है: " ग्यारह-परीक्षण के लिए और अन्य व्यावहारिक उपयोगों के लिए, लंबाई 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

@isaacg मैंने इस संबंध में (डच) विकिपीडिया पृष्ठ के लिंक के साथ नियम जोड़ा है। आप वास्तव में सही हैं, यह Aसूत्र से बाहर निकलता है (या मूल रूप 0से इसे लंबाई 9 बनाने के लिए एक अग्रणी जोड़ता है , जिसके परिणामस्वरूप इसे छोड़ दिया जाता है A)।

— केविन क्रूज़सेन

"सम [...] के लिए टेस्ट केस 0. नहीं होना चाहिए": 000000012

— betseg

@betseg मैंने इसे सूची में शामिल किया है

— केविन क्रूज़सेन

Answer 1

05AB1E , 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

जावास्क्रिप्ट (ईएस 6) 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 बाइट्स लंबा है :-)

— अरनॉल्ड 15

@Arnauld हां मुझे विश्वास नहीं हो रहा है कि मैंने फिर से गलत गिना , धन्यवाद

— edc65

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 अंतरिक्ष द्वारा अलग किए गए मान दर्ज करें और वे वर्णों के वेक्टर में संचित हैं। बारी-बारी से बीच-बीच में एंट्री मारकर उन्हें एक-एक करके डालें।

— बिलीवोब 15

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))। साथ ही, दो वैक्टरों के जोड़ीदार उत्पाद का योग उनके डॉट-गुणा के समान है %*%।

— JAD

@JarkoDubbeldam अच्छा! डॉट उत्पाद वास्तव में चतुर है।

— बिलीवॉब

Answer 4

जावास्क्रिप्ट (ईएस 6), 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 3 बाइट बचाने के लिए @MartinEnder को धन्यवाद !

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कि यह सही लंबाई का नहीं है।

— क्रिश्चियन सेवर्स

यह मेरे व्यक्तिगत बीएसएन के साथ काम नहीं करता है।

— roberrrt-s

उम्मीद है तय है।

— betseg

निश्चित नहीं। मेरा साथ काम नहीं करता है।

— डेविडपोस्टिल

@Roberrrt, @DavidPostill; क्या यह ठीक है या अब मुझे छोड़ देना चाहिए? = (

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

एक संख्यात्मक वेक्टर में एक्स को विभाजित करता है, फिर 0 को जोड़ता है यदि लंबाई 8 है, तो वेक्टर वाई और के डॉटप्रोडक्ट की गणना करता है c(9,8,7,6,5,4,3,2,-1)। टेस्ट यदि परिणाम नॉनजरो और 11 से विभाज्य है।

16 बाइट्स को @Enigma द्वारा तर्क के लिए धन्यवाद, संक्षेप में वेक्टर के निर्माण में 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)'

---

सत्य 1मूल्य के रूप में आउटपुट , 0या गलत मूल्यों के लिए कुछ भी नहीं है।

Comments

आप शुरुआत में कुछ बाइट्स बचा सकते हैं $r+=$_*(-1,2..9)[$i++]for reverse@F:। इसके अलावा, -F -pe(और अंतिम न्यूलाइन के बिना आपूर्ति की गई इनपुट, echo -nउदाहरण के लिए) पर्याप्त है (जब तक कि आपका पर्ल बहुत पुराना नहीं है, उस स्थिति में आपको किस -aचीज की आवश्यकता होगी (लेकिन हाल के पर्ल्स पर, यह इसके द्वारा निहित है -F) अंत में, आपका कोड 70 बाइट्स लंबा था। , 52 नहीं;)

— दादा

Answer 8

सी ++ 14, 107 106 बाइट्स

लूप के intबदले में 1 बाइट auto।

अनाम पैरामीटर के रूप में अनाम पैरामीटर के माध्यम से लौट रहा है। इनपुट की आवश्यकता होती है 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

Befunge, 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

MATL, 36 बाइट्स

नहीं सबसे लंबे समय तक Matl कार्यक्रम मैंने कभी लिखा है , लेकिन जैसे मैं कैसे if/ elseबयान भाषाओं गोल्फ में बहुत जल्दी बहुत लंबा मिलता है। मुझे लगता है कि यह समाधान MATL में इष्टतम नहीं हो सकता है, लेकिन अभी तक मैं इसे किसी भी तरह से अनुकूलित नहीं कर सकता। मैं कहीं और डबल 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-

— लुइस मेंडो

फिर से हराया :-P

— लुइस मेंडू

@LuisMendo बहुत बुरा। [a2:9]*एक गैर-तत्व-वार गुणा में परिणाम होता है, इसलिए दूसरे की !आवश्यकता होगी जो प्रारंभिक लाभ को ऑफसेट करेगा।

— Sanchises

Answer 11

MATL , 26 बाइट्स

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

परिणाम एक गैर-खाली कॉलम वेक्टर है, जो सत्य है अगर इसकी सभी प्रविष्टियां नॉनजरो हैं ।

इसे ऑनलाइन आज़माएं!

या एक अलग लाइन पर प्रत्येक परिणाम के साथ सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

यह निम्नलिखित क्रम में तीन स्थितियों का परीक्षण करता है:

1. भारित राशि nonzero है;
2. भारित राशि 11 से विभाजित होती है;
3. लंबाई 8 या 9 है।

'8925'स्पष्टीकरण के लिए इनपुट पर विचार करें । ;matrices के लिए पंक्ति विभाजक है।

!     % 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 को कैसे छोटा किया जाए Gn8-tg=।

— Sanchises

वैसे, एक कॉलम वेक्टर इनपुट बीएसएन का प्रतिनिधित्व करने वाले एक चार-सरणी के रूप में अर्हता प्राप्त नहीं करेगा , जो आपको पहले बचा रहा है !?

— Sanchises

@Sanchises समस्या यह है कि तब Gएक स्तंभ वेक्टर को धकेलता है और मुझे इसे पुनरावृत्ति करने के लिए स्थानांतरित करने की आवश्यकता हैg*

— लुइस मेंडू

ओह बिल्कुल सही। कोई बात नहीं!

— सांचेस 17

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बहुत से बाइट लेने के चेक ।

EDIT: लिन को धन्यवाद और 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

दुर्भाग्य से मैं केवल दो के बजाय एक उत्तर को स्वीकार कर सकता हूं, क्योंकि आपके पास @Emigna के 05AB1E उत्तर के समान 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

इनपुट के रूप में एक स्ट्रिंग लेता है। फ़ंक्शन '0'स्ट्रिंग के सामने एक जोड़ देता है चाहे उसे इसकी आवश्यकता हो या नहीं, और तत्वों को जोड़ने के लिए पायथन के नकारात्मक सूचकांकों का उपयोग करता है, स्ट्रिंग के अंत से शुरू होता है और बैक-टू-फ्रंट काम करता है।

-1xIअलग से नियंत्रित किया जाता है, के लिए एक दूसरी कॉल का उपयोग कर int()। मैं समझ नहीं पा रहा था कि मैं इससे ज्यादा बाइट खर्च किए बिना इससे कैसे बचूं।

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

PowerShell v2 +, 96 बाइट्स

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

ठीक है, मैं मानता हूँ, यह पूरी तरह गड़बड़ है। और यह थोड़े है। लेकिन, मेरे साथ सहन करो और हम इसके माध्यम से प्राप्त करेंगे।

हम इनपुट लेते हैं $n(एक charऐरे के रूप में ) और माइनस बूलियन मान के $iबराबर सेट 8करते हैं कि इसमें 8 आइटम हैं या नहीं $n। मतलब, अगर 8 आइटम हैं, तो $iहोगा 7।

अगला भाग हमारे आउटपुट के साथ गणना को जोड़ता है। अंदर से काम करते हुए, हम $nसाथ में लूप करते हैं $n|%{...}। या तो - हर यात्रा, हम में से दो परिणाम एक साथ आने के लिए एक छद्म त्रिगुट का उपयोग -"$_"या (($i+1)*+"$_")। सूचकांक इस बात पर आधारित है कि क्या $iहै 0या नहीं (यानी, हमने -1xIमामले को चुनौती समीकरण से मारा है), जो अगले गो-राउंड के लिए पदावनत हो जाता है। उन सभी को परेंसेंस में इकट्ठा किया जाता है और -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

PHP 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

PHP, 86 85 84 83 82 79 बाइट्स

नोट: नकारात्मक स्ट्रिंग सूचकांकों के लिए PHP 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

PHP <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 suffices, एक बाइट बचत
• कम से कम महत्वपूर्ण अंक घटाना करने के लिए छोटा रास्ता
• एक्सओआर के बजाय नेगेट चार, एक बाइट की बचत
• उपलब्ध -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.