चुनौती

फ़ाइल के प्रत्येक बाइट को प्रदर्शित करने के लिए कंसोल प्रोग्राम बनाएँ।

जीतना

चूंकि यह कोड-गोल्फ है , कम से कम बाइट्स जीतता है।

नियम

प्रोग्राम को एक कंसोल एप्लिकेशन होना चाहिए , जिसका अर्थ है कि इसे किसी प्रकार के कमांड-लाइन दुभाषिया से चलाया जाएगा;
प्रत्येक बाइट को एक स्पेस द्वारा अलग किया गया अपरकेस हो सकता है, और यह 2 अंक का होना चाहिए; (यदि यह 1 अंक है, तो इससे पहले 0 नंबर डालें)
फ़ाइल को IO या वैकल्पिक का उपयोग करके पढ़ा जाना चाहिए , न कि हार्ड-कोडेड;
फ़ाइल पथ को कमांड-लाइन तर्क या उपयोगकर्ता प्रॉम्प्ट (जैसे STDIN) के रूप में निर्दिष्ट किया जाना चाहिए ;
नो लूपहोल्स प्लीज ;

उदाहरण

test.txt (एलएफ के साथ समाप्त होता है)

Hello World!

$ ./hexdump.exe test.txt
48 65 6C 6C 6F 20 57 6F 72 6C 64 21 0A

code-golf

— facepalm42
स्रोत

16

@ facepalm42 फेसपाल से बचने के लिए, मैं दृढ़ता से सैंडबॉक्स का उपयोग करने की सलाह देता हूं ताकि आपको उन्हें पोस्ट करने से पहले भविष्य की चुनौतियों को डिजाइन करने में मदद मिल सके।

— Adám

2

स्क्रीन पर फिट नहीं होने पर एक बार में सभी बाइट मानों को प्रदर्शित करना कैसे संभव है? स्क्रॉलिंग स्पष्ट रूप से "एक बार में" नहीं है। इसके अलावा, क्या गलत है (एक समारोह) सिर्फ मूल्यों को लौटाने में?

— Adám

7

@ facepalm42 चुनौती पोस्ट करने के बाद कृपया इतने लंबे समय के लिए कल्पना को न बदलें। मूल पोस्ट ने हेक्साडेसिमल संख्याओं के सटीक प्रारूप को निर्दिष्ट नहीं किया, जिससे यह उत्तरदाताओं तक पहुंच गया। आपके नवीनतम संपादन ने मेरे मौजूदा उत्तर को अमान्य कर दिया है!

— Adám

11

क्या कोई विशेष कारण है कि आप केवल कमांड-लाइन तर्क या उपयोगकर्ता संकेत की अनुमति देते हैं? एक फ़ंक्शन तर्क के रूप में फ़ाइल नाम लेने में क्या गलत है?

— Adám

3

यह उपयोगी होगा यदि आपके पास एक इनपुट केhello.txt रूप में एक साधारण पाठ फ़ाइल है और अपेक्षित आउटपुट क्या होना चाहिए। उदाहरण के लिए, यदि निहित शब्द केवल एक पंक्ति विराम के साथ है, तो इसे आउटपुट में कैसे व्यक्त किया जाएगा? क्या आप 16-बिट, 32-बिट या 64-बिट शब्दों में बाइट्स समूहीकृत कर रहे हैं? या प्रत्येक बाइट को दो अंकों के हेक्स के रूप में व्यक्त किया जाता है? क्या रिक्त स्थान प्रत्येक बाइट के बाद हेक्स के रूप में स्वीकार्य हैं, या प्रत्येक एक्स-बिट शब्द के बाद? क्या आपको प्रत्येक बाइट के लिए पूर्व-निर्धारण की आवश्यकता है ? hello.txthello0x

— शॉन बेयबर्स

11

सी (जीसीसी) पर * निक्स, 73 71 बाइट्स

i;main(c,v)int**v;{for(c=open(v[1],0);read(c,&i,1);printf("%02X ",i));}

इसे ऑनलाइन आज़माएं! परीक्षण सूट

जोहान डू टिट को -2 बाइट्स धन्यवाद

यह कहां O_RDONLY == 0और int_one == 1कहां पर निर्भर करता है int int_one; *(char*)&int_one = 1;।

— wastl
स्रोत

11

69 बाइट्स ;)

— जोहान डू टिट

6

रूबी , 26 बाइट्स

$<.bytes{|b|$><<"%02X "%b}

इसे ऑनलाइन आज़माएं!

— जीबी
स्रोत

क्या यह प्रोग्राम तर्क के रूप में एक फ़ाइल-पथ दिए गए फ़ाइल की सामग्री को पढ़ता है? TIO के आधार पर यह सिर्फ STDIN से पढ़ा गया लगता है, लेकिन मैं रूबी को अच्छी तरह से नहीं जानता कि यह गलत है।

— केवि क्रूज़सेन

1

@ केविनक्रूजसेन हाँ, यह प्रोग्राम तर्क के रूप में फ़ाइल पथ (ओं) को लेता है। यदि कोई तर्क नहीं है, तो $<इसके बजाय STDIN से पढ़ने के लिए स्विच करें।

— मूल्य स्याही

6

पॉवरशेल , 45 40 बाइट्स

"$(gc $args -ra|% *ay|%{'{0:X2}'-f+$_})"

इसे ऑनलाइन आज़माएं!

-5 बाइट्स mazzy के लिए धन्यवाद

— आंद्रेई ओडेगो
स्रोत

के लिए धन्यवाद ./.input.tio। CRLF के साथ 40 बाइट संरक्षित हैं।

— माज़ी

1

मैंने केविन क्रूज़सेन समाधान से यह सीखा ।

— आंद्रेई ओडेगो

6

जावा 11, 156 154 बाइट्स

import java.nio.file.*;interface M{static void main(String[]a)throws Exception{for(int b:Files.readAllBytes(Path.of(a[0])))System.out.printf("%02X ",b);}}

-2 बाइट्स @Holger को धन्यवाद ।

./.input.tioतर्क फ़ाइल-पथ के रूप में उपयोग करके इसे ऑनलाइन आज़माएं , जिसमें फ़ाइल-सामग्री के रूप में दिया गया इनपुट होगा।

स्पष्टीकरण:

import java.nio.file.*;        // Required import for Files and Paths
interface M{                   // Class
  static void main(String[]a)  //  Mandatory main method
      throws Exception{        //  With mandatory thrown clause for the readAllBytes builtin
                                         a[0]    // Get the first argument
                                 Path.of(    )   // Get the file using that argument as path
              Files.readAllBytes(             )  // Get all bytes from this file
    for(int b:                                 ) // Loop over each of them:
      System.out.printf(                         //  And print the current byte
                        "%02X ",b);}}            //  As uppercase hexadecimal with leading 0
                                                 //  and trailing space as delimiter

— केविन क्रूज़सेन
स्रोत

interfaceइसके बजाय उपयोग करने के पीछे तर्क क्या है class?

— जेकडॉट

4

@ जेकडॉट मुख्य को सार्वजनिक होना आवश्यक है, इंटरफ़ेस विधियां हमेशा सार्वजनिक होती हैं, + interfaceसे छोटी होती हैं । classpublic

— ग्रैमी

3

जावा 11 के साथ, आप Path.ofPaths.get

— Holger

1

@ होल्गर धन्यवाद! :)

— केविन क्रूज़सेन

2

@ 9 जावा के बाद से, इंटरफ़ेस के तरीके हमेशा नहीं होते हैं public, लेकिन वे publicतब तक होते हैं जब तक कि स्पष्ट रूप से घोषित नहीं किया जाता है private।

— होल्गर

6

PHP , 60 59 54 बाइट्स

<?=wordwrap(bin2hex(implode(file($argv[1]))),2,' ',1);

-1 बाइट थैंक्स टू मनस्सेख्ट्ज
-5 बाइट्स ब्लैकहोल के लिए धन्यवाद

इसे ऑनलाइन आज़माएं!

— जॉन
स्रोत

1

अनुगामी को छोड़ने ?>और 2 बाइट्स को बचाने में सक्षम होना चाहिए , या यदि वह काम नहीं करता है तो ?>अर्धविराम के साथ बदलें और 1 बाइट बचाएं।

— मनश्शेख्ज़-मूविंग 2 कोडिडैक्ट

2

(-4 बाइट्स) के implode(file($x))बजाय का उपयोग करें file_get_contents($x)।

— ब्लैकहोल

2

और wordwrap(), 1अंतिम पैरामीटर के रूप में, एक बाइट से कम है chunk_split()।

— ब्लैकहोल

5

पर्ल 5 ( `-aF//`), 23 बाइट्स

printf"%02X ",ord for@F

TIO

— नहुएल फौलीउल
स्रोत

4

एपीएल (डायलॉग यूनिकोड) , 16 बाइट्स

बेनामी tacit उपसर्ग समारोह। रिटर्न (और स्पष्ट रूप से प्रिंट करता है, यदि मूल्य अन्यथा भस्म नहीं होता है) शीर्ष 4 बिट्स के साथ एक दो-पंक्ति मैट्रिक्स, जो शीर्ष पंक्ति में दशमलव संख्या 0-15 के रूप में दर्शाया गया है और नीचे 4 बिट्स इसी तरह नीचे पंक्ति में दर्शाए गए हैं। यही है, मैट्रिक्स में कई कॉलम हैं जैसे फ़ाइल में बाइट्स हैं।

16 16⊤83 ¯1∘⎕MAP

इसे ऑनलाइन आज़माएं!

⎕MAP
∘ पैरामीटर के साथ किसी सरणी में तर्क फ़ाइल नाम को मैप करें :
¯1 फ़ाइल की पूरी लंबाई
83 8-बिट पूर्णांक के रूप में पढ़ी जाती है

16 16⊤ 2-स्थिति हेक्साडेसिमल में परिवर्तित (एंटी-बेस)

— एडम
स्रोत

1

@ facepalm42 यह बहुत हेक्साडेसिमल में है। ईजी H72 है, जो 4 × 16¹ + 8 × 16 [या [4,8] is है। इसलिए उदाहरण में पहला कॉलम पढ़ता है [4,8]।

— Adám

ओह, मैं पूरी तरह से भूल गया! माफ़ करना।

— फेसपालम

4

पायथन 3, 59 बाइट्स

-11 बाइट्स ज्यादातर हानिरहित के लिए धन्यवाद!

-8 बाइट्स जेम्स के पोल्क को धन्यवाद!

-24 बाइट्स ब्लू के लिए धन्यवाद!

print(' '.join('%02X'%ord(i)for i in open(input()).read()))

इसे ऑनलाइन आज़माएं!

यह बहुत सीधा है; यह STDIN पर इनपुट के रूप में दिया गया एक फ़ाइल नाम खोलता है, इसे पढ़ता है, प्रत्येक वर्ण को उसके ASCII मान में रूपांतरित करता है, प्रत्येक संख्या को हेक्स में रूपांतरित करता है, "0x"उस से छीनता है, जो पायथन में हेक्सैडमिक मानों से पहले होता है, यदि आवश्यक हो तो मान को शून्य से पैड करता है, फिर मानों को जोड़ता है एक साथ रिक्त स्थान के साथ।

— mprogrammer
स्रोत

'%02X'%ord(i)हेक्स के उत्पादन को कम करने के बजाय कुछ बाइट्स बचा सकते हैं

— ज्यादातर

@MostlyHarmless किया! -11 बाइट्स। धन्यवाद!

— mprogrammer

कैसे '% 02x' के बजाय '% 02X' के बारे में, और छुटकारा .upper()

— पाएं

आप इसके बजाय फ़ाइल नाम के रूप में import sysउपयोग करके बाइट्स को बचा सकते हैं raw_input(); नियम उपयोगकर्ता को संकेत देने की अनुमति देते हैं।

— ब्लू

@ धन्यवाद! और यह पायथन 3 में भी छोटा है, जहां आप बस कर सकते हैंinput()

— mprogrammer

3

बैश , 33 23 बाइट्स

मदद का एक बहुत कुछ के साथ ...:
-3 धन्यवाद manatwork
-4 धन्यवाद करने के लिए spuck
-3 के लिए धन्यवाद Nahuel Fouilleul

echo `xxd -c1 -p -u $1`

इसे ऑनलाइन आज़माएं!

ध्यान दें कि ऊपर दिया गया TIO लिंक इनपुट का उपयोग करता है - हम स्थानीय रूप से फ़ाइलों को लिख सकते हैं, इसलिए यह इसे एक फ़ाइल पथ लेने वाले प्रोग्राम के रूप में काम करता है।

— जोनाथन एलन
स्रोत

मामूली कटौती xxd -u -p $1|fold -2|tr \\n \ :।

— मैनेटवर्क

धन्यवाद, किसी भी विचार कैसे पाने के लिए \nऔर \ 'इस' लिंक संस्करण में काम करने के लिए? संपादित करें: मैंने एक और बच चरित्र जोड़ा।

— जोनाथन एलन

अगर मैं आपको सही तरीके से समझूं, तो आप सिर्फ दोहरे उद्धरण चिह्नों से एकल उद्धरणों में बदलना चाहते हैं: इसे ऑनलाइन आज़माएं!

— मैनटवर्क

बहुत बढ़िया धन्यवाद!

— जोनाथन एलन

xxd -c1 -p -u $1|tr \\n \

— बजे

3

कोटलिन , 130 127 104 93 92 बाइट्स

fun main(a:Array<String>){java.io.File(a[0]).readBytes().forEach{print("%02X ".format(it))}}

इसे ऑनलाइन आज़माएं!

संपादित करें: -11 बाइट्स @ChrisParton के लिए धन्यवाद

संपादित करें: कार्य TIO

संपादित करें: -1 बाइट @ केविनक्रूजसेन को धन्यवाद

— क्विन
स्रोत

1

क्या आप इसके बजाय आयात और संदर्भ Fileको java.io.Fileखोद सकते हैं?

— क्रिस पार्टन

@ क्रिसपार्टन आप सही हैं, धन्यवाद!

— क्विन

यहाँ एक काम TIO। आप ./.input.tioफ़ाइल-पथ तर्क के रूप में उपयोग कर सकते हैं , और यह फ़ाइल-सामग्री के रूप में STDIN का उपयोग करेगा। :)

— केविन क्रूज़सेन

@ केविनक्रूजसेन धन्यवाद! बस अद्यतन जवाब

— क्विन

1

मुझे पता नहीं है कि कोटलिन, लेकिन टीआईओ अभी भी काम करता है अगर मैं अंतरिक्ष को हटाता हूं a:Array, तो मुझे लगता है कि आप एक बाइट बचा सकते हैं।

— केविन क्रूज़सेन

2

डार्ट , 140 134 बाइट्स

import'dart:io';main(a){print(new File(a[0]).readAsBytesSync().map((n)=>n.toRadixString(16).toUpperCase().padLeft(2,'0')).join(' '));}

इसे ऑनलाइन आज़माएं!

-6 बाइट्स क्योंकि मैं चर नामों को कम करना भूल गया

— Elcan
स्रोत

डार्ट के लिए +1। इस तरह की एक अविकसित भाषा।

— vasilescur

गोल्फ के साथ मुश्किल है, क्योंकि यह मूल रूप से बहुत ही

— लक्स

2

हास्केल, 145 143 बाइट्स

import System.Environment
import Text.Printf
import Data.ByteString
main=getArgs>>=Data.ByteString.readFile.(!!0)>>=mapM_(printf"%02X ").unpack

— डेमियन
स्रोत

1

थोड़ा छोटा: import Data.ByteStringप्लस main=getArgs>>=Data.ByteString.readFile.(!!0)>>=mapM_(printf"%02X ").unpack।

— नीमी

2

जंग, 141 बाइट्स (योगदान संस्करण)

use std::{io::*,fs::*,env::*};fn main(){for x in File::open(args().nth(1).unwrap()).unwrap().bytes(){print!("{:02X} ",x.unwrap())}println!()}

जंग, 151 बाइट्स (मूल संस्करण)

fn main(){std::io::Read::bytes(std::fs::File::open(std::env::args().nth(1).unwrap()).unwrap()).map(|x|print!("{:02X} ",x.unwrap())).count();println!()}

— Vi।
स्रोत

-10 बाइट्स: TIO

— हरमन एल

2

बैश + स्टैक्स, 6 + 4 + 1 = 11 बाइट्स

यह इस बिंदु पर पूर्ण सिद्धांत शिल्प है। आप वास्तव में इसे नहीं चला सकते। यदि सब कुछ अपनी कल्पना के अनुसार काम करता है तो यह काम करेगा, लेकिन सब कुछ अभी तक नहीं करता है।

बैश स्क्रिप्ट है

]<$1

और स्टैक्स कार्यक्रम को संकलित और सहेजा जाना चाहिए] है

╛↕ßú┼_

अपने चरित्र को ISO 8859-1 पर सेट करें (Windows-1252 यहां काम नहीं करेगा) और जाओ

अनपैक और समझाया गया

_          push all input as a single array
F          run the rest of the program for each element of the array
 |H        write the hex of the byte to standard output
 |         write a space to standard output

— यहोशू
स्रोत

2

इमोजीकोड , 186 162 बाइट्स

📦files🏠🏁🍇🔂b🍺📇🐇📄🆕🔡👂🏼❗️❗️🍇👄📫🍪🔪🔡🔢b❗️➕256 16❗️1 2❗️🔤 🔤🍪❗️❗️🍉🍉

इसे यहाँ ऑनलाइन आज़माएँ ।

Ungolfed:

📦 files 🏠  💭 Import the files package into the default namespace
🏁 🍇  💭 Main code block
🔂 b  💭 For each b in ...
  🍺  💭 (ignoring IO errors)
  📇 🐇 📄  💭 ... the byte representation of the file ...
  🆕 🔡 👂🏼  💭 ... read from user input:
  ❗️ ❗️ 🍇
    👄  💭 Print ...
    📫  💭 ... in upper case (numbers in bases > 10 are in lower case) ...
    🍪  💭 ... the concatenation of:
      🔪 🔡 🔢 b ❗️ ➕ 256  💭 b + 256 (this gives the leading zero in case the hex representation of b is a single digit) ...
              16  💭 ... represented in hexadecimal ...
           ❗️
         1 2  💭 ... without the leading one,
      ❗️
      🔤 🔤  💭 ... and a space
    🍪
    ❗️❗️
  🍉
🍉

— OOBalance
स्रोत

2

पर्ल 6 , 45 बाइट्स

@*ARGS[0].IO.slurp(:bin).list.fmt('%02X').say

इसे ऑनलाइन आज़माएं!

@*ARGS[0] पहला कमांड-लाइन तर्क है।
.IOएक IO::Pathवस्तु में फ़ाइल नाम (प्रकल्पित) बदल जाता है ।
.slurp(:bin)पूरी फाइल को Bufबाइट्स के बफर में पढ़ता है । ( :binफ़ाइल सामग्री के बिना एक यूनिकोड स्ट्रिंग के रूप में वापस किया जाएगा।)
.list बफ़र से बाइट मानों की एक सूची देता है।
.fmt('%02X')एक Listविधि है जो दी गई प्रारूप स्ट्रिंग का उपयोग करके सूची के तत्वों को प्रारूपित करती है, फिर उन्हें रिक्त स्थान के साथ जोड़ देती है। (सुविधाजनक!)
.say उस तार को प्रिंट करता है।

— शॉन
स्रोत

पायथन के उत्तर के आधार पर, TIO लिंक वास्तव में काफी संभव है।

— Draco18s अब SE

कुछ रीक्रेंजिंग 41 बाइट्स के .listलिए निकाल सकते हैं

— जो किंग

1

डी , 98 बाइट्स

import std;void main(string[]s){File(s[1]).byChunk(9).joiner.each!(a=>writef("%02X ",a.to!byte));}

इसे ऑनलाइन आज़माएं!

— शमूएल
स्रोत

1

पायथन 3, 75 बाइट्स

ज्यादातर मैक्सवेल के अजगर 2 जवाब की एक प्रति ।

import sys
print(' '.join('%02X'%b for b in open(sys.argv[1],'rb').read()))

— राष्ट्रपति जेम्स चालन पोल्क
स्रोत

आप शायद मतलब है sys.argv[1]। साथ sys.argv[0]इस स्क्रिप्ट अधिक एक Quine तरह ;-) काम करता है

— ऋणायन

@ आयन: ऊप्स, हाहा, फिक्सिंग ...

— प्रेसिडेंट जेम्स मूवॉन पोलक

1

रैकेट, 144 बाइट्स

यह सबमिशन एक अनुगामी स्थान और कोई अनुगामी न्यूलाइन आउटपुट नहीं करता है। मुझे पता है अगर यह एक बचाव का रास्ता माना जाता है :)

(command-line #:args(f)(for([b(call-with-input-file f port->bytes)])(printf"~a "(string-upcase(~r b #:base 16 #:min-width 2 #:pad-string"0")))))

सफाई की

(command-line #:args (f)
 (for ([b (call-with-input-file f port->bytes)])
   (printf "~a "
           (string-upcase
            (~r b #:base 16 #:min-width 2 #:pad-string "0")))))

— winny
स्रोत

1

फोर्थ (gforth) , 71 बाइट्स

: f slurp-file hex 0 do dup c@ 0 <# # # #> type space 1+ loop ;
1 arg f

इसे ऑनलाइन आज़माएं!

TIO 3 argकी अंतिम पंक्ति है क्योंकि TIO कोड में पास होने से पहले कमांड लाइन पार्सर को "-e बाय" देता है

कोड स्पष्टीकरण

: f             \ start a function definition
  slurp-file    \ open the file indicated by the string on top of the stack,
                \ then put its contents  in a new string on top of the stack
  hex           \ set the interpreter to base 16
  0 do          \ loop from 0 to file-length - 1 (inclusive)
    dup c@      \ get the character value from the address on top of the stack
    0 <# # # #> \ convert to a double-length number then convert to a string of length 2
    type        \ output the created string 
    space       \ output a space 
    1+          \ add 1 to the current address value
  loop          \ end the loop
;               \ end the word definition
1 arg f         \ get the filename from the first command-line argument and call the function

— reffu
स्रोत

1

जावास्क्रिप्ट, 155 बाइट्स

for(b=WScript,a=new ActiveXObject("Scripting.FileSystemObject").OpenTextFile(b.Arguments(0));;b.echo(('0'+a.read(1).charCodeAt(0).toString(16)).slice(-2)))

— पीटर फेरि
स्रोत

1

VBScript, 143 बाइट्स

set a=CreateObject("Scripting.FileSystemObject").OpenTextFile(WScript.Arguments(0)):while 1 WScript.echo(right("0"+Hex(Asc(a.read(1))),2)):wend

— पीटर फेरि
स्रोत

1

वोल्फ्राम भाषा (गणितज्ञ) , 94 89 बाइट्स

Print@ToUpperCase@StringRiffle@IntegerString[BinaryReadList@Last@$ScriptCommandLine,16,2]

इसे ऑनलाइन आज़माएं!

लंबे कमांड नामों के कारण कोड काफी आत्म-व्याख्यात्मक है। इसे ज्यादातर दाईं से बाईं ओर पढ़ा जाना चाहिए:

$ScriptCommandLine       is a list of {scriptname, commandlinearg1, commandlinearg2, ...}
Last@...                 extracts the last command-line argument
BinaryReadList@...       reads the named file into a list of bytes
IntegerString[...,16,2]  converts each byte to a 2-digit hex string (lowercase)
StringRiffle@...         converts this list of strings into a single string with spaces
ToUpperCase@...          converts the string to uppercase
Print@...                prints the result to stdout

— रोमन
स्रोत

1

गामा , 45 वर्ण

?=@fill-right{00;@radix{10;16;@char-int{?}}}

नमूना रन:

bash-5.0$ gema '?=@fill-right{00;@radix{10;16;@char-int{?}}} ' <<< 'Hello World!'
48 65 6C 6C 6F 20 57 6F 72 6C 64 21 0A

इसे ऑनलाइन आज़माएं!

— आदमी काम पर है
स्रोत

1

पायथ , 12 बाइट्स

jdcr1.Hjb'w2

इसे ऑनलाइन आज़माएं!

उपयोगकर्ता प्रॉम्प्ट के रूप में इनपुट लेता है (कमांड लाइन आर्ग्युमेंट्स AFAIK तक पहुंचने का कोई तरीका नहीं)।

jd           # join on spaces
  c        2 # chop into pieces of length 2
   r1        # convert to uppercase
     .H      # convert to hex string, interpreting as base 256 (*)
       jb    # join on newlines
         '   # read file as list of lines
          w  # input()

(*) अगर यह इरादा है तो मैं 100% निश्चित नहीं हूं, लेकिन एक आधार 256 अंक (जैसा कि, एक चरित्र), हमेशा शून्य हेक्स के साथ पैड की आवश्यकता को समाप्त करते हुए, वास्तव में 2 हेक्स अंकों में बदल जाएगा।

— ar4093
स्रोत

1

नोड.जेएस, 118 बाइट्स

console.log([...require("fs").readFileSync(process.argv[2])].map(y=>(y<16?0:"")+y.toString(16).toUpperCase()).join` `)

परिणाम कैसा दिखता है:

Btw test.txtउदाहरण में सामग्री इस प्रकार है:

做乜嘢要輸出大楷姐，搞到要加番toUpperCase()去轉番，咁就13byte啦。

(क्यों पृथ्वी पर ऊपरी-केस आउटपुट आवश्यक है। मुझे रूपांतरण के साथ जोड़ना पड़ा toUpperCase(), और इसकी लागत 13 बाइट थी।)

— शायरु असकोतो
स्रोत

0

C # .NET फ्रेमवर्क 4.7.2 - 235 213 203 191 175 140 बाइट्स

इसे ऑनलाइन आज़माएं!

using System.IO;class P{static void Main(string[]a){foreach(var b in File.ReadAllBytes(a[0])){System.Console.Write(b.ToString("X2")+" ");}}}

using System;
using System.IO;

namespace hexdump
{
    class Program
    {
        static void Main(string[] args)
        {
            // Read the bytes of the file
            byte[] bytes = File.ReadAllBytes(args[0]);

            // Loop through all the bytes and show them
            foreach (byte b in bytes)
            {
                // Show the byte converted to hexadecimal
                Console.Write(b.ToString("X2") + " ");
            }
        }
    }
}

— facepalm42
स्रोत

1

मुझे लगता है कि निम्नलिखित कुछ बाइट्स (अब 181 मुझे लगता है) बचाएगा: System.IO का उपयोग करना; वर्ग P {स्टेटिक शून्य मेन (स्ट्रिंग [] a) {if (a .ength> 0 && File.Exists ([0]) ) {foreach (File.ReadAllBytes में वर ख (क [0])) {System.Console.Write ($ "{b.ToString (" X2 ")}");}}}}

— PmanAce

@PmanAce यदि आप कुछ व्हाट्सएप को हटा देते हैं, तो यह 175 से नीचे हो जाता है।

— फेसपल्म

0

05AB1E , 18 बाइट्स

IvyÇh2j' 0.:' Jvy?

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

IvyÇh2j' 0.:' Jvy?
Iv                 Loop through each character in input
  y                Push current character
   Ç               ASCII value
    h              Convert to hexadecimal
     2j            Pad with at least 2 spaces
       ' 0.:       Replace all spaces with 0s
            ' J    Add space to end
               vy? Convert to string and print
IvyÇh2j' 0.:' Jvy?

— facepalm42
स्रोत

सबसे कम हेक्स डंपिंग कार्यक्रम

चुनौती

जीतना

नियम

उदाहरण

सी (जीसीसी) पर * निक्स, 73 71 बाइट्स

रूबी , 26 बाइट्स

पॉवरशेल , 45 40 बाइट्स

जावा 11, 156 154 बाइट्स

PHP , 60 59 54 बाइट्स

पर्ल 5 ( -aF//), 23 बाइट्स

एपीएल (डायलॉग यूनिकोड) , 16 बाइट्स

पायथन 3, 59 बाइट्स

बैश , 33 23 बाइट्स

कोटलिन , 130 127 104 93 92 बाइट्स

डार्ट , 140 134 बाइट्स

हास्केल, 145 143 बाइट्स

जंग, 141 बाइट्स (योगदान संस्करण)

जंग, 151 बाइट्स (मूल संस्करण)

बैश + स्टैक्स, 6 + 4 + 1 = 11 बाइट्स

इमोजीकोड , 186 162 बाइट्स

पर्ल 6 , 45 बाइट्स

डी , 98 बाइट्स

पायथन 3, 75 बाइट्स

रैकेट, 144 बाइट्स

सफाई की

फोर्थ (gforth) , 71 बाइट्स

कोड स्पष्टीकरण

जावास्क्रिप्ट, 155 बाइट्स

VBScript, 143 बाइट्स

वोल्फ्राम भाषा (गणितज्ञ) , 94 89 बाइट्स

गामा , 45 वर्ण

पायथ , 12 बाइट्स

नोड.जेएस, 118 बाइट्स

C # .NET फ्रेमवर्क 4.7.2 - 235 213 203 191 175 140 बाइट्स

05AB1E , 18 बाइट्स

पर्ल 5 ( `-aF//`), 23 बाइट्स