Programmieren lernen

def ipTransformation(s):
   li=s.split('.')
   li.reverse()
   fact =1
   ip_nr =0
   for number in li:
      ip_nr = ip_nr + fact*int(number)
      fact = fact*256
   return ip_nr

print ipTransformation('192.122.45.45')

print ipTransformation('131.152.226.144')
                

public class Main {

    public static void main(String[] args) {
        long ipl = ipTransformation( "192.128.255.127" );
        System.out.println( ipl );
        System.out.printf( "%08X\n", ipl );
    }

    public static long ipTransformation( String ipstr ) {
        long ipnum = 0;
        String[] parts = ipstr.split( "\\." );

        if ( parts.length != 4 )
            return -1;

        for ( int i = 0; i < 4; i++ ) {
            ipnum <<= 8;
            ipnum |= Long.parseLong( parts[i] );
        }

        return ipnum;
    }
}

                

import java.util.Scanner;


// Lösung ohne Bit-Shift (philipp gressly freimann)
public class IPAdressen {

public static void main(String[] args) {
    new IPAdressen().top();}
   
   void top() {
       String eingabe   = einlesenIPString();
       long   resultat  = ipTransformation(eingabe); 
       System.out.println(eingabe +" als int ist gleich " + resultat);
   }
   
   String einlesenIPString() {
      Scanner sc = new Scanner(System.in);
      System.out.println("Geben Sie eine IP Adresse in der Form '211.43.23.156' ein: ");
      return sc.next(); }

  long ipTransformation(String dec) {
      long resultat = 0;
      int  actDec   = 0;
      int  pos      = 0; // Pos im String
      while(pos < dec.length()) {
          char akt = dec.charAt(pos);
          if('.' == akt) { // Auswerten bei '.' ...
              resultat = 256 * resultat + actDec;
              actDec = 0; }
          else { // Ziffer dazuzählen
              actDec = actDec*10 + (akt - '0');
          }
          pos = pos + 1;
      }
      // ... und am Ende
      return 256 * resultat + actDec; }
  
} // end of class IPAdressen
                

/*=======================================================================*\
|* Ein weiterer höhepunkt in der steilen karriere dieser website durch    |
|* unfassbar unklar formulierte aufgaben, deren raison d'être sich selbst |
|* nach der lösung nicht erschließen will.                                |
|*                                                                        |
|* Aber dies hier funktioniert, im sinne der verifikation.                |
\*=======================================================================*/

function transformIp(ip) {
  ip = ip.split('.');

  function leadZero(inp) {
    while (inp.length < 8) inp = '0' + inp;
    return inp;
  }

  for (let i = 0; i < ip.length; i++)
    ip[i] = leadZero(parseInt(ip[i]).toString(2));

  return parseInt(ip.join(''), 2);
}

// test
console.log( transformIp('110.120.130.140') );
console.log( transformIp('211.43.23.156') );        // lisssalanda@gmx.at

                

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

// NET 6.x | C# 10.x | VS-2022

var ip = "110.120.130.140";

Console.WriteLine($"{ConvertStringIPToInt(ip):#,##0}");

static long ConvertStringIPToInt(string ip) => Convert.ToInt64(string.Join("", ip.Split('.').Select(x => int.Parse(x))
    .Select(x => Convert.ToString(x, 2)).Select(x => $"0000000{x}"[^8..])), 2);
                

Lösung von: Jens Kelm (@JKooP)

// C++ 14 | VS-2022
#include <iostream>
#include <bitset>
#include <string>
#include <regex>

const auto get_int_from_ip(const std::string& str) {
    const std::regex reg("\\d{1,3}");
    std::string out{};
    std::sregex_iterator next{ str.begin(), str.end(), reg }, end;

    while (next != end) {
        const auto& match{ *next };
        out += std::bitset<8>(std::stoi(match.str())).to_string();
        next++;
    }
    return std::bitset<32>(out).to_ulong();
}

int main() {
    std::cout << get_int_from_ip("110.120.130.140") << "\n";
}
                

Lösung von: Jens Kelm (@JKooP)