Étant donné une serrure à combinaison standard comme celle de l'image. Le moyen de le déverrouiller consiste à aligner les 4 chiffres du code sur la ligne de combinaison. Après des années de bons et loyaux services, vous avez été licencié de la fabrique de serrures et vous avez décidé de vous venger en ne mélangeant pas les serrures avant de les envoyer, laissant ainsi chaque serrure avec la combinaison pour la déverrouiller sur la ligne de combinaison.

Vous savez également qu'en regardant l'ordre des numéros dans les autres lignes, il est possible de déterminer quels numéros doivent être sur la ligne de combinaison (et donc la combinaison pour la déverrouiller).

Si chaque ligne de la serrure reçoit un numéro à partir de la ligne 0 pour la ligne de combinaison (la ligne qui déverrouille la serrure) à la ligne 9. Par exemple, si les numéros de la ligne 4 le sont 5336, alors la combinaison pour la déverrouiller serait 1992.

Malheureusement, les serrures ont déjà été emballées et votre vue de chaque serrure est obscurcie, vous ne pouvez donc voir que les numéros sur différentes lignes de la serrure.

Le défi

Étant donné 4 paires de chiffres, où le premier chiffre de l'entier représente le numéro de ligne et le deuxième chiffre représente le numéro qui apparaît sur cette ligne, déterminez la combinaison du verrou. Par exemple, si vous saisissez:

57 23 99 45

Ensuite, il devrait sortir:

2101

Ou

25 78 63 15

et

3174

Supposons que l'entrée sera toujours 4 entiers positifs sous la forme `25 64 72 18.

Il s'agit de code-golf , donc les programmes les plus courts en nombre d'octets gagnent.

C'est aussi ma première question, donc tout commentaire est apprécié.

CJam, 9 8 octets

ea9fbAf%

Lit les paires de chiffres comme arguments de ligne de commande. Pour essayer le code en ligne , passez eaà lS/pour lire à partir de STDIN simulé.

Exemple d'exécution

$ cjam <(echo ea9fbAf%) 57 23 99 45; echo
2101
$ cjam <(echo ea9fbAf%) 25 78 63 15; echo
3174

Comment ça marche

Le code de caractère du chiffre d est 48 + d . Ainsi, en considérant la chaîne à deux chiffres xy, un nombre de base 9 donne 9 * (48 + x) + (48 + y) = 10 * (48 + x) + y - x ≡ y - x (mod 10) .

ea       " Push the array of command-line arguments.                                      ";
  9fb    " Mapped base 9 conversion; replace each string 'xy' with (9 * ord(x) + ord(y)). ";
     Af% " Take the results modulo 10.                                                    ";

CJam, 13 12 11 caractères

Grâce à user23013, il est maintenant réduit à 11 caractères :)

4{Ar:--A%}*

Explications:

4{       }*     "Run the code block 4 times";
   r            "Read the next input token (whitespace separated)";
    :-          "Subtract 2nd number from the first treating r as a 2 numbered string";
  A   -         "Subtract the result of above from 10";
       A%       "Take modulus of 10 and store it on stack";

Essayez-le en ligne

Je sais qu'on peut jouer au golf plus. Mais c'est ma première vraie tentative sur CJam et je suis limité par l'expérience :)

Alternativement, les autres méthodes pour faire la même chose avec 1 caractère supplémentaire:

l~]{_A/-A%}/     // My previous solution

ou

4{ri_A/-A%}*     // As pointed out by Ingo

ou

ea{i_A/-A%}/     // If input is passed through command line

Golfscript (14 13 )

Essayez-le en ligne ici

C'est à peu près la même chose que la solution d'Optimizer , mais dans une langue différente. Il est difficile de l'aborder différemment car le problème est assez simple , donc la cravate va certainement à l'Optimizer, dont l'entrée était plus tôt de toute façon.

~]{.10:^/-^%}/

Pour le même nombre d'octets que vous pouvez faire

~]{.10/- 10%}/

GNU dc , 14 octets

Emprunter le truc astucieux de base 9 de Dennis :

9i[?A%nd]dxxxx

Entiers d'entrée lus depuis STDIN, un par ligne.

Explication:

9i                # Set input radix to 9
  [     ]         # push a macro, defined thus:
   ?              #   read number from STDIN and push
    A             #   push literal 10
     %            #   calculate number mod 10
      n           #   print, with no newline
       d          #   duplicate macro
         d        # duplicate macro
          xxxx    # execute the macro 4 times    

Sortie:

$ for i in 57 23 99 45; do echo $i; done | dc ./combolock.dc
2101$ 
$ for i in 25 78 63 15; do echo $i; done | dc ./combolock.dc
3174$ 
$ 

Réponse précédente, 18 octets:

Parce que je pensais que je pourrais me rapprocher des langues "golf" avec ça (mais je ne l'ai pas fait):

[A?A~--A%n]dddxxxx

C 64 63 56 ou 61

Si l'entrée peut être envoyée depuis un fichier

main(a){while(scanf("%d",&a)>0)putchar(48+(a-a/10)%10);}

Si l'entrée doit être tapée en stdin

i;main(a){for(;i++-4;putchar(48+(a-a/10)%10))scanf("%d",&a);}

Lit les quatre nombres dans une boucle puis traite chacun en soustrayant le premier chiffre de la valeur et en imprimant le résultat modulo 10.

Économies grâce aux divers commentaires ci-dessous et en utilisant également putchar au lieu de printf

Python 3, 64

Simple.

print(''.join([(i-i//10)%10 for i in map(int,input().split())]))

Il peut être plus court si je suis autorisé à imprimer, disons à la [2, 1, 0, 1]place ( 46 ):

print([i%10-i//10 for i in map(int,input().split())])

C, 92

#define a(n) ,(10+v[n][1]-*v[n])%10
main(int c,char**v){printf("%d%d%d%d"a(1)a(2)a(3)a(4));}

Entrée depuis la ligne de commande. Soustrait le premier code ASCII de chaque argument du second, ajoute 10 et prend modulo 10.

Je pense que c'est la première fois que j'écris un printfavec quatre %s et sans virgule (la virgule est dans le #define.)

Java - 203 octets

Juste parce qu'il doit y avoir une entrée Java, j'ai vu une belle opportunité de donner une chance au golf (première soumission jamais).

class M{public static void main(String[] a){String r="";for(int i=0;i<4;i++){int l=Byte.valueOf(a[i].substring(1));int f=Byte.valueOf(a[i].substring(0,1));r+=(l-f<0)?l-f+10:l-f;}System.out.print(r);}}

S'il y a de la place pour quelques améliorations, je serais heureux de les connaître ;-)

Lua - 46 personnages

while''do a,b=io.read(1,1,1)print((b-a)%10)end

Lit trois caractères à la fois (accordez-moi la petite pitié de saisir un espace à la fin), et même si a et b sont string-y ... ba MAGICALEMENT leur permet de concevoir un bébé entier sain. Est-ce que le retour à la ligne est vérifié lors de l'impression.

JavaScript ES6 - 53 43 octets

f=n=>n.replace(/.. ?/g,a=>(1+a[1]-a[0])%10)

Fonction assez simple, utilise l'expression régulière pour obtenir les chiffres. Essayez-le sur http://jsfiddle.net/efc93986/1/ . Si les fonctions ne sont pas autorisées, un programme autonome à 52 octets:

alert(prompt().replace(/.. ?/g,a=>(1+a[1]-a[0])%10))

Comme ES6 ne fonctionne actuellement que sur Firefox, le code suivant fonctionne sur n'importe quel navigateur moderne, à 70 octets:

alert(prompt().replace(/.. ?/g,function(a){return(1+a[1]-a[0])%10}))

Python 2 - 33 octets

for i in input():print(i-i/10)%10

Accepte les entrées utilisateur séparées par des virgules. Par exemple, entrée:

29,26, 31, 88

Sortie:

7
4
8
0

Si la sortie doit correspondre exactement à l'exemple, elle est beaucoup plus longue. 47 octets:

print"%d"*4%tuple((i-i/10)%10 for i in input())

APL, 14

10|{--/⍎¨⍕⍵}¨⎕

L'explication
⎕ prend l'entrée de l'écran. Les valeurs séparées par des espaces sont analysées sous forme de tableau.
{...}¨pour chaque numéro, introduisez-le dans la fonction.
⍎¨⍕⍵prend l'argument, créez un tableau de ses chiffres.
--/calcule les unités moins les dizaines.
10|mod 10.

J - 20 15

La forme non verbale (comme instruction au lieu de la définition de la fonction) est 5 caractères plus courte:

10|-~/|:10#.inv

La forme verbale qui est un joli train :

10|[:-~/[:|:10#.inv]

Ce verbe utilisé sur les exemples d'entrées:

   10|-~/|:10#.inv 57 23 99 45
2 1 0 1
   10|-~/|:10#.inv 25 78 63 15
3 1 7 4

rotd =: 10|[:-~/[:|:10#.inv] NB. verb form

   rotd 25 78 63 15
3 1 7 4
   rotd 57 23 99 45
2 1 0 1

Haskell 60 58

main=interact$show.map((\x->mod(x-x`div`10)10).read).words

Chiffres à un seul caractère, un véritable ennemi du golf à Haskell.

Perl: 38 40

print abs($_-int$_/10)%10for split" ",<>

Sortie:

% perl code.pl
57 23 99 45
2101

25 78 63 15                                     
3174

Rubis, 35 octets

$*.map{|n|a,b=n.bytes;$><<(b-a)%10}

Explication

L'entrée est prise comme argument de ligne de commande. String#bytesrenvoie un tableau d'entiers (codes de caractères ASCII). Seule la différence entre le dernier et le premier code de caractère est importante, pas les entiers eux-mêmes.

C # et LinqPad: 104

Util.ReadLine<string>("").Split(' ').Select(s =>(s[1]-s[0])).Aggregate("",(r,a)=>r+(a<0?10+a:a)).Dump();

C ++ 118

int main()
{
int a,b,c;
for(int i=0; i<4; i++)
{
cin>>a;
b=a/10;
a=a%10;
c=a-b;
if(c<0)c+=10;
cout<<c;
}
}

PHP - 90 caractères

Je pensais que j'essaierais le golf de code alors voici, ma première tentative - peut probablement être joué plus.

<?php $a=array(57,23,99,45);foreach($a as$b){echo abs(substr($b,0,1)-substr($b,1,1)%10);}

58 personnages (gracieuseté d'Ismael Miguel)

for($i=0,$a=$_GET[n];$i<8;)echo abs($a[$i++]-$a[$i++]);

Accéder au fichier à l'aide

file.php?n=57239945

Python 3, 60

for x in input().split():print(-eval('-'.join(x))%10,end='')

Entrer et sortir exactement comme spécifié, bien qu'il n'imprime pas de nouvelle ligne de fin. Deux astuces intéressantes ici: 1) remplacer deux appels à int()un appel à eval(), et 2) utiliser join()pour obtenir a-b, puis l'annuler b-asi nécessaire. Heureusement, l'opérateur modulo de Python donne des valeurs positives même si le premier argument est négatif!