Dada uma lista de Nnúmeros inteiros, cada um com Ndígitos, produz um número que difere do primeiro número por causa do primeiro dígito, do segundo número por causa do segundo dígito, etc.

Exemplo

Dada esta lista:

1234
4815
1623
4211

O 2932primeiro dígito do número é diferente do primeiro dígito do primeiro número, seu segundo dígito é diferente do segundo dígito do segundo número, etc. Portanto, seria uma saída válida.

Entradas

• Você pode pegar a lista e Ncomo entrada, ou apenas a lista, se desejar.
• Cada número inteiro na lista terá necessariamente tantos dígitos quanto o comprimento da lista ( N)
• Os números não terão zeros à esquerda
• A lista de entrada deve conter números e não cadeias.
• Você pode receber entradas como argumentos de função, através STDINou qualquer coisa semelhante.
• Você pode assumir que a lista não terá mais de 10 elementos (e nenhum número na lista será maior que 2147483647)

Saídas

• Não é suficiente que a saída não esteja na lista. Os dígitos devem diferir conforme explicado acima.
• Você pode usar qualquer estratégia de seleção de dígitos que respeite a restrição de dígitos diferentes.
• O número não pode ter zeros à esquerda
• Você pode enviar o número através de STDOUT, retornar de uma função, etc.

Casos de teste

Input:
12345678
23456789
34567890
45678901
56789012
67890123
78901234
89012345

Possible output: 24680246


Input:
1

Possible output: 2

Pontuação

Isso é código-golfe , então a resposta mais curta em bytes vence.

Geléia, 8 7 bytes

1 byte economizado graças a Dennis.

DŒDḢỊ‘Ḍ

Experimente online!

Explicação

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 cada dígito em 1, exceto 0e 1se torna 2.

CJam ( 15 14 bytes)

qN/ee{:=i2%)}%

Demonstração online

Agradecemos a Adnan por economizar um byte.

Dissecação

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 bytes

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

Graças a @xnor por jogar fora 2 bytes!

Teste em Ideone .

Como funciona

`x`produz uma representação em cadeia da lista x .

Para o primeiro caso de teste, isso fornece a sequência

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

[1::n+3]recupera cada (n + 3) ^th personagem - onde n é o comprimento de X começando com a segunda. Contabilizando 2 caracteres ,, recuperamos o primeiro dígito do primeiro número, o segundo dígito do segundo número, etc.

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

Agora, pegamos o número módulo 10 ⁿ ÷ 2 para mapear o primeiro dígito no intervalo [0, 4] .

Para 93579135 , obtemos 93579135% 50000000 = 43579135 .

Finalmente, adicionamos 10 ⁿ ÷ 9 ao último resultado, que aumenta - passando de 9 para 0 - todos os dígitos em 1 (sem transporte) ou 2 (com transporte).

Para 43579135 , obtemos 43579135 + 11111111 = 54690246 .

MATL, 11 10 9 bytes

VXd9\QV!U

Leva apenas um vetor de coluna de números inteiros como entrada. Nnão é fornecido.

Experimente Online

Explicação

    % 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

Pitão, 11 bytes

jk.eh!ts@`b

Loop simples, altere cada dígito para 1, exceto 1 se torna 2.

Retina, 39. 38. 37.

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

Guardado 1 byte obrigado Martin!

Requer um avanço de linha à direita na entrada.

Obtém diagonais e converte 0 e 2-9 para 1 e 1 para 2.

A idéia básica para obter as diagonais é empurrar uma captura para cada linha acima da linha atual e, em seguida, consumir uma captura para corresponder a um caractere, mantendo o próximo caractere.

Experimente online

J, 26 22 bytes

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

Abordagem semelhante às outras usando o método <= 1e incrementda diagonal.

Uso

Requer apenas a lista de números inteiros como argumento.

   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 bytes

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

Java, 94 bytes

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

Operações numéricas puras para a vitória! :)

Entrada / saída de amostra:

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

Programa completo (com código não bloqueado):

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 bytes

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

Saída

Input:
12345678
23456789
34567890
45678901
56789012
67890123
78901234
89012345

Output:
99991999

Input:
1234
4815
1623
4211

Output:
9999

J, 37 bytes

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

Provavelmente pode ser jogado, mas esqueci se havia um comando para "diagonais".

Reng v.3.3, 60 bytes

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

Para Reng, isso foi bastante simples. Experimente aqui! Entrada é uma lista de números separada por espaço.

1: init

k1-#kaiír1ø

ké o número de entradas (número de números) e decrementamos 1 e restauramos para o estágio do loop. aiírecebe toda a entrada.rinverte a pilha para o processamento da entrada.1øvai para a próxima linha.

2: loop

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

1[tira o item superior da pilha e entra em uma nova pilha. ådivide em dígitos. {$}empurra um bloco de código que contém a operação "drop"; isso é repetido kvezes ( k*) e o bloco de código é descartado ( $. k1-#kdiminui k. )9(coloca 9no STOS e -subtrai o TOS do STOS. #oarmazena esse número oe a$;remove todos os membros da pilha. ]fecha a pilha pai. ocoloca de ovolta em topo; esta é a nossa dígitos estamos economizando. )move-o para a parte inferior para que possamos continuar a nossa looping. sgeralmente verifica a existência de não-entrada (ou seja, a igualdade de-1 ), mas podemos usá-lo para interromper nosso loop quandok == -1 . Tãos^sobe quando k == -1. $cai kda pilha e nosso loop começa novamente.

3: final

                     ~; !nb$<

<direciona o ponteiro para a esquerda e $cai kda pilha. bé um espelho do lado esquerdo, então entramos nele, mas ele se recupera quando bate ;, um espelho de condição de pilha. !nimprime um dígito se e somente se vamos para a esquerda. ~termina o programa quando terminarmos de imprimir.

Mathematica 52 bytes

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

Isso segue a abordagem de Peter Taylor e outros (sem usar códigos Ascii).

Exemplo

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

2112

ClojureScript, 58 caracteres

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

Os requisitos de tipo tornaram isso um pouco mais demorado do que o necessário, e o fato de map-indexedter tantos caracteres não ajudou.

Muitas vezes, meus envios também são válidos para o Clojure, mas isso está usando parte do vazamento do ClojureScript com JavaScript. Subtração de um número e seqüência de caracteres a força a um número - ou seja, é (- 9 "5")igual a 4.

PHP, 46/41/40 bytes

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;

Vários seletores de dígitos para comparação. Eu pensei que "9 dígitos" seria o mais curto, mas o caso especial necessário para manter um zero fora do primeiro dígito o sobrecarrega.

Alimentado pelos argumentos da CLI:

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

Ruby, 21 bytes

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

Um programa completo. Corra com a -nbandeira. Usa a seguinte mapeamento: n -> n%2+1.

JavaScript (ES6), 41

O truque% 9 + 1 é emprestado da resposta de Suever. Pela primeira vez, .reducebate .map. Observe que o +=operador é usado para evitar parênteses.

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

Perl, 18 bytes

Inclui +1 para -p

Execute com as linhas de entrada no STDIN. A saída é 1, exceto 2, quando a diagonal é 1

cantor.pl

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

Pitão, 14 bytes

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

Experimente online!