รับรายการ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

เกณฑ์การให้คะแนน

นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ

เยลลี่, 8 7 ไบต์

บันทึก 1 ไบต์ขอบคุณ Dennis

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และจะกลายเป็น12

CJam ( 15 14 ไบต์)

qN/ee{:=i2%)}%

การสาธิตออนไลน์

ขอบคุณAdnanสำหรับการบันทึกหนึ่งไบต์

การผ่า

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

Python 2, 47 45 ไบต์

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

ขอบคุณ @xnor สำหรับการเล่นกอล์ฟ 2 ไบต์!

ทดสอบบนIdeone

มันทำงานอย่างไร

`x`อัตราผลตอบแทนการแสดงสตริงของรายการx

สำหรับกรณีทดสอบครั้งแรกสิ่งนี้จะทำให้สตริง

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

[1::n+3]ดึงตัวละครทุกตัว(n + 3) ^th - โดยที่nคือความยาวของxเริ่มต้นด้วยตัวที่สอง การบัญชี2ตัวอักษรสำหรับ,เราดึงตัวเลขแรกของตัวเลขแรก, ตัวเลขที่สองของตัวเลขที่สอง ฯลฯ

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

ตอนนี้เราใช้แบบโมดูโลจำนวน10 ⁿ ÷ 2เพื่อแมหลักแรกในช่วง[0, 4]

สำหรับ93579135ที่เราได้รับ93579135 50000000% = 43579135

ในที่สุดเราเพิ่ม10 ⁿ ÷ 9ในผลลัพธ์สุดท้ายซึ่งเพิ่มขึ้น - ล้อมรอบจาก9เป็น0 - ตัวเลขทั้งหมดโดย1 (ไม่มีการพกพา) หรือ2 (พร้อมพก)

สำหรับ43579135ที่เราได้รับ43579135 + 11111111 = 54690246

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

Pyth, 11 ไบต์

jk.eh!ts@`b

Simple loop เปลี่ยนทุกหลักเป็น 1 ยกเว้น 1 กลายเป็น 2

จอประสาทตา 39 38 37

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

บันทึกแล้ว 1 ไบต์ขอบคุณ Martin!

ต้องใช้ตัวป้อนบรรทัดต่อท้ายในอินพุต

รับ diagonals และแปล 0 และ 2-9 เป็น 1 และ 1 ถึง 2

แนวคิดพื้นฐานสำหรับการรับ diagonals คือการกดการจับสำหรับแต่ละแถวเหนือแถวปัจจุบันและจากนั้นใช้การจับภาพเพื่อจับคู่อักขระแล้วเก็บอักขระถัดไป

ลองออนไลน์

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

Python 2, 54 ไบต์

d,r=1,""
for n in input():r+=`1+-~n/d%9`;d*=10
print r

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

โปรแกรมเต็มรูปแบบ (ด้วยรหัส ungolfed):

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

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

J, 37 ไบต์

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

สามารถเล่นกอล์ฟได้ แต่ฉันลืมไปว่ามีคำสั่ง "diagonals"

Reng v.3.3, 60 ไบต์

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

สำหรับ Reng นั้นค่อนข้างง่าย ลองที่นี่! อินพุตคือรายการตัวเลขคั่นด้วยช่องว่าง

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(ใส่9ที่ STOS และ-ลบ TOS จาก STOS #oเก็บตัวเลขนี้ในoและa$;ลดสมาชิกทั้งหมดของสแต็ก]ปิดสแต็กหลักoวางoกลับไปที่ ด้านบนนี่คือหลักของเราที่เราบันทึก)ย้ายไปที่ด้านล่างเพื่อให้เราสามารถวนรอบต่อไปได้sโดยปกติจะตรวจสอบที่ไม่ใช่อินพุต (เช่นความเท่าเทียมกัน-1) แต่เราสามารถใช้มันเพื่อแยกออกจากวงของเราเมื่อk == -1ดังนั้นs^k == -1ไปขึ้นเมื่อ $ลดลงkจากสแต็คและวงของเราเริ่มต้นอีกครั้ง

3: ขั้นสุดท้าย

                     ~; !nb$<

<นำตัวชี้ไปทางซ้ายและ$ลดลงkจากสแต็ก bเป็นกระจกทางซ้ายมือเราจึงใส่มันเข้าไป แต่มันจะกระเด้งกลับมาเมื่อโดน;กระจกเงาแบบกองซ้อน !nพิมพ์ตัวเลขถ้าหากว่าเราจะจากไป ~สิ้นสุดโปรแกรมเมื่อเราพิมพ์เสร็จ

Mathematica 52 ไบต์

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

สิ่งนี้เป็นไปตามแนวทางของ Peter Taylor และอื่น ๆ (โดยไม่ต้องใช้รหัส Ascii)

ตัวอย่าง

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

2112

ClojureScript 58 ตัวอักษร

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

ข้อกำหนดประเภททำให้เรื่องนี้ยาวเกินความจำเป็นเล็กน้อยและmap-indexedการมีตัวอักษรจำนวนมากก็ไม่ได้ช่วยอะไร

บ่อยครั้งที่การส่งของฉันเป็น Clojure ที่ถูกต้องเช่นกัน แต่นี่ใช้การรั่วของ ClojureScript กับ JavaScript การลบของจำนวนและสตริง coerces สายไปยังหมายเลข - นั่นคือเท่ากับ(- 9 "5")4

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 หลัก" จะสั้นที่สุด แต่กรณีพิเศษที่จำเป็นเพื่อป้องกันไม่ให้เลขศูนย์แรกหายไป

Fed จากอาร์กิวเมนต์ CLI:

php -r "while($a=$argv[++$i])echo($b=9-$a[$i-1])?$b:1;" 12345678 23456789 34567890 45678901 56789012 67890123 78901234 89012345
86421864

ทับทิม 21 ไบต์

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

โปรแกรมเต็มรูปแบบ วิ่งด้วย-nธง n -> n%2+1การทำแผนที่การใช้ประโยชน์ต่อไปนี้:

JavaScript (ES6), 41

เคล็ดลับ% 9 + 1 นั้นยืมมาจากคำตอบของ Suever สำหรับครั้งเต้น.reduce .mapหมายเหตุตัว+=ดำเนินการถูกใช้เพื่อหลีกเลี่ยงวงเล็บ

a=>+a.reduce((t,n,d)=>t+=(n+t)[d]%9+1,'')

Perl, 18 ไบต์

รวม +1 สำหรับ -p

รันด้วยบรรทัดอินพุตบน STDIN ผลลัพธ์คือ 1 ยกเว้น 2 เมื่อเส้นทแยงมุมคือ 1

cantor.pl

#!/usr/bin/perl -p
pos=$.;$_=/1\G/+1

Pyth, 14 ไบต์

s.e|-\1@bk\2`M

ลองออนไลน์!