En tant qu'enfant, ma sœur m'a montré ce petit calcul d'amour pour voir combien de chances vous avez de nouer une relation fructueuse avec votre béguin. Tout ce dont vous avez besoin est 2 noms et un morceau de papier.

• John
• Jeanne

Ensuite, vous séparez ces noms avec le mot Loves . Vous pouvez écrire ceci sur une ligne ou sur de nouvelles lignes.

John
aime
Jane

Alors commence le calcul. Vous commencez par compter le nombre de fois où un personnage se produit de gauche à droite et dans le cas où vous utilisez de nouvelles lignes également de haut en bas. Chaque personnage est compté une fois. Ainsi, après avoir compté le J de John, vous n'avez pas à les compter à nouveau lorsque vous démarrez avec Jane. Le résultat de cet exemple sera le suivant:

J: 2 ([J] ohn | [J] ane)
O: 2 (J [o] hn | L [o] ves)
H: 1 (Jo [h] n)
N: 2 (Joh [n] | Ja [n] e)
__
L: 1 ([L] oves)
O: sauté
V: 1 (Lo [v] es)
E: 2 (Lov [e] s | Jan [e])
S: 1 (Amour ])
__
J: sauté
A: 1 (J [a] ne)
N: sauté
E: sauté
__
Résultat final: 2 2 1 2 1 1 2 1 1

La prochaine étape consistera à ajouter les chiffres qui vont de l’extérieur au milieu.

2 2 1 2 1 1 2 1 1 (2 + 1 = 3)
2 2 1 2 1 1 2 1 1 (2 + 1 = 3)
2 2 1 2 1 2 1 1 (1 + 2 = 3)
2 2 1 2 1 1 2 1 1 (2 + 1 = 3)
2 2 1 2 1 1 2 1 1 (1)
__
Résultat: 3 3 3 3 1

Vous continuerez ainsi jusqu'à ce que vous ayez un nombre entier inférieur ou égal à 100.

3 3 3 3 1
4 6 3
76%

Il peut arriver que la somme de 2 chiffres devienne ≥ 10, dans ce cas, le nombre sera divisé en 2 à la ligne suivante.
Exemple:

5 3 1 2 5 4 1 8
13 (sera utilisé comme 1 3)
1 3 4 5 7
8 8 4 (8 + 4 = 12 utilisé comme 1 2)
1 2 8
92%

Exigences

• Votre programme devrait pouvoir accepter n'importe quel nom de longueur raisonnable (100 caractères)
• Les caractères [A..Z, a..z] sont autorisés.
• Insensible à la casse donc A == a

Gratuit pour vous de décider

• Comment gérer les caractères spéciaux (Ö, è, etc.)
• Inclure les noms de famille oui ou non, les espaces seront ignorés
• Toute langue est autorisée.

Le gagnant sera déterminé par vote le 28 et le 14 février.

Bonne codage

Ps C’est la première fois que je mets quelque chose ici, s’il ya un moyen de l’améliorer, n’hésitez pas à me le faire savoir = 3

Edit: Changement de date de fin en jour de la Saint-Valentin, pensant que ce serait plus approprié pour ce défi :)

Déclenchement

글⓵닆뭶뉗밃變充梴⓶壹꺃뭩꾠⓶꺐合合替虛終梴⓷縮⓶終併❶뉀大套鈮⓶充銻⓷加⓶鈮⓶終併❶뉀大終깐

Attend l’entrée sous forme de deux mots séparés par des espaces (par exemple John Jane ). Il est insensible à la casse, mais ne supporte que les caractères qui ne sont pas des caractères regex spéciaux (donc, n'utilisez pas (ou *en votre nom!). De plus, il n'attend que deux mots. Par conséquent, si votre amour est «Mary Jane», vous devez écrire MaryJaneun mot. sinon, il évaluera "YourName aime que Mary aime Jane".

Explication

La partie la plus difficile a été de gérer le cas de nombre impair de chiffres: vous devez laisser le chiffre du milieu seul au lieu de l'ajouter à lui-même. Je pense que ma solution est intéressante.

글⓵닆뭶뉗밃變 | replace space with "loves"
充 | while non-empty...
    梴 | get length of string
    ⓶壹 | get first character of string (let’s say it’s “c”)
    꺃뭩꾠⓶꺐合合 | construct the regex “(?i:c)”
    替虛終 | replace all matches with empty string
    梴 | get new length of that
    ⓷縮 | subtract the two to get a number
    ⓶ | move string to front
終 | end while
併 | Put all the numbers accrued on the stack into a single string
❶뉀大 | > 100
套 | while true...
    鈮⓶ | chop off the first digit
    充 | while non-empty... (false if that digit was the only one!)
        銻⓷加 | chop off last digit and add them
        ⓶鈮⓶ | chop off the first digit again
                 (returns the empty string if the string is empty!)
    終 | end while
    併 | Put all the numbers (± an empty string ;-) ) on the stack into a single string
    ❶뉀大 | > 100
終 | end while
깐 | add "%"

Quand il vous reste quelque chose ≤ 100, la boucle se terminera, la réponse sera sur la pile et donc restituée.

Fonction

Ce programme attend l'entrée séparée par un espace (par exemple John Jane). Il est insensible à la casse pour les caractères AZ / az; pour tout autre caractère Unicode, il «confondera» deux caractères égaux entre 32 et 32 ​​(par exemple, Āet Ġ, ou ?et _). De plus, je n’ai aucune idée de ce que fera ce programme si l’entrée contient un NUL (\0 ), alors n'utilisez pas ça :)

De plus, comme StackExchange ajoute trop d’espacement des lignes, voici le texte brut sur pastebin . Vous pouvez également exécuter le code suivant dans la console JavaScript de votre navigateur pour le corriger ici:$('pre').css('line-height',1)

                               ╓───╖ ╓───╖ ╓───╖ ╓───╖ ╓───╖ ╓───╖
                               ║ Ḷ ║┌╢ Ọ ╟┐║ Ṿ ║ ║ Ẹ ║┌╢ Ṛ ╟┐║ Ṣ ╟┐
                               ╙─┬─╜│╙───╜│╙─┬─╜ ╙─┬─╜│╙─┬─╜│╙─┬─╜│
                                 │  │     │  │     │  │  │  │  │  │
                                 │  │     │  │     │  │  │  │  │  │
                                 │  │     │  │     │  │  │  │  │  │
                                 │  │     │  │     │  │  │  │  │  └───────────┐
                                 │  │     │  │     │  │  │  │  └─────────────┐│
                         ┌───────┘  │     │  │     │  │  │  └───────────────┐││
                         │┌─────────┘     │  │     │  │  └─────────────────┐│││
                         ││┌──────────────┘  │     │  └───────────────────┐││││
                         │││     ┌───────────┘     └──────────────────┐   │││││
                         │││ ┌───┴───┐  ┌─────────────────────────────┴─┐ │││││
                         │││ │ ╔═══╗ │  │                               │ ││││└─────────┐
                         │││ │ ║ 2 ║ │  │     ┌───┐   ┌───┐             │ │││└─────────┐│
                         │││ │ ║ 1 ║ │  │    ┌┴┐  │  ┌┴┐  │             │ ││└─────────┐││
                         │││ │ ║ 1 ║ │  │    └┬┘  │  └┬┘  │             │ │└─────────┐│││
┌────────────────────────┘││ │ ║ 1 ║ │  │   ┌─┴─╖ │ ┌─┴─╖ │     ┌───╖   │ └─────────┐││││
│┌────────────────────────┘│ │ ║ 0 ║ │  │   │ ♯ ║ │ │ ♯ ║ ├─────┤ ℓ ╟───┴─┐         │││││
││┌────────────────────────┘ │ ║ 6 ║ │  │   ╘═╤═╝ │ ╘═╤═╝ │     ╘═══╝   ┌─┴─╖       │││││
│││                    ┌─────┘ ║ 3 ║ │  │    ┌┴┐  │  ┌┴┐  └─────────────┤ · ╟──────┐│││││
│││┌───────────────────┴┐┌───╖ ║ 3 ║ │  │    └┬┘  │  └┬┘                ╘═╤═╝      ││││││
││││                   ┌┴┤ = ╟─╢ 3 ║ │  │ ┌───┘   └───┴─────┐         ┌───┴───┐    ││││││
││││      ╔════╗ ┌───╖ │ ╘═╤═╝ ║ 1 ║ │  │ │ ╔═══╗         ┌─┴─╖       │ ╔═══╗ │    ││││││
││││      ║ 37 ╟─┤ ‼ ╟─┘ ┌─┘   ║ 9 ║ │  │ │ ║ 1 ║ ┌───────┤ · ╟─┐     │ ║ 0 ║ │    ││││││
││││      ╚════╝ ╘═╤═╝  ┌┴┐    ║ 6 ║ │  │ │ ╚═╤═╝ │       ╘═╤═╝ ├─────┘ ╚═╤═╝ │    ││││││
││││ ┌───╖ ┌───╖ ┌─┴─╖  └┬┘    ║ 3 ║ │  │ │ ┌─┴─╖ │ ╔═══╗ ┌─┴─╖ │ ╔═══╗ ┌─┴─╖ │    ││││││
│││└─┤ Ẹ ╟─┤ Ṿ ╟─┤ ? ╟───┤     ║ 3 ║ │  │ └─┤ ʃ ╟─┘ ║ 1 ╟─┤ ʃ ╟─┘ ║ 1 ╟─┤ ʃ ╟─┘    ││││││
│││  ╘═══╝ ╘═══╝ ╘═╤═╝  ┌┴┐    ║ 7 ║ │  │   ╘═╤═╝   ╚═══╝ ╘═╤═╝   ╚═══╝ ╘═╤═╝      ││││││
│││                │    └┬┘    ╚═══╝ │  │     │  ┌──────────┘             └──────┐ ││││││
│││              ╔═══╗ ┌─┴─╖ ┌───╖   │  │     │  │ ┌─────────╖ ┌───╖ ┌─────────╖ │ ││││││
│││              ║ 3 ╟─┤ > ╟─┤ ℓ ╟───┘  │     │  └─┤ str→int ╟─┤ + ╟─┤ str→int ╟─┘ ││││││
│││              ╚═══╝ ╘═══╝ ╘═══╝      │     │    ╘═════════╝ ╘═╤═╝ ╘═════════╝   ││││││
││└───────────────────────────────────┐ │     │             ┌────┴────╖            ││││││
│└───────────────────────────────┐    │ │     │             │ int→str ║            ││││││
│          ╔═══╗                 │    │ │     │ ┌───╖ ┌───╖ ╘════╤════╝            ││││││
│          ║ 0 ║                 │    │ │     └─┤ Ẹ ╟─┤ ‼ ╟──────┘                 ││││││
│          ╚═╤═╝                 │    │ │       ╘═══╝ ╘═╤═╝   ┌────────────────────┘│││││
│    ╔═══╗ ┌─┴─╖                 │    │ │             ┌─┴─╖ ┌─┴─╖ ╔═══╗             │││││
│    ║ 1 ╟─┤ ʃ ╟─────────────────┴┐   │ └─────────────┤ ? ╟─┤ ≤ ║ ║ 2 ║             │││││
│    ╚═══╝ ╘═╤═╝                  │   │               ╘═╤═╝ ╘═╤═╝ ╚═╤═╝             │││││
│          ┌─┴─╖                  │   │                 │     └─────┘               │││││
│        ┌─┤ Ṣ ╟──────────────────┴┐  │    ╔═══╗   ┌────────────────────────────────┘││││
│        │ ╘═╤═╝                   │  │    ║   ║   │  ┌──────────────────────────────┘│││
│        │ ┌─┴─╖                   │  │    ╚═╤═╝   │  │    ┌──────────────────────────┘││
│        └─┤ · ╟─────────────┐     │  │    ┌─┴─╖   │┌─┴─╖┌─┴─╖                         ││
│          ╘═╤═╝             │     │  │    │ Ḷ ║   └┤ · ╟┤ · ╟┐                        ││
│      ┌─────┴───╖         ┌─┴─╖ ┌─┴─╖│    ╘═╤═╝    ╘═╤═╝╘═╤═╝│                        ││
│      │ int→str ║ ┌───────┤ · ╟─┤ · ╟┴┐     │      ┌─┴─╖  │  │                        ││
│      ╘═════╤═══╝ │       ╘═╤═╝ ╘═╤═╝ │           ┌┤ · ╟──┘  │                        ││
│            │   ┌─┴─╖ ┌───╖ │     │   │         ┌─┘╘═╤═╝   ┌─┴─╖                      ││
│            │   │ ‼ ╟─┤ Ọ ╟─┘     │   │         │ ┌──┴─────┤ · ╟───────┐              ││
│            │   ╘═╤═╝ ╘═╤═╝       │   │         │ │ ╔════╗ ╘═╤═╝ ╔═══╗ │              ││
│            └─────┘     │         │   │         │ │ ║ 21 ║   │   ║ 2 ║ │              ││
│                ┌───╖ ┌─┴─╖       │   │  ┌──────┘ │ ╚═══╤╝   │   ║ 0 ║ │              ││
│            ┌───┤ Ṿ ╟─┤ ? ╟───────┘   │  │┌───╖ ┌─┴─╖ ┌─┴──╖ │   ║ 9 ║ │              ││
│            │   ╘═══╝ ╘═╤═╝           │ ┌┴┤ ♯ ╟─┤ Ṛ ╟─┤ >> ║ │   ║ 7 ║ │              ││
│            │           │             │ │ ╘═══╝ ╘═╤═╝ ╘══╤═╝ │   ║ 1 ║ │              ││
│            └─────────┐   ┌───────────┘ │ ╔═══╗ ┌─┴─╖    ├───┴─┬─╢ 5 ║ │              ││
└───────────────────┐  └───┘             │ ║ 0 ╟─┤ ? ╟────┘     │ ║ 1 ║ │              ││
╔════╗              │                    │ ╚═══╝ ╘═╤═╝   ┌──────┤ ╚═══╝ │              ││
║ 21 ║              │                    │       ┌─┴─╖ ┌─┴─╖ ╔══╧══╗    │              ││
╚═╤══╝              │                    └───────┤ ? ╟─┤ ≠ ║ ║ −33 ║    │              ││
┌─┴─╖ ┌────╖        │                            ╘═╤═╝ ╘═╤═╝ ╚══╤══╝   ┌┴┐             ││
│ × ╟─┤ >> ╟────────┴────────────┐                 │     └──────┤      └┬┘             ││
╘═╤═╝ ╘═╤══╝ ┌───╖   ╔═════════╗ │                              └───────┘              ││
┌─┴─╖   └────┤ ‼ ╟───╢ 2224424 ║ │                ┌────────────────────────────────────┘│
│ ♯ ║        ╘═╤═╝   ║ 4396520 ║ │                │    ┌────────────────────────────────┘
╘═╤═╝        ┌─┴─╖   ║ 1237351 ║ │                │    │    ┌─────────────────────┐
  └──────────┤ · ╟─┐ ║ 2814700 ║ │                │  ┌─┴─╖  │     ┌─────┐         │
             ╘═╤═╝ │ ╚═════════╝ │              ┌─┴──┤ · ╟──┤     │    ┌┴┐        │
 ╔═══╗ ┌───╖ ┌─┴─╖ │   ╔════╗    │            ┌─┴─╖  ╘═╤═╝┌─┴─╖   │    └┬┘        │
 ║ 0 ╟─┤ Ọ ╟─┤ ‼ ║ │   ║ 32 ║    │   ┌────────┤ · ╟────┴──┤ Ṛ ╟───┤   ┌─┴─╖       │
 ╚═══╝ ╘═╤═╝ ╘═╤═╝ │   ╚═╤══╝    │   │        ╘═╤═╝       ╘═╤═╝   │   │ ♯ ║       │
         │   ┌─┴─╖ ├─┐ ┌─┴─╖     │ ┌─┴─╖      ┌─┴─╖       ╔═╧═╗   │   ╘═╤═╝       │
           ┌─┤ ʃ ╟─┘ └─┤ ʘ ║     │┌┤ · ╟──────┤ · ╟───┐   ║ 1 ║   │    ┌┴┐        │
           │ ╘═╤═╝     ╘═╤═╝     ││╘═╤═╝      ╘═╤═╝   │   ╚═══╝   │    └┬┘        │
           │ ╔═╧═╗       ├───────┘│  │       ┌──┴─╖ ┌─┴─╖ ┌───╖ ┌─┴─╖ ┌─┴─╖ ╔═══╗ │
           │ ║ 0 ║       │        │  │       │ >> ╟─┤ Ṣ ╟─┤ ‼ ╟─┤ · ╟─┤ ʃ ╟─╢ 0 ║ │
           │ ╚═══╝       │        │  │       ╘══╤═╝ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ ╚═══╝ │
           └─────────────┘        │  │ ╔════╗ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ┌─┘     ├─────────┘
                                  │  │ ║ 21 ╟─┤ × ╟─┤ · ╟─┤ · ╟─┴─┐     │
                                  │  │ ╚════╝ ╘═══╝ ╘═╤═╝ ╘═╤═╝   │     │
                                  │  └────────────────┘   ┌─┴─╖   │     │
                                  │                   ┌───┤ ? ╟───┴┐    │
                                  │                   │   ╘═╤═╝    │    │
                                  │           ┌───╖ ┌─┴─╖   │    ┌─┴─╖  │
                                  └───────────┤ ♯ ╟─┤ · ╟─┐   ┌──┤ ? ╟─ │
                                              ╘═══╝ ╘═╤═╝ └───┘  ╘═╤═╝  │
                                                      │          ╔═╧═╗  │
                                                      │          ║ 0 ║  │
                                                      │          ╚═══╝  │
                                                      └─────────────────┘

Explication rapide

• Le programme prend juste STDIN et appelle Ḷavec.

• Ḷtrouve le premier espace de la chaîne, le remplace par loveset passe le résultat à Ọ.

• Ọprend à plusieurs reprises le premier caractère de la chaîne d'entrée, appelle Ṣavec elle et concatène le nombre d'occurrences sur une chaîne de résultat. Lorsque la chaîne d'entrée est vide, il appelle Ṿavec la chaîne de résultat.

• Ṿappelle de manière répétée Ẹjusqu'à obtenir un résultat égal "100"ou inférieur à 3. ( 100peut réellement se produire: considérez l'entrée lovvvv eeeeeess). Lorsque c'est le cas, il ajoute "%"et renvoie ce résultat.

• Ẹcalcule une itération complète de l'algorithme de calcul de l'amour; c'est-à-dire qu'il faut une chaîne de chiffres et renvoie la chaîne de chiffres suivante.

• Ṛprend une botte de foin et une aiguille et trouve l'index de la première occurrence d' aiguille dans la botte de foin en utilisant le critère de fausse insensibilité à la casse ( or 32).

• Ṣprend une botte de foin et une aiguille et applique Ṛà plusieurs reprises pour supprimer toutes les instances de l' aiguille . Il retourne le résultat final après tous les retraits, ainsi que le nombre de retraits effectués.

Rubis

     f=IO.         read(
   __FILE__)     .gsub(/[^
 \s]/x,?#);s=   $**'loves';s
.upcase!;i=1;a =s.chars.uniq.
map{|c|s.count(c)};loop{b='';
b<<"#{a.shift.to_i+a.pop.to_i
 }"while(a.any?);d=b.to_i;a=
   b.chars;d<101&&abort(d>
     50?f:f.gsub(/^.*/){
       |s|i=13+i%3;s[\
         i...i]=040.
           chr*3;s
             })}
              V

Imprime un coeur si la chance d'une relation est supérieure à 50%

$ ruby ♥.rb sharon john
     #####         #####
   #########     #########
 ############   ############
############## ##############
#############################
#############################
 ###########################
   #######################
     ###################
       ###############
         ###########
           #######
             ###
              #

Et imprime un cœur brisé si les chances sont inférieures à 50% :(

$ ruby ♥.rb sharon epidemian
     #####            #####
   #########        #########
 ############      ############
##############    ##############
###############   ##############
#############   ################
 #############   ##############
   ############   ###########
     ########   ###########
       #######   ########
         ######   #####
           ##   #####
             #   ##
              # 

Branlant John ...

Quoi qu'il en soit, il est insensible à la casse et prend en charge les requêtes polygames (par exemple ruby ♥.rb Alice Bob Carol Dave).

APL, 80

{{n←⍎∊⍕¨(⍵[⌈m]/⍨m≠⌊m),⍨+/(⌊m←2÷⍨≢⍵)↑[1]⍵,⍪⌽⍵⋄n≤100:n⋄∇⍎¨⍕n}∪⍦32|⎕UCS⍺,'Loves',⍵}

Parce que l' amour est amour code-golf est code-golf (même si ce n'est pas le cas)

Version obligatoire ♥ en forme de ︎:

    {f←{m←  2÷⍨≢⍵
  n←+/(⌊m)↑[1]⍵,⍪⌽⍵
n←⍎∊⍕¨n,(⍵[⌈m]/⍨m≠⌊m)
n≤100:n⋄∇⍎¨⍕n}⋄u←⎕UCS
   s←u⍺,'Loves',⍵
       f∪⍦32|s
          }

La version golfée me donne un comportement quelque peu erratique, à cause d'un bogue avec ∪⍦lequel j'étudie les développeurs de NARS:

      'John'{{n←⍎∊⍕¨(⍵[⌈m]/⍨m≠⌊m),⍨+/(⌊m←2÷⍨≢⍵)↑[1]⍵,⍪⌽⍵⋄n≤100:n⋄∇⍎¨⍕n}∪⍦32|⎕UCS⍺,'Loves',⍵}'Jane'
VALUE ERROR

Mais j'ai pu l'exécuter par morceaux et obtenir le résultat correct:

      'John'{∪⍦32|⎕UCS⍺,'Loves',⍵}'Jane'
2 2 1 2 1 1 2 1 1
      {n←⍎∊⍕¨(⍵[⌈m]/⍨m≠⌊m),⍨+/(⌊m←2÷⍨≢⍵)↑[1]⍵,⍪⌽⍵⋄n≤100:n⋄∇⍎¨⍕n}2 2 1 2 1 1 2 1 1
76

Javascript

Probablement pourrait être plus propre, mais cela fonctionne. Exemple verbeux

function z(e) {
    for (var t = 0, c = '', n = e.length - 1; n >= t; n--, t++) {
        c += n != t ? +e[t] + (+e[n]) : +e[t];
    }
    return c
}
for (var s = prompt("Name 1").toLowerCase() + "loves" + prompt("Name 2").toLowerCase(),b = '', r; s.length > 0;) {
    r = new RegExp(s[0], "g");
    b+=s.match(r).length;
    s = s.replace(r, "")
}
for (; b.length > 2; b = z(b)) {}
console.log("Chances of being in love are: " + b + "%")

Python

Eh bien, je pensais que c'était un code-golf ...

a=filter(str.isalpha,raw_input()+"loves"+raw_input()).lower();a=[x[1]for x in sorted(set(zip(a,map(str.count,[a]*len(a),a))),key=lambda(x,y):a.index(x))]
while reduce(lambda x,y:x*10+y,a)>100:a=reduce(list.__add__,map(lambda x: x<10 and[x]or map(int,str(x)),[a[n]+a[-n-1]for n in range(len(a)/2)]+(len(a)%2 and[a[len(a)/2]]or[])))
print str(reduce(lambda x,y:x*10+y,a))+"%"

Ungolfed:

a = filter(str.isalpha,
           raw_input() + "loves" + raw_input()).lower()

a = [x[1] for x in sorted(set(zip(a,
                                  map(str.count, [a] * len(a), a))),
                          key=lambda (x, y): a.index(x))]

while reduce(lambda x, y: x * 10 + y, a) > 100:
    a = reduce(list.__add__,
               map(lambda x: x < 10 and [x] or map(int, str(x)), 
                   [a[n] + a[-n - 1] for n in range(len(a) / 2)] + (len(a) % 2 and [a[len(a) / 2]] or [])))

print str(reduce(lambda x, y: x * 10 + y, a)) + "%"

PHP

<?php

$name1 = $argv[1];
$name2 = $argv[2];

echo "So you think {$name1} and {$name2} have any chance? Let's see.\nCalculating if \"{$name1} Loves {$name2}\"\n";

//prepare it, clean it, mince it, knead it
$chances = implode('', array_count_values(str_split(preg_replace('/[^a-z]/', '', strtolower($name1.'loves'.$name2)))));
while(($l = strlen($chances))>2 and $chances !== '100'){
    $time = time();
    $l2 = intval($l/2);
    $i =0;
    $t = '';
    while($i<$l2){
        $t.=substr($chances, $i, 1) + substr($chances, -$i-1, 1);
        $i++;
    }
    if($l%2){
        $t.=$chances[$l2];
    }
    echo '.';
    $chances = $t;
    while(time()==$time){}
}

echo "\nTheir chances in love are {$chances}%\n";
$chances = intval($chances);
if ($chances === 100){
    echo "Great!!\n";
}elseif($chances > 50){
    echo "Good for you :) !!\n";
}elseif($chances > 10){
    echo "Well, it's something.\n";
}else{
    echo "Ummm.... sorry.... :(\n";
}

exemple de résultat

$ php loves.php John Jane
So you think John and Jane have any chance? Let's see.
Calculating if "John Loves Jane"
...
Their chances in love are 76%
Good for you :) !!

GolfScript

Code de golf obligatoire dans GolfScript:

' '/'loves'*{65- 32%65+}%''+:x.|{{=}+x\,,}%{''\{)\(@+@\+\.(;}do 0+{+}*+{[]+''+~}%.,((}do{''+}%''+

Accepte les entrées sous forme de noms séparés par des espaces, par exemple

echo 'John Jane' | ruby golfscript.rb love.gs
-> 76

C #

using System;
using System.Collections.Generic;
using System.Linq;

namespace LovesMeWhat
{
    class Program
    {
        static void Main(string[] args)
        {
            if (args.Length < 2) throw new ArgumentException("Ahem, you're doing it wrong.");

            Func<IEnumerable<Int32>, String> fn = null;
            fn = new Func<IEnumerable<Int32>, String> (input => {
                var q = input.SelectMany(i => i.ToString().Select(c => c - '0')).ToArray();

                if (q.Length <= 2) return String.Join("", q);

                IList<Int32> next = new List<Int32>();
                for (int i = 0, j = q.Length - 1; i <= j; ++i, --j)
                {
                    next.Add(i == j ? q[i] : q[i] + q[j]);
                }
                return fn(next);
            });

            Console.Write(fn(String.Concat(args[0], "LOVES", args[1]).ToUpperInvariant().GroupBy(g => g).Select(g => g.Count())));
            Console.Write("%");
            Console.ReadKey(true);
        }
    }
}

Haskell

Ma version est assez longue, c'est parce que j'ai décidé de me concentrer sur la lisibilité, j'ai pensé qu'il serait intéressant de formaliser votre algorithme en code. J'agrège les nombres de caractères dans un pli gauche , il fait essentiellement boule de neige et l'ordre est dans l'ordre d'apparition dans la chaîne. J'ai également réussi à remplacer la partie de l'algorithme qui nécessitait normalement l'indexation de tableaux avec le pliage de liste . En fin de compte, votre algorithme implique essentiellement de plier la liste de nombres en deux et d'ajouter des nombres alignés. Il y a deux cas de pliage, même les listes sont bien divisées au milieu, les listes impaires se plient autour d'un élément central et cet élément ne participe pas en plus. La fission prend la liste et scinde des nombres qui ne sont plus des chiffres uniques, comme> = 10 . Je devais écrire mon propre dépli , je ne sais pas si c'est en fait un dépli , mais il semble faire ce dont j'ai besoin. Prendre plaisir.

import qualified Data.Char as Char
import qualified System.Environment as Env

-- | Takes a seed value and builds a list using a function starting 
--   from the last element
unfoldl :: (t -> Maybe (t, a)) -> t -> [a]
unfoldl f b  =
  case f b of
   Just (new_b, a) -> (unfoldl f new_b) ++ [a]
   Nothing -> []

-- | Builds a list from integer digits
number_to_digits :: Integral a => a -> [a]
number_to_digits n = unfoldl (\x -> if x == 0 
                                     then Nothing 
                                     else Just (div x 10, mod x 10)) n

-- | Builds a number from a list of digits
digits_to_number :: Integral t => [t] -> t
digits_to_number ds = number
  where (number, _) = foldr (\d (n, p) -> (n+d*10^p, p+1)) (0,0) ds

-- | Bends a list at n and returns a tuple containing both parts 
--   aligned at the bend
bend_at :: Int -> [a] -> ([a], [a])
bend_at n xs = let 
                 (left, right) = splitAt n xs
                 in ((reverse left), right)

-- | Takes a list and bends it around a pivot at n, returns a tuple containing 
--   left fold and right fold aligned at the bend and a pivot element in between
bend_pivoted_at :: Int -> [t] -> ([t], t, [t])
bend_pivoted_at n xs
  | n > 1 = let 
              (left, pivot:right) = splitAt (n-1) xs
              in ((reverse left), pivot, right)

-- | Split elements of a list that satisfy a predicate using a fission function
fission_by :: (a -> Bool) -> (a -> [a]) -> [a] -> [a]
fission_by _ _ [] = []
fission_by p f (x:xs)
  | (p x) = (f x) ++ (fission_by p f xs)
  | otherwise = x : (fission_by p f xs)

-- | Bend list in the middle and zip resulting folds with a combining function.
--   Automatically uses pivot bend for odd lists and normal bend for even lists
--   to align ends precisely one to one
fold_in_half :: (b -> b -> b) -> [b] -> [b]
fold_in_half f xs
  | odd l = let 
              middle = (l-1) `div` 2 + 1
              (left, pivot, right) = bend_pivoted_at middle xs
              in pivot:(zipWith f left right)
  | otherwise = let 
                  middle = l `div` 2
                  (left, right) = bend_at middle xs
                  in zipWith f left right
  where 
    l = length xs

-- | Takes a list of character counts ordered by their first occurrence 
--   and keeps folding it in half with addition as combining function
--   until digits in a list form into any number less or equal to 100 
--   and returns that number
foldup :: Integral a => [a] -> a
foldup xs
  | n > 100 = foldup $ fission $ reverse $ (fold_in_half (+) xs)
  | otherwise = n
  where 
    n = (digits_to_number xs)
    fission = fission_by (>= 10) number_to_digits 

-- | Accumulate counts of keys in an associative array
count_update :: (Eq a, Integral t) => [(a, t)] -> a -> [(a, t)]
count_update [] x = [(x,1)]
count_update (p:ps) a
  | a == b = (b,c+1) : ps
  | otherwise = p : (count_update ps a)
  where
    (b,c) = p

-- | Takes a string and produces a list of character counts in order 
--   of their first occurrence
ordered_counts :: Integral b => [Char] -> [b]
ordered_counts s = snd $ unzip $ foldl count_any_alpha [] s
  where 
    count_any_alpha m c
      | Char.isAlpha c = count_update m (Char.toLower c)
      | otherwise = m

-- | Take two names and perform the calculation
love_chances n1 n2 =  foldup $ ordered_counts (n1 ++ " loves " ++ n2) 

main = do
   args <- Env.getArgs
   if (null args) || (length args < 2)
     then do
            putStrLn "\nUSAGE:\n"
            putStrLn "Enter two names separated by space\n"
     else let 
            n1:n2:_ = args 
            in putStrLn $ show (love_chances n1 n2) ++ "%"

Quelques résultats:

"Romeo" "Juliet" 97% - Les tests empiriques sont importants
"Romeo" "Julier" 88% - Version abrégée moderne ...
"Horst Draper" "Jane" 20%
"Horst Draper" "Jane (Cheval)" 70% - Il y a eu un développement ...
"Bender Bender Rodriguez" "Fenny Wenchworth" 41% - Bender dit que "Plier c'est pour les femmes!"
"Philip Fry" "Turanga Leela" 53% - Vous pouvez voir pourquoi il a fallu 7 saisons pour qu'ils épousent
"Maria" "Abraham" - 98%
"John" "Jane" 76%

Rubis

math = lambda do |arr|
  result = []
  while arr.any?
    val = arr.shift + (arr.pop || 0)
    result.push(1) if val >= 10
    result.push(val % 10)
  end
  result.length > 2 ? math.call(result) : result
end
puts math.call(ARGV.join("loves").chars.reduce(Hash.new(0)) { |h, c| h[c.downcase] += 1; h }.values).join

Minified:

l=->{|a|r=[];while a.any?;v=a.shift+(a.pop||0);r.push(1) if v>=10;r.push(v%10) end;r[2]?l[r]:r}
puts l[ARGV.join("loves").chars.reduce(Hash.new(0)){|h, c| h[c.downcase]+=1;h}.values].join

Appeler:

$ ruby love.rb "John" "Jane"
76

Python 3

Une solution simple qui n'utilise aucun module. I / O est assez jolie.

J'ai utilisé l'erreur de capture en tant que sauvegarde pour le moment où le deuxième itérateur est hors limites; s'il détecte l'erreur d'index de Python, il suppose 1. Bizarre, mais cela fonctionne.

names = [input("Name 1: ").lower(), "loves", input("Name 2: ").lower()]
checkedLetters = []

def mirrorAdd(n):
    n = [i for i in str(n)]
    if len(n) % 2:
        n.insert(int(len(n)/2), 0)
    return(int(''.join([str(int(n[i]) + int(n[len(n)-i-1])) for i in range(int(len(n)/2))])))

cn = ""

positions = [0, 0]
for i in [0, 1, 2]:
    checkAgainst = [0, 1, 2]
    del checkAgainst[i]
    positions[0] = 0
    while positions[0] < len(names[i]):
        if not names[i][positions[0]] in checkedLetters:
            try:
                if names[i][positions[0]] in [names[checkAgainst[0]][positions[1]], names[checkAgainst[1]][positions[1]]]:
                    positions[1] += 1
                    cn = int(str(cn) + "2")
                else:
                    cn = int(str(cn) + "1")
            except:
                cn = int(str(cn) + "1")
            checkedLetters.append(names[i][positions[0]])
        positions[0] += 1

print("\n" + str(cn))

while cn > 100:
    cn = mirrorAdd(cn)
    print(cn)

print("\n" + str(cn) + "%")

Voici un exemple de parcours:

Name 1: John
Name 2: Jane

221211211
33331
463
76

76%

Java

Il peut arriver que la somme de 2 chiffres devienne supérieure à 10, dans ce cas, le nombre sera divisé en 2 à la ligne suivante.

Et si le nombre est égal à 10? Je viens d'ajouter 1 et 0, est-ce correct?

J'ai décidé d'ignorer le cas.

public class LoveCalculation {
    public static void main(String[] args) {
        String chars = args[0].toLowerCase() + "loves" + args[1].toLowerCase();
        ArrayList<Integer> charCount = new ArrayList<Integer>();
        HashSet<Character> map = new HashSet<Character>();
        for(char c: chars.toCharArray()){
            if(Pattern.matches("[a-z]", "" + c) && map.add(c)){
                int index = -1, count = 0;
                while((index = chars.indexOf(c, index + 1)) != -1)
                    count++;
                charCount.add(count);
            }
        }
        while(charCount.size() > 2){
            ArrayList<Integer> numbers = new ArrayList<Integer>();
            for(int i = 0; i < (charCount.size()/2);i++)
                addToArray(charCount.get(i) + charCount.get(charCount.size()-1-i), numbers);
            if(charCount.size() % 2 == 1){
                addToArray(charCount.get(charCount.size()/2), numbers);
            }
            charCount = new ArrayList<Integer>(numbers);
        }
        System.out.println(Arrays.toString(charCount.toArray()).replaceAll("[\\]\\[,\\s]","") + "%");
    }
    public static ArrayList<Integer> addToArray(int number, ArrayList<Integer> numbers){
        LinkedList<Integer> stack = new LinkedList<Integer>();
        while (number > 0) {
            stack.push(number % 10);
            number = number / 10;
        }
        while (!stack.isEmpty())
            numbers.add(stack.pop());
        return numbers;
    }
}

contribution:

Maria
Abraham

sortie:

98%

contribution:

Wasi
codegolf.stackexchange.com

sortie:

78%

C

Il pourrait y avoir beaucoup d'amélioration, mais c'était amusant à coder.

#include <stdio.h>
#include <string.h>
int i, j, k, c, d, r, s = 1, l[2][26];
char a[204], *p, *q;

main(int y, char **z) {
    strcat(a, z[1]);
    strcat(a, "loves");
    strcat(a, z[2]);
    p = a;
    q = a;
    for (; *q != '\0'; q++, p = q, i++) {
        if (*q == 9) {
            i--;
            continue;
        }
        l[0][i] = 1;
        while (*++p != '\0')
            if ((*q | 96) == (*p | 96)&&*p != 9) {
                (l[0][i])++;
                *p = 9;
            }
    }
    for (;;) {
        for (j = 0, k = i - 1; j <= k; j++, k--) {
            d = j == k ? l[r][k] : l[r][j] + l[r][k];
            if (d > 9) {
                l[s][c++] = d % 10;
                l[s][c++] = d / 10;
            } else l[s][c++] = d;
            if (k - j < 2)break;
        }
        i = c;
        if (c < 3) {
            printf("%d", l[s][0]*10 + l[s][1]);
            break;
        }
        c = r;
        r = s;
        s = c;
        c = 0;
    }
}

Et bien sûr, version golfée obligatoire: 496

#include <stdio.h>
#include <string.h>
int i,j,k,c,d,r,s=1,l[2][26];char a[204],*p,*q;main(int y,char **z){strcat(a,z[1]);strcat(a,"loves");strcat(a,z[2]);p=q=a;for(;*q!='\0';q++,p=q,i++){if(*q==9){i--;continue;}l[0][i]=1;while(*++p!='\0')if((*q|96)==(*p|96)&&*p!=9){(l[0][i])++;*p=9;}}for(;;){for(j=0,k=i-1;j<=k;j++,k--){d=j==k?l[r][k]:l[r][j]+l[r][k];if(d>9){l[s][c++]=d%10;l[s][c++]=d/10;}else l[s][c++]=d;if(k-j<2)break;}i=c;if(c<3){printf("%d",l[s][0]*10+l[s][1]);break;}c=r;r=s;s=c;c=0;}}

Python 3

Cela prendra deux noms en entrée. décaper les espaces supplémentaires et ensuite calculer l'amour. Consultez la sortie pour plus de détails.

s=(input()+'Loves'+input()).strip().lower()
a,b=[],[]
for i in s:
    if i not in a:
        a.append(i)
        b.append(s.count(i))
z=int(''.join(str(i) for i in b))
while z>100:
    x=len(b)
    t=[]
    for i in range(x//2):
        n=b[-i-1]+b[i]
        y=n%10
        n//=10
        if n:t.append(n)
        t.append(y)
    if x%2:t.append(b[x//2])
    b=t
    z=int(''.join(str(i) for i in b))
print("%d%%"%z)

contribution:

Maria
Abraham

sortie:

98%

Ou essayez celui-ci;)

contribution:

Wasi Mohammed Abdullah
code golf

sortie:

99%

k, 80

{{$[(2=#x)|x~1 0 0;x;[r:((_m:(#x)%2)#x+|x);$[m=_m;r;r,x@_m]]]}/#:'.=x,"loves",y}

En voici quelques exemples:

{{$[(2=#x)|x~1 0 0;x;[r:((_m:(#x)%2)#x+|x);$[m=_m;r;r,x@_m]]]}/#:'.=x,"loves",y}["john";"jane"]
7 6

J

Voici un exemple simple en J:

r=:({.+{:),$:^:(#>1:)@}:@}.
s=:$:^:(101<10#.])@("."0@(#~' '&~:)@":"1)@r
c=:10#.s@(+/"1@=)@(32|3&u:@([,'Loves',]))
exit echo>c&.>/2}.ARGV

Il prend les noms sur la ligne de commande, par exemple:

$ jconsole love.ijs John Jane
76

Sensationnel

Voici la version groovy, avec des tests.

countChars = { res, str -> str ? call(res+str.count(str[0]), str.replace(str[0],'')) : res }
addPairs = { num -> def len = num.length()/2; (1..len).collect { num[it-1].toInteger() + num[-it].toInteger() }.join() + ((len>(int)len) ? num[(int)len] : '') }
reduceToPct = { num -> /*println num;*/ num.length() > 2 ? call( addPairs(num) ) : "$num%" }

println reduceToPct( countChars('', args.join('loves').toLowerCase()) )

assert countChars('', 'johnlovesjane') == '221211211'
assert countChars('', 'asdfasdfateg') == '3222111'
assert addPairs('221211211') == '33331'
assert addPairs('33331') == '463'
assert addPairs('463') == '76'
assert addPairs('53125418') == '13457'
assert addPairs('13457') == '884'
assert addPairs('884') == '128'
assert addPairs('128') == '92'
assert reduceToPct( countChars('','johnlovesjane') ) == '76%'

Explication:

• "countChars" récursive et supprime tout en construisant une chaîne de chiffres
• "addPairs" prend une chaîne de chiffres en ajoutant les chiffres de l'extérieur dans ** la "collecte..join" effectue l'ajout des chiffres qui travaillent à l'extérieur dans et les rejoint en tant que chaîne ** le "+ (... c [ (int) len]) "jette à nouveau le chiffre du milieu lorsque c est une longueur impaire
• "recudeToPct" s’appelle en ajoutant des paires jusqu’à moins de 3 chiffres

CodeGolf Groovy, 213 caractères

Voyant qu'il s'agit de codegolf, nous pouvons aligner les fermetures et en arriver à ceci:

println({c->l=c.length()/2;m=(int)l;l>1?call((1..m).collect{(c[it-1]as int)+(c[-it]as int)}.join()+((l>m)?c[m]:'')):"$c%"}({r,s->s?call(r+s.count(s[0]),s.replace(s[0],'')):r}('',args.join('loves').toLowerCase())))

Enregistrez-le en tant que lovecalc.groovy. courir "groovy lovecalc john jane"

Sortie:

$ groovy lovecalc john jane
76%
$ groovy lovecalc romeo juliet
97%
$ groovy lovecalc mariah abraham
99%
$ groovy lovecalc maria abraham
98%
$ groovy lovecalc al bev
46%
$ groovy lovecalc albert beverly
99%

Java

Cela prend 2 paramètres de chaîne au début et affiche le nombre de chaque caractère et le résultat.

import java.util.ArrayList;
import java.util.LinkedHashMap;

public class LUV {
    public static void main(String[] args) {
        String str = args[0].toUpperCase() + "LOVES" + args[1].toUpperCase();
        LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
        for (int i = 0; i < str.length(); i++) {
            if (!map.containsKey(String.valueOf(str.charAt(i)))) {
                map.put(String.valueOf(str.charAt(i)), 1);
            } else {
                map.put(String.valueOf(str.charAt(i)), map.get(String.valueOf(str.charAt(i))).intValue() + 1);
            }
        }
        System.out.println(map.toString());
        System.out.println(addValues(new ArrayList<Integer>(map.values()))+"%");
    }

    private static int addValues(ArrayList<Integer> list) {
        if ((list.size() < 3) || (Integer.parseInt((String.valueOf(list.get(0)) + String.valueOf(list.get(1))) + String.valueOf(list.get(2))) == 100)) {
            return Integer.parseInt((String.valueOf(list.get(0)) + String.valueOf(list.get(1))));
        } else {
            ArrayList<Integer> list2 = new ArrayList<Integer>();
            int size = list.size();
            for (int i = 0; i < size / 2; i++) {
                int temp = list.get(i) + list.get(list.size() -1);
                if (temp > 9) {
                    list2.add(temp/10);
                    list2.add(temp%10);
                } else {
                    list2.add(temp);
                }
                list.remove(list.get(list.size()-1));
            }
            if (list.size() > list2.size()) {
                list2.add(list.get(list.size()-1));
            }
            return addValues(list2);
        }
    }
}

Sûrement pas le plus court (Java), mais clair et lisible.

Donc si vous appelez

java -jar LUV.jar JOHN JANE

vous obtenez la sortie

{J=2, O=2, H=1, N=2, L=1, V=1, E=2, S=1, A=1}
76%

R

Je ne gagnerai aucun prix de compacité, mais je me suis bien amusé quand même:

problove<-function(name1,name2, relation='loves') {
sfoo<-tolower( unlist( strsplit(c(name1,relation,name2),'') ) )
startrow <- table(sfoo)[rank(unique(sfoo))]
# check for values > 10 . Not worth hacking an arithmetic approach
startrow <- as.integer(unlist(strsplit(as.character(startrow),'')))
while(length(startrow)>2 ) {
    tmprow<-vector()
    # follow  by tacking on middle element if length is odd
    srlen<-length(startrow)
     halfway<-trunc( (srlen/2))
    tmprow[1: halfway] <- startrow[1:halfway] + rev(startrow[(srlen-halfway+1):srlen])
    if ( srlen%%2) tmprow[halfway+1]<-startrow[halfway+1]
    startrow <- as.integer(unlist(strsplit(as.character(tmprow),'')))
    }
as.numeric(paste(startrow,sep='',collapse=''))
}

Testé: valable pour 'john' & 'jane' et pour 'romeo' & 'juliet'. par mon commentaire sous la question,

Rgames> problove('john','jane','hates')
[1] 76
Rgames> problove('romeo','juliet','hates')
[1] 61