Dada una lista de N enteros, cada uno con Ndígitos, genera un número que difiere del primer número debido al primer dígito, el segundo número debido al segundo dígito, etc.

Ejemplo

Dada esta lista:

1234
4815
1623
4211

El número 2932 primer dígito del número es diferente del primer dígito del primer número, su segundo dígito es diferente del segundo dígito del segundo número, etc. Por lo tanto, sería una salida válida.

Entradas

• Puede tomar tanto la lista como N como la entrada, o solo la lista si lo desea.
• Cada número entero en la lista necesariamente tendrá tantos dígitos como la longitud de la lista (N )
• Los números no tendrán ceros a la izquierda
• La lista de entrada debe contener números y no cadenas.
• Puede tomar entradas como argumentos de función, a través de STDIN o cualquier cosa similar.
• Puede suponer que la lista no tendrá más de 10 elementos (y ningún número en la lista será mayor que 2147483647)

Salidas

• No es suficiente que la salida no esté en la lista. Los dígitos deben diferir como se explicó anteriormente.
• Puede usar cualquier estrategia de selección de dígitos que respete la restricción de diferentes dígitos.
• El número no puede tener ceros a la izquierda
• Puede enviar el número STDOUT, devolverlo desde una función, etc.

Casos de prueba

Input:
12345678
23456789
34567890
45678901
56789012
67890123
78901234
89012345

Possible output: 24680246


Input:
1

Possible output: 2

Puntuación

Este es el código de golf , por lo que gana la respuesta más corta en bytes.

Jalea, 8 7 bytes

1 byte guardado gracias a Dennis.

DŒDḢỊ‘Ḍ

Pruébalo en línea!

Explicación

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.

Convierte cada dígito en 1, excepto 0y se 1convierte en 2.

CJam ( 15 14 bytes)

qN/ee{:=i2%)}%

Demostración en línea

Gracias a Adnan por un ahorro de un byte.

Disección

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

¡Gracias a @xnor por jugar 2 bytes!

Pruébalo en Ideone .

Cómo funciona

`x`produce una representación de cadena de la lista x .

Para el primer caso de prueba, esto da la cadena

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

[1::n+3]recupera todos los caracteres (n + 3) ^th , donde n es la longitud de x que comienza con el segundo. Contando 2 caracteres para ,, recuperamos el primer dígito del primer número, el segundo dígito del segundo número, etc.

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

Ahora tomamos el módulo número 10 ⁿ ÷ 2 para mapear el primer dígito en el rango [0, 4] .

Para 93579135 , obtenemos 93579135% 50000000 = 43579135 .

Finalmente, agregamos 10 ⁿ ÷ 9 al último resultado, que incrementa - pasando de 9 a 0 - todos los dígitos en 1 (sin acarreo) o 2 (con acarreo).

Para 43579135 , obtenemos 43579135 + 11111111 = 54690246 .

MATL, 11 10 9 bytes

VXd9\QV!U

Toma solo un vector de columna de enteros como entrada. NNo se proporciona.

Pruébalo en línea

Explicació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 bytes

jk.eh!ts@`b

Bucle simple, cambie cada dígito a 1, excepto que 1 se convierte en 2.

Retina, 39 38 37

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

Guardado 1 byte gracias Martin!

Requiere un salto de línea final en la entrada.

Obtiene diagonales y traduce 0 y 2-9 a 1 y 1 a 2.

La idea básica para obtener las diagonales es empujar una captura para cada fila por encima de la fila actual y luego consumir una captura para que coincida con un personaje, luego mantener el siguiente carácter.

Pruébalo en línea

J, 26 22 bytes

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

Enfoque similar a los demás utilizando el método <= 1y incrementde la diagonal.

Uso

Solo requiere la lista de enteros 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;}

¡Operaciones numéricas puras para la victoria! :)

Entrada / salida de muestra:

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 (con código sin golf):

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

Sin golf

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

Salida

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))

Probablemente se pueda jugar golf, pero olvidé si había un comando para "diagonales".

Reng v.3.3, 60 bytes

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

Para Reng, eso fue bastante simple. Pruébalo aquí! La entrada es una lista de números separados por espacios.

1: init

k1-#kaiír1ø

kes el número de entradas (número de números), y disminuimos en 1 y restauramos para la etapa de bucle. aiítoma toda la entrada. rinvierte la pila para el procesamiento de la entrada. 1øva a la siguiente línea

2: bucle

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

1[saca el elemento superior de la pila y lo coloca en una nueva pila. ålo divide en dígitos. {$}empuja un bloque de código que contiene la operación "soltar"; esto se repite kveces ( k*) y el bloque de código se deja caer ( $. k1-#kdecrementos k. )9(pone 9en el STOS, y -resta TOS del STOS. #oalmacena este número en oy a$;cae todos los miembros de la pila. ]cierra la pila de los padres. opone ode vuelta en la parte superior; este es nuestro dígito que estamos guardando. lo )mueve a la parte inferior para que podamos continuar nuestro bucle. Por lo sgeneral, verifica si no hay entrada (es decir, la igualdad a-1 ), pero podemos usarlo para salir de nuestro bucle cuandok == -1 . Entoncess^sube cuando k == -1. $cae kde la pila, y nuestro ciclo comienza de nuevo.

3: final

                     ~; !nb$<

<dirige el puntero hacia la izquierda y $cae kde la pila. bes un espejo hacia la izquierda, por lo que ingresamos a través de él, pero se recupera cuando golpea ;, un espejo con condición de pila. !nimprime un dígito si y solo si vamos a la izquierda. ~finaliza el programa cuando terminamos de imprimir.

Mathematica 52 bytes

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

Esto sigue el enfoque de Peter Taylor y otros (sin usar códigos Ascii).

Ejemplo

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

Los requisitos de tipo hicieron que esto fuera un poco más de lo necesario, y map-indexedser tantos caracteres no ayudó.

A menudo, mis presentaciones también son válidas para Clojure, pero esto está utilizando algunas de las fugas de ClojureScript con JavaScript. La resta de un número y una cadena obliga a la cadena a un número, es decir, es (- 9 "5")igual 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;

Varios selectores de dígitos para la comparación. Pensé que "9 dígitos" sería el más corto, pero el caso especial necesario para mantener un cero fuera del primer dígito lo abruma.

Fed de argumentos 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

Un programa completo Corre con la -nbandera. Utiliza la siguiente asignación: n -> n%2+1.

JavaScript (ES6), 41

El truco% 9 + 1 se toma prestado de la respuesta de Suever. Por una vez, .reducelate .map. Tenga en cuenta que el +=operador se utiliza para evitar paréntesis.

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

Perl, 18 bytes

Incluye +1 para -p

Ejecutar con las líneas de entrada en STDIN. La salida es 1 excepto 2 cuando la diagonal es 1

cantor.pl

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

Pyth, 14 bytes

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

Pruébalo en línea!