Dato un elenco di Nnumeri interi, ciascuno con Ncifre, emette un numero che differisce dal primo numero a causa della prima cifra, il secondo numero a causa della seconda cifra, ecc.

Esempio

Dato questo elenco:

1234
4815
1623
4211

La 2932prima cifra del numero è diversa dalla prima cifra del primo numero, la seconda cifra è diversa dalla seconda cifra del secondo numero, ecc. Pertanto sarebbe un output valido.

ingressi

• Puoi prendere sia l'elenco che Ncome input, o solo l'elenco se lo desideri.
• Ogni numero intero nell'elenco avrà necessariamente tante cifre quante sono le lunghezze dell'elenco ( N)
• I numeri non avranno zero iniziali
• L'elenco di input deve contenere numeri e non stringhe.
• È possibile accettare input come argomenti di funzione, tramite STDINo simili.
• Si può presumere che l'elenco non sarà più lungo di 10 elementi (e nessun numero nell'elenco sarà più grande di 2147483647)

Uscite

• Non è sufficiente che l'output non sia nell'elenco. Le cifre devono differire come spiegato sopra.
• È possibile utilizzare qualsiasi strategia di selezione delle cifre che rispetti il ​​vincolo di diverse cifre.
• Il numero non può avere zero iniziali
• È possibile emettere il numero attraverso STDOUT, restituirlo da una funzione, ecc.

Casi test

Input:
12345678
23456789
34567890
45678901
56789012
67890123
78901234
89012345

Possible output: 24680246


Input:
1

Possible output: 2

punteggio

Questo è code-golf , quindi vince la risposta più breve in byte.

Gelatina, 8 7 byte

1 byte salvato grazie a Dennis.

DŒDḢỊ‘Ḍ

Provalo online!

Spiegazione

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.

Converte ogni cifra in 1, tranne 0e 1diventa 2.

CJam ( 15 14 byte)

qN/ee{:=i2%)}%

Demo online

Grazie ad Adnan per un risparmio di un byte.

Dissezione

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 byte

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

Grazie a @xnor per giocare a golf con 2 byte!

Provalo su Ideone .

Come funziona

`x`restituisce una rappresentazione in formato stringa dell'elenco x .

Per il primo caso di test, questo fornisce la stringa

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

[1::n+3]recupera ogni (n + 3) carattere ^th - dove n è la lunghezza di x che inizia con il secondo. Considerando 2 caratteri per ,, recuperiamo la prima cifra del primo numero, la seconda cifra del secondo numero, ecc.

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

Ora prendiamo il numero modulo 10 ⁿ ÷ 2 per mappare la prima cifra nell'intervallo [0, 4] .

Per 93579135 , otteniamo il 93579135% 50000000 = 43579135 .

Infine, aggiungiamo 10 ⁿ ÷ 9 all'ultimo risultato, che aumenta - avvolgendo da 9 a 0 - tutte le cifre di 1 (nessun carry) o 2 (con carry).

Per 43579135 , otteniamo 43579135 + 11111111 = 54690246 .

MATL, 11 10 9 byte

VXd9\QV!U

Accetta solo un vettore di colonna di numeri interi come input. Nnon è fornito.

Provalo online

Spiegazione

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

jk.eh!ts@`b

Ciclo semplice, cambia ogni cifra in 1, tranne 1 diventa 2.

Retina, 39 38 37

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

Salvato 1 byte grazie Martin!

Richiede un avanzamento riga finale nell'input.

Ottiene le diagonali e traduce 0 e 2-9 in 1 e 1 a 2.

L'idea di base per ottenere le diagonali è di spingere una cattura per ogni riga sopra la riga corrente e quindi consumare una cattura per abbinare un personaggio, quindi mantenere il personaggio successivo.

Provalo online

J, 26 22 byte

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

Approccio simile agli altri usando il metodo <= 1e incrementdella diagonale.

uso

Richiede solo l'elenco di numeri interi come argomento.

   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 byte

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

Java, 94 byte

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

Operazioni numeriche pure per la vittoria! :)

Ingresso / uscita campione:

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

Programma completo (con codice non golfizzato):

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 byte

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

Produzione

Input:
12345678
23456789
34567890
45678901
56789012
67890123
78901234
89012345

Output:
99991999

Input:
1234
4815
1623
4211

Output:
9999

J, 37 byte

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

Probabilmente si può giocare a golf, ma ho dimenticato se c'era un comando per "diagonali".

Reng v.3.3, 60 byte

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

Per Reng, era piuttosto semplice. Provalo qui! L'input è un elenco di numeri separato da spazi.

1: init

k1-#kaiír1ø

kè il numero di ingressi (numero di numeri) e diminuiamo di 1 e ripristiniamo per lo stadio del loop. aiíaccetta tutti gli input. rinverte lo stack per l'elaborazione dell'input. 1øpassa alla riga successiva.

2: loop

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

1[toglie l'oggetto in cima alla pila e in una nuova pila. ålo divide in cifre. {$}invia un blocco di codice contenente l'operazione "drop"; questo viene ripetuto kvolte ( k*) e il blocco di codice viene eliminato ( $. k1-#kdecrementa k. )9(mette 9in STOS e -sottrae TOS da STOS. #omemorizza questo numero oe a$;rilascia tutti i membri dello stack. ]chiude lo stack padre. orimette oa la parte superiore; questa è la nostra cifra che stiamo salvando, la )sposta verso il basso in modo da poter continuare il nostro ciclo. di ssolito controlla la presenza di non input (ovvero l'uguaglianza in -1), ma possiamo usarla per uscire dal nostro ciclo quando k == -1. Cosìs^sale quando k == -1. $scende kdallo stack e il nostro loop ricomincia.

3: finale

                     ~; !nb$<

<dirige il puntatore a sinistra e $scende kdalla pila. bè uno specchio a sinistra, quindi entriamo attraverso di esso, ma rimbalza quando colpisce ;, uno specchio a condizione di pila. !nstampa una cifra se e solo se stiamo andando a sinistra. ~termina il programma al termine della stampa.

Mathematica 52 byte

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

Questo segue l'approccio di Peter Taylor e altri (senza usare i codici Ascii).

Esempio

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

2112

ClojureScript, 58 caratteri

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

I requisiti di tipo lo hanno reso un po 'più lungo del necessario, e map-indexedessendo così tanti caratteri non ha aiutato.

Spesso anche le mie osservazioni sono valide per Clojure, ma questo utilizza alcune delle perdite di ClojureScript con JavaScript. La sottrazione di un numero e di una stringa costringe la stringa a un numero, ovvero (- 9 "5")uguale a 4.

PHP, 46/41/40 byte

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;

Vari selettori di cifre per il confronto. Ho pensato che "9 cifre" sarebbe il più breve, ma il caso speciale necessario per mantenere uno zero fuori dalla prima cifra lo sopraffà.

Alimentato da argomenti CLI:

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

Rubino, 21 byte

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

Un programma completo. Corri con la -nbandiera. Utilizza il seguente mappatura: n -> n%2+1.

JavaScript (ES6), 41

Il trucco% 9 + 1 è preso in prestito dalla risposta di Suever. Per una volta, .reducebatte .map. Nota, l' +=operatore viene utilizzato per evitare le parentesi.

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

Perl, 18 byte

Include +1 per -p

Esegui con le righe di input su STDIN. L'output è 1 tranne 2 quando la diagonale è 1

cantor.pl

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

Pyth, 14 byte

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

Provalo online!