विभाजक तार

Question

टास्क

एक स्ट्रिंग को देखते हुए s, एक सत्य मान का उत्पादन करें यदि प्रत्येक अक्षर का एएससीआईआई कोड लंबाई से विभाज्य है s, और एक फाल्सी अन्यथा।

इनपुट आउटपुट

इनपुट एक गैर-रिक्त स्ट्रिंग है जिसमें केवल ASCII है [32-126]। आउटपुट एक मानक सत्य / गलत मूल्य है। ध्यान दें कि आप मानों को स्विच कर सकते हैं, उदाहरण के लिए 0/ Falseयदि विभाज्य और इसके विपरीत

परीक्षण के मामलों

Input         Output

Hello         False       (72 101 108 108 111), 5
lol           True        (108 111 108), 3
Codegolf      False       (67 111 100 101 103 111 108 102), 8
A             True        (65), 1
nope          False       (110 111 112 101),4
8  8          True        (56 32 32 56), 4

Answer 1

MATL , 4 बाइट्स

tn\~

• विभाज्य तारों के लिए आउटपुट केवल 1एस युक्त एक वेक्टर है , जो सत्य है ।
• अन्यथा आउटपुट एक वेक्टर है जिसमें कई 1एस और कम से कम एक होता है 0, जो मिथ्या है ।

इसे ऑनलाइन आज़माएं! या सत्यता / मिथ्या परीक्षा सहित सभी परीक्षण मामलों को सत्यापित करें ।

यह काम किस प्रकार करता है

t   % Implicit input. Duplicate
n   % Number of elements
\   % Modulo
~   % Negate. Implicit display

Answer 2

Befunge-98 (FBBI) , 31 बाइट्स

आउटपुट एक्ज़िट कोड के माध्यम से है 1, 0सच्चाई के लिए , फाल्सी मामलों के लिए।

#v~\1+
v>53p
>:#v_1q
^  >' %#@_

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

---

इनपुट्स के साथ चलने वाला कोड lolऔर ab:

^{छोटी संख्याएं शाब्दिक बाइट मूल्यों का प्रतिनिधित्व करती हैं}

Answer 3

हास्केल , 42 39 बाइट्स

(<1).sum.(map=<<flip(mod.fromEnum).length)

f s=sum[fromEnum c`mod`length s|c<-s]<1

3 कम बाइट्स अंडाशय और xnor के लिए धन्यवाद!

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

Answer 4

05AB1E , 5 बाइट्स

ÇsgÖP

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

टिप्पणी की गई

        # implicit input    "lol"
Ç       # push ASCII value  [108, 111, 108]
 s      # swap (with input) [108, 111, 108], "lol"
  g     # length            [108, 111, 108], 3
   Ö    # is divisible?     [1, 1, 1]
    P   # product           1

Answer 5

रॉकस्टार , 205 192 175 162 बाइट्स

खैर, यह मजेदार था। रॉकस्टार के पास सीधे एक स्ट्रिंग की लंबाई पढ़ने का कोई तरीका नहीं है, वर्णों को कोडपॉइंट्स में नहीं बदल सकता है और इसमें कोई मॉडुलो ऑपरेटर नहीं है। हैरानी की बात यह है कि यह छोटा है!

listen to S
cut S
X's0
D's0
while S at X
N's32
while N-127
cast N into C
if C is S at X
let M be N/S
turn down M
let D be+N-S*M

let N be+1

let X be+1

say not D

इसे यहां आज़माएं (कोड को पेस्ट करना होगा)

Answer 6

पायथ , 8 बाइट्स

!sm%CdlQ

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

!sm%CdlQ
  m       : map implicit input on
          : lambda d:
    Cd    :   Ascii value of d
   %  lQ  :   mod length of input
 s        : sum result of map
!         : logical negate it

Answer 7

जावास्क्रिप्ट, 32 बाइट्स

ऊपुत उलटा है।

s=>Buffer(s).some(c=>c%s.length)

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

Answer 8

PHP , 56 52 बाइट्स

for(;$c=ord($argn[$i++]);$c%strlen($argn)?die(f):1);

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

आउटपुट उलट है

fकिसी भी चार विभाज्य नहीं है, या खाली स्ट्रिंग (PHP में झूठा) अगर सभी विभाज्य हैं तो निष्पादन बंद हो जाता है

संपादित करें: @ 640KB के लिए 4 बाइट्स सहेजे गए

Answer 9

पायथन 2 , 41 39 बाइट्स

lambda s:all(ord(i)%len(s)<1for i in s)

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

-2 बाइट्स थैंक्स टू @ovs

Answer 10

के (ओके) , 11 बाइट्स

{~+/(#x)!x}

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

Answer 11

जंग , 36 बाइट्स

|s|s.iter().all(|x|1>x%s.len()as u8)

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

इनपुट को एक के रूप में लेता है &[u8], एक को आउटपुट करता है bool।

Answer 12

पिप , 12 बाइट्स

!$+(A_Ma)%#a

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

व्याख्या

!$+(A_Ma)%#a a → input
   (A_Ma)    Map a to Unicode/ASCII codepoints
         %#a Modulo the list by it's length
 $+          Sum up the remainders
!            Not(returns 0 for any positive number, 1 for 0)

Answer 13

रूबी , 43 37 36 32 बाइट्स

->a{a.bytes.all?{|n|n%a.size<1}}

यदि केवल तार तार पर इस्तेमाल किया जा सकता है ..

-10 बाइट्स ओव्स से।

डिंगस से -1 बाइट।

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

Answer 14

पर्ल 5 -pF , 20 बाइट्स

$_=!grep ord()%@F,@F

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

Answer 15

सी (जीसीसी) , 54 53 बाइट्स

l;r;f(char*s){l=strlen(s);for(r=0;*s;)r|=*s++%l;l=r;}

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

यदि प्रत्येक अक्षर का ASCII मान इनपुट स्ट्रिंग या सत्य की लंबाई से विभाज्य है, तो यह गलत है।

स्पष्टीकरण:

l;r;f(char*s){l=strlen(s);for(r=0;*s;)r|=*s++%l;l=!r;}  
l;r;                                                  // Declare 2 int variables
    f(                                                // Function f taking
      char*s){                                        //   string parameter s  
              l=strlen(s);                            // Store length of s in l
                          for(                        // Loop
                              r=0;                    //   initialising r to 0
                                  *s;)                //   until end of s  
                                      r|=             // Bitwise or r with 
                                         *s           //   the ASCII value of the next
                                                      //   character...  
                                           ++         // Aside: push s pointer forward
                                             %l;      //  ... mod the string length
                                                r=l;  // Return r (r will be 0
                                                      //   iff every character was
                                                      //   divisible by l)

Answer 16

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 40 बाइट्स

{0}==##&@@ToCharacterCode@#~Mod~Tr[1^#]&

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

@ बाइट के लिए धन्यवाद कुछ बाइट्स बचाने के लिए

Answer 17

APL (Dyalog Extended) , 7 बाइट्स ( SBCS )

बेनामी tacit उपसर्ग समारोह

⍱≢|⎕UCS

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

⍱ क्या निम्न में से कोई भी सत्य (गैर-शून्य) नहीं है?

≢ लम्बाई

| विभाजित (विभाजित होने पर जलाया हुआ विभाजन)

⎕UCS कोड अंक

Answer 18

सी # (.NET कोर) , 25 बाइट्स

a=>a.All(x=>x%a.Length<1)

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

Answer 19

जाप -e , 6 बाइट्स

c vNÎÊ

कोशिश करो

Answer 20

मठगोल्फ , 4 बाइट्स

$h÷╓

वर्णों की सूची के रूप में इनपुट।

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

स्पष्टीकरण:

$     # Get the codepoint of each character in the (implicit) input-list
 h    # Push the length of this list (without popping the list itself)
  ÷   # Check for each codepoint if it's divisible by this length
   ╓  # Pop and push the minimum of the list
      # (after which the entire stack joined together is output implicitly as result)

Answer 21

जेली , 4 बाइट्स

LḍOP

इसे ऑनलाइन आज़माएं! या सभी मामलों को सत्यापित करें!

प्रतिबद्ध: ^{(कम से कम मुझे लगता है कि यह इस तरह काम करता है)}

   P  # product of ...
L     #   does the length 
 ḍ    #   ... divide ...
  O   #   the char codes

Answer 22

आर , 39 38 बाइट्स

संपादित करें: -1byte नए नियम के लिए धन्यवाद कि हम TRUE के लिए FALSE और FALSE के लिए TRUE आउटपुट कर सकते हैं

function(s)any(utf8ToInt(s)%%nchar(s))

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

या मूल 39-बाइट संस्करण का प्रयास करें जो TRUE के लिए TRUE का उत्पादन करता है ...

Answer 23

क्लोजर, 41 वर्ण

(every? #(= 0 (mod (int %) (count x))) x)

टिप्पणी 37 वर्ण के बाद रिक्त स्थान निकाल रहा है

(every? #(= 0(mod(int %)(count x)))x) 

Answer 24

MAWP , 34 33 24 23 बाइट्स

`|_=M0=A0/[M%{0:.}?`]1:

कोशिश करो!

9 बाइट बचाने के लिए @Razetime का शुक्रिया!

स्पष्टीकरण:

`        Remove starting 1 on stack
|        Push input on stack as ASCII codes
_=M      Set variable M to length of stack (length of input)
0=A      Set variable A to 0
0/       Push 0 and cycle stack
[        Start of loop
M%       Modulo by M
{0:.}    If not 0 then print 0 and terminate
?`       If 0 then pop value
]        End of loop
1:       Print 1

Answer 25

ब्रेकीलॉग , 8 बाइट्स

ạfᵐ∋ᵛ~l?

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

ạfᵐ∋ᵛ~l?
ạ        characters to integer
 fᵐ      find all factors
   ∋ᵛ    every list of factors contain …
     ~l? the length of the input

वैकल्पिक संस्करण,

⟨ạzl⟩%ᵛ0
⟨fhg⟩    forks! fA & gB ∧ [A, B]h
 ạzl     zip the code blocks with the length;
          [[108, 3], [111, 3], [108, 3]]
     %ᵛ0 every list must be 0 after modulo

Answer 26

पायथन 3 , 55 52 बाइट्स

N=input();print(not sum([ord(i)%len(N) for i in N]))

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

Answer 27

GolfScript , 20 बाइट्स

.,0@{(3$%@+\}3$*;!\;

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

यदि स्ट्रिंग विभाज्य है और 0 नहीं है तो यह 1 आउटपुट करता है। आज्ञा देना एस स्ट्रिंग और एल इसकी लंबाई है।

.,0@                  # The stack from bottom up will be: L  0  S
    {       }3$* # Execute this block L times ( # Separate first char from the string as a number 3$%             # Previous number mod L
         @+\          # Add result to the acumulator
                ;     # Discard the ""
                 !    # 1 iff the acumulator is 0
                  \;  # Discard L

Answer 28

चारकोल , 8 बाइट्स

¬⊙θ﹪℅ιＬθ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। आउटपुट चारकोल बूलियन है, यानी -सच के लिए, झूठे के लिए कुछ भी नहीं। स्पष्टीकरण:

  θ         Input string
 ⊙          Is there a character where
     ι      Current character
    ℅       Ordinal
   ﹪        Modulo (i.e. is not divisible by)
       θ    Input string
      Ｌ     Length
¬           Boolean NOT
            Implicitly print

⬤θ¬﹪℅ιＬθ भी काम करता है।

Answer 29

फैक्टर , 62 बाइट्स

: f ( s -- ? ) dup length [ mod ] curry [ + ] map-reduce 0 = ;

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

Answer 30

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 81 बाइट्स

(s)=>{var bs = ASCIIEncoding.ASCII.GetBytes(s);return bs.All(b=>b%s.Length==0);};

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

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 27 26 बाइट्स

s=>s.All(c=>c%s.Length<1);

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