Nazwa forum

jarek · 2011-03-11 00:11:06

Kopiowanie z klawiatury do pliku:

Kod:

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;


public class j1 
{

    
    public static void main(String[] args) throws IOException,FileNotFoundException  
    {
        System.out.print("j1\r\n");

        BufferedReader inStd=new BufferedReader(new InputStreamReader (System.in));
        PrintWriter wr=new PrintWriter(new BufferedWriter(new FileWriter("out1.txt",true)));
        String s1=new String();
        while(true)
        {
            s1=inStd.readLine();
            if(s1.equals("")) 
            {
                break;
            }
            
            wr.printf("%s\r\n",s1);
        }
        wr.close();
    }

}

Zliczanie ilości znaków w pliku:

Kod:

 import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;


public class j2 
{

    
    public static void main(String[] args) throws IOException,FileNotFoundException  
    {
        BufferedReader in;
        BufferedReader inStd=new BufferedReader(new InputStreamReader (System.in));
        System.out.print("j2\r\n");

        String fnam="plik_wejsciowy.txt";

        int[] freq1=new int[256];
        for(int n=0;n<256;n++)
        {
            freq1[n]=0;
        }
        
        try               // bez try/catch też będzie hulać
        {
            in=new BufferedReader(new FileReader(fnam));

            while(true)
            {
                int znak=in.read();
                if(znak==-1)
                {
                    break;
                }

                freq1[znak]++;
            }

        
            PrintWriter wr=new PrintWriter(new BufferedWriter(new FileWriter("freq.txt",false)));
            wr.printf("FREQ: %s\r\n\r\n",fnam);
            String s1=new String();
            for(int n=0x40;n<0x7f;n++)
            {
                wr.printf("C%02X [%c]: %d\r\n",n,n,freq1[n]);
            }
            wr.close();
        }
        catch(IOException e)
        {
            System.out.print("brak pliku");
        }

        System.out.print("koniec.");
    }

}

Liczby Wymierne, plik klasy Wymierna (Wymierna.java):

Kod:

public class Wymierna 
{
    public Wymierna()
    {
        n=0;
        m=1;
    }

    
    public Wymierna(int _n, int _m)
    {
        n=_n;
        m=_m;
    }

    
    public void Mul(Wymierna r)
    {
        n*=r.n;
        m*=r.m;
    }
    

    public static Wymierna Mul(Wymierna r1, Wymierna r2)
    {
        return new Wymierna(r1.n*r2.n,r1.m*r2.m);
    }
    

    
    public void Add(Wymierna r)
    {
        n=r.n*m+n*r.m;
        m=r.m*m;
    }
    

    public static Wymierna Add(Wymierna r1, Wymierna r2)
    {
        return new Wymierna(r1.n*r2.m+r2.n*r1.m,r1.m*r2.m);
    }
    

    public String toString()
    {
        String ret=new String();
        ret=String.format("%d/%d", n,m);
        return ret;
    }

    public int n;
    public int m;
}

Liczby Wymierne, plik główny (j3.java):

Kod:

public class j3 
{

    public static void main(String[] args) 
    {
        System.out.print("j3\r\n");

        Wymierna r1=new Wymierna(1,2);
        System.out.println(r1);

        Wymierna r2=new Wymierna(3,5);
        r1.Add(r2);
        System.out.println(r1);

        Wymierna r3=new Wymierna(7,3);
        r3.Mul(r2);
        System.out.println(r3);

        Wymierna w4=Wymierna.Add(r3,r1);
        System.out.println(r4);
    }

}

Ostatnio edytowany przez jarek (2011-03-11 01:03:27)

Bartek · 2011-03-23 20:53:18

Zadanie nr 3.

class Wymierna
{
public int Mianownik;
public int Licznik;
//--------------------------------------------------------------------------------------------
//------konstruktory ------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
Wymierna(int licznik)
{
Licznik = licznik;
Mianownik = 1;
}
//--------------------------------------------------------------------------------------------
Wymierna(int licznik,int mianownik)
{
Licznik = licznik;
Mianownik = mianownik;
}
//--------------------------------------------------------------------------------------------
Wymierna()
{
Licznik = 1;
Mianownik = 1;
}
//--------------------------------------------------------------------------------------------
//------metody ------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
public String toString()
{
String s = new String();
return s = String.valueOf(Licznik)+ "/" + String.valueOf(Mianownik);
}
//--------------------------------------------------------------------------------------------
public static Wymierna mnoz(Wymierna a,Wymierna b)
{
int li = a.Licznik*b.Licznik;
int mi = a.Mianownik*b.Mianownik;
return new Wymierna(li,mi);
}
//----------------------------------------------------------------------------------------------
public static Wymierna dodaj(Wymierna a,Wymierna b)
{
int li = a.Licznik*b.Mianownik+a.Mianownik*b.Licznik;
int mi = a.Mianownik*b.Mianownik;
return new Wymierna(li,mi);
}
//---------------------------------------------------------------------------------------------
public static Wymierna odejmij(Wymierna a,Wymierna b)
{
int li = a.Licznik*b.Mianownik-b.Licznik*a.Mianownik;
int mi = b.Mianownik*a.Mianownik;
return new Wymierna(li,mi);
}
//---------------------------------------------------------------------------------------------
public static Wymierna podziel(Wymierna a,Wymierna b)
{
int li = a.Licznik*b.Mianownik;
int mi = a.Mianownik*b.Licznik;
return new Wymierna(li,mi);
}
//----------------------------------------------------------------------------------------------
public Wymierna mnoz(Wymierna a)
{
int li = Licznik*a.Licznik;
int mi = Mianownik*a.Mianownik;
return new Wymierna(li,mi);
}
//---------------------------------------------------------------------------------------------
public Wymierna dodaj(Wymierna a)
{
int li = Licznik*a.Mianownik+a.Licznik*Mianownik;
int mi = Mianownik*a.Mianownik;
return new Wymierna(li,mi);
}
//---------------------------------------------------------------------------------------------
public Wymierna odejmij(Wymierna a)
{
int li = Licznik*a.Mianownik-a.Licznik*Mianownik;
int mi = Mianownik*a.Mianownik;
return new Wymierna(li,mi);
}
//---------------------------------------------------------------------------------------------
public Wymierna podziel(Wymierna a)
{
int li = Licznik*a.Mianownik;
int mi = Mianownik*a.Licznik;
return new Wymierna(li,mi);
}
//---------------------------------------------------------------------------------------------
public static int NWD(int a, int b)
{
int c;
while (b != 0)
{
c = a % b;
a = b;
b = c;
}
return a;
}
//---------------------------------------------------------------------------------------------
public Wymierna skroc()
{

if(Licznik>=Mianownik)
{
int nwd = NWD(Licznik,Mianownik);
while(nwd!=1)
{
Licznik /= nwd;
Mianownik /= nwd;
nwd = NWD(Licznik,Mianownik);
}
return new Wymierna(Licznik,Mianownik);
}
else
{
int nwd = NWD(Mianownik,Licznik);
while(nwd!=1)
{
Licznik /= nwd;
Mianownik /= nwd;
nwd = NWD(Mianownik,Licznik);
}
return new Wymierna(Licznik,Mianownik);
}

}
//---------------------------------------------------------------------------------------------
}

//---------------------------------------------------------------------------------------------
public class Glowna {

public static void main(String[] args) {

Wymierna w1 = new Wymierna(7,3);
Wymierna w2 = new Wymierna(2);
Wymierna w3 = new Wymierna();
Wymierna w4 = new Wymierna(164,32);
Wymierna w5 = new Wymierna(7);
Wymierna w6 = new Wymierna(9,16);
int a = 183;
int b = 21;

System.out.println("Liczba w1 = "+ w1);
System.out.println("Liczba w2 = "+ w2);
System.out.println("Liczba w3 = "+ w3);
System.out.println("Dodawanie liczb (metoda statyczna) w1 w2 = " + Wymierna.dodaj(w1,w2));
System.out.println("Dodawanie liczb w1 w2 = " + w1.dodaj(w2));
System.out.println("Odejmowanie liczb (metoda statyczna) w1 w2 = " + Wymierna.odejmij(w1,w2));
System.out.println("Odejmowanie liczb w1 w2 = " + w1.odejmij(w2));
System.out.println("Mnożenie liczb (metoda statyczna) w1 w2 = " + Wymierna.mnoz(w1,w2));
System.out.println("Mnożenie liczb w1 w2 = " + w1.mnoz(w2));
System.out.println("Dzielenie liczb (metoda statyczna) w1 w2 = " + Wymierna.podziel(w1,w2));
System.out.println("Dzielenie liczb w1 w2 = " + w1.podziel(w2));
System.out.println("Liczba w4 = " + w4);
System.out.println("Liczba w4 po skróceniu = " + w4.skroc());
System.out.println("Metoda NWD oblicza najwyższy wspólny dzielnik dwóch liczb typu int");
System.out.println("a = " + a + ", b = " + b);
System.out.println("NWD(a,b) = " + Wymierna.NWD(a, b));

}

}

Whytek · 2011-04-05 19:06:02

Zadanie 4: Wektory

Kod:

 
class Wektor
{
    public double[] wsp;
    
//--------------------------------------------------------------------------------------------
//------konstruktory  ------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
    Wektor(double[] a)
    {
        wsp = new double[a.length];
        for(int i=0;i<a.length;i++)
        wsp[i] = a[i];
    }
    Wektor(int a)
    {
        wsp = new double[a];
        for(int i=0;i<a;i++)
            wsp[i]=0;
    }
    Wektor()
    {
        wsp = new double[1];
        wsp[0] = 0;
    }
//--------------------------------------------------------------------------------------------
    public String toString()
{
    String s = new String();
    for(int i=0;i<wsp.length;i++)
    {
        s += String.valueOf(wsp[i]) + ",";
    }
    return s;
}
//--------------------------------------------------------------------------------------------    
public static Wektor dodaj(Wektor a, Wektor b)
    {
        double[] suma = new double[a.wsp.length];
        for(int i=0;i<a.wsp.length;i++)
            suma[i] = a.wsp[i] + b.wsp[i];
        return new Wektor(suma);
    }
//--------------------------------------------------------------------------------------------    
public static double iloczynSkalarny(Wektor a,Wektor b)
{
    double iloczyn = 0;
    for(int i=0;i<a.wsp.length;i++)
        iloczyn += a.wsp[i]*b.wsp[i];
    return iloczyn;
}
//--------------------------------------------------------------------------------------------
public double dlugosc()
{
    double dl=0;
    for (int i=0; i<wsp.length; i++)
        dl += wsp[i]*wsp[i];
    return dl;
}
//--------------------------------------------------------------------------------------------
}




public class ZadWektor {

    public static void main(String[] args) {
        double[] a = {1,0,3};
        double[] b = {1,4,3};
        Wektor w1 = new Wektor(a);
        Wektor w2 = new Wektor(b);
        System.out.println("Zadane Wektory :");
        System.out.println(w1);
        System.out.println(w2);
        System.out.println("Suma wektorów :");
        System.out.println(Wektor.dodaj(w1,w2));
        System.out.println("Iloczyn skalarny :");
        System.out.println(Wektor.iloczynSkalarny(w1,w2));

    }

}

Zad 3 Liczby Wymierne:

Kod:

class Wymierna {

    int licznik;
    int mianownik;
    Wymierna(int li, int mi){
        licznik = li;
        mianownik = mi;
    }
    Wymierna(){
        licznik = 1;
        mianownik = 1;
    }
    void wypisz (){
        System.out.print(licznik);
        System.out.print("/");
        System.out.print(mianownik);
        
    
    }
static Wymierna iloczyn(Wymierna w1,Wymierna w2){
        
        Wymierna wynik = new Wymierna();
        wynik.licznik = w1.licznik*w2.licznik;
        wynik.mianownik = w1.mianownik*w2.mianownik;
        return wynik;
    }


Wymierna iloczyn(Wymierna w){
    Wymierna wynik = new Wymierna();
    wynik.licznik = licznik*w.licznik;
    wynik.mianownik = mianownik*w.mianownik;
    return wynik;
}
}
public class Moja {

    
    public static void main(String[] args) {
        

        Wymierna w1 = new Wymierna(7,9);
        Wymierna w2 = new Wymierna(5,3);
        Wymierna w3,w4;// = new Wymierna(5,6);
        w3 = Wymierna.iloczyn(w1,w2);
        
        w4 =w1.iloczyn(w2);

        w1.wypisz();
        System.out.print(" * ");
        w2.wypisz();
        System.out.print(" = ");
        w3.wypisz();
        
        
        
        
        }

}

Bartek · 2011-04-19 17:55:49

import java.util.*;

public class Moja {

public static void main(String[] args) {

Stos a = new Stos();
Random rand = new Random();
for(int i=0;i<15;i++)
{
a.top(rand.nextInt(100));
}
Iterator it = a.iterator();
for(;it.hasNext()
System.out.println(it.next());

}

}
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
class Stos implements Iterable
{
public int[] zawartosc;
public int top;

Stos()
{
top=-1;
zawartosc = new int[99];
}

public Iterator iterator()
{
return new StosIterator(this);
}
public int pop()
{
if(top>=0)
{
int a = zawartosc[top];
top--;
return a;
}
else return 0;
}
public void top(int a)
{
zawartosc[++top]=a;
}
}
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
class StosIterator implements Iterator
{
Stos s;
int p;

StosIterator(Stos a)
{
s=a;
p=-1;
}

public Object next()
{
return s.zawartosc[++p];
}
public boolean hasNext()
{
if(p<s.top)
return true;
else
return false;
}
public void remove()
{
if(p>=0)
s.zawartosc[p--]=0;

}
}

Whytek · 2011-05-31 18:01:19

Paczka - matematyka

Solvable

Kod:

package Matematyka;

public interface Solvable {
    
    double [] Solve();

}

Simplificable

Kod:

package Matematyka;

public interface Simplificable {
    
    void Simplify();
}

Equation

Kod:

package Matematyka;

public interface Equation extends Solvable{

    double [] getCoeffs();
    
}

Równanie Liniowe (LinEq)

Kod:

package Matematyka;

public class LineEq implements Equation, Simplificable {
    
    double wa,wb;
    
    public LineEq(double a, double b){
        wa=a;
        wb=b;
    }
    
    public String toString(){
        String str = wa+"x+"+wb+"=0";
        return str;
    }
    
    public double [] Solve(){
        double [] tab  = new double[1];
        if (wa!=0)
          tab[0]=-wa/wb;
        else 
            tab[0]= Double.NaN;
            return tab;
    }
    
    public void Simplify() {
        if (wa!=0){
            wa=1;
            wb/=wa;
        }
    }
    
    public double[] getCoeffs(){
        double [] tab = new double[2];
        tab[0]=wa;
        tab[1]=wb;
        return tab;
        
    }
}

Równanie kwadratowe(QuadEq)

Kod:

package Matematyka;

public class QuadEq implements Equation, Simplificable {
    
    double wa,wb,wc;
    
    public QuadEq(double a, double b, double c){
        wa=a;
        wb=b;
        wc=c;
    }
    public String toString(){
        String str = wa+"x^2+"+wb+"x+"+wc+"=0";
        return str;
    }
    
    public double delta(){
        double del;
        del = wb*wb-4*wa*wc;
        return del;
    }
    
    public double [] Solve(){
        double [] tab = new double [2];
        
        if (delta()>0){
            tab[0]=(-wb-Math.sqrt(delta()))/(2*wa);
            tab[1]=(-wb+Math.sqrt(delta()))/(2*wa);}
        else if (delta()==0){
            tab[0]=-wb/(2*wa);
            tab[1]=-wb/(2*wa);}
        else{
            tab[0]=Double.NaN;
            tab[1]=Double.NaN;}    
            return tab;        
    }
    
    public void Simplify() {
        if (wa!=0){
            wa=1;
            wb/=wa;
            wc/=wa;
        }
    }
    
    public double[] getCoeffs(){
        double [] tab = new double[3];
        tab[0]=wa;
        tab[1]=wb;
        tab[2]=wc;
        return tab;        
    }

}

Matma

Kod:

import Matematyka.QuadEq;


public class Matma {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
         QuadEq w = new QuadEq(1,0,1);
         System.out.println(w);
         double[] tab = w.Solve();
         double[] tab2 = w.getCoeffs();
         System.out.println(tab[0]);
         System.out.println(tab[1]);
         System.out.println(tab2[0]);
         System.out.println(tab2[1]);
         System.out.println(tab2[2]);

    }

}

Copyright Adrian G.

Nazwa forum

#1 2011-03-11 00:11:06

Java

Kod:

Kod:

Kod:

Kod:

#2 2011-03-23 20:53:18

Re: Java

#3 2011-04-05 19:06:02

Re: Java

Kod:

Kod:

#4 2011-04-19 17:55:49

Re: Java

#5 2011-05-31 18:01:19

Re: Java

Kod:

Kod:

Kod:

Kod:

Kod:

Kod:

Stopka forum