La sfida

Scrivi un programma che emetta Hello World, from line X!, dove si Xtrova il numero di riga, nel codice sorgente, dell'istruzione di stampa stessa.

Le regole

• In questo contesto, vogliamo il primo numero di riga della dichiarazione, che emette la stringa da visualizzare astdout
• Dovresti evitare di cercare semplicemente il tuo codice sorgente come una stringa (file o quine) per trovare il numero di riga
• Se vengono aggiunti spazi bianchi o istruzioni aggiuntive (che non interrompono il flusso del codice) al codice sorgente, questo dovrebbe essere riflesso in fase di esecuzione (dopo la compilazione, se applicabile)

raccomandazioni

Se fornito dalla lingua, è possibile utilizzare eccezioni / tracce di stack per raggiungere questo obiettivo. Fai del tuo meglio per usare un codice portatile su diversi sistemi / implementazioni, ma nota che questo non è un requisito. L'uso di variabili definite come __LINE__, sebbene consentito dalle regole, è scoraggiato.

Il vincitore

• Questo è un concorso di popolarità (terminato il 10 giugno 2014), in cui la risposta votata più alta dalla community verrà dichiarata vincitrice in base ai voti attuali in quel momento

• Quando voti, ti preghiamo di considerare la creatività della risposta di qualcuno, quanto elaborata o interessante . e le difficoltà / vincoli del linguaggio di programmazione utilizzato

Sinclair Basic

10 PRINT "Hello world, from line ";PEEK 23621;"!"

Ciao mondo, dalla linea 10!

Questo funzionerà per qualsiasi riga PEEKinserendo l'indirizzo che memorizza il numero di riga corrente, quindi funzionerà anche:

341 PRINT "Hello world, from line ";PEEK 23621;"!"

Ciao mondo, dalla linea 341!

DI BASE

Penso che questo faccia tutto ciò che è stato chiesto:

10 PRINT "Hello World, from line 10!"

Giava

public class Hello{
    public static void main(String[] args) {
        System.out.println("Hello World, from line "+new Exception().getStackTrace()[0].getLineNumber()+"!");
    }
}

Perl

close STDERR;
open FOOBAR,">",\$_;


print!warn,'Hello World, from line ',/(\d+)\.$/,'!';

Non abbastanza corto come usare __LINE__, ma forse più interessante.

warnè uno strumento di debug, che emette un'istruzione a STDERR, indicando in quale file e su quale riga è stato emesso l'avviso ... a meno che non STDERR sia stato precedentemente chiuso o altrimenti inaccessibile, nel qual caso l'avviso viene emesso al file aperto più di recente handle: si tratta di un comportamento non documentato. Non sono sicuro che sarebbe meglio classificato come funzionalità o bug.

Qui,STDERR viene chiuso e un nuovo handle di file identificato come FOOBARviene aperto e instradato alla variabile $_. Questo viene quindi analizzato per recuperare il numero di riga dell'avviso, che è incorporato nell'istruzione print.

C ++

#include <iostream>
#include <utility>
#include <type_traits>

#define __(A,B,C,...) B##C##A
#define _(A,...) __(__VA_ARGS__, A)
template<unsigned...Is> struct v;
template<unsigned I0, unsigned... Is> struct v<I0, Is...>:v<I0-1,I0-1, Is...> {};
template<unsigned...Is> struct v<0,Is...>:std::integral_constant<unsigned, sizeof...(Is)> {};

int main() {
  std::cout << "Hello world from line " << v<_(EXTRACT,_(Q,_,E,_,$$main$$,),_(@22,,_,_),_(Z,N,L,I,_,,L),__STACK_TRACE__)>::value << "\n";
}

esempio dal vivo

Lua

print("Hello world, from line "..debug.getinfo(1).currentline.."!")

C #

C # 5.0 [CallerLineNumber]fa il trucco:

using System;
using System.Linq;
using System.Runtime.CompilerServices;
namespace LineNumberConsole
{
    class Program
    {
        public static void Main()
        {
            Console.WriteLine("Hello World, from line {0}!", ToRoman(GetLineNumber()));
            Console.ReadLine();
        }

        private static int GetLineNumber([CallerLineNumber] int sourceLineNumber = 0)
        {
            return sourceLineNumber;
        }

        private static string ToRoman(int number)
        {
            // TODO: Copy some source code from http://pastebin.com/w0hm9n5W
            // Skipped here for brevity
            return number.ToString();
        }
    }
}

Produzione

Hello World, from line X!

C

#include <stdio.h>
main(){
printf("Hello World, from line %d!", __LINE__);
}

Pitone

Esempio (10 righe, 213 caratteri):

import sys
import traceback
lineno = None
while True:
    try:
        print 'Hello World, from line %d!' % lineno
        break
    except:
        lineno = traceback.tb_lineno(sys.exc_info()[2])
        continue

Prova online qui . È possibile aggiungere il codice che non modifica il flusso e gli spazi bianchi e il programma visualizzerà il conteggio delle righe aggiornato e, allo stesso modo, questo frammento di codice può essere utilizzato anche in qualsiasi punto di un programma esistente. Uscita prevista:

Hello World, from line 6!

Un altro esempio (prova online qui) per mostrare che funziona quando viene aggiunto il codice / spazi bianchi. Uscita prevista:

Down we go...
Gotta catch 'em all.
Down we go...
Hello World, from line 11!
Awesome!

Javascript

function getLine(n) {
   try {
      to
   } catch (dat) {
      var stack = dat.stack.split('\n');
       for (var i = 0; i < stack.length; i++) {
           if (~stack[i].indexOf ('getLine')) break;          
       }
      return dat.stack.split ('\n')[i + ~~n].match (/:(\d+)/)[1] - ~~window.hasOwnProperty ('__commandLineAPI')
   }
}
//Line 12
console.log ('Hello World, from line ' + getLine(1) + ' !')

Nota: le espressioni, valutate dall'interno della console di sviluppo di Chrome, saranno racchiuse in withun'istruzione. Quindi, se è il caso, dobbiamo ridurre di una riga la linea

Python 3

import hashlib
with open(__file__) as f:
    line_num = 0
    for line in f.readlines():
        line = line.rstrip() # make it work with or without newline at the end
        line_num += 1
        if hashlib.sha256(bytes(line, "UTF-8")).hexdigest()[0:6] == 'cc46f7':
            print('Hello world, from line {}!'.format(line_num)) # cc46f7

Ciao mondo, dalla linea 8!

Questo codice di auto-lettura contiene un hash autoreferenziale. La somma SHA256 dell'ultima riga (con lo spazio bianco iniziale e senza spazio bianco finale) inizia con cc46f7... . Quando esegue l' printhashing della linea, scopre che l'hash corrisponde al valore magico che sta cercando.

GNU COBOL

Bene, hanno detto che non si poteva fare. In realtà, sono stato io a dire che non si poteva fare. Ora è fatto e una funzionalità di linguaggio obsoleto reimplementata usando il metodo applicato.

La domanda afferma:

Se vengono aggiunti spazi bianchi o istruzioni aggiuntive (che non interrompono il flusso del codice) al codice sorgente, questo dovrebbe essere riflesso in fase di esecuzione (dopo la compilazione, se applicabile).

Qualsiasi quantità di roba può essere inserita prima delle tre DISPLAYs che causano l'inizio dell'output, e qualsiasi cosa dopo la DISPLAYs "interromperà il flusso del codice", quindi va bene.

COBOL aveva un TRACEverbo (istruzione) che elencava semplicemente i numeri di riga sorgente mentre venivano eseguiti (nessun accesso al numero di riga nel programma). Sebbene di uso limitato, ho incluso un'implementazione di TRACE.

   ID Division.
   Program-ID. HIWHERE.
   ENVIRONMENT DIVISION.
   configuration section.
          source-computer. TinkerToy with debugging mode.
   Procedure Division.
   Declaratives.
   Debug-Declaratives Section.
       Use For Debugging on a b
       .
   Debug-Declaratives-Paragraph.
       Display Debug-Line "!"
       .
   End Declaratives
       .
   Main-Program Section.
       DISPLAY "Perform"
       Display "Hello World, from line " no advancing Perform b
       display "GO TO"
       Display "Hello World, from line " no advancing GO TO a
       .
   a.
       dISPLay "Fall through"
       Display "Hello World, from line " no advancing. b.
   The-Last-bit-OF-the-PROGRAM.
       GOBACK
       .

L'output è

Perform
Hello World, from line     18!
GO TO
Hello World, from line     20!
Fall through
Hello World, from line     23!

Come una dimostrazione della potenza e della flessibilità della scrittura della lingua, questo esempio usa maiuscole e minuscole, tutte minuscole e interamente maiuscole, tutte allo stesso tempo. Non importa, come quando viene elaborato, tutto viene "piegato" in MAIUSCOLO.

L'unico modo COBOL standard per ottenere un numero di riga di origine nel programma in esecuzione, dal programma in esecuzione, è con a DEBUGGING DECLARATIVE. All'interno di a SECTION, rigorosamente all'interno di un paragrafo all'interno di a SECTION, di tale dichiarante si ha accesso al registro speciale DEBUG-LINE. Questo contiene il numero di riga di origine del verbo (istruzione) che ha causato il trasferimento del controllo a un particolare nome-procedura (paragrafo o SECTION).

Quindi, con PERFORM, o GO TO, o "fall through" SECTIONviene eseguito il paragrafo nei dichiarativi di debug .

Ok ma DISPLAY non causa il trasferimento del controllo.

Nessun problema. Mettilo sulla stessa linea del trasferimento del controllo.

Problema, poiché se "qualsiasi spazio bianco o istruzione aggiuntiva (che non interrompe il flusso del codice) viene aggiunto al codice sorgente, dovrebbe essere riflesso in fase di esecuzione (dopo la compilazione se applicabile)".

Quindi, mettilo sulla stessa riga ma davanti a un trasferimento di controllo, dividi il contenuto del DISPLAYin due pezzi (ricorda, "In questo contesto, vogliamo che sia visualizzato il numero della prima riga dell'istruzione che genera la stringa" ) e produce la prima parte prima del trasferimento del controllo e la seconda parte dalDEBUG-LINE , una volta all'interno della procedura di debug.

Il bit finale è per il "fall through" (le "procedure" possono essere modificate PERFORM, possono essere il bersaglio di un GO TOo possono essere inserite semplicemente essendo la riga successiva). In questo caso, metti DISPLAY sulla riga che definisce la procedura, ma davanti alla definizione .

I nomi delle "procedure" ( ae b) sono stati severamente abbreviati per consentire loro di adattarsi alla stessa linea sorgente del DISPLAY. Un nome di procedura COBOL dovrebbe iniziare da qualche parte dalla colonna otto alla colonna 11. Tuttavia, la sintassi è, al giorno d'oggi, molto più rilassata al riguardo. Nella misura in cui posso definire un nome di procedura sulla stessa riga di un codice. Perfino incorporato nel codice. Sono necessarie cure e un arresto occasionale.

Nel PROCEDURE DIVISION ogni punto completo mostrato è richiesto, e non lo sono più.

Compilare:

cobc -x -g hiwhere.cbl

Per eseguire (linux):

COB_SET_DEBUG=Y ./hiwhere

Infine, il ritorno di TRACE (senza READY / RESET).

   ID Division.
   Program-ID. tRacE.
   ENVIRONMENT DIVISION.
   configuration section.
          source-computer. TinkerToy with debugging mode.
   Procedure Division.
   Declaratives.
   Debug-Declaratives Section.
       Use For Debugging on a
       .
   Debug-Declaratives-Paragraph.
       Display Debug-Line
       .
   End Declaratives
       .
   Main-Program Section.
  *    Just append "perform a" to a single-line statement.
       DISPLAY "1" . perform a
       Display "2" . perform a
       display "3" . perform a
  *    Or prepend "perform a." for a multi-line statement, or a
  *    statement which won't "come back". 
       perform a. GOBACK
       .
   a.
       CONTINUE
       .

L'output è:

1
    17
2
    18
3
    19
    20

Dove 1, 2 e 3 vengono emessi dalle tre istruzioni DISPLAY e 17, 18, 19 e 20 sono i numeri di riga delle righe "eseguibili" (senza debug).

Giava

Utilizzo del comportamento dello stack stack di Exception per ottenere la riga corrente. fintanto che Printstatement non viene modificato in più righe o viene alterato il file di classe, dovrebbe funzionare

public class PrittLnbr
{
    public static void main(String[] args)
    {
        System.out.println("Hello World, from line "+new Error().getStackTrace()[0].toString().split(":")[1]+"!");
    }
}

Pitone

import traceback, inspect
frame = inspect.currentframe()
print("Hello World, from line "+traceback.format_stack(frame)[0].split()[3][:-1]+"!")  

Perl

print 'Hello World, from line '.__LINE__.'!';

Giava

public class HelloFrom {
    public static void main(String[] args) {
        System.out.println("Hello World, from line " + Thread.currentThread().getStackTrace()[1].getLineNumber() + "!");
    }
}

Pitone

import inspect
print ("Hello world from line %d!" % (inspect.getlineno(inspect.currentframe())))

Produzione

Hello World from line 2!

Befunge

Fatto solo per divertimento.

>00g1+:00p"v"\10v  
    v-*45g00p\g <  
#v+1_$10g1vv,,,,<  
^<p000p01+<#>,,,^  
>" enil morf ,oll"v
@.,,,,,,,,,<^,"He"<

Condizionale: la parte superiore sinistra del codice deve essere 0 <x <20 e 0 <= y <62; e le due prime celle devono essere vuote.

esempio:

                         v                  

                         0                  
                         0                  
                         0                  
                         p                  
                         0                  
                         1                  
                         0                  
                         p                  
                         >00g1+:00p"v"\10v  
                             v-*45g00p\g <  
                         #v+1_$10g1vv,,,,<  
                         ^<p000p01+<#>,,,^  
                         >" enil morf ,oll"v
                         @.,,,,,,,,,<^,"He"<

Uscita:

Ciao, dalla linea 10

C

Usando una macro variadica, possiamo creare una funzione di stampa che aggiunge automaticamente il numero di riga alla fine di un'istruzione arbitraria printf e stampa sempre su stdout.

test.c:

#include <stdio.h>

#define printfl(format, ...) fprintf(stdout, format " From line %d\n", ##__VA_ARGS__, __LINE__)

int main() {
    printfl("Hello World! I have %d argument(s).", 1);
    return 0;
}

uscite:

% ./test
Hello World! I have 1 argument(s). From line 6

Nota: ho deviato dal modello per dimostrare che printfl è ancora una funzione variadica valida; se ti interessa davvero il formato dell'output, puoi sempre cambiare i letterali che uso.

bash

#
# some comments to fill some lines...
#
echo "Hello World, from line $LINENO!"

Produzione

Hello World, from line 4!

D

void main ()
{
    import std.stdio;
    writefln("Hello World, from line %d", __LINE__);
}

C o C ++ e AWK

lineno.c:

// code or comments
// ....
#error Hello World, from line
// other code or comments

Uso:

gcc lineno.c 2>&1 | awk '{ split($0,a,":"); ; printf("%s %s!\n", gensub(".*#error ","",1), a[2]); exit; }'

Produzione:

Ciao, mondo, dalla linea 3

Gli appunti:

• Nessun codice scritto dall'utente cerca il file.
• g ++ funzionerà su un file c ++.

Tipo di noioso in Ruby:

puts "Hello World, from line #{__LINE__}!"

Questo non è barare, giusto?

Javascript

Una riga usando lo stack trace.

(function (o) { console.log("Hello World, from line " + (Error.captureStackTrace(o) || o.stack.match(/\d+/)[0] - !!__commandLineAPI) + "!"); })({});

Cobra

class Program
    def main
        print 'Hello World, from line [System.Diagnostics.StackFrame(true).getFileLineNumber]!'

Rubino

File.write "hello.rb", "x=2\n"+"x+=1\n"*rand(rand(100))+'puts "Hello World, from line #{x}!"'
system "ruby hello.rb"
File.delete "hello.rb"

PowerShell

Mossa economica

Function LemmeGetDatError() {
    "Too busy chuggin along"
    "Then all of a sudden, I meet a new programmer"
    "And he's all like"
    Write-Output "$(Try {"Hello World from"; Throw "error" } Catch {$_.ScriptStackTrace.Split(":")[1]})"
}

LemmeGetDatError

PowerShell

$l=(Get-PSCallStack | ForEach{$_.Location})[0].split(' ')[-1]; "Hello World, from line $l!"

E:

try{ I AM ERROR. } catch { $l=$error[0].InvocationInfo.ScriptLineNumber; "Hello World, from line $l!" }

Entrambi funzionano così:

PS C:\MyFolder> .\helloworld.ps1
Hello World, from line 1!

Pitone

import traceback

print 'Hello World, from line %i!' % traceback.extract_stack()[0][1]

Breve e dolce

Perl

Un altro Perl:

use warnings;

$SIG{__WARN__} = sub { ($line = shift) =~ s/\D//g; };

$x=$x+1; print "Hello World, form line $line!\n";