Finite Cantor का विकर्ण

20

Nपूर्णांक की एक सूची को देखते हुए , प्रत्येक Nअंक के साथ , एक संख्या को आउटपुट करता है जो पहले अंक से भिन्न होता है, दूसरे अंक के कारण दूसरा नंबर, आदि।

उदाहरण

इस सूची को देखते हुए:

1234
4815
1623
4211

जो नंबर 2932 के पहले अंक पहले नंबर का पहला अंक से अलग है, अपनी दूसरी अंकों दूसरे नंबर की दूसरी अंकों, आदि इसलिए यह एक वैध उत्पादन होगा से अलग है।

इनपुट

  • आप दोनों सूची और ले सकते हैं N इनपुट रूप में, या केवल सूची को अपनी इच्छानुसार ले सकते हैं।
  • सूची में प्रत्येक पूर्णांक में आवश्यक रूप से सूची की लंबाई के रूप में कई अंक होंगे (N )
  • नंबरों में कोई अग्रणी शून्य नहीं होगा
  • इनपुट सूची में नंबर होने चाहिए और तार नहीं होने चाहिए।
  • आप फ़ंक्शन तर्कों के माध्यम से इनपुट ले सकते हैं STDIN , इसी तरह या कुछ भी।
  • आप मान सकते हैं कि सूची 10 तत्वों से अधिक नहीं होगी (और सूची में कोई संख्या इससे बड़ी नहीं होगी 2147483647)

आउटपुट

  • यह पर्याप्त नहीं है कि आउटपुट सूची में नहीं है। ऊपर बताए अनुसार अंकों में अंतर होना चाहिए।
  • आप किसी भी अंक चयन रणनीति का उपयोग कर सकते हैं जो विभिन्न अंकों की बाधा का सम्मान करता है।
  • संख्या में अग्रणी शून्य नहीं हो सकते
  • आप नंबर को आउटपुट कर सकते हैं STDOUT, इसे फंक्शन से वापस कर सकते हैं, आदि।

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

Input:
12345678
23456789
34567890
45678901
56789012
67890123
78901234
89012345

Possible output: 24680246


Input:
1

Possible output: 2

स्कोरिंग

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है।

code-golf  number  number-theory 
— Fatalize
स्रोत
तो हमें STDINपार्स करने से पहले पूर्णांक में बदलना होगा ?
— लीक नून
@KennyLau इनपुट के लिए नंबर होना चाहिए, यदि आप भाषा को सीधे अंकों को पार्स कर सकते हैं तो आपको कुछ भी बदलने की आवश्यकता नहीं है।
— घातक
लेकिन STDINडिफ़ॉल्ट रूप से स्ट्रिंग है ...
— लीक नून
फिर इनपुट स्ट्रिंग को पूर्णांकों की सूची में बदलें।
— Fatalize
क्या हम अंकों की सूची का उत्पादन कर सकते हैं?
— कॉनर ओ'ब्रायन

जवाबों:

4

जेली, 8 7 बाइट्स

1 बाइट ने डेनिस को धन्यवाद दिया।

DŒDḢỊ‘Ḍ

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

व्याख्या

DŒDḢỊ‘Ḍ    Main link. Takes list as argument.
D          Convert each integer to decimal.
 ŒD        Get the diagonals.
   Ḣ       Get the first diagonal.
    Ị      Check if every digit <= 1.
     ‘     Increment every digit.
      Ḍ    Convert back to integer from decimal.

प्रत्येक अंक को 1छोड़कर, 0और 1बन जाता है 2।

— लीक नन
स्रोत
8

CJam ( 15 14 बाइट्स)

qN/ee{:=i2%)}%

ऑनलाइन डेमो

एक-बाइट की बचत के लिए अदनान को धन्यवाद ।

विच्छेदन

qN/    e# Split input on newlines
ee{    e# Label each line with its index and map:
  :=i  e#   Get the character at the same index (i.e. diagonalise)
  2%)  e#   Compute (ASCII value mod 2) + 1
       e#   Maps 0 1 2 3 4 5 6 7 8 9
       e#     to 1 2 1 2 1 2 1 2 1 2
}%
— पीटर टेलर
स्रोत
1
@ अदनान, यह काम करता है, धन्यवाद। वैकल्पिक रूप i2%)से 49&), ASCII कोड के बजाय सीधे वर्णों के साथ काम किया जा सकता है ।
— पीटर टेलर
7

पायथन 2, 47 45 बाइट्स

lambda x,n:int(`x`[1::n+3])%(10**n/2)+10**n/9

2 बाइट बंद करने के लिए @xnor को धन्यवाद!

Ideone पर इसका परीक्षण करें ।

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

`x`सूची x का एक स्ट्रिंग प्रतिनिधित्व पैदावार ।

पहले परीक्षण मामले के लिए, यह स्ट्रिंग देता है

[92345678, 23456789, 34567890, 45678901, 56789012, 67890123, 78901234, 89012345]

[1::n+3]प्रत्येक (n + 3) वें वर्ण को पुनः प्राप्त करता है - जहाँ n की लंबाई x की शुरुआत दूसरे के साथ है। 2 वर्णों के लिए लेखांकन ,, हम पहली संख्या के पहले अंक, दूसरी संख्या के दूसरे अंक, आदि को पुनः प्राप्त करते हैं।

[92345678, 23456789, 34567890, 45678901, 56789012, 67890123, 78901234, 89012345]
 ^          ^          ^          ^          ^          ^          ^          ^

अब हम संख्या modulo 10 n map 2 को सीमा में पहला अंक मैप करने के लिए लेते हैं [0, 4] ।

के लिए 93579135 पर हम पाते हैं 93579135% 50000000 = 43579135 ।

अंत में, हम अंतिम परिणाम में 10 n to 9 जोड़ते हैं , जो वृद्धि - 9 से 0 के आसपास लपेटकर - 1 (कोई कैरी) या 2 (कैरी के साथ ) सभी अंक ।

के लिए 43579135 पर हम पाते हैं 43579135 + 11111111 = 54,690,246 ।

— डेनिस
स्रोत
4

MATL, 11 10 9 बाइट्स

VXd9\QV!U

इनपुट के रूप में पूर्णांकों का केवल एक कॉलम वेक्टर लेता है। Nप्रदान नहीं किया गया है।

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

व्याख्या

    % Implicity grab input as column vector of numbers
V   % Convert the input column vector into a 2D character array
Xd  % Grab the diagonal elements of the character array
9\  % Take the modulus of each ASCII code and 9
Q   % Add 1 to remove all zeros
V   % Convert the result to a string
!   % Transpose to yield a row vector of characters
U   % Convert back to an integer (as per the rules)
    % Implicitly display result
— Suever
स्रोत
1
@LuisMendo ओह crud। ऐसा लगता है कि यह एक प्रमुख शून्य मुद्दा है, हालांकि जब पहला अंक होता है 2: matl.tryitonline.net/…
— Suever
हो सकता हैVXd9\QV!U
— स्वेवर
ओह, मैंने ज़ीरो लीड करने के बारे में नहीं सोचा था ...
— लुइस मेंडू
@LuisMendo क्या यह मायने रखता है कि वे अद्वितीय नहीं हैं? जब तक वे इनपुट के रूप में एक ही मूल्य नहीं हैं यह बात नहीं होनी चाहिए।
— स्वेअर
तुम बिलकुल ठीक कह रहे हो। मैं इसके बारे में गलत तरीके से सोच रहा था
— लुइस मेंडू
3

अजगर, 11 बाइट्स

jk.eh!ts@`b

सरल लूप, हर अंक को 1 में बदल दें, 1 को छोड़कर 2 हो जाता है।

— orlp
स्रोत
निहितार्थ का अच्छा उपयोग Qऔर k! आप डिजिट-ट्रांसफॉर्मेशन के दौरान एक-एक बाइट बचा सकते हैं:s.eh-12@`b
— जकुबे
3

रेटिना, 39 38 37

(?<=(.*¶)*)(?<-1>.)*(.).*¶
$2
T`d`121

बच गया 1 बाइट धन्यवाद मार्टिन!

इनपुट में अनुगामी लाइनफीड की आवश्यकता होती है।

विकर्ण हो जाता है और 0 और 2-9 से 1 और 1 से 2 का अनुवाद करता है।

विकर्णों को प्राप्त करने का मूल विचार वर्तमान पंक्ति के ऊपर प्रत्येक पंक्ति के लिए कैप्चर को पुश करना है और फिर किसी वर्ण से मिलान करने के लिए कैप्चर का उपभोग करना है, फिर अगले चरित्र को रखें।

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

— FryAmTheEggman
स्रोत
3

जे, 26 22 बाइट्स

1+1>:i.@#{"_1"."0@":"0

विकर्ण की विधि <= 1और incrementविधि का उपयोग करते हुए दूसरों के लिए समान दृष्टिकोण ।

प्रयोग

केवल एक तर्क के रूप में पूर्णांकों की सूची की आवश्यकता है।

   f =: 1+1>:i.@#{"_1"."0@":"0
   f 1234 4815 1623 4211
2 1 1 2
   f 92345678 23456789 34567890 45678901 56789012 67890123 78901234 89012345
1 1 1 1 1 2 1 1
— मील की दूरी पर
स्रोत
1 लकीर को तोड़ने के लिए क्षमा करें ...
— NoOneIsHere
2

जावा, 94 बाइट्स

int c(int[]d){int p=1,r=0,l=d.length,i=0;for(;i<l;p*=10)r+=(d[l-++i]/p%10==1?2:1)*p;return r;}

जीत के लिए शुद्ध सांख्यिक संचालन! :)

नमूना इनपुट / आउटपुट:

8            <-- size
12345678     <-- start of list
23456789
34567890
45678901
56789012
67890123
78901234
89012345     <-- end of list
21111211     <-- result from ungolfed code
21111211     <-- result from golfed code

पूर्ण कार्यक्रम (अनगुल्ड कोड के साथ):

import java.util.Scanner;

public class Q79444 {
    int cantor_ungolfed(int[] data){
        int power = 1;
        int result = 0;
        for(int i=0;i<data.length;i++){
            result += (((data[data.length-i-1]/power))%10==1? 2 : 1)*power;
            power *= 10;
        }
        return result;
    }
    int c(int[]d){int p=1,r=0,l=d.length,i=0;for(;i<l;p*=10)r+=(d[l-++i]/p%10==1?2:1)*p;return r;}
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] input = new int[n];
        for(int i=0;i<n;i++){
            input[i] = sc.nextInt();
        }
        System.out.println(new Q79444().cantor_ungolfed(input));
        System.out.println(new Q79444().c(input));
        sc.close();
    }
}
— लीक नन
स्रोत
2

जावा, 93 बाइट्स

String k(int n,int[]a){String s="";for(int i=0;i<n;)s+=(a[i]+s).charAt(i++)<57?9:1;return s;}

Ungolfed

String k(int n, int[] a) {
    String s = "";
    for (int i = 0; i < n; ) 
        s += (a[i] + s).charAt(i++) < 57 ? 9 : 1;
    return s;
}

उत्पादन

Input:
12345678
23456789
34567890
45678901
56789012
67890123
78901234
89012345

Output:
99991999

Input:
1234
4815
1623
4211

Output:
9999
— मार्व
स्रोत
1

जे, 37 बाइट्स

f@(9&-@"."0@((>:@#*i.@#){f=:[:,":"0))

शायद गोल्फ हो सकता है, लेकिन मैं भूल गया अगर "विकर्ण" के लिए एक कमान थी।

— कोनोर ओ ब्रायन
स्रोत
मैंने देखा है यह पहले इस्तेमाल किया, मार्टिन इस्तेमाल किया विरोधी विकर्ण यहाँ ।
— FryAmTheEggman
@FryAmTheEggman हाँ, यह करीब है। मैं अभी भी देख रहा हूँ, लेकिन वहाँ नहीं हो सकता।
— कॉनर ओ'ब्रायन
यह एक प्रमुख शून्य उत्पन्न करता है यदि विकर्ण 9 से शुरू होता है
— ज़र्गब
यदि आप इनपुट nका उपयोग करते हैं तो आप अंक तालिका बना सकते हैं <list> (#:~#&10) <n>। पहला विकर्ण (< 0 1) |: <list>कहाँ पाया जा सकता है जहाँ (< 0 1)कुल्हाड़ियों का चयन करने के लिए कुल्हाड़ियों का एक बॉक्स है, दोनों का उपयोग करके|:
— मील
1

रेंग v.3.3, 60 बाइट्स

k1-#kaiír1ø          ~; !nb$<
1[å{$}k*$k1-#k)9(-#oa$;]o)ks^$

रेंग के लिए, बल्कि यह सरल था। यहाँ कोशिश करो! इनपुट संख्याओं की एक अलग-अलग सूची है।

1: init

k1-#kaiír1ø

kइनपुट की संख्या (संख्याओं की संख्या) है, और हम 1 से घटते हैं और लूप चरण के लिए पुनर्स्थापित करते हैं। aiíसभी इनपुट लेता है। rइनपुट के प्रसंस्करण के लिए स्टैक को उलट देता है। 1øअगली पंक्ति में जाता है।

2: लूप

1[å{$}k*$k1-#k)9(-#oa$;]o)ks^$

1[स्टैक से शीर्ष आइटम लेता है और एक नए स्टैक में। åइसे अंकों में विभाजित करता है। {$}एक कोड ब्लॉक करता है जिसमें ऑपरेशन "ड्रॉप" होता है; इस दोहराया है kबार ( k*) और कोड ब्लॉक गिरा दिया जाता है ( $। k1-#kdecrements k। )9(पुट 9STOS पर, और -घटाता STOS से TOS। #oमें इस संख्या की दुकानों o, और a$;ढेर के सभी सदस्यों को चला जाता है। ]बंद कर देता है माता पिता ढेर। oपुट oपर वापस शीर्ष, यह हमारा अंक है जिसे हम सहेज रहे हैं। )इसे नीचे तक ले जाते हैं ताकि हम अपना लूपिंग जारी रख सकें। sआमतौर पर नॉन-इनपुट (यानी, समानता -1) के लिए जाँच करता है , लेकिन हम इसका उपयोग अपने लूप से बाहर निकलने के लिए कर सकते हैंk == -1 । इसलिएs^जब ऊपर जाता है बूँदेंk == -1। स्टैक से, और हमारा लूप फिर से शुरू होता है।$k

3: अंतिम

                     ~; !nb$<

<सूचक को छोड़ दिया निर्देशित करता है, और स्टैक से $गिरता kहै। bएक वाममार्ग दर्पण है, इसलिए हम इसके माध्यम से प्रवेश करते हैं, लेकिन यह वापस उछलता है जब मारता है ;, एक स्टैक-कंडीशन दर्पण। !nएक अंक प्रिंट करता है अगर और केवल अगर हम बाएं जा रहे हैं। ~जब हम प्रिंटिंग कर रहे होते हैं तब प्रोग्राम समाप्त होता है।

— कोनोर ओ ब्रायन
स्रोत
1

गणितज्ञ 52 बाइट्स

FromDigits[Mod[#,2]+1&/@Diagonal[IntegerDigits/@#]]&

यह पीटर टेलर और अन्य के दृष्टिकोण (एससीआई कोड का उपयोग किए बिना) का अनुसरण करता है।

उदाहरण

FromDigits[Mod[#,2]+1&/@Diagonal[IntegerDigits/@ #]]&[{1234,4815,1623,4211}]

2112

— DavidC
स्रोत
1

क्लोजुरस्क्रिप्ट, 58 वर्ण

#(int(apply str(map-indexed(fn[i x](- 9(get(str x)i)))%)))

प्रकार की आवश्यकताओं ने इसे आवश्यकता से थोड़ा अधिक लंबा कर दिया, और map-indexedइतने सारे चार्ट होने से मदद नहीं मिली।

अक्सर मेरी प्रस्तुतियाँ मान्य क्लीजुरे के रूप में अच्छी तरह से होती हैं, लेकिन यह कुछ क्लोजुरस्क्रिप्ट के जावास्क्रिप्ट के साथ रिसाव का उपयोग कर रहा है। एक संख्या और स्ट्रिंग का घटाव स्ट्रिंग को एक संख्या तक ले जाता है - अर्थात, (- 9 "5")बराबर होता है 4।

— MattPutnam
स्रोत
1

PHP, 46/41/40 बाइट्स

while($a=$argv[++$i])echo($b=9-$a[$i-1])?$b:1;

while($a=$argv[++$i])echo$a[$i-1]==7?6:7;

while($a=$argv[++$i])echo($a[$i-1]%2)+1;

तुलना के लिए विभिन्न अंकों का चयनकर्ता। मैंने सोचा था कि "9-अंक" सबसे छोटा होगा, लेकिन पहले अंक से शून्य रखने के लिए आवश्यक विशेष मामले इसे अभिभूत करते हैं।

CLI तर्कों से फेड:

php -r "while($a=$argv[++$i])echo($b=9-$a[$i-1])?$b:1;" 12345678 23456789 34567890 45678901 56789012 67890123 78901234 89012345
86421864
— Toxik-दही
स्रोत
1

रूबी, 21 बाइट्स

$><<$_[$.-1].hex%2+1

एक पूरा कार्यक्रम। -nझंडे के साथ भागो । निम्न मानचित्रण का उपयोग करता है n -> n%2+1:।

— xsot
स्रोत
1

जावास्क्रिप्ट (ईएस 6), 41

Suever के उत्तर से% 9 + 1 चाल का उधार लिया गया है। एक बार के लिए, .reduceधड़कता है .map। ध्यान दें, +=कोष्ठक से बचने के लिए ऑपरेटर का उपयोग किया जाता है।

a=>+a.reduce((t,n,d)=>t+=(n+t)[d]%9+1,'')
— edc65
स्रोत
1

पर्ल, 18 बाइट्स

के लिए +1 शामिल है -p

STDIN पर इनपुट लाइनों के साथ चलाएँ। विकर्ण 1 होने पर आउटपुट 2 को छोड़कर 1 है

cantor.pl

#!/usr/bin/perl -p
pos=$.;$_=/1\G/+1
— टन हास्पेल
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.