Ihre Herausforderung besteht darin, einen Quellcode als Eingabe zu verwenden und auszugeben, in welcher Programmiersprache er geschrieben ist.

Beispielsweise könnten Sie die Eingabe haben

class A{public static void main(String[]a){System.out.println("Hello, World!");}}

Und Ausgabe

Java

Ihre beiden Hauptziele sind Vielfalt (wie viele Programmiersprachen können Sie erkennen) und Genauigkeit (wie gut Sie diese Sprachen erkennen).

Bei mehrsprachigen Programmen (Programme, die in mehreren Sprachen gültig sind) können Sie entscheiden, was zu tun ist. Sie könnten einfach die Sprache ausgeben, die Ihr Programm für wahrscheinlicher hält, oder Sie könnten einen Fehler ausgeben, oder Sie könnten eine Reihe möglicher Auswahlen ausgeben (die wahrscheinlich mehr Gegenstimmen als nur einen Fehler erhalten würden!).

Dies ist ein Beliebtheitswettbewerb , da es sehr schwierig wäre, ein anderes objektives Gewinnkriterium festzulegen. Wähler, bitte stimmen Sie ab, wie viele Sprachen es erkennen kann und wie genau es ist.

234 Textformate - Unix-Shell

(nicht alle von ihnen Sprachen - ich muss sie sorgfältig zählen)

file $1

Ich zögere, diese etwas kluge Antwort zu posten, aber ich sehe nichts in den Regeln, die sie verbieten, und das fileShell-Dienstprogramm leistet wirklich gute Arbeit. z.B:

$ file golfscript.rb 
golfscript.rb: Ruby module source, ASCII text
$ file template.c 
template.c: ASCII C program text
$ file adams.sh
adams.sh: Bourne-Again shell script, ASCII text executable
$ 

Außerdem können Sie die -kOption verwenden, um beim Testen eines Polyglots "weiterzumachen":

 -k, --keep-going
         Don't stop at the first match, keep going.  Subsequent matches
         will be have the string ‘\012- ’ prepended.  (If you want a new‐
         line, see the -r option.)

Die -lOption gibt Ihnen auch eine Vorstellung davon, wie gut der Algorithmus für verschiedene Sprachen ist:

$ file -l | grep shell
unknown, 0: Warnung: Verwenden der regulären Magic-Datei "/ etc / magic"
Strength = 280: Shell-Archivtext [application / octet-stream]
Strength = 250: Tenex C-Shell-Skripttext ausführbar [text / x-shellscript]
Strength = 250: Bourne-Again-Shell-Skripttext ausführbar [text / x-shellscript]
Strength = 240: Paul Falstads ausführbare zsh-Skriptdatei [text / x-shellscript]
Stärke = 240: Neil Browns ausführbarer Ash-Skript-Text [text / x-shellscript]
Strength = 230: Neil Browns ausführbarer ae-Skripttext [text / x-shellscript]
Strength = 210: Tenex C-Shell-Skript-Text ausführbar [text / x-shellscript]
Strength = 210: Bourne-Again-Shell-Skripttext ausführbar [text / x-shellscript]
Strength = 190: Tenex C-Shell-Skripttext ausführbar [text / x-shellscript]
Strength = 190: Bourne-Again-Shell-Skripttext ausführbar [text / x-shellscript]
Strength = 180: Paul Falstads ausführbare zsh-Skriptdatei [text / x-shellscript]
Strength = 150: Tenex C-Shell-Skripttext ausführbar [text / x-shellscript]
Strength = 150: Bourne-Again-Shell-Skripttext ausführbar [text / x-shellscript]
Strength = 140: Ausführbare C-Shell-Skriptdatei [text / x-shellscript]
Strength = 140: Korn Shell Skript Text ausführbar [text / x-shellscript]
Strength = 140: Paul Falstads ausführbare zsh-Skriptdatei [text / x-shellscript]
Strength = 130: ausführbarer POSIX-Shell-Skript-Text [text / x-shellscript]
Strength = 130: Plan 9 rc-Shell-Skripttext ausführbar []
$ 

Dies ist file-5.09(unter Ubuntu 12.04)

Bash - ungefähr 50 35 Bytes pro kompilierbarer Sprache

Der Trick besteht darin, nur zu kompilieren, dann müssen Sie sich keine Gedanken über das Verknüpfen von Fehlern aus fehlenden Bibliotheken machen, und es ist verzeihender, wenn Sie nur Codeausschnitte haben.

Danke an Shahbaz für die kürzeren Formen!

gcc -c $1 && (echo C; exit 0)
g++ -c $1 && (echo C++; exit 0)
gpc -c $1 && (echo Pascal; exit 0)
gfortran -c $1 && (echo Fortran; exit 0)

etc...

18 Programmiersprachen, 1002 Bytes, Genauigkeit: Überzeugen Sie sich selbst :)

(Ja, ich weiß, das ist kein Code-Golf, aber zum Spaß)

Das Programm sucht nach ikonischen Codefragmenten, die Überprüfungen sind so angeordnet, dass die klarsten Überprüfungen oben und die in anderen Programmiersprachen eingebetteten Programmiersprachen unten aufgeführt sind (z. B. HTML in PHP).

Dies scheitert offensichtlich bei Programmen wie System.out.println('<?php');

t = (p) ->
    h = (x) -> -1 != p.indexOf x
    s = (x) -> 0 == p.indexOf x

    if h "⍵" then "APL"
    else if h "<?php" then "PHP"
    else if h("<?xml") and h "<html" then "XHTML"
    else if h "<html" then "HTML"
    else if h "<?xml" then "XML"
    else if h("jQuery") or h "document.get" then "JavaScript"
    else if h "def __init__(self" then "Python"
    else if h "\\documentclass" then "TeX"
    else if h("java.") or h "public class" then "Java"
    else if s("SELE") or s("UPDATE") or s "DELE" then "SQL"
    else if /[-\+\.,\[\]\>\<]{9}/.test p then "Brainfuck"
    else if h "NSString" then "Objective-C"
    else if h "do |" then "Ruby"
    else if h("prototype") or h "$(" then "JavaScript"
    else if h "(defun" then "Common Lisp"
    else if /::\s*[a-z]+\s*->/i.test p then "Haskell"
    else if h "using System" then "C#"
    else if h "#include"
        if h("iostream") or h "using namespace" then "C++"
        else "C"
    else "???"

program = ""
process.stdin.on 'data', (chunk) -> program += chunk
process.stdin.on 'end', -> console.log t program

Verwendung auf Knoten: coffee timwolla.coffee < Example.java

Demo ( Online-Demo auf JSFiddle ):

[timwolla@~/workspace/js]coffee puzzle.coffee < ../c/nginx/src/core/nginx.c 
C
[timwolla@~/workspace/js]coffee puzzle.coffee < ../ruby/github-services/lib/service.rb
Ruby
[timwolla@~/workspace/js]coffee puzzle.coffee < ../python/seafile/python/seaserv/api.py
Python

Diese Antwort ist ein Proof of Concept, der wahrscheinlich keine Arbeit mehr von mir erhalten wird.

Es fällt in mehrfacher Hinsicht zu kurz:

• Die Ausgabe entspricht nicht genau den Anforderungen der Frage, ist jedoch nah genug und kann leicht geändert werden, um die genaue erforderliche Ausgabe zu erzielen.
• Es gibt verschiedene Möglichkeiten, die Leistung des Codes zu verbessern und / oder die Datenstrukturen besser darzustellen.
• und mehr

Die Idee ist, eine Liste von Schlüsselwörtern / Zeichen / Phrasen festzulegen, die eine bestimmte Sprache identifizieren und diesem Schlüsselwort für jede Sprache eine Punktzahl zuweisen können. Überprüfen Sie dann die Quelldatei (en) für diese Schlüsselwörter und zählen Sie die Ergebnisse für jede Sprache auf, für die Sie Schlüsselwörter finden. Am Ende ist die Sprache mit der höchsten Punktzahl der wahrscheinliche Gewinner. Dies ist auch für mehrsprachige Programme geeignet, da beide (oder alle) relevanten Sprachen eine hohe Punktzahl erzielen.

Das einzige, was Sie tun können, um weitere Sprachen hinzuzufügen, ist, ihre "Signaturen" zu identifizieren und sie dem Mapping hinzuzufügen.

Sie können auch verschiedenen Stichwörtern pro Sprache unterschiedliche Bewertungen zuweisen. Wenn Sie beispielsweise der Meinung volatilesind, dass in Java mehr als in C verwendet wird, setzen Sie den Score für das volatileSchlüsselwort auf 2 für Java und 1 für C.

public class SourceTest {

  public static void main(String[] args) {
    if (args.length < 1) {
      System.out.println("No file provided.");
      System.exit(0);
    }
    SourceTest sourceTest = new SourceTest();
    for (String fileName : args) {
      try {
        sourceTest.checkFile(fileName);
      } catch (FileNotFoundException e) {
        System.out.println(fileName + " : not found.");
      } catch (IOException e) {
        System.out.println(fileName + " : could not read");
      }
    }
    System.exit(0);
  }

  private Map<String, LanguagePoints> keyWordPoints;
  private Map<LANGUAGES, Integer> scores;

  private enum LANGUAGES {
    C, HTML, JAVA;
  }

  public SourceTest() {
    init();
  }

  public void checkFile(String fileName) throws FileNotFoundException, IOException {
    String fileContent = getFileContent(fileName);
    testFile(fileContent);
    printResults(fileName);
  }

  private void printResults(String fileName) {
    System.out.println(fileName);
    for (LANGUAGES lang : scores.keySet()) {
      System.out.println("\t" + lang + "\t" + scores.get(lang));
    }
  }

  private void testFile(String fileContent) {
    for (String key : keyWordPoints.keySet()) {
      if (fileContent.indexOf(key) != -1) {
        for (LANGUAGES lang : keyWordPoints.get(key).keySet()) {
          scores.put(lang, scores.get(lang) == null ? new Integer(1) : scores.get(lang) + 1);
        }
      }
    }
  }

  private String getFileContent(String fileName) throws FileNotFoundException, IOException {
    File file = new File(fileName);
    FileReader fr = new FileReader(file);// Using 1.6 so no Files
    BufferedReader br = new BufferedReader(fr);
    StringBuilder fileContent = new StringBuilder();
    String line = br.readLine();
    while (line != null) {
      fileContent.append(line);
      line = br.readLine();
    }
    return fileContent.toString();
  }

  private void init() {
    scores = new HashMap<LANGUAGES, Integer>();

    keyWordPoints = new HashMap<String, LanguagePoints>();
    keyWordPoints.put("public class", new LanguagePoints().add(LANGUAGES.JAVA, 1));
    keyWordPoints.put("public static void main", new LanguagePoints().add(LANGUAGES.JAVA, 1));
    keyWordPoints.put("<html", new LanguagePoints().add(LANGUAGES.HTML, 1));
    keyWordPoints.put("<body", new LanguagePoints().add(LANGUAGES.HTML, 1));
    keyWordPoints.put("cout", new LanguagePoints().add(LANGUAGES.C, 1));
    keyWordPoints.put("#include", new LanguagePoints().add(LANGUAGES.C, 1));
    keyWordPoints.put("volatile", new LanguagePoints().add(LANGUAGES.JAVA, 1).add(LANGUAGES.C, 1));
  }

  private class LanguagePoints extends HashMap<LANGUAGES, Integer> {
    public LanguagePoints add(LANGUAGES l, Integer i) {
      this.put(l, i);
      return this;
    }
  }
}

Nur ein paar allgemeine Verallgemeinerungen.

Ich denke es ist ziemlich genau.

Das ist übrigens Ruby. Nimmt (mehrzeilige) Eingaben von stdin auf.

puts case $<.read
when /\)\)\)\)\)/
  "Lisp"
when /}\s+}\s+}\s+}/
  "Java"
when /<>/
  "Perl"
when /|\w+|/
  "Ruby"
when /\w+ :- \w+ \./
  "Prolog"
when /^[+-<>\[\],.]+$/
  "brainfuck"
when /\[\[.*\]\]/
  "Bash"
when /~]\.{,/
  "golfscript"
end

Javascript - 6 Sprachen - hohe Genauigkeit

Aktuelle Sprachen: Java, C, HTML, PHP, CSS, Javascript

Ich arbeite nach dem Prinzip, dass jedes Mal, wenn eine Eingabe ein Kriterium erfüllt, eine Punktzahl vergeben wird und basierend auf dieser Punktzahl die Ergebnisse vergeben werden.

Eigenschaften:

• Keine eingebauten Funktionen, die den verwendeten Sprachtyp bestimmen.
• Gibt nicht sofort an, dass der eingegebene Text xbeim Anzeigen eines Schlüsselworts die Sprache ist.
• Schlägt auch andere mögliche Sprachen vor.

Sollten Sie das Gefühl haben, dass Ihre Eingaben in den Programmen (die ich bis jetzt gemacht habe) nicht abgefangen wurden oder ungültige Ergebnisse erhalten, melden Sie sich bitte und ich würde sie gerne korrigieren.

Sample Input 1:

class A{public static void main(String[]a){System.out.println("<?php");}}

Beispielausgabe 1:

My program thinks you have :
Java with a chance of 100%
Php with a chance of 25%
----------------

Erläuterung:

Damit hätte das Programm scheitern sollen, und ich hätte gedruckt PHP, aber da mein Programm auf der Grundlage von Punktzahlen arbeitet, scheitert nichts und es identifiziert leicht Java an erster Stelle, gefolgt von anderen möglichen Ergebnissen.

Sample Input 2:

class A{public static void main(String[]a){System.out.println("HelloWorld!");}}

Beispielausgabe 2:

Java
----------------

Beispiel Input 3:

ABCDEFGHIJKLMNOPQRSTUVWXYZ

Beispielausgabe 3:

Language not catched! Sorry.
----------------

Der Code:

// Helper functions

String.prototype.m = function(condition){
  return this.match(condition);
};

String.prototype.capitalize = function(){
  return this[0].toUpperCase() + this.substr(1);
};

function getFuncName(func){
  var temp =  func.toString();
  temp = temp.substr( "function ".length);
  temp = temp.substr( 0, temp.indexOf("("));
  return temp.capitalize();
}

// Get input
var lang_input = prompt("Enter programming language");

// Max score of 4 per lang

function java(input){
  var score = 0;
  score += input.m(/class[\s\n]+[\w$]+[\s\n]*\{/) ? 1 : 0;
  score += input.m(/public[\s\n]+static[\s\n]+void[\s\n]+main[\s\n]*/) ? 1 : 0;
  score += input.m(/\}[\s\n]*\}[\s\n]*$/) ? 1 : 0;
  score += input.m(/System[\s\n]*[.][\s\n]*out/) ? 1 : 0;
  return score;
}

function c(input){
  var score = 0;
  // if java has passsed
  if(checks[0][1] >= 3)return 0;

  score += input.m(/^#include\s+<[\w.]+>\s*\n/) ? 1 : 0;
  score += input.m(/main[\s\n]*\([\s\n]*(void)?[\s\n]*\)[\s\n]*\{/) ? 1 : 0;
  score += input.m(/printf[\s\n]+\(/) || input.m(/%d/) ? 1 : 0;
  score += input.m(/#include\s+<[\w.]+>\s*\n/) || input.m(/(%c|%f|%s)/) ? 1 : 0;
  return score;
}

function PHP(input){
  var score = 0;
  score += input.m(/<\?php/) ? 1 : 0;
  score += input.m(/\?>/) ? 1 : 0;
  score += input.m(/echo/) ? 1 : 0;
  score += input.m(/$[\w]+\s*=\s*/) ? 1 : 0;
  return score;
}

function HTML(input){
  var score = 0;
  // if php has passed
  if(checks[2][1] >= 2) return 0;

  score += input.m(/<!DOCTYPE ["' \w:\/\/]*>/) ? 1 : 0;
  score += input.m(/<html>/) && input.m(/<\/html>/) ? 1 : 0;
  score += input.m(/<body>/) && input.m(/<\/body/) ? 1 :  0;
  score += input.m(/<head>/) && input.m(/<\/head>/) ? 1 : 0;
  return score;
}

function javascript(input){
  var score = 0;
  score += input.m(/console[\s\n]*[.][\s\n]*log[\s\n*]\(/) ? 1 : 0;
  score += input.m(/[\s\n]*var[\s\n]+/) ? 1 : 0;
  score += input.m(/[\s\n]*function[\s\n]+[\w]+[\s\n]+\(/) ? 1 : 0;
  score += input.m(/document[\s\n]*[.]/) || 
           ( input.m(/\/\*/) && input.m(/\*\//) ) ||
           ( input.m(/\/\/.*\n/) )? 1 : 0;
  return score;
}

function CSS(input){
  var score = 0;
  score += input.m(/[a-zA-Z]+[\s\n]*\{[\w\n]*[a-zA-Z\-]+[\s\n]*:/) ? 1 : 0;
  // since color is more common, I give it a separate place
  score += input.m(/color/) ? 1 : 0;          
  score += input.m(/height/) || input.m(/width/) ? 1 : 0;
  score += input.m(/#[a-zA-Z]+[\s\n]*\{[\w\n]*[a-zA-Z\-]+[\s\n]*:/) ||
           input.m(/[.][a-zA-Z]+[\s\n]*\{[\w\n]*[a-zA-Z\-]+[\s\n]*:/) ||
           ( input.m(/\/\*/) && input.m(/\*\//) ) ? 1 : 0;
  return score;
}

// [Langs to check, scores]
var checks = [[java, 0], [c, 0], [PHP, 0], [HTML, 0], [javascript, 0], [CSS, 0]];
//Their scores

// Assign scores
for(var i = 0; i < checks.length; i++){
  var func = checks[i][0];
  checks[i][1] = func(lang_input);
}

// Sort the scores
checks.sort(function(a,b){ return b[1] - a[1]; });

var all_zero = true;

function check_all_zero(index){
  if(checks[index][1] > 0){ all_zero = false; return 0; } // someone is above zero

  // check next index only if it defined, else return zero
  if(checks[index + 1])
    check_all_zero(index + 1);
}

check_all_zero(0);

if(all_zero){
  console.log("Language not catched! Sorry.");
}else {
  var new_arr = [];                   // temp

  checks.map(function(value, index){
    if(value[1] > 0){
      var temp = [getFuncName(value[0]), value[1]];
      new_arr.push(temp);
    }
  });

  checks = new_arr.slice(0);          // array copy, because of mutation

  if(checks.length === 1){
    console.log(checks[0][0]);
  }else{
    console.log("My program thinks you have :");
    checks.map(function(value){
      var prob = (value[1]/4 * 100);
      console.log(value[0] + " with a chance of " + prob + "%");
    });
  }

} // Main else block finish

console.log("----------------");