Étant donné une liste d' Nentiers, chacun avec des Nchiffres, sortez un nombre qui diffère du premier nombre en raison du premier chiffre, du deuxième nombre en raison du deuxième chiffre, etc.

Exemple

Compte tenu de cette liste:

1234
4815
1623
4211

Le 2932premier chiffre du numéro est différent du premier chiffre du premier numéro, son deuxième chiffre est différent du deuxième chiffre du deuxième numéro, etc. Par conséquent, ce serait une sortie valide.

Contributions

• Vous pouvez prendre la liste et Nen entrée, ou seulement la liste si vous le souhaitez.
• Chaque entier de la liste aura nécessairement autant de chiffres que la longueur de la liste ( N)
• Les nombres n'auront pas de zéros en tête
• La liste d'entrée doit contenir des nombres et non des chaînes.
• Vous pouvez prendre les entrées en tant qu'arguments de fonction, via STDINou tout autre élément similaire.
• Vous pouvez supposer que la liste ne comportera pas plus de 10 éléments (et aucun nombre dans la liste ne sera plus grand que 2147483647)

Les sorties

• Il ne suffit pas que la sortie ne figure pas dans la liste. Les chiffres doivent différer comme expliqué ci-dessus.
• Vous pouvez utiliser n'importe quelle stratégie de sélection de chiffres qui respecte la contrainte des différents chiffres.
• Le nombre ne peut pas avoir de zéros en tête
• Vous pouvez sortir le numéro STDOUT, le renvoyer d'une fonction, etc.

Cas de test

Input:
12345678
23456789
34567890
45678901
56789012
67890123
78901234
89012345

Possible output: 24680246


Input:
1

Possible output: 2

Notation

Il s'agit de code-golf , donc la réponse la plus courte en octets l'emporte.

Gelée, 8 7 octets

1 octet économisé grâce à Dennis.

DŒDḢỊ‘Ḍ

Essayez-le en ligne!

Explication

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.

Convertit chaque chiffre en 1, sauf 0et 1devient 2.

CJam ( 15 14 octets)

qN/ee{:=i2%)}%

Démo en ligne

Merci à Adnan pour une économie d'un octet.

Dissection

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 octets

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

Merci à @xnor d'avoir joué au golf sur 2 octets!

Testez-le sur Ideone .

Comment ça fonctionne

`x`donne une représentation sous forme de chaîne de la liste x .

Pour le premier cas de test, cela donne la chaîne

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

[1::n+3]récupère chaque (n + 3) ^ème caractère - où n est la longueur de x en commençant par le second. Comptant 2 caractères ,, on récupère le premier chiffre du premier chiffre, le deuxième chiffre du deuxième chiffre, etc.

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

Nous prenons maintenant le nombre modulo 10 ⁿ ÷ 2 pour mapper le premier chiffre de la plage [0, 4] .

Pour 93579135 , nous obtenons 93579135% 50000000 = 43579135 .

Enfin, nous ajoutons 10 ⁿ ÷ 9 au dernier résultat, qui incrémente - en passant de 9 à 0 - tous les chiffres de 1 (pas de report) ou de 2 (avec report).

Pour 43579135 , nous obtenons 43579135 + 11111111 = 54690246 .

MATL, 11 10 9 octets

VXd9\QV!U

Prend uniquement un vecteur de colonne d'entiers en entrée. Nn'est pas fourni.

Essayez-le en ligne

Explication

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

jk.eh!ts@`b

Boucle simple, changez chaque chiffre en 1, sauf que 1 devient 2.

Rétine, 39 38 37

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

Enregistré 1 octet merci Martin!

Nécessite un saut de ligne de fin dans l'entrée.

Obtient les diagonales et traduit 0 et 2-9 en 1 et 1 en 2.

L'idée de base pour obtenir les diagonales est de pousser une capture pour chaque ligne au-dessus de la ligne actuelle, puis de consommer une capture pour correspondre à un caractère, puis de conserver le caractère suivant.

Essayez-le en ligne

J, 26 22 octets

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

Approche similaire aux autres utilisant la méthode <= 1et incrementla diagonale.

Usage

Nécessite uniquement la liste des entiers comme argument.

   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 octets

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

Java, 94 octets

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

Opérations numériques pures pour la victoire! :)

Exemple d'entrée / sortie:

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

Programme complet (avec code non 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 octets

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

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

Production

Input:
12345678
23456789
34567890
45678901
56789012
67890123
78901234
89012345

Output:
99991999

Input:
1234
4815
1623
4211

Output:
9999

J, 37 octets

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

Peut probablement être joué au golf, mais j'ai oublié s'il y avait une commande pour les "diagonales".

Reng v.3.3, 60 octets

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

Pour Reng, c'était plutôt simple. Essayez-le ici!L'entrée est une liste de nombres séparés par des espaces.

1: init

k1-#kaiír1ø

kest le nombre d'entrées (nombre de nombres), et nous décrémentons de 1 et restaurons pour l'étape de boucle. aiíprend toutes les entrées. rinverse la pile pour le traitement de l'entrée.1øpasse à la ligne suivante.

2: boucle

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

1[prend l'élément supérieur de la pile et dans une nouvelle pile. åle divise en chiffres. {$}pousse un bloc de code contenant l'opération "drop"; ceci est répété kfois ( k*) et le bloc de code est supprimé ( $. k1-#kdécrémente k. )9(place 9au STOS, et -soustrait TOS du STOS. #ostocke ce nombre dans o, et a$;supprime tous les membres de la pile. ]ferme la pile parente. oremet oà en haut; c'est notre chiffre que nous enregistrons. le )déplace vers le bas afin que nous puissions continuer notre boucle. svérifie généralement la non-entrée (c'est-à-dire, l'égalité à -1), mais nous pouvons l'utiliser pour sortir de notre boucle lorsque k == -1. Doncs^monte quand k == -1. $tombe kde la pile, et notre boucle recommence.

3: finale

                     ~; !nb$<

<dirige le pointeur vers la gauche et $tombe kde la pile. best un miroir de gauche, donc nous entrons à travers, mais il rebondit en frappant ;, un miroir de condition de pile. !nimprime un chiffre si et seulement si nous allons à gauche. ~termine le programme lorsque nous avons terminé l'impression.

Mathematica 52 octets

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

Cela suit l'approche de Peter Taylor et d'autres (sans utiliser les codes Ascii).

Exemple

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

2112

ClojureScript, 58 caractères

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

Les exigences de type ont rendu cela un peu plus long que nécessaire, et map-indexedle nombre de caractères n'a pas aidé.

Souvent, mes soumissions sont également valides pour Clojure, mais cela utilise une partie de la fuite de ClojureScript avec JavaScript. La soustraction d'un nombre et d'une chaîne contraint la chaîne à un nombre, c'est-à-dire (- 9 "5")égale 4.

PHP, 46/41/40 octets

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;

Divers sélecteurs de chiffres pour comparaison. Je pensais que "9 chiffres" serait le plus court, mais le cas spécial devait garder un zéro sur le premier chiffre le submerge.

Alimenté par les arguments CLI:

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

Rubis, 21 octets

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

Un programme complet. Courez avec le -ndrapeau. Utilise le mappage suivant: n -> n%2+1.

JavaScript (ES6), 41

L'astuce% 9 + 1 est empruntée à la réponse de Suever. Pour une fois, .reducebat .map. Notez que l' +=opérateur est utilisé pour éviter les parenthèses.

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

Perl, 18 octets

Comprend +1 pour -p

Exécutez avec les lignes d'entrée sur STDIN. La sortie est 1 sauf 2 lorsque la diagonale est 1

cantor.pl

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

Pyth, 14 octets

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

Essayez-le en ligne!