गणितज्ञ, 100%, 141 बाइट्स
f@x_:=Count[1>0]@Table[ImageInstanceQ[x,"caprine animal",RecognitionThreshold->i/100],{i,0,50}];If[f@#>f@ImageReflect@#,"Up","Down"]<>"goat"&
खैर, यह एक छोटे से अधिक की तरह लगता है धोखा। यह बहुत ही मूर्खतापूर्ण होने के साथ-साथ अविश्वसनीय रूप से धीमा भी है। फ़ंक्शन fमोटे तौर पर देखता है कि आप गणितज्ञ के कंप्यूटर विज़न बिल्डिंस में से एक में मान्यता थ्रेशोल्ड को कितना सेट कर सकते हैं, और अभी भी एक कैप्रीन जानवर के रूप में छवि को पहचान सकते हैं।
फिर हम देखते हैं कि क्या छवि या फ़्लिप की छवि अधिक बकरी है। आपकी प्रोफ़ाइल छवि पर केवल इसलिए काम करता है क्योंकि टाई डाउनगेट के पक्ष में टूट गया है। संभवत: ऐसे तरीकों का भार है, जिसमें यह पूछा जाना शामिल है कि अगर छवि Bovids या Caprine पशु इकाई प्रकार के अन्य सामान्यीकरणों का प्रतिनिधित्व करती है, तो इसमें सुधार किया जा सकता है।
पहले परीक्षण सेट के लिए 100% और दूसरे परीक्षण सेट के लिए 94% के लिखित उत्तर के रूप में उत्तर दें, क्योंकि एल्गोरिथ्म बकरी के लिए एक अनिर्णायक परिणाम देता है। इसे एक अधिक लंबे समय तक कम्प्यूटेशनल समय की कीमत पर 100% तक वापस उठाया जा सकता है। के अधिक मूल्यों का परीक्षण RecognitionThreshold। से स्थापना 100करने के लिए 1000sufficies; किसी कारण से गणितज्ञ को लगता है कि यह एक बहुत ही अहम् छवि है! कैप्रीन जानवर से मान्यता प्राप्त संस्था को होफेड स्तनपायी में बदलना भी काम करने लगता है।
Ungolfed:
goatness[image_] := Count[
Table[
ImageInstanceQ[
image, Entity["Concept", "CaprineAnimal::4p79r"],
RecognitionThreshold -> threshold
],
{threshold, 0, 0.5, 0.01}
],
True
]
Function[{image},
StringJoin[
If[goatness[image] > goatness[ImageReflect[image]],
"Up",
"Down"
],
"goat"
]
]
वैकल्पिक समाधान, 100% + बोनस
g[t_][i_] := ImageInstanceQ[i, "caprine animal", RecognitionThreshold -> t]
f[i_, l_: 0, u_: 1] := Module[{m = (2 l + u)/3, r},
r = g[m] /@ {i, ImageReflect@i};
If[Equal @@ r,
If[First@r, f[i, m, u], f[i, l, m]],
If[First@r, "Up", "Down"] <> "goat"
]
]
यह पहले की तरह ही रणनीति का उपयोग करता है, लेकिन दहलीज पर एक द्विआधारी खोज के साथ। यहां दो कार्य शामिल हैं:
g[t]लौटता है या नहीं, इसका तर्क एक बकरी की छवि है t।fतीन पैरामीटर लेता है: एक छवि, और दहलीज पर एक ऊपरी और निचली सीमा। यह पुनरावर्ती है; यह mऊपरी और निचले थ्रेसहोल्ड (निचले की ओर पक्षपाती) के बीच एक दहलीज का परीक्षण करके काम करता है । यदि छवि और परावर्तित छवि दोनों बकरी या गैर-बकरी हैं, तो यह सीमा के निचले या ऊपरी हिस्से को उपयुक्त रूप से समाप्त कर देता है और खुद को फिर से कॉल करता है। अन्यथा, यदि एक छवि बकरी है और दूसरी गैर-बकरी है, तो यह वापस आ जाती है Upgoatयदि पहली छवि बकरी है और Downgoatअन्यथा (यदि दूसरी, प्रतिबिंबित छवि बकरी है)।
फ़ंक्शन परिभाषाएँ थोड़ी व्याख्या के योग्य हैं। सबसे पहले, फ़ंक्शन अनुप्रयोग बाएँ-सहयोगी है। इसका मतलब यह है कि जैसा कुछ g[x][y]समझा जाता है (g[x])[y]; "के लिए g[x]लागू परिणाम y।"
दूसरा, मैथेमेटिका में असाइनमेंट लगभग एक प्रतिस्थापन नियम को परिभाषित करने के बराबर है। इसका मतलब f[x_] := x^2यह नहीं है कि " fपैरामीटर के साथ एक फ़ंक्शन घोषित करें xजो रिटर्न देता है x^2;" इसका अर्थ करीब है, "जब भी आपको कुछ दिखाई देता है f[ ... ], तो उस चीज़ को अंदर बुलाएं xऔर पूरी चीज़ को बदल दें x^2।"
इन दोनों को एक साथ रखते हुए, हम देख सकते हैं कि असाइनमेंट के राइट-साइड के साथ gफॉर्म के किसी भी एक्सप्रेशन को बदलने के लिए मैथेमेटिका बता रहा है (g[ ... ])[ ... ]।
जब गणितज्ञ अभिव्यक्ति का सामना करता है g[m](दूसरी पंक्ति में f), यह देखता है कि अभिव्यक्ति किसी भी नियम से मेल नहीं खाती है जिसे वह जानता है और इसे अपरिवर्तित छोड़ देता है। फिर यह Mapऑपरेटर से मेल खाता है /@, जिनके तर्क g[m]और सूची है {i, ImageReflect@i}। ( /@infix संकेतन; यह अभिव्यक्ति बिल्कुल इसके बराबर है Map[g[m], { ... }]।) Mapइसके दूसरे तर्क के प्रत्येक तत्व में अपना पहला तर्क लागू करके प्रतिस्थापित किया जाता है, इसलिए हम प्राप्त करते हैं {(g[m])[i], (g[m])[ ... ]}। अब गणितज्ञ देखता है कि प्रत्येक तत्व gप्रतिस्थापन की परिभाषा से मेल खाता है और करता है।
इस तरह हमें gएक फंक्शन की तरह काम करना पड़ा जो एक और फंक्शन लौटाता है; यह है, यह मोटे तौर पर कार्य करता है जैसे हमने लिखा था:
g[t_] := Function[{i}, ImageInstanceQ[i, "caprine animal", RecognitionThreshold -> t]]
(इस मामले g[t]को छोड़कर अपने आप में एक का मूल्यांकन करता है Function, जबकि पहले g[t]अपने आप में बिल्कुल भी रूपांतरित नहीं हुआ था।)
मेरे द्वारा उपयोग की जाने वाली अंतिम ट्रिक एक वैकल्पिक पैटर्न है। पैटर्न का l_ : 0अर्थ है "किसी भी अभिव्यक्ति से मेल खाना और उसे उपलब्ध करना l, या कुछ नहीं से मिलान करना और 0जैसा भी हो उपलब्ध करना l।" इसलिए, यदि आप f[i]एक तर्क (परीक्षण करने के लिए छवि) के साथ कहते हैं, तो ऐसा लगता है जैसे आपने बुलाया था f[i, 0, 1]।
यहाँ परीक्षण का उपयोग मैंने किया है:
gist = Import["https://api.github.com/gists/3fb94bfaa7364ccdd8e2", "JSON"];
{names, urls} = Transpose[{"filename", "raw_url"} /. Last /@ ("files" /. gist)];
images = Import /@ urls;
result = f /@ images
Tally@MapThread[StringContainsQ[##, IgnoreCase -> True] &, {names, result}]
(* {{True, 18}} *)
user = "items" /.
Import["https://api.stackexchange.com/2.2/users/40695?site=codegolf", "JSON"];
pic = Import[First["profile_image" /. user]];
name = First["display_name" /. user];
name == f@pic
(* True *)
